@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/sync-seed-defers-to-hub.test.ts

@@ -1,83 +0,0 @@
-// An empty REPLICA is not an empty HUB — the cell-side half of the F1
-// concurrent cold-seed collision.
-//
-// WHAT WENT WRONG IN THE FIELD. A cell runs two writers over one checkout: the
-// hub's workspace agent projects every document onto disk, and the supervised
-// studio child scans that same disk. So a canvas created on the DESKTOP landed
-// in the cell's checkout as a file the child had no descriptor for — a
-// brand-new local canvas, as far as it could tell. It connected, found its own
-// replica still empty (the hub's state was in flight), and adopted: a
-// clear-and-rebuild from the file. The desktop had already done exactly that on
-// its own replica, and two rebuilds from two clientIDs do not dedupe — Yjs
-// CONCATENATES them. Every peer ended up with the body twice (two
-// `export default`, `0 ARTBOARDS`), on essentially every desktop-created canvas.
-//
-// The listing is the only enumeration a peer has, so it is the only thing that
-// can tell "the hub has never heard of this canvas" from "the hub's copy has
-// not arrived yet". These pin both directions of that answer.
-
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import * as Y from 'yjs';
-
-import { htmlFromDoc } from '../sync/codec.ts';
-import { migrateSeed } from '../sync/migrate-seed.ts';
-
-const BODY = [
-  'import { DesignCanvas } from "@maude/canvas-lib";',
-  'export default function Screen() {',
-  '  return <DesignCanvas><h1>Hello</h1></DesignCanvas>;',
-  '}',
-  '',
-].join('\n');
-
-function fixture() {
-  const dir = mkdtempSync(join(tmpdir(), 'seed-defer-'));
-  const html = join(dir, 'screen.tsx');
-  writeFileSync(html, BODY);
-  return {
-    slug: 'ui-screen',
-    doc: new Y.Doc(),
-    paths: {
-      html,
-      comments: join(dir, '_comments', 'screen.json'),
-      annotations: join(dir, 'ui-screen.annotations.svg'),
-    },
-  };
-}
-
-describe('migrateSeed — an empty replica against a hub that already has the document', () => {
-  test('does NOT seed when the hub listing says the document holds bytes', async () => {
-    const f = fixture();
-    const result = await migrateSeed({ ...f, hubHasState: () => true });
-    expect(result).toBe('defer-hub-state');
-    // Nothing written into the doc — the hub's state arrives on its own, and a
-    // second rebuild here is the concatenation this guard exists to prevent.
-    expect(htmlFromDoc(f.doc)).toBe('');
-  });
-
-  test('still adopts when the hub has never heard of the slug', async () => {
-    const f = fixture();
-    const result = await migrateSeed({ ...f, hubHasState: () => false });
-    expect(result).toBe('local-adopt');
-    expect(htmlFromDoc(f.doc)).toBe(BODY);
-  });
-
-  test('still adopts when no listing is available at all (older hub)', async () => {
-    const f = fixture();
-    const result = await migrateSeed(f);
-    expect(result).toBe('local-adopt');
-    expect(htmlFromDoc(f.doc)).toBe(BODY);
-  });
-
-  test('a hub row with zero bytes is not state — that canvas still adopts', async () => {
-    const f = fixture();
-    // The row exists (the document was created) but carries nothing. Deferring
-    // here would leave a canvas that never syncs in either direction.
-    const result = await migrateSeed({ ...f, hubHasState: (slug) => slug === 'other' });
-    expect(result).toBe('local-adopt');
-    expect(htmlFromDoc(f.doc)).toBe(BODY);
-  });
-});

package/apps/studio/test/sync-settings-routes.test.ts

@@ -1,195 +0,0 @@
-// `/_api/sync/settings` + `/_api/sync/ownership` — the MAIN-origin half
-// (feature-before-first-external-users Task 2).
-//
-// `canvas-origin-gate.test.ts` asserts both are unreachable from the canvas
-// origin; this file asserts the complementary posture on the main origin
-// (same shape as sync-resync-routes.test.ts): cross-origin write → 403,
-// foreign Host → 403 on BOTH methods (these routes also serve GET, so the
-// rebinding guard has to cover the read too — the settings read names the
-// project's hub), plus honest same-origin answers on an unlinked sandbox.
-// The linked-project write paths are covered at module level in
-// sync-settings.test.ts — a sandbox with a fake linkedHub would spend the
-// whole suite trying to reach a hub that does not exist.
-
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import type { Subprocess } from 'bun';
-
-import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
-
-const HTTP = readFileSync(join(import.meta.dir, '..', 'http.ts'), 'utf8');
-
-let proc: Subprocess;
-let base: string;
-
-const ROUTES = ['/_api/sync/settings', '/_api/sync/ownership', '/_api/sync/trash'];
-
-beforeAll(async () => {
-  const { root } = makeSandbox();
-  const port = nextPort();
-  base = `http://localhost:${port}`;
-  proc = await bootServer(root, port);
-});
-
-afterAll(async () => {
-  await killProc(proc);
-});
-
-describe('cross-origin writes are refused (the CSRF guard)', () => {
-  for (const route of ROUTES) {
-    test(`POST ${route} from another origin is 403`, async () => {
-      const res = await fetch(`${base}${route}`, {
-        method: 'POST',
-        headers: { Origin: 'https://evil.example' },
-      });
-      expect(res.status).toBe(403);
-    });
-
-    test(`a CORS-simple POST to ${route} is still refused`, async () => {
-      const res = await fetch(`${base}${route}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'text/plain', Origin: 'https://evil.example' },
-        body: '{"syncFiles":false}',
-      });
-      expect(res.status).toBe(403);
-    });
-  }
-});
-
-describe('a foreign Host header is refused on BOTH methods (DNS rebinding)', () => {
-  for (const route of ROUTES) {
-    for (const method of ['GET', 'POST'] as const) {
-      test(`${method} ${route} with a rebinding Host is 403`, async () => {
-        const res = await fetch(`${base}${route}`, {
-          method,
-          headers: { Host: 'sync.127.0.0.1.nip.io' },
-        });
-        expect(res.status).toBe(403);
-      });
-    }
-  }
-});
-
-describe('same-origin behaviour on an unlinked sandbox', () => {
-  test('settings GET answers null — the panel must not render dead controls', async () => {
-    const res = await fetch(`${base}/_api/sync/settings`);
-    expect(res.status).toBe(200);
-    expect(await res.json()).toEqual({ settings: null });
-  });
-
-  test('settings POST refuses honestly when nothing is linked', async () => {
-    const res = await fetch(`${base}/_api/sync/settings`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ syncFiles: false }),
-    });
-    expect(res.status).toBe(400);
-    const json = (await res.json()) as { ok: boolean; detail?: string };
-    expect(json.ok).toBe(false);
-    expect(json.detail).toContain('no linked hub');
-  });
-
-  test('settings POST with an empty patch is a 400, not a silent no-op', async () => {
-    const res = await fetch(`${base}/_api/sync/settings`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: '{}',
-    });
-    expect(res.status).toBe(400);
-  });
-
-  test('settings POST validates value types before touching disk', async () => {
-    const res = await fetch(`${base}/_api/sync/settings`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ propagateDeletes: 'yes please' }),
-    });
-    expect(res.status).toBe(400);
-  });
-
-  test('ownership GET reports a mode and the linked state', async () => {
-    const res = await fetch(`${base}/_api/sync/ownership`);
-    expect(res.status).toBe(200);
-    const json = (await res.json()) as { mode: string; linked: boolean; git: boolean };
-    expect(['repo-owned', 'hub-owned', 'hybrid']).toContain(json.mode);
-    expect(json.linked).toBe(false);
-  });
-
-  test('ownership adopt refuses when nothing is linked (no owner would remain)', async () => {
-    const res = await fetch(`${base}/_api/sync/ownership`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ action: 'adopt' }),
-    });
-    expect(res.status).toBe(400);
-    const json = (await res.json()) as { ok: boolean; detail?: string };
-    expect(json.ok).toBe(false);
-    expect(json.detail).toContain('Link a workspace first');
-  });
-
-  test('ownership rejects an unknown action', async () => {
-    const res = await fetch(`${base}/_api/sync/ownership`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ action: 'yeet' }),
-    });
-    expect(res.status).toBe(400);
-  });
-});
-
-describe('trash on an empty sandbox', () => {
-  test('GET lists honestly empty', async () => {
-    const res = await fetch(`${base}/_api/sync/trash`);
-    expect(res.status).toBe(200);
-    expect(await res.json()).toEqual({ entries: [], total: 0, bytes: 0 });
-  });
-
-  test('restore of a non-_trash path is refused', async () => {
-    const res = await fetch(`${base}/_api/sync/trash`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ action: 'restore', trashRel: 'ui/Hero.tsx' }),
-    });
-    expect(res.status).toBe(400);
-  });
-
-  test('a 0-day prune is refused — "empty the trash" needs its own gesture', async () => {
-    const res = await fetch(`${base}/_api/sync/trash`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ action: 'prune', olderThanDays: 0 }),
-    });
-    expect(res.status).toBe(400);
-  });
-
-  test('prune with a sane window reports counts', async () => {
-    const res = await fetch(`${base}/_api/sync/trash`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ action: 'prune' }),
-    });
-    expect(res.status).toBe(200);
-    expect(await res.json()).toEqual({ ok: true, pruned: 0, bytes: 0, kept: 0 });
-  });
-});
-
-// Source pins — properties that need a linked project + live hub to observe.
-describe('source pins', () => {
-  test('a settings write hot-reloads config AND asks for a restart only when free', () => {
-    const block =
-      /sync\/settings[\s\S]{0,3000}reloadConfig\(ctx\)[\s\S]{0,600}control\.busy\?\.\(\)/;
-    expect(block.test(HTTP)).toBe(true);
-  });
-
-  test('ownership detach goes through the SAME unlink lane as Cloud detach', () => {
-    // Two unlink implementations would drift on credential handling — the
-    // route must reuse cloudApi.detach(), which drops the stored credential
-    // and cycles the runtime to solo NOW.
-    expect(HTTP).toMatch(/sync\/ownership[\s\S]{0,4000}await cloudApi\.detach\(\)/);
-  });
-
-  test('ownership refuses to edit a .gitignore it did not write', () => {
-    expect(HTTP).toMatch(/refused-malformed/);
-  });
-});

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

@@ -1,151 +0,0 @@
-// feature-before-first-external-users Task 2 — the sync-settings module: the
-// three user-facing toggles stop meaning "edit linkedHub.* JSON by hand".
-
-import { describe, expect, test } from 'bun:test';
-import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { isFirstAnchorMode, readSyncSettings, writeSyncSettings } from '../sync/settings.ts';
-
-function makeRepo(config?: unknown): string {
-  const root = mkdtempSync(join(tmpdir(), 'maude-sync-settings-'));
-  mkdirSync(join(root, '.design'), { recursive: true });
-  if (config !== undefined) {
-    writeFileSync(
-      join(root, '.design', 'config.json'),
-      typeof config === 'string' ? config : `${JSON.stringify(config, null, 2)}\n`
-    );
-  }
-  return root;
-}
-
-const LINKED = {
-  name: 'p',
-  linkedHub: { url: 'https://hub.example.com', linkedAt: 123, syncTsx: false },
-};
-
-describe('sync settings — read', () => {
-  test('absent keys read as the runtime defaults (ON, ON, ask)', () => {
-    const root = makeRepo(LINKED);
-    expect(readSyncSettings(root)).toEqual({
-      syncFiles: true,
-      propagateDeletes: true,
-      resolveFirstAnchor: 'ask',
-    });
-  });
-
-  test('no linked hub → null (the panel must not render dead controls)', () => {
-    expect(readSyncSettings(makeRepo({ name: 'p' }))).toBeNull();
-    expect(readSyncSettings(makeRepo())).toBeNull();
-  });
-
-  test('explicit values read through', () => {
-    const root = makeRepo({
-      name: 'p',
-      linkedHub: {
-        url: 'https://hub.example.com',
-        linkedAt: 1,
-        syncFiles: false,
-        propagateDeletes: false,
-        resolveFirstAnchor: 'keep-local',
-      },
-    });
-    expect(readSyncSettings(root)).toEqual({
-      syncFiles: false,
-      propagateDeletes: false,
-      resolveFirstAnchor: 'keep-local',
-    });
-  });
-});
-
-describe('sync settings — write', () => {
-  test('false is written explicitly; true REMOVES the key (default = absent)', async () => {
-    const root = makeRepo(LINKED);
-    await writeSyncSettings(root, { syncFiles: false, propagateDeletes: false });
-    let hub = JSON.parse(readFileSync(join(root, '.design', 'config.json'), 'utf8')).linkedHub;
-    expect(hub.syncFiles).toBe(false);
-    expect(hub.propagateDeletes).toBe(false);
-    await writeSyncSettings(root, { syncFiles: true, propagateDeletes: true });
-    hub = JSON.parse(readFileSync(join(root, '.design', 'config.json'), 'utf8')).linkedHub;
-    expect('syncFiles' in hub).toBe(false);
-    expect('propagateDeletes' in hub).toBe(false);
-  });
-
-  test("resolveFirstAnchor 'ask' removes the key — absence IS the ask state", async () => {
-    const root = makeRepo(LINKED);
-    await writeSyncSettings(root, { resolveFirstAnchor: 'keep-cloud' });
-    let hub = JSON.parse(readFileSync(join(root, '.design', 'config.json'), 'utf8')).linkedHub;
-    expect(hub.resolveFirstAnchor).toBe('keep-cloud');
-    await writeSyncSettings(root, { resolveFirstAnchor: 'ask' });
-    hub = JSON.parse(readFileSync(join(root, '.design', 'config.json'), 'utf8')).linkedHub;
-    expect('resolveFirstAnchor' in hub).toBe(false);
-  });
-
-  test('every other config field survives a write verbatim', async () => {
-    const root = makeRepo({
-      ...LINKED,
-      themeDefault: 'dark',
-      canvasGroups: [{ label: 'UI', path: 'ui' }],
-    });
-    await writeSyncSettings(root, { propagateDeletes: false });
-    const cfg = JSON.parse(readFileSync(join(root, '.design', 'config.json'), 'utf8'));
-    expect(cfg.themeDefault).toBe('dark');
-    expect(cfg.canvasGroups).toEqual([{ label: 'UI', path: 'ui' }]);
-    expect(cfg.linkedHub.syncTsx).toBe(false); // untouched sibling key
-    expect(cfg.linkedHub.url).toBe('https://hub.example.com');
-  });
-
-  test('no linked hub → throws (never invents a linkedHub block)', async () => {
-    const root = makeRepo({ name: 'p' });
-    await expect(writeSyncSettings(root, { syncFiles: false })).rejects.toThrow(/no linked hub/);
-  });
-
-  test('corrupt config → refuses to overwrite (fail closed)', async () => {
-    const root = makeRepo('{ this is not json');
-    await expect(writeSyncSettings(root, { syncFiles: false })).rejects.toThrow(/not valid JSON/);
-    expect(readFileSync(join(root, '.design', 'config.json'), 'utf8')).toBe('{ this is not json');
-  });
-
-  test('invalid resolveFirstAnchor value → throws', async () => {
-    const root = makeRepo(LINKED);
-    await expect(
-      // @ts-expect-error — deliberately wrong value
-      writeSyncSettings(root, { resolveFirstAnchor: 'keep-both' })
-    ).rejects.toThrow(/invalid resolveFirstAnchor/);
-  });
-});
-
-describe('sync settings — vocabulary', () => {
-  test('isFirstAnchorMode accepts exactly the three modes', () => {
-    expect(isFirstAnchorMode('ask')).toBe(true);
-    expect(isFirstAnchorMode('keep-local')).toBe(true);
-    expect(isFirstAnchorMode('keep-cloud')).toBe(true);
-    expect(isFirstAnchorMode('keep-both')).toBe(false);
-    expect(isFirstAnchorMode(true)).toBe(false);
-    expect(isFirstAnchorMode(undefined)).toBe(false);
-  });
-
-  test('the schema knows every runtime linkedHub key (the drift this task found)', () => {
-    // config.schema.json had additionalProperties:false with only 4 of the 9
-    // runtime keys — a user who followed a breaker remediation string
-    // ("set linkedHub.propagateDeletes=false") failed config lint for it.
-    const schema = JSON.parse(
-      readFileSync(join(import.meta.dir, '..', 'config.schema.json'), 'utf8')
-    );
-    const props = Object.keys(schema.properties.linkedHub.properties);
-    for (const key of [
-      'url',
-      'linkedAt',
-      'adopt',
-      'syncTsx',
-      'workspaceId',
-      'syncFiles',
-      'propagateDeletes',
-      'resolveFirstAnchor',
-      'fileEvents',
-    ]) {
-      expect(props).toContain(key);
-    }
-  });
-});

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

@@ -1,261 +0,0 @@
-// Sync status store tests — Phase 9 Task 8.
-
-import { describe, expect, test } from 'bun:test';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import type { SyncStatusSnapshot } from '../sync/connection-state.ts';
-import { createSyncStatusStore, type SyncStatusPayload } from '../sync/status.ts';
-
-function snap(partial: Partial<SyncStatusSnapshot> = {}): SyncStatusSnapshot {
-  return {
-    state: 'online',
-    queuedOps: 0,
-    lastSyncAt: null,
-    offlineSince: null,
-    flash: null,
-    updatedAt: 1,
-    ...partial,
-  };
-}
-
-function makeStore() {
-  const writes: SyncStatusPayload[] = [];
-  const broadcasts: SyncStatusPayload[] = [];
-  const store = createSyncStatusStore({
-    url: 'https://hub.example.com',
-    canvases: 3,
-    write: (p) => writes.push(p),
-    broadcast: (p) => broadcasts.push(p),
-    now: () => 42,
-  });
-  return { store, writes, broadcasts };
-}
-
-describe('sync status store', () => {
-  test('update() writes + broadcasts the merged payload', () => {
-    const { store, writes, broadcasts } = makeStore();
-    store.update(snap({ state: 'offline', queuedOps: 2 }));
-    expect(writes).toHaveLength(1);
-    expect(broadcasts).toHaveLength(1);
-    expect(writes[0].state).toBe('offline');
-    expect(writes[0].queuedOps).toBe(2);
-    expect(writes[0].url).toBe('https://hub.example.com');
-    expect(writes[0].canvases).toBe(3);
-    expect(writes[0].conflicts).toEqual([]);
-  });
-
-  test('addConflict() appends a stamped conflict + reflects in get()', () => {
-    const { store } = makeStore();
-    store.addConflict({ slug: 'screen', kind: 'cold-start-hub-wins' });
-    const p = store.get();
-    expect(p.conflicts).toHaveLength(1);
-    expect(p.conflicts[0]).toEqual({ slug: 'screen', kind: 'cold-start-hub-wins', at: 42 });
-  });
-
-  test('conflict list is capped at maxConflicts (drops oldest)', () => {
-    const writes: SyncStatusPayload[] = [];
-    const store = createSyncStatusStore({
-      url: 'https://h',
-      canvases: 1,
-      write: (p) => writes.push(p),
-      maxConflicts: 2,
-      now: () => 1,
-    });
-    store.addConflict({ slug: 'a', kind: 'git-pull' });
-    store.addConflict({ slug: 'b', kind: 'git-pull' });
-    store.addConflict({ slug: 'c', kind: 'git-pull' });
-    const p = store.get();
-    expect(p.conflicts.map((c) => c.slug)).toEqual(['b', 'c']);
-  });
-
-  test('a throwing writer never propagates into the caller', () => {
-    const store = createSyncStatusStore({
-      url: 'https://h',
-      canvases: 1,
-      write: () => {
-        throw new Error('disk full');
-      },
-    });
-    expect(() => store.update(snap({ state: 'offline' }))).not.toThrow();
-  });
-});
-
-// DDR-102 — the payload carries the per-doc rollup + rich conflicts additively.
-describe('sync status store — DDR-102 additive fields', () => {
-  test('docs + rejectedSlugs flow through update() into the payload', () => {
-    const writes: SyncStatusPayload[] = [];
-    const store = createSyncStatusStore({
-      url: 'https://h.example.com',
-      canvases: 3,
-      write: (p) => writes.push(p),
-    });
-    store.update({
-      state: 'online',
-      queuedOps: 0,
-      lastSyncAt: 123,
-      offlineSince: null,
-      flash: null,
-      updatedAt: 456,
-      docs: { synced: 1, pending: 0, rejected: 2 },
-      rejectedSlugs: ['ui-x', 'ui-y'],
-    });
-    const p = store.get();
-    expect(p.docs).toEqual({ synced: 1, pending: 0, rejected: 2 });
-    expect(p.rejectedSlugs).toEqual(['ui-x', 'ui-y']);
-    expect(p.lastSyncAt).toBe(123);
-  });
-
-  test('addConflict carries winner + snapshots (cold-start-diverged)', () => {
-    const store = createSyncStatusStore({
-      url: 'https://h.example.com',
-      canvases: 1,
-      write: () => {},
-      now: () => 999,
-    });
-    store.addConflict({
-      slug: 'ui-maskot',
-      kind: 'cold-start-diverged',
-      winner: 'local',
-      snapshots: { local: '2026-06-11T10:00:00.000Z', hub: '2026-06-11T10:00:00.001Z' },
-    });
-    const c = store.get().conflicts[0];
-    expect(c.kind).toBe('cold-start-diverged');
-    expect(c.winner).toBe('local');
-    expect(c.snapshots?.local).toBe('2026-06-11T10:00:00.000Z');
-    expect(c.at).toBe(999);
-  });
-
-  test('old-shape payload readers: a snapshot WITHOUT docs/rejectedSlugs still works', () => {
-    const store = createSyncStatusStore({
-      url: 'https://h.example.com',
-      canvases: 1,
-      write: () => {},
-    });
-    store.update({
-      state: 'online',
-      queuedOps: 0,
-      lastSyncAt: null,
-      offlineSince: null,
-      flash: null,
-      updatedAt: 1,
-    });
-    const p = store.get();
-    expect(p.docs).toBeUndefined();
-    expect(p.rejectedSlugs).toBeUndefined();
-    expect(p.state).toBe('online');
-  });
-});
-
-describe('sync status store — asset lane (feature-sync-progress-modal)', () => {
-  test('updateAssets() merges progress into the payload + flushes', () => {
-    const { store, writes, broadcasts } = makeStore();
-    const progress = {
-      total: 10,
-      done: 4,
-      pushed: 3,
-      skipped: 1,
-      failedCount: 0,
-      failures: [],
-      active: 'assets/hero.png',
-      finished: false,
-    };
-    store.updateAssets(progress);
-    expect(writes[writes.length - 1].assets).toEqual(progress);
-    expect(broadcasts[broadcasts.length - 1].assets).toEqual(progress);
-    // …and a later monitor update keeps the asset lane (separate slices).
-    store.update(snap({ state: 'online' }));
-    expect(store.get().assets).toEqual(progress);
-  });
-
-  test('payloads before the first asset emit carry no assets field', () => {
-    const { store } = makeStore();
-    store.update(snap());
-    expect('assets' in store.get()).toBe(false);
-  });
-
-  test('updateFiles() merges the file plane into the payload + flushes', () => {
-    // feature-sync-file-plane — same slice discipline as assets: a lane, not
-    // a connection, surviving later monitor updates untouched.
-    const { store, writes, broadcasts } = makeStore();
-    const files = { synced: 103, pulled: 103, conflicts: 1 };
-    store.updateFiles(files);
-    expect(writes[writes.length - 1].files).toEqual(files);
-    expect(broadcasts[broadcasts.length - 1].files).toEqual(files);
-    store.update(snap({ state: 'online' }));
-    expect(store.get().files).toEqual(files);
-  });
-
-  test('payloads before the first file-plane emit carry no files field', () => {
-    const { store } = makeStore();
-    store.update(snap());
-    expect('files' in store.get()).toBe(false);
-  });
-});
-
-describe('held breakers reach the status payload', () => {
-  // Between the plane and the panel sits `noteFilePlane`, which is where the
-  // holds were being dropped: it read synced/pulled/conflicts/pushed/delivery
-  // and nothing else, so the fields existed and never travelled.
-  test('the FilePlaneStatus shape carries them', () => {
-    const src = readFileSync(join(import.meta.dir, '..', 'sync', 'status.ts'), 'utf8');
-    expect(src).toContain('held?:');
-    expect(src).toMatch(/'delete-out' \| 'delete-in' \| 'first-anchor' \| 'reanchor'/);
-  });
-
-  test('and the sync runtime actually fills it in', () => {
-    const src = readFileSync(join(import.meta.dir, '..', 'sync', 'index.ts'), 'utf8');
-    expect(src).toContain('result.deleteHeld');
-    expect(src).toContain('result.firstAnchorHeld');
-    expect(src).toContain('result.reanchorHeld');
-    // And the first-anchor hold has an ANSWER wired, not just a report.
-    expect(src).toContain('resolveFirstAnchor');
-  });
-});
-
-describe('sync status store — consent notices (feature-before-first-external-users T1)', () => {
-  test('notice() lands in the payload, stamped, and persists + broadcasts', () => {
-    const { store, writes } = makeStore();
-    store.notice({ id: 'shared-doc', severity: 'warn', text: 'shared-doc is ON' });
-    const p = store.get();
-    expect(p.notices).toEqual([
-      { id: 'shared-doc', severity: 'warn', text: 'shared-doc is ON', at: 42 },
-    ]);
-    expect(writes.at(-1)?.notices).toHaveLength(1);
-  });
-
-  test('notice() is idempotent by id — a repeat neither duplicates nor re-flushes', () => {
-    const { store, writes } = makeStore();
-    store.notice({ id: 'tsx-bodies', severity: 'warn', text: 'first' });
-    const flushesAfterFirst = writes.length;
-    store.notice({ id: 'tsx-bodies', severity: 'warn', text: 'second (ignored)' });
-    expect(store.get().notices).toHaveLength(1);
-    expect(store.get().notices?.[0]?.text).toBe('first');
-    expect(writes.length).toBe(flushesAfterFirst);
-  });
-
-  test('old-shape readers: a payload with no notices simply omits the field', () => {
-    const { store } = makeStore();
-    expect('notices' in store.get()).toBe(false);
-  });
-
-  test('the A7 sites route through the store, not only console.warn (source pin)', () => {
-    // The regression this task exists for: both consent notices lived ONLY in
-    // console.warn. Pin that the notice sites reach store.notice with the two
-    // stable ids the SyncPanel dismiss ack keys on.
-    const src = readFileSync(join(import.meta.dir, '../sync/index.ts'), 'utf8');
-    expect(src).toMatch(/store\.notice\(\{\s*id: 'tsx-bodies'/);
-    expect(src).toMatch(/store\.notice\(\{\s*id: 'shared-doc'/);
-  });
-});
-
-describe('F-12 (post-1.0 burn-down) — the reconnect trigger is cooled', () => {
-  test('a reconnect-driven poll goes through the cooldown, not around it', () => {
-    // A hub that churns the WebSocket drives reconnects at its own pace; the
-    // poke cooldown never saw that trigger. The cooled path keeps a genuine
-    // one-off reconnect immediate (nothing poked recently ⇒ runs at once) and
-    // folds a churn into the scheduled tick.
-    const src = readFileSync(join(import.meta.dir, '../sync/index.ts'), 'utf8');
-    expect(src).toMatch(/wasDisconnected\) pollRemoteSoon\(\{ cooled: true \}\)/);
-  });
-});