agentbox-app 0.1.11 → 0.1.13

package/main/corner-tag.mjs

@@ -0,0 +1,489 @@
+// THE CORNER TAG'S WINDOWS (w-dafae58a23). shared/corner-tag.mjs decides what
+// it says, when it shows and where it sits; this file is the live half: the
+// tag's own small window, the list that opens beside it, the screens they sit
+// on, and her choices about them.
+//
+// What the windows have to get right, each learned from the drawings, from
+// real-Electron runs, from four reviews by Codex, and from real mouse events
+// posted at the real windows (2026-10-08), which is where the last three of
+// these were found:
+//
+// - A PRESS ON THE TAG MUST NOT BRING THE APP FORWARD. It did, on every
+//   floating-window setting tried: macOS makes the app active on a press, and
+//   a window that may not take focus hands it to the app's main window, which
+//   comes to the front. So the tag and its list MAY take focus. A press makes
+//   the tag the active window and the app's window stays exactly where it was.
+// - EACH WINDOW IS EXACTLY ITS PILL OR ITS LIST. The first version padded the
+//   windows for a drawn shadow and let clicks fall through the padding, and
+//   switching that on and off under the pointer told the page the pointer had
+//   left, so a real first click fell straight through to the app beneath.
+//   With no margin there is nothing to fall through. The page draws the
+//   glass, its small corners and its edge. The window has no system shadow:
+//   with one, macOS also drew its own window outline (a black hairline and a
+//   light band) around the glass, a strong border no picture had shown.
+// - A DRAG FOLLOWS THE REAL CURSOR. The page only says when the button went
+//   down and up; between the two, this process reads the cursor itself, so a
+//   drag never depends on the page being sent every move.
+// - POINTING OPENS THE LIST, A CLICK OPENS THE APP (her ask, 2026-10-08: with
+//   16 waiting she wants to go straight in, not click through the list). The
+//   pointer has to rest on the tag a moment, so passing over the corner opens
+//   nothing, and after a drag it has to leave and come back. The list is in
+//   its own window so the tag never moves. Off both for a moment and it shuts.
+// - IT SHOWS OVER FULL-SCREEN APPS, IT HIDES FOR A WHILE AND COMES BACK, it is
+//   off for good only in Settings, it steps aside while she is in the app, and
+//   it goes when the app's window goes.
+//
+// What the tag counts is not decided here. Only the page knows what the inbox
+// is, so it hands over what is ready and how many are working on
+// `zero:corner-tag`; shared/corner-tag.mjs puts it newest first.
+
+import { cardPlacement, hiddenUntil, keepCorner, readyNow, restingSpot, tagShows, HIDE_CHOICES } from '../shared/corner-tag.mjs';
+
+// How long the pointer may be off both the tag and its list before the list
+// shuts: long enough to cross the gap between them, short enough to feel like
+// it follows the pointer.
+export const CLOSE_AFTER_MS = 450;
+// How long the pointer rests on the tag before the list opens: long enough
+// that crossing the corner on the way to something else opens nothing.
+export const OPEN_AFTER_MS = 220;
+// Far enough that a click with a shaky hand is still a click.
+export const DRAG_FROM_PX = 6;
+// How often a drag reads the cursor: once a frame.
+const FRAME_MS = 16;
+// A press whose release never came is let go after this long.
+const PRESS_GIVES_UP_MS = 60_000;
+
+const HIDE_LABELS = { '5m': 'Hide for 5 minutes', '30m': 'Hide for 30 minutes', today: 'Hide for the rest of today' };
+const CHANNELS = [
+  'zero:corner-tag', 'corner-tag:ready', 'corner-tag:size', 'corner-tag:hover', 'corner-tag:toggle',
+  'corner-tag:press', 'corner-tag:release', 'corner-tag:go', 'corner-tag:hide', 'corner-tag:settings', 'corner-tag:menu',
+];
+
+export function createCornerTag({
+  BrowserWindow, screen, ipcMain, Menu, powerMonitor, config, saveConfig, mainWindow, load, preload,
+  now = () => Date.now(), setTimer = setTimeout, clearTimer = clearTimeout, mac = process.platform === 'darwin',
+}) {
+  const wins = { tag: null, card: null };
+  const loaded = { tag: false, card: false };
+  const hovered = { tag: false, card: false };
+  let ready = [];
+  let working = 0;
+  // The tag's rectangle on screen; its window is exactly this.
+  let tag = null;
+  let tagSize = { width: 96, height: 26 };
+  let measured = false;
+  let cardSize = null;
+  let open = false;
+  // A press on the tag: where the cursor and the tag were when it went down,
+  // and whether it has moved far enough to be a drag.
+  let press = null;
+  let wake = null;
+  let closing = null;
+  let watching = null;
+  let opening = null;
+  // After a drag the pointer is still on the tag; the list waits for it to
+  // leave and come back rather than opening under it.
+  let settling = false;
+  let gone = false;
+
+  const fresh = () => readyNow(ready, now());
+  const areas = () => screen.getAllDisplays().map((d) => d.workArea);
+  const areaOf = (r) => screen.getDisplayMatching({ x: Math.round(r.x), y: Math.round(r.y), width: Math.max(1, Math.round(r.width)), height: Math.max(1, Math.round(r.height)) }).workArea;
+  const inApp = () => {
+    try { return !!mainWindow && !mainWindow.isDestroyed() && mainWindow.isFocused(); } catch { return false; }
+  };
+  const alive = (part) => !!wins[part] && !wins[part].isDestroyed();
+  const rounded = (r) => ({ x: Math.round(r.x), y: Math.round(r.y), width: Math.round(r.width), height: Math.round(r.height) });
+  const send = (part, channel, payload) => { if (alive(part) && loaded[part]) wins[part].webContents.send(channel, payload); };
+  const sendState = () => {
+    const s = { ready: fresh(), working, now: now(), open };
+    send('tag', 'corner-tag:state', s);
+    send('card', 'corner-tag:state', s);
+  };
+  const shouldShow = () => tagShows({
+    on: config.cornerTag, hiddenUntil: config.cornerTagHiddenUntil ?? 0, now: now(), inApp: inApp(), ready: fresh().length, working,
+  });
+  // The list may only appear beside a tag that is on screen and should be.
+  // A click that was on its way while the tag hid must not open it alone.
+  const tagUp = () => !gone && alive('tag') && wins.tag.isVisible() && shouldShow();
+
+  const placeTag = () => {
+    const spot = restingSpot(tag ? { x: tag.x, y: tag.y } : config.cornerTagSpot ?? null, tagSize, areas());
+    tag = { ...spot, ...tagSize };
+    if (alive('tag')) wins.tag.setBounds(rounded(tag));
+  };
+
+  const placeCard = () => {
+    if (!tag || !cardSize || !alive('card')) return;
+    wins.card.setBounds(rounded(cardPlacement(tag, cardSize, areaOf(tag)).card));
+  };
+
+  const make = (part) => {
+    const win = new BrowserWindow({
+      show: false,
+      frame: false,
+      transparent: true,
+      backgroundColor: '#00000000',
+      // Clear and unrounded: the page draws the glass and its small corners.
+      // The system's frosted material would blur what is behind, but it comes
+      // only with the system's own rounder corners or square ones, and the
+      // approved tag has neither.
+      roundedCorners: false,
+      hasShadow: false,
+      resizable: false,
+      movable: false,
+      minimizable: false,
+      maximizable: false,
+      fullscreenable: false,
+      skipTaskbar: true,
+      // May take focus, so a press never hands it to the app's main window.
+      focusable: true,
+      // The first click on a window that is not active still counts.
+      acceptFirstMouse: true,
+      alwaysOnTop: true,
+      // A panel floats over full-screen apps without turning the whole app
+      // into a background app, which would take the dock icon away.
+      ...(mac ? { type: 'panel' } : {}),
+      webPreferences: { preload, contextIsolation: true, nodeIntegration: false, sandbox: true },
+    });
+    win.setAlwaysOnTop(true, 'floating');
+    try { win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true, skipTransformProcessType: true }); } catch {}
+    win.on('closed', () => { wins[part] = null; loaded[part] = false; });
+    // A reload starts the handshake again: the window goes, anything half
+    // done with it is let go, and until the page says it is ready nothing is
+    // sent to it and it is not shown. The first load is not a reload.
+    win.webContents.on('did-start-loading', () => {
+      if (!loaded[part]) return;
+      loaded[part] = false;
+      hovered[part] = false;
+      if (part === 'tag') { endPress(true); if (win.isVisible()) win.hide(); }
+      closeCard();
+    });
+    wins[part] = win;
+    if (part === 'tag') placeTag();
+    load(win, part);
+    return win;
+  };
+
+  const cancelClose = () => { if (closing) { clearTimer(closing); closing = null; } };
+
+  function closeCard() {
+    cancelClose();
+    open = false;
+    hovered.card = false;
+    if (alive('card') && wins.card.isVisible()) wins.card.hide();
+    send('tag', 'corner-tag:open', false);
+  }
+
+  const showCard = () => {
+    if (open && tagUp() && loaded.card && cardSize && alive('card') && !wins.card.isVisible()) wins.card.showInactive();
+  };
+
+  function openCard() {
+    if (!tag || press?.moved || !tagUp()) return;
+    open = true;
+    send('tag', 'corner-tag:open', true);
+    watch();
+    reconsider();
+    if (!alive('card')) { make('card'); return; }
+    sendState();
+    placeCard();
+    showCard();
+  }
+
+  /* --------------------- where the pointer really is ---------------------- */
+  // The page says when the pointer comes and goes, and that is trusted, but a
+  // boundary event can go missing, so while the list is open the real cursor
+  // is read a few times a second and wins. Nothing is read otherwise.
+  const within = (pt, r) => !!r && pt.x >= r.x && pt.x < r.x + r.width && pt.y >= r.y && pt.y < r.y + r.height;
+  const drawn = (part) => (alive(part) && wins[part].isVisible() ? wins[part].getBounds() : null);
+  const readCursor = () => {
+    const pt = screen.getCursorScreenPoint?.();
+    if (!pt || press) return false;
+    for (const part of ['tag', 'card']) hovered[part] = within(pt, drawn(part));
+    return true;
+  };
+
+  function watch() {
+    if (watching || gone) return;
+    const tick = () => {
+      watching = null;
+      if (gone) return;
+      readCursor();
+      reconsider();
+      if (open || hovered.tag || hovered.card) watching = setTimer(tick, 200);
+    };
+    watching = setTimer(tick, 200);
+  }
+
+  // Whether the open list should start, keep or drop its countdown to shutting.
+  function reconsider() {
+    if (!open || hovered.tag || hovered.card) { cancelClose(); return; }
+    if (closing) return;
+    closing = setTimer(() => {
+      closing = null;
+      // The last word is the real cursor's: a pointer that came back without
+      // the page noticing keeps the list open.
+      readCursor();
+      if (!hovered.tag && !hovered.card) closeCard();
+      else watch();
+    }, CLOSE_AFTER_MS);
+  }
+
+  const cancelOpen = () => { if (opening) { clearTimer(opening); opening = null; } };
+
+  // The pointer came onto the tag: open the list if it is still there in a
+  // moment. The real cursor has the last word, as it does for shutting.
+  function meanToOpen() {
+    if (open || opening || settling || press) return;
+    opening = setTimer(() => {
+      opening = null;
+      readCursor();
+      if (hovered.tag && !settling && !press) openCard();
+    }, OPEN_AFTER_MS);
+  }
+
+  /* ------------------------------- the press ------------------------------ */
+  // Where the cursor is now, against where it was when the button went down.
+  const follow = () => {
+    const pt = screen.getCursorScreenPoint?.();
+    if (!pt || !press) return;
+    const dx = pt.x - press.start.x;
+    const dy = pt.y - press.start.y;
+    if (!press.moved && Math.hypot(dx, dy) >= DRAG_FROM_PX) {
+      press.moved = true;
+      cancelOpen();
+      settling = true;
+      closeCard();
+      send('tag', 'corner-tag:dragging', true);
+    }
+    if (press.moved && alive('tag')) {
+      tag = { ...tag, x: press.from.x + dx, y: press.from.y + dy };
+      wins.tag.setPosition(Math.round(tag.x), Math.round(tag.y));
+    }
+  };
+
+  function step() {
+    if (!press || gone) return;
+    press.timer = null;
+    follow();
+    if (now() - press.at > PRESS_GIVES_UP_MS) { endPress(true); return; }
+    press.timer = setTimer(step, FRAME_MS);
+  }
+
+  // The button came up (or the press was taken away). A drag lands where the
+  // cursor left it and is remembered; a press that never moved is a click.
+  function endPress(cancelled) {
+    if (!press) return;
+    if (press.timer) clearTimer(press.timer);
+    press.timer = null;
+    const p = press;
+    if (!cancelled) follow();
+    press = null;
+    if (p.moved) {
+      tag = { ...restingSpot({ x: tag.x, y: tag.y }, tagSize, areas()), ...tagSize };
+      if (alive('tag')) wins.tag.setBounds(rounded(tag));
+      saveConfig(config, { cornerTagSpot: { x: Math.round(tag.x), y: Math.round(tag.y) } });
+      send('tag', 'corner-tag:dragging', false);
+    } else if (!cancelled) {
+      cancelOpen();
+      goTo(null);
+    }
+  }
+
+  // Everything that is not on screen is back where it starts: the list shut,
+  // no press half-done, so the tag comes back exactly as it was first drawn.
+  const reset = () => {
+    endPress(true);
+    cancelOpen();
+    settling = false;
+    closeCard();
+    hovered.tag = false;
+    send('tag', 'corner-tag:reset', null);
+    if (alive('tag') && tag) wins.tag.setBounds(rounded(tag));
+  };
+
+  function refresh() {
+    if (gone) return;
+    if (wake) { clearTimer(wake); wake = null; }
+    const until = config.cornerTagHiddenUntil ?? 0;
+    // A hide comes back by itself the moment it runs out.
+    if (until > now()) wake = setTimer(refresh, until - now() + 50);
+    if (!shouldShow()) {
+      if (alive('tag') && wins.tag.isVisible()) { wins.tag.hide(); reset(); }
+      else if (open) closeCard();
+      return;
+    }
+    if (!alive('tag')) { make('tag'); return; }
+    sendState();
+    if (loaded.tag && !wins.tag.isVisible()) wins.tag.showInactive();
+  }
+
+  const bringAppForward = () => {
+    if (!mainWindow || mainWindow.isDestroyed()) return false;
+    if (mainWindow.isMinimized()) mainWindow.restore();
+    mainWindow.show();
+    mainWindow.focus();
+    return true;
+  };
+
+  // Into the app: on a thread when a line of the list was picked, or just the
+  // app as it is when it was the tag.
+  function goTo(id) {
+    closeCard();
+    if (!bringAppForward()) return;
+    if (typeof id === 'string' && id) mainWindow.webContents.send('zero:open-item', { id });
+  }
+
+  const hide = (choice) => {
+    const until = hiddenUntil(choice, now());
+    if (!until) return;
+    saveConfig(config, { cornerTagHiddenUntil: until });
+    refresh();
+  };
+
+  const openSettings = () => {
+    closeCard();
+    if (bringAppForward()) mainWindow.webContents.send('zero:open-settings', { pane: 'general' });
+  };
+
+  const partOf = (p) => (p?.part === 'card' ? 'card' : 'tag');
+
+  /* ------------------------------ from the app's page ---------------------- */
+  ipcMain.handle('zero:corner-tag', (_e, state) => {
+    ready = Array.isArray(state?.ready) ? state.ready : [];
+    working = Number.isFinite(state?.working) ? state.working : 0;
+    refresh();
+    return null;
+  });
+
+  /* ------------------------------ from the tag's pages --------------------- */
+  ipcMain.handle('corner-tag:ready', (_e, p) => {
+    const part = partOf(p);
+    loaded[part] = true;
+    sendState();
+    if (part === 'tag') refresh();
+    else if (open) { placeCard(); showCard(); }
+    return null;
+  });
+
+  ipcMain.handle('corner-tag:size', (_e, p) => {
+    if (!p || !(p.width > 0) || !(p.height > 0)) return null;
+    const size = { width: Math.ceil(p.width), height: Math.ceil(p.height) };
+    if (partOf(p) === 'card') {
+      cardSize = size;
+      if (open) { placeCard(); showCard(); }
+      return null;
+    }
+    tagSize = size;
+    // Nothing moves under the pointer while it is dragging.
+    if (press?.moved) return null;
+    // The first measure places it where she left it. Every one after keeps
+    // the edge nearest its corner still as the words change length.
+    tag = tag && measured ? keepCorner(tag, tagSize, areaOf(tag)) : null;
+    measured = true;
+    placeTag();
+    if (open) placeCard();
+    return null;
+  });
+
+  ipcMain.handle('corner-tag:hover', (_e, p) => {
+    const part = partOf(p);
+    hovered[part] = !!p?.inside;
+    if (part === 'tag') {
+      if (p?.inside) meanToOpen();
+      else { settling = false; cancelOpen(); }
+    }
+    reconsider();
+    if (p?.inside) watch();
+    return null;
+  });
+
+  ipcMain.handle('corner-tag:toggle', () => {
+    if (open) closeCard(); else openCard();
+    return null;
+  });
+
+  // `at` is where the button went down, from the page. The message can arrive
+  // after the cursor has already moved, and starting from the cursor then put
+  // the tag about 30 px off under it. A press on a tag that has since hidden
+  // starts nothing.
+  ipcMain.handle('corner-tag:press', (_e, at) => {
+    const pt = Number.isFinite(at?.x) && Number.isFinite(at?.y) ? { x: at.x, y: at.y } : screen.getCursorScreenPoint?.();
+    if (!pt || !tag || !tagUp() || press) return null;
+    press = { start: pt, from: { x: tag.x, y: tag.y }, moved: false, at: now(), timer: null };
+    press.timer = setTimer(step, FRAME_MS);
+    return null;
+  });
+  ipcMain.handle('corner-tag:release', (_e, p) => { endPress(!!p?.cancelled); return null; });
+
+  ipcMain.handle('corner-tag:go', (_e, id) => { goTo(id); return null; });
+  ipcMain.handle('corner-tag:hide', (_e, choice) => { hide(choice); return null; });
+  ipcMain.handle('corner-tag:settings', () => { openSettings(); return null; });
+
+  // A right-click on the tag offers the same choices as the list does.
+  ipcMain.handle('corner-tag:menu', () => {
+    if (!alive('tag')) return null;
+    closeCard();
+    Menu.buildFromTemplate([
+      ...HIDE_CHOICES.map((c) => ({ label: HIDE_LABELS[c.key], click: () => hide(c.key) })),
+      { type: 'separator' },
+      { label: 'Turn off in Settings…', click: openSettings },
+    ]).popup({ window: wins.tag });
+    return null;
+  });
+
+  /* ------------------------------ from the system -------------------------- */
+  // A screen that comes, goes or changes shape: the list shuts and the tag is
+  // pulled back onto a screen if it was left hanging off one.
+  const reseat = () => {
+    if (gone) return;
+    closeCard();
+    if (!tag || press) return;
+    tag = { ...restingSpot({ x: tag.x, y: tag.y }, tagSize, areas()), ...tagSize };
+    if (alive('tag')) wins.tag.setBounds(rounded(tag));
+  };
+  // After sleep the screens may have changed and a hide may have run out.
+  const woke = () => { reseat(); refresh(); };
+
+  const onFocus = () => refresh();
+  // The app's window is gone, and the tag goes with it. Left behind, it would
+  // hold the app open with nothing behind it and nothing it could open.
+  const dispose = () => {
+    if (gone) return;
+    gone = true;
+    endPress(true);
+    cancelClose();
+    if (wake) { clearTimer(wake); wake = null; }
+    if (watching) { clearTimer(watching); watching = null; }
+    cancelOpen();
+    for (const part of ['tag', 'card']) if (alive(part)) wins[part].destroy();
+    for (const ch of CHANNELS) { try { ipcMain.removeHandler?.(ch); } catch {} }
+    try {
+      screen.removeListener?.('display-added', reseat);
+      screen.removeListener?.('display-removed', reseat);
+      screen.removeListener?.('display-metrics-changed', reseat);
+      powerMonitor?.removeListener?.('resume', woke);
+      powerMonitor?.removeListener?.('unlock-screen', woke);
+    } catch {}
+  };
+
+  if (mainWindow) {
+    mainWindow.on('focus', onFocus);
+    mainWindow.on('blur', onFocus);
+    mainWindow.on('closed', dispose);
+  }
+  try {
+    screen.on('display-added', reseat);
+    screen.on('display-removed', reseat);
+    screen.on('display-metrics-changed', reseat);
+  } catch {}
+  try { powerMonitor?.on?.('resume', woke); powerMonitor?.on?.('unlock-screen', woke); } catch {}
+
+  return {
+    refresh,
+    dispose,
+    // Tests, and nothing else.
+    _state: () => ({ ready: fresh(), working, tag, open, visible: alive('tag') && wins.tag.isVisible() }),
+  };
+}

package/main/crash-report.mjs

@@ -63,15 +63,38 @@ export function report(kind, err, extra = {}) {
   return write(payload);
 }
 
+// THE ONE KIND WHOSE PROCESS DOES NOT SURVIVE BEING REPORTED. `onUncaught`
+// re-throws, by the decision three lines below where it does it, so the main
+// process stops. posthog-node's `capture` only buffers (flushAt 20,
+// flushInterval 10s), and the `will-quit` flush never runs for a process that
+// died, so for this kind the file on disk is the only copy that can reach
+// anybody. It is therefore kept even when the live send said it took the
+// report: one report counted twice is a worse number, and no report at all is
+// a worse app.
+const DIES_REPORTING = new Set(['main-uncaught']);
+
 function write(payload) {
   try {
     fs.mkdirSync(ctx.dir, { recursive: true });
     const file = path.join(ctx.dir, `crash-${payload.ts.replace(/[:.]/g, '-')}-${Math.floor(Math.random() * 1e6)}.json`);
     fs.writeFileSync(file, JSON.stringify(payload, null, 2));
     prune();
-    // No await, no retry, no queue drain here: this runs while the process is
-    // dying. Delivery is the transport's problem, on the next boot if it has to be.
-    if (transport) { try { transport(payload); } catch {} }
+    // ON DISK FIRST, ALWAYS, because this can run while the process is dying
+    // and there is no time to wait on a socket. No await, no retry.
+    //
+    // AND THEN TAKEN BACK OFF IT IF IT WENT. The queue is for a report nobody
+    // has sent yet; a report that HAS been sent and stays in it is sent a
+    // second time by the next launch's `drainCrashes`, which is 6 of the 21
+    // crash events since the Oct 6 launch being 6 crashes counted twice, and
+    // three of them filed against the version that drained them rather than
+    // the one they happened on (PostHog, 2026-10-08).
+    if (transport) {
+      let took = false;
+      try { took = transport(payload) !== false; } catch { took = false; }
+      if (took && !DIES_REPORTING.has(payload.kind)) {
+        try { fs.unlinkSync(file); } catch {}
+      }
+    }
     return file;
   } catch { return null; }
 }

package/main/demo.mjs

@@ -34,9 +34,8 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { DEMO_DOCS, DEMO_ENV, DEMO_PRODUCTS, demoLedgerLines } from '../shared/demo-world.mjs';
 import { prepareHome } from '../shared/fresh-user-home.mjs';
-import { Name } from '../shared/product-name.mjs';
 import { relaunchCommand } from './fresh-user.mjs';
-import { encodeProjectPath, storeRootEnv } from './store/home.mjs';
+import { defaultStoreRoot, encodeProjectPath, storeRootEnv } from './store/home.mjs';
 import { NAME, nameSlug } from '../shared/product-name.mjs';
 
 /**
@@ -87,22 +86,21 @@ export function clearDemoHomes() {
 /**
  * Where the demo copy will keep its store, and where it will keep its own
  *  records. Both are derived from the throwaway home rather than configured,
- *  because the copy derives them the same way from the same home: `storeRoot`
- *  defaults to `<home>/<Name>` (main/config.mjs) and the app's home defaults
- *  to `<home>/.agentbox` (main/store/home.mjs).
+ *  because the copy derives them the same way from the same home. Both are
+ *  `defaultStoreRoot` for that home with no inherited data directory: on
+ *  macOS a folder of the app's name, on Linux the XDG path under the
+ *  throwaway. Passing the machine's XDG_DATA_HOME would seed the demo into
+ *  the real store.
  *
- *  THE FOLDER IS READ FROM THE SAME CONSTANT AS THAT DEFAULT, not spelled out
- *  again. It was the literal 'the app' mirroring what config.mjs then said,
- *  and when that default was renamed on 2026-09-22 this line went on pointing
- *  at the old folder: the demo copy would have written its store to one place
- *  and looked for it in another. Two literals that have to agree is the defect;
- *  one import is the fix. */
+ *  THE FOLDER IS THAT FUNCTION, not a second spelling of it. A literal next
+ *  to the default is how the demo once wrote its store in one place and
+ *  looked for it in another. */
 export function demoPaths(home) {
-  const storeRoot = path.join(home, Name);
+  const storeRoot = defaultStoreRoot({ home, env: {} });
   return {
     storeRoot,
     accountRoot: path.join(storeRoot, 'accounts', DEMO_ACCOUNT),
-    appHome: path.join(home, `.${nameSlug}`),
+    appHome: storeRoot,
   };
 }
 
@@ -192,7 +190,12 @@ export function seedDemoStore(home, { now = Date.now() } = {}) {
  *  standing in an invented store. */
 export function demoEnv(home, env = process.env) {
   const { appHome } = demoPaths(home);
-  return { ...env, HOME: home, CFFIXED_USER_HOME: home, ...storeRootEnv(appHome), [DEMO_ENV]: '1' };
+  const next = { ...env, HOME: home, CFFIXED_USER_HOME: home, ...storeRootEnv(appHome), [DEMO_ENV]: '1' };
+  // The copy's store is defaultStoreRoot of ITS home. The parent's
+  // XDG_DATA_HOME is the real data directory, and leaving it set points the
+  // demo at that directory. The other base directories go for the same reason.
+  for (const key of ['XDG_DATA_HOME', 'XDG_CONFIG_HOME', 'XDG_STATE_HOME', 'XDG_CACHE_HOME']) delete next[key];
+  return next;
 }
 
 /**