pmx-canvas 0.6.5 → 0.7.0

package/src/cli/agent.ts

@@ -26,6 +26,9 @@ import './commands/groups.js';
 import './commands/view.js';
 import './commands/query.js';
 import './commands/pins.js';
+import './commands/boards.js';
+import './commands/backup.js';
+import './commands/export.js';
 import './commands/history.js';
 import './commands/ax.js';
 import './commands/pump.js';
@@ -78,6 +81,7 @@ Canvas commands:
   pmx-canvas layout                   Full canvas state (JSON)
   pmx-canvas status                   Quick summary
   pmx-canvas search <query>           Search nodes by content
+  pmx-canvas context [options]        Budgeted cross-board context brief
   pmx-canvas open                     Open the current workbench in a browser
   pmx-canvas arrange [--layout MODE]  Auto-arrange (grid|column|flow)
   pmx-canvas batch [--file FILE]      Run many canvas operations at once

package/src/cli/commands/ax.ts

@@ -384,6 +384,19 @@ cmd(
   },
 );
 
+cmd(
+  'ax reads',
+  'Read the context read log (which context each agent read, and whether pinned nodes reached it)',
+  ['pmx-canvas ax reads', 'pmx-canvas ax reads --limit 200'],
+  async (args) => {
+    const { flags } = parseFlags(args);
+    if (flags.help || flags.h) return showCommandHelp('ax reads');
+
+    const limit = optionalNumberFlag(flags, 'limit', 'pmx-canvas ax reads --limit <n>');
+    output(await invokeOperation('ax.reads.list', limit ? { limit } : {}));
+  },
+);
+
 cmd(
   'ax work add',
   'Add a canvas-bound AX work item',

package/src/cli/commands/backup.ts

@@ -0,0 +1,66 @@
+// Library backup commands (plan 012): backup, backup status, backup schedule, restore.
+
+import { resolve } from 'node:path';
+import {
+  cmd,
+  die,
+  getStringFlag,
+  invokeOperation,
+  optionalNumberFlag,
+  output,
+  parseFlags,
+  showCommandHelp,
+} from '../shared.js';
+
+cmd(
+  'backup',
+  'Back up every board to a folder (safe while the server runs)',
+  ['pmx-canvas backup', 'pmx-canvas backup --to ~/Backups/pmx --keep 14'],
+  async (args) => {
+    const { flags } = parseFlags(args);
+    if (flags.help || flags.h) return showCommandHelp('backup');
+    const to = getStringFlag(flags, 'to');
+    const keep = optionalNumberFlag(flags, 'keep', 'pmx-canvas backup --keep <n>');
+    output(await invokeOperation('backup.run', { ...(to ? { to: resolve(to) } : {}), ...(keep ? { keep } : {}) }));
+  },
+);
+
+cmd('backup status', 'Show the backup folder, schedule and backups', ['pmx-canvas backup status'], async (args) => {
+  const { flags } = parseFlags(args);
+  if (flags.help || flags.h) return showCommandHelp('backup status');
+  output(await invokeOperation('backup.status', {}));
+});
+
+cmd(
+  'backup schedule',
+  'Back up on a schedule, run by the server',
+  ['pmx-canvas backup schedule --every 24h --keep 14 --to ~/Backups/pmx', 'pmx-canvas backup schedule --off'],
+  async (args) => {
+    const { flags } = parseFlags(args);
+    if (flags.help || flags.h) return showCommandHelp('backup schedule');
+    const every = flags.off ? 'off' : getStringFlag(flags, 'every');
+    if (!every) die('Usage: pmx-canvas backup schedule --every <30m|24h|7d> [--keep <n>] [--to <folder>] | --off');
+    const to = getStringFlag(flags, 'to');
+    const keep = optionalNumberFlag(flags, 'keep', 'pmx-canvas backup schedule --keep <n>');
+    output(
+      await invokeOperation('backup.schedule', {
+        every,
+        ...(to ? { to: resolve(to) } : {}),
+        ...(keep ? { keep } : {}),
+      }),
+    );
+  },
+);
+
+cmd(
+  'restore',
+  'Replace every board with a backup (the current file is kept as canvas.db.before-restore)',
+  ['pmx-canvas restore ~/Backups/pmx/canvas-20260927T090000000Z.db'],
+  async (args) => {
+    const { positional, flags } = parseFlags(args);
+    if (flags.help || flags.h) return showCommandHelp('restore');
+    const file = positional[0];
+    if (!file) die('Usage: pmx-canvas restore <backup-file>');
+    output(await invokeOperation('backup.restore', { file: resolve(file) }));
+  },
+);

package/src/cli/commands/boards.ts

@@ -0,0 +1,71 @@
+// Board commands (plan 012): board list, board create, board rename, board category.
+// Opening, switching and deleting boards is the human's, in the workbench.
+
+import { cmd, die, getStringFlag, invokeOperation, output, parseFlags, showCommandHelp } from '../shared.js';
+
+cmd('board list', 'List boards, most recently opened first', ['pmx-canvas board list'], async (args) => {
+  const { flags } = parseFlags(args);
+  if (flags.help || flags.h) return showCommandHelp('board list');
+  output(await invokeOperation('board.list', {}));
+});
+
+cmd(
+  'board from',
+  'Preview or create a board from selected cards on another board',
+  ['pmx-canvas board from <source-id> "Follow-up" --nodes id1,id2 --readme --structure'],
+  async (args) => {
+    const { positional, flags } = parseFlags(args, { boolFlags: ['preview', 'readme', 'structure'] });
+    if (flags.help || flags.h) return showCommandHelp('board from');
+    const [sourceBoardId, ...nameParts] = positional;
+    const name = nameParts.join(' ').trim() || 'New board';
+    if (!sourceBoardId) die('Usage: pmx-canvas board from <source-board-id> <name>');
+    const nodes = getStringFlag(flags, 'nodes');
+    output(
+      await invokeOperation('board.create-from', {
+        sourceBoardId,
+        name,
+        ...(nodes ? { nodeIds: nodes.split(',').filter(Boolean) } : {}),
+        includeReadme: !!flags.readme,
+        includeStructure: !!flags.structure,
+        preview: !!flags.preview,
+      }),
+    );
+  },
+);
+
+cmd(
+  'board create',
+  'Create an empty board (the human opens it in the workbench)',
+  ['pmx-canvas board create "Q4 planning"', 'pmx-canvas board create "Q4 planning" --category Planning'],
+  async (args) => {
+    const { positional, flags } = parseFlags(args);
+    if (flags.help || flags.h) return showCommandHelp('board create');
+    const name = positional.join(' ').trim();
+    if (!name) die('Usage: pmx-canvas board create <name> [--category <category>]');
+    const category = getStringFlag(flags, 'category');
+    output(await invokeOperation('board.create', { name, ...(category ? { category } : {}) }));
+  },
+);
+
+cmd('board rename', 'Rename a board', ['pmx-canvas board rename board-abc123 "Q4 planning"'], async (args) => {
+  const { positional, flags } = parseFlags(args);
+  if (flags.help || flags.h) return showCommandHelp('board rename');
+  const [id, ...rest] = positional;
+  const name = rest.join(' ').trim();
+  if (!id || !name) die('Usage: pmx-canvas board rename <board-id> <name>');
+  output(await invokeOperation('board.update', { id, name }));
+});
+
+cmd(
+  'board category',
+  'File a board under a category on Home (--clear removes it)',
+  ['pmx-canvas board category board-abc123 "Planning"', 'pmx-canvas board category board-abc123 --clear'],
+  async (args) => {
+    const { positional, flags } = parseFlags(args);
+    if (flags.help || flags.h) return showCommandHelp('board category');
+    const [id, ...rest] = positional;
+    const category = flags.clear ? '' : rest.join(' ').trim();
+    if (!id || (!category && !flags.clear)) die('Usage: pmx-canvas board category <board-id> <category> | --clear');
+    output(await invokeOperation('board.update', { id, category }));
+  },
+);

package/src/cli/commands/export.ts

@@ -0,0 +1,30 @@
+// Static board export (plan 013): export.
+
+import { copyFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { cmd, getStringFlag, invokeOperation, output, parseFlags, showCommandHelp } from '../shared.js';
+
+cmd(
+  'export',
+  'Export a board as one self-contained HTML file anyone can open',
+  [
+    'pmx-canvas export',
+    'pmx-canvas export --board board-abc123 --out ~/Desktop/okrs.html',
+    'pmx-canvas export --include-files',
+  ],
+  async (args) => {
+    const { flags } = parseFlags(args);
+    if (flags.help || flags.h) return showCommandHelp('export');
+    const board = getStringFlag(flags, 'board');
+    const out = getStringFlag(flags, 'out');
+    const result = (await invokeOperation('export.run', {
+      ...(board ? { board } : {}),
+      includeFiles: flags['include-files'] === true,
+    })) as { path: string };
+    if (out) {
+      copyFileSync(result.path, resolve(out));
+      result.path = resolve(out);
+    }
+    output(result);
+  },
+);

package/src/cli/commands/nodes.ts

@@ -796,7 +796,10 @@ cmd(
     const id = positional[0];
     if (!id) die('Missing node ID', 'pmx-canvas node get <node-id>');
 
-    const result = (await invokeOperation('node.get', { id })) as Record<string, unknown>;
+    const result = (await invokeOperation('node.get', {
+      id,
+      board: typeof flags.board === 'string' ? flags.board : undefined,
+    })) as Record<string, unknown>;
     const requestedFields = collectRequestedFields(args, flags);
     if (requestedFields.length > 0) {
       const picked = Object.fromEntries(requestedFields.map((field) => [field, resolveNodeFieldValue(result, field)]));

package/src/cli/commands/pins.ts

@@ -17,7 +17,9 @@ cmd(
     if (flags.help || flags.h) return showCommandHelp('pin');
 
     if (flags.list) {
-      const result = await invokeOperation('pinned-context.get', {});
+      const result = await invokeOperation('pinned-context.get', {
+        board: typeof flags.board === 'string' ? flags.board : undefined,
+      });
       output(result);
       return;
     }
@@ -36,7 +38,9 @@ cmd(
     }
 
     // Default: list
-    const result = await invokeOperation('pinned-context.get', {});
+    const result = await invokeOperation('pinned-context.get', {
+      board: typeof flags.board === 'string' ? flags.board : undefined,
+    });
     output(result);
   },
 );

package/src/cli/commands/pump.ts

@@ -91,6 +91,9 @@ function runExec(template: string, steer: PendingSteer, consumer: string): Promi
         PMX_STEER_CONSUMER: consumer,
       },
     });
+    // A command that exits without reading stdin (`exit 1`, a notifier) closes
+    // the pipe first; the EPIPE is not the command's result — its exit code is.
+    child.stdin.on('error', () => {});
     child.stdin.write(steer.message);
     child.stdin.end();
     child.on('close', (code) => resolve(code ?? 1));

package/src/cli/commands/query.ts

@@ -36,11 +36,30 @@ cmd(
     const query = positional[0] || (typeof flags.query === 'string' ? flags.query : '');
     if (!query) die('Missing search query', 'pmx-canvas search "query"');
 
-    const result = await invokeOperation('search', { q: query });
+    const result = await invokeOperation('search', { q: query, ...(flags.library ? { scope: 'library' } : {}) });
     output(result);
   },
 );
 
+cmd(
+  'context',
+  'Read the budgeted cross-board context brief',
+  ['pmx-canvas context --consumer codex --budget 16000'],
+  async (args) => {
+    const { flags } = parseFlags(args);
+    if (flags.help || flags.h) return showCommandHelp('context');
+    output(
+      await invokeOperation('context.get', {
+        ...(typeof flags.consumer === 'string' ? { consumer: flags.consumer } : {}),
+        ...(typeof flags.since === 'string' || typeof flags.since === 'number' ? { since: Number(flags.since) } : {}),
+        ...(typeof flags.budget === 'string' || typeof flags.budget === 'number'
+          ? { budget: Number(flags.budget) }
+          : {}),
+      }),
+    );
+  },
+);
+
 // ── validate ─────────────────────────────────────────────────
 cmd(
   'validate',
@@ -114,13 +133,20 @@ cmd('code-graph', 'Show auto-detected file dependency graph', ['pmx-canvas code-
 });
 
 // ── spatial ──────────────────────────────────────────────────
-cmd('spatial', 'Spatial analysis: clusters, reading order, neighborhoods', ['pmx-canvas spatial'], async (args) => {
-  const { flags } = parseFlags(args);
-  if (flags.help || flags.h) return showCommandHelp('spatial');
+cmd(
+  'spatial',
+  'Spatial analysis: clusters, reading order, neighborhoods',
+  ['pmx-canvas spatial', 'pmx-canvas spatial --board <id>'],
+  async (args) => {
+    const { flags } = parseFlags(args);
+    if (flags.help || flags.h) return showCommandHelp('spatial');
 
-  const result = await invokeOperation('spatial.get', {});
-  output(result);
-});
+    const result = await invokeOperation('spatial.get', {
+      board: typeof flags.board === 'string' ? flags.board : undefined,
+    });
+    output(result);
+  },
+);
 
 // ── watch ────────────────────────────────────────────────────
 cmd(

package/src/cli/commands/view.ts

@@ -42,16 +42,17 @@ cmd('open', 'Open the current workbench in the browser', ['pmx-canvas open'], as
 cmd(
   'layout',
   'Get the full canvas layout (nodes, edges, viewport)',
-  ['pmx-canvas layout', 'pmx-canvas layout --summary'],
+  ['pmx-canvas layout', 'pmx-canvas layout --board <id>', 'pmx-canvas layout --summary'],
   async (args) => {
     const { flags } = parseFlags(args, { boolFlags: ['summary'] });
     if (flags.help || flags.h) return showCommandHelp('layout');
 
+    const board = typeof flags.board === 'string' ? flags.board : undefined;
     if (flags.summary || flags.compact) {
-      output(await invokeOperation('summary.get', {}));
+      output(await invokeOperation('summary.get', { board }));
       return;
     }
-    const result = await invokeOperation('layout.get', {});
+    const result = await invokeOperation('layout.get', { board });
     output(result);
   },
 );
@@ -61,12 +62,13 @@ cmd('status', 'Quick canvas summary', ['pmx-canvas status'], async (args) => {
   const { flags } = parseFlags(args);
   if (flags.help || flags.h) return showCommandHelp('status');
 
-  const layout = (await invokeOperation('layout.get', {})) as {
+  const board = typeof flags.board === 'string' ? flags.board : undefined;
+  const layout = (await invokeOperation('layout.get', { board })) as {
     nodes: Array<Record<string, unknown>>;
     edges: unknown[];
     viewport: unknown;
   };
-  const pinned = (await invokeOperation('pinned-context.get', {})) as { count: number; nodeIds: string[] };
+  const pinned = (await invokeOperation('pinned-context.get', { board })) as { count: number; nodeIds: string[] };
 
   const typeCounts: Record<string, number> = {};
   for (const n of layout.nodes) {

package/src/cli/index.ts

@@ -38,6 +38,7 @@ const AGENT_COMMANDS = new Set([
   'edge',
   'json-render',
   'search',
+  'context',
   'layout',
   'status',
   'arrange',
@@ -45,6 +46,10 @@ const AGENT_COMMANDS = new Set([
   'fit',
   'screenshot',
   'pin',
+  'board',
+  'backup',
+  'restore',
+  'export',
   'ax',
   'pump',
   'undo',
@@ -306,6 +311,10 @@ Agent CLI (works against running server):
   diagram add                         Add an Excalidraw diagram node
   html primitive add|schema           Add or inspect HTML communication primitives
   pin <ids...> | --list | --clear     Manage context pins
+  board list|create|rename|category   Manage boards (the human opens them in the workbench)
+  backup [status|schedule]            Back up every board, now or on a schedule
+  restore <backup-file>               Replace every board with a backup
+  export [--board id] [--out file]    Export a board as one HTML file anyone can open
   undo / redo / history               Time travel
   snapshot save|list|restore|diff|delete
                                       Manage snapshots
@@ -425,14 +434,15 @@ Examples:
   console.log('    pmx-canvas --help          (all commands)');
   console.log('\n  Press Ctrl+C to stop\n');
 
-  process.on('SIGINT', () => {
+  const shutdown = () => {
     console.log('\nShutting down...');
-    canvas.stop();
-    process.exit(0);
-  });
-
-  process.on('SIGTERM', () => {
-    canvas.stop();
-    process.exit(0);
-  });
+    try {
+      canvas.stop();
+      process.exit(0);
+    } catch (error) {
+      console.error('Shutdown refused: canvas changes could not be saved. Fix persistence and retry shutdown.', error);
+    }
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
 }

package/src/client/App.tsx

@@ -8,9 +8,13 @@ import { CanvasViewport } from './canvas/CanvasViewport';
 import { CommandBar } from './canvas/CommandBar';
 import { ConnectionBanner } from './canvas/ConnectionBanner';
 import { CommandPalette } from './canvas/CommandPalette';
+import { BoardLinkDialog } from './canvas/BoardLinkDialog';
 import { ContextMenu, useContextMenu } from './canvas/ContextMenu';
 import { ContextPinBar } from './canvas/ContextPinBar';
 import { EmptyState } from './canvas/EmptyState';
+import { HomeView } from './canvas/HomeView';
+import { ExportDialog } from './canvas/ExportDialog';
+import { activeBoardId, boardsLoaded } from './state/boards-store';
 import { createNodeInView } from './canvas/create-in-view';
 import { undoFromKeyboard } from './state/session-store';
 import { ActivityFeed, WritersSheet } from './canvas/ExternalWriters';
@@ -67,11 +71,13 @@ export function App() {
   const [minimapVisible, setMinimapVisible] = useState(true);
   const [snapshotOpen, setSnapshotOpen] = useState(false);
   const [paletteOpen, setPaletteOpen] = useState(false);
+  const [boardLinkOpen, setBoardLinkOpen] = useState(false);
   const [shortcutsOpen, setShortcutsOpen] = useState(false);
   const [annotationTool, setAnnotationTool] = useState<AnnotationTool>(null);
   const snapshotBtnRef = useRef<HTMLButtonElement>(null);
   const { menu, openNodeMenu, openCanvasMenu, openEdgeMenu, closeMenu } = useContextMenu();
   const hasInitialLayout = hasInitialServerLayout.value;
+  const onHome = boardsLoaded.value && activeBoardId.value === null;
   // rail-chrome-v2: the one selector every agent surface mounts on. Exposed
   // as a data attribute so styling and tests can key on it; the quiet board
   // (no attached session) must stay byte-clean of agent chrome.
@@ -90,6 +96,12 @@ export function App() {
     return connectSSE();
   }, []);
 
+  useEffect(() => {
+    const open = () => setBoardLinkOpen(true);
+    window.addEventListener('pmx-open-board-link', open);
+    return () => window.removeEventListener('pmx-open-board-link', open);
+  }, []);
+
   // Keep the server's idea of this window's size current (0.4.6 orb feedback
   // #2) so an agent `fit` computes a scale that actually fits the human's
   // canvas region. Connect-time reporting lives in the SSE bridge; this covers
@@ -357,16 +369,21 @@ export function App() {
           <AttentionHistory />
           <ActivityFeed />
           <WritersSheet />
-          {hasInitialLayout && allNodes.length === 0 && intents.value.size === 0 && (
-            <EmptyState onOpenPalette={() => setPaletteOpen(true)} />
+          {onHome ? (
+            <HomeView />
+          ) : (
+            hasInitialLayout &&
+            allNodes.length === 0 &&
+            intents.value.size === 0 && <EmptyState onOpenPalette={() => setPaletteOpen(true)} />
           )}
           {selectedNodeIds.value.size > 0 && <SelectionBar />}
           {sessionIsActive ? <CommandBar /> : contextPinnedNodeIds.value.size > 0 && <ContextPinBar />}
           <SessionReceipt onOpenSnapshots={() => setSnapshotOpen(true)} />
           <TextPrompt />
+          <ExportDialog />
           {expandedNodeId.value && <ExpandedNodeOverlay />}
           <SnapshotPanel open={snapshotOpen} onClose={handleCloseSnapshot} anchorRef={snapshotBtnRef} />
-          {minimapVisible && (
+          {minimapVisible && !onHome && (
             <Minimap
               viewport={viewport}
               nodes={nodes}
@@ -381,6 +398,7 @@ export function App() {
       {sessionIsActive && <SessionPanel />}
       {menu && <ContextMenu menu={menu} onClose={closeMenu} />}
       {paletteOpen && <CommandPalette onClose={() => setPaletteOpen(false)} onToggleMinimap={handleToggleMinimap} />}
+      {boardLinkOpen && <BoardLinkDialog onClose={() => setBoardLinkOpen(false)} />}
       {shortcutsOpen && <ShortcutOverlay onClose={() => setShortcutsOpen(false)} />}
     </div>
   );

package/src/client/canvas/BoardCopyDialog.tsx

@@ -0,0 +1,153 @@
+import { useEffect, useRef, useState } from 'preact/hooks';
+import {
+  createBoardFrom,
+  openBoard,
+  previewBoardCopy,
+  type BoardCopyPreview,
+  type BoardSummary,
+} from '../state/boards-store';
+import { useFocusTrap } from './use-focus-trap';
+
+export function BoardCopyDialog({ board, onClose }: { board: BoardSummary; onClose: () => void }) {
+  const dialogRef = useRef<HTMLDivElement>(null);
+  const nameRef = useRef<HTMLInputElement>(null);
+  const [preview, setPreview] = useState<BoardCopyPreview | null>(null);
+  const [selected, setSelected] = useState<Set<string>>(new Set());
+  const [name, setName] = useState(`${board.name} copy`);
+  const [includeReadme, setIncludeReadme] = useState(true);
+  const [includeStructure, setIncludeStructure] = useState(true);
+  const [openAfter, setOpenAfter] = useState(false);
+  const [error, setError] = useState('');
+  const [saving, setSaving] = useState(false);
+  useFocusTrap(dialogRef, true, { initial: nameRef });
+
+  useEffect(() => {
+    let active = true;
+    void previewBoardCopy(board.id).then((result) => {
+      if (!active) return;
+      if (!result || !Array.isArray(result.cards)) return setError('Could not load reusable cards. Try again.');
+      setPreview(result);
+      setSelected(new Set(result.cards.filter((card) => card.reusable).map((card) => card.id)));
+    });
+    return () => {
+      active = false;
+    };
+  }, [board.id]);
+
+  const submit = async (event: Event) => {
+    event.preventDefault();
+    if (!name.trim() || !preview) return;
+    setSaving(true);
+    setError('');
+    const created = await createBoardFrom({
+      sourceBoardId: board.id,
+      name: name.trim(),
+      ...(board.category ? { category: board.category } : {}),
+      nodeIds: [...selected],
+      includeReadme,
+      includeStructure,
+    });
+    setSaving(false);
+    if (!created) return setError('Could not create the board. Try a different name.');
+    if (openAfter) await openBoard(created.id);
+    onClose();
+  };
+
+  return (
+    <div class="text-prompt-backdrop" onMouseDown={onClose}>
+      <div
+        ref={dialogRef}
+        class="text-prompt board-copy-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby="board-copy-title"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <form onSubmit={submit}>
+          <h2 id="board-copy-title">Create from {board.name}</h2>
+          <label class="board-copy-field">
+            Board name
+            <input
+              ref={nameRef}
+              class="text-prompt-input"
+              value={name}
+              onInput={(e) => setName(e.currentTarget.value)}
+            />
+          </label>
+          {!preview && !error && (
+            <div class="board-copy-status" role="status">
+              Loading reusable cards…
+            </div>
+          )}
+          {error && (
+            <div class="board-copy-error" role="alert">
+              {error}
+            </div>
+          )}
+          {preview && (
+            <fieldset class="board-copy-cards">
+              <legend>Cards to copy</legend>
+              {preview.cards.filter((card) => card.reusable).length === 0 ? (
+                <div class="board-copy-status">No reusable cards on this board.</div>
+              ) : (
+                preview.cards
+                  .filter((card) => card.reusable)
+                  .map((card) => (
+                    <label class="board-copy-card" key={card.id}>
+                      <input
+                        type="checkbox"
+                        checked={selected.has(card.id)}
+                        onChange={(e) => {
+                          const next = new Set(selected);
+                          e.currentTarget.checked ? next.add(card.id) : next.delete(card.id);
+                          setSelected(next);
+                        }}
+                      />
+                      <span>
+                        <strong>{card.title || 'Untitled card'}</strong>
+                        <small>{card.type}</small>
+                      </span>
+                    </label>
+                  ))
+              )}
+            </fieldset>
+          )}
+          <div class="board-copy-options">
+            <label>
+              <input
+                type="checkbox"
+                checked={includeStructure}
+                onChange={(e) => setIncludeStructure(e.currentTarget.checked)}
+              />{' '}
+              Preserve groups and connections
+            </label>
+            <label>
+              <input
+                type="checkbox"
+                checked={includeReadme}
+                disabled={!preview?.readmeNodeId}
+                onChange={(e) => setIncludeReadme(e.currentTarget.checked)}
+              />{' '}
+              Include README
+            </label>
+            <label>
+              <input type="checkbox" checked={openAfter} onChange={(e) => setOpenAfter(e.currentTarget.checked)} /> Open
+              the new board after creating
+            </label>
+          </div>
+          <p class="board-copy-note">
+            Only selected cards and structure are copied. Asks, history, and context pins start clear.
+          </p>
+          <div class="text-prompt-actions">
+            <button type="button" onClick={onClose}>
+              Cancel
+            </button>
+            <button type="submit" disabled={!preview || !name.trim() || saving}>
+              {saving ? 'Creating…' : 'Create board'}
+            </button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}