pindeck 3.0.0-beta.3 → 3.2.0-beta.1

package/server.mjs

@@ -10,16 +10,15 @@
    - answers `cli.mjs layout|shot|slides|pdf|pdf-figure` for the assistant's self-checks, exports and PDF figures
    - exports the deck as a PDF handout or a PDF presentation (build steps on separate pages)
    - stores figures and audio attached to chat messages in <deck>/figures/ for the assistant to use, and attached
-     PDFs (papers, reports, figures) in ~/.pindeck, outside the deck
+     PDFs (papers, reports, figures) in ~/.pindeck-v3, outside the deck
    - imports slides from PowerPoint files in the deck's own layouts
    Listens on 127.0.0.1 only; the editor, the deck and every API call need the per-run token (a login
    cookie in the browser, a header for the CLI).
-   Runtime files (chat, screenshots, backups) live in ~/.pindeck, never in the deck or the package. */
+   Runtime files (chat, screenshots, backups) live in ~/.pindeck-v3, never in the deck or the package. */
 
 import http from "node:http";
 import { EventEmitter } from "node:events";
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import crypto from "node:crypto";
 import { spawn, execFile } from "node:child_process";
@@ -29,9 +28,9 @@ import { unifiedDiff } from "./lib/diff.mjs";
 import { ClaudeSession } from "./lib/claude.mjs";
 import { CodexSession } from "./lib/codex.mjs";
 import { createDeckTools } from "./lib/agent-tools.mjs";
-import { migrateSettings, selectModel, handoverSummary, curateModels } from "./lib/models.mjs";
+import { PROVIDERS, migrateSettings, selectModel, handoverSummary, curateModels } from "./lib/models.mjs";
 import { formatLayout, formatPin } from "./lib/layout.mjs";
-import { printLayout, printPdf, PDF_HEAD_TAG, PDF_PAGE_TAG } from "./lib/pdf.mjs";
+import { printLayout, printPdf, chromeReason, ROOT_ARGS, PDF_HEAD_TAG, PDF_PAGE_TAG } from "./lib/pdf.mjs";
 import { readPptx } from "./lib/pptx.mjs";
 import { exportPdf as pptxToPdf, renderJobs, renderAvailable, pdfInfo } from "./lib/pptx-render.mjs";
 import { buildImport, planSlides } from "./lib/pptx-import.mjs";
@@ -39,19 +38,17 @@ import { isSupportedPlatform, detectCapabilities, publicCapabilities, capability
 import { unsupportedMessage } from "./lib/frameworks.mjs";
 import { readInstructions } from "./lib/instructions.mjs";
 import { writeAtomic, sameContent, revision, scanFiles, scanChanges } from "./lib/deck-files.mjs";
+import { deckTarget, homeDir, homeWarning } from "./lib/deck-target.mjs";
+import { listDecks, linkProblem } from "./lib/deck-list.mjs";
+import { assetRoots } from "./lib/asset-roots.mjs";
+import { registerServer, printLogin, alive } from "./lib/servers.mjs";
+import { goodHost, LOGIN_PAGE, createLogin, openOnEnter } from "./lib/login.mjs";
+import { USAGE } from "./lib/usage.mjs";
 
 /* ---- Config ------------------------------------------------------------------ */
-const USAGE = `Usage: pindeck [deck-folder | deck-file.html] [--port 5180] [--provider claude|codex] [--model <name>] [--asset-root <folder>]...
-       pindeck login [deck-folder | deck-file.html]
-
-Opens a reveal.js deck in PinDeck: a deck file such as talk.html, or a folder (default: the current
-folder), which then opens its index.html. A deck made otherwise names its slides in its <head> with
-<meta name="pindeck:slides" content="<CSS selector>"> and <meta name="pindeck:size" content="1440x1080">.
-login prints a new one-time login link for the PinDeck running for that deck
-(without a deck: for the PinDeck started last).
---asset-root lets the deck use files outside its folder: a folder that contains the deck (paths such as
-../shared/style.css then work), or one that symlinks in the deck may point to. Repeatable; also
-"assetRoots" in ~/.pindeck-v3/config.json.`;
+/* Started by the front (pindeck, front.mjs) for one of the decks it serves: the front logs browsers in and
+   prints the links; this server tells it its address over IPC. */
+const FRONT = !!process.env.PINDECK_FRONT && !!process.send;
 const EDITOR_DIR = path.dirname(fileURLToPath(import.meta.url));
 const argv = process.argv.slice(2);
 if (argv.includes("--help") || argv.includes("-h")) { console.log(USAGE); process.exit(0); }
@@ -70,42 +67,26 @@ const LOGIN = argv[0] === "login";
 if (LOGIN) argv.shift();
 const PROVIDER = opt("--provider", "");
 const MODEL = opt("--model", "");
-/* The deck: a file (talk.html), or a folder, which means its index.html. A path ending in .html or .htm
-   that is not a folder is a file, so a missing file gets a clear message. */
-const TARGET = path.resolve(argv[0] || process.cwd());
-const isFolder = (() => { try { return fs.statSync(TARGET).isDirectory(); } catch { return false; } })();
-const DECK_DIR = isFolder || !/\.html?$/i.test(TARGET) ? TARGET : path.dirname(TARGET);
-const DECK_FILE = DECK_DIR === TARGET ? "index.html" : path.basename(TARGET);
-const NAMED = DECK_FILE !== "index.html";             // a deck file with its own name; several can share a folder
-const DECK_NAME = NAMED ? DECK_FILE.replace(/\.html?$/i, "") : path.basename(DECK_DIR);   // for exports and titles
+if (process.env.CLAUDE_MODEL && !LOGIN && !FRONT)   // PinDeck 2 read it; behind the front, the front says so
+  console.warn(`CLAUDE_MODEL is not used by PinDeck 3: choose the model in the editor's model menu, or start with --model ${process.env.CLAUDE_MODEL}.`);
+/* The deck: a file (talk.html), or a folder, which means its index.html (see lib/deck-target.mjs) */
+const { dir: DECK_DIR, file: DECK_FILE, named: NAMED, name: DECK_NAME, key: deckKey } = deckTarget(argv[0] || process.cwd());
 const EDITABLE = [DECK_FILE, "theme.css"];         // both backends may edit these
 const LOCKED = ["brand.css"];                      // never, enforced twice
-const HOME_DIR = process.env.PINDECK_HOME || path.join(os.homedir(), ".pindeck-v3");
-/* State per deck file. A folder's index.html keeps the key it always had, so existing chats and undo
-   histories stay; a named file gets its own, so two decks in one folder never share chat or undo. */
-const deckKey = (NAMED ? `${path.basename(DECK_DIR)}-${DECK_NAME}` : path.basename(DECK_DIR)).replace(/[^\w.-]+/g, "_") + "-" +
-  crypto.createHash("sha1").update(NAMED ? path.join(DECK_DIR, DECK_FILE) : DECK_DIR).digest("hex").slice(0, 8);
+const HOME_DIR = homeDir();
 const STATE_DIR = path.join(HOME_DIR, "decks", deckKey);
 const SHOT_DIR = path.join(STATE_DIR, "shots");
+const SHOT_NAME = /^[\w-][\w.-]*\.png$/;   // a file name in SHOT_DIR, as the editor may ask for it
 const PDF_DIR = path.join(STATE_DIR, "attachments");   // attached PDFs: reading material, not part of the deck
-/* pindeck login: a new one-time login link from the running server, asked with the token in its server
-   file (readable only by this user) */
-if (LOGIN) {
-  const files = [path.join(STATE_DIR, "server.json"), ...(argv[0] ? [] : [path.join(HOME_DIR, "server.json")])];
-  let info = null;
-  for (const f of files) { try { info = JSON.parse(fs.readFileSync(f, "utf8")); break; } catch {} }
-  if (!info) { console.error(`No PinDeck is running${argv[0] ? ` for ${DECK_DIR}` : ""}.`); process.exit(1); }
-  try {
-    const res = await fetch(`${info.url}/api/login-link`, { headers: { "x-editor-token": info.token } });
-    if (!res.ok) throw new Error(res.status);
-    console.log(`PinDeck (${info.deckDir}): ${(await res.json()).url}`);
-    process.exit(0);
-  } catch {
-    console.error(`The PinDeck for ${info.deckDir} at ${info.url} does not answer. Is it still running?`);
-    process.exit(1);
-  }
-}
+/* pindeck login: a new one-time login link from the PinDeck that serves the deck (see lib/servers.mjs) */
+if (LOGIN) await printLogin(HOME_DIR, argv[0] ? deckTarget(argv[0]) : null);
 const TOKEN = crypto.randomBytes(16).toString("hex");
+/* The deck's pages are untrusted content: a deck (or a template, or a script the assistant wrote) must not
+   reach the API, the chat or other decks. They are served with a sandbox policy, which gives them an origin
+   of their own (no cookie, no token, no access to the editor page), under /v/<VIEW_TOKEN>/: a path that
+   lets them load their own files, and nothing else. */
+const VIEW = `/v/${crypto.randomBytes(16).toString("hex")}`;
+const SANDBOX = "sandbox allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-modals allow-downloads allow-presentation";
 let ORIGIN = `http://127.0.0.1:${PORT}`;   // set again from the bound port once listening
 const CLI_REL = path.relative(DECK_DIR, path.join(EDITOR_DIR, "cli.mjs")).split(path.sep).join("/");
 const CLI_CMD = cliCommand(CLI_REL);
@@ -115,6 +96,8 @@ const CAPS = detectCapabilities();
 function checkDeck() {
   const file = path.join(DECK_DIR, DECK_FILE);
   if (!fs.existsSync(file)) return `No ${DECK_FILE} in ${DECK_DIR}`;
+  const linked = linkProblem(DECK_DIR, DECK_FILE);
+  if (linked) return linked + " Nothing was changed.";
   try { fs.accessSync(file, fs.constants.R_OK | fs.constants.W_OK); }
   catch { return `${file} cannot be read and written (check its permissions).`; }
   // saving replaces the file through a temporary file next to it, so the folder must be writable too
@@ -122,6 +105,8 @@ function checkDeck() {
   catch { return `${DECK_DIR} is not writable: PinDeck saves the deck through a temporary file in that folder.`; }
   return null;
 }
+const homeNote = !FRONT && homeWarning(HOME_DIR);   // behind the front, the front says it
+if (homeNote) console.warn(homeNote);
 const deckProblem = checkDeck();
 if (deckProblem) {
   console.error(`${deckProblem}\n\n${USAGE}`);
@@ -129,27 +114,44 @@ if (deckProblem) {
 }
 // reveal.js, or a deck that names its slides: another framework's deck is left exactly as it is (no ids, no state)
 const deckAtStart = fs.readFileSync(path.join(DECK_DIR, DECK_FILE), "utf8");
+const ENDS_HTML = /<\/html>\s*$/i;
 const frameworkProblem = unsupportedMessage(deckAtStart, DECK_FILE);
 if (frameworkProblem) {
   console.error(frameworkProblem);
   process.exit(1);
 }
+/* One PinDeck per deck: two deck servers on one state folder would overwrite each other's chat and undo. The
+   one that has the deck open holds STATE_DIR/open.json; a second one says where the deck is open and stops,
+   before anything is written. */
+const LOCK_FILE = path.join(STATE_DIR, "open.json");
+const lockHolder = () => {
+  try { const o = JSON.parse(fs.readFileSync(LOCK_FILE, "utf8")); return o.pid !== process.pid && alive(o.pid) ? o : null; } catch { return null; }
+};
+const openElsewhere = (o) => `${path.join(DECK_DIR, DECK_FILE)} is open in another PinDeck already (${o.url}, process ${o.pid}). ` +
+  `Use that one, or stop it first: two PinDecks on one deck would overwrite each other's chat and undo.`;
+if (lockHolder()) { console.error(openElsewhere(lockHolder())); process.exit(1); }
 /* Runtime files hold the token, the chat and attachments: private to the user. Written only after the
-   port is bound (see Start), so a failed start leaves no state behind. */
-const SERVER_FILES = [path.join(STATE_DIR, "server.json"), path.join(HOME_DIR, "server.json")];   // the second: the CLI's fallback
+   port is bound (see Start), so a failed start leaves no state behind. The server file (lib/servers.mjs) lets
+   pindeck login and cli.mjs find this server; behind the front, login goes to the front (a deck server's port
+   is no use to a browser behind a tunnel), and the assistant's CLI gets this server's address. */
+let unregister = () => {};
 function writeServerInfo() {
   for (const d of [HOME_DIR, STATE_DIR, SHOT_DIR]) fs.mkdirSync(d, { recursive: true, mode: 0o700 });
-  const info = JSON.stringify({ url: ORIGIN, token: TOKEN, deckDir: DECK_DIR, pid: process.pid }, null, 2);
-  for (const f of SERVER_FILES) {
-    fs.writeFileSync(f, info, { mode: 0o600 });
-    fs.chmodSync(f, 0o600);
+  const lock = JSON.stringify({ pid: process.pid, url: process.env.PINDECK_FRONT_URL || ORIGIN });
+  try { fs.writeFileSync(LOCK_FILE, lock, { flag: "wx", mode: 0o600 }); }
+  catch (e) {
+    if (e.code !== "EEXIST") throw e;
+    const other = lockHolder();
+    if (other) throw Object.assign(new Error(openElsewhere(other)), { plain: true });
+    fs.writeFileSync(LOCK_FILE, lock, { mode: 0o600 });   // left by a PinDeck that is gone
   }
+  unregister = registerServer(HOME_DIR, { url: ORIGIN, token: TOKEN, key: deckKey, deckDir: DECK_DIR, deckFile: DECK_FILE,
+    ...(FRONT ? { behindFront: true } : {}) });
 }
-/* On exit: only our own server files, never those of a PinDeck started since for this or another deck. */
+/* On exit: only our own files, never those of a PinDeck started since for this or another deck. */
 function removeServerInfo() {
-  for (const f of SERVER_FILES) {
-    try { if (JSON.parse(fs.readFileSync(f, "utf8")).token === TOKEN) fs.rmSync(f, { force: true }); } catch {}
-  }
+  unregister();
+  try { if (JSON.parse(fs.readFileSync(LOCK_FILE, "utf8")).pid === process.pid) fs.rmSync(LOCK_FILE, { force: true }); } catch {}
 }
 
 /* ---- Small helpers --------------------------------------------------------------- */
@@ -182,9 +184,23 @@ function writeDeck(f, content, manual = false) {
   ourWrites.set(f, { hash: hash(content), manual });
   writeAtomic(path.join(DECK_DIR, f), content);
 }
+/* A file PinDeck itself writes or deletes in the deck folder (an upload, a picture, an export, a file Undo
+   brings back or removes) must be there once symlinks are followed: a figures/ or export/ that links
+   elsewhere is not written through, as serving refuses to read through it. */
+function deckPath(rel) {
+  const abs = path.join(DECK_DIR, rel);
+  let p = abs;
+  while (!fs.existsSync(p) && path.dirname(p) !== p) p = path.dirname(p);
+  const real = realOr(p), deck = realOr(DECK_DIR);
+  if (real !== deck && !real.startsWith(deck + path.sep))
+    throw Object.assign(new Error(`${rel} leads out of the deck folder (through a symlink): PinDeck does not write or delete there.`), { status: 409 });
+  return abs;
+}
+const removeDeckFile = (rel) => fs.rmSync(deckPath(rel), { force: true });
 /* Other files PinDeck writes into the deck (uploads, imported pictures, undo/redo of deleted files) */
 function writeDeckFile(rel, data, manual = true) {
-  const abs = path.join(DECK_DIR, rel);
+  const abs = deckPath(rel);
+  state.turn?.touched.add(rel);
   fs.mkdirSync(path.dirname(abs), { recursive: true });
   ourWrites.set(rel, { hash: hash(data.toString("utf8")), manual });   // manual: no slide reload for a new file
   writeAtomic(abs, data);
@@ -197,7 +213,7 @@ const isText = (v) => v == null || typeof v === "string" || !v.includes(0);
 const asText = (v) => (v == null ? "" : String(v));
 const isAs = (rel, v) => sameContent(path.join(DECK_DIR, rel), v ?? null);
 function putDeckFile(rel, v) {   // undo and redo: back to v (null: remove the file)
-  if (v == null) return fs.rmSync(path.join(DECK_DIR, rel), { force: true });
+  if (v == null) return removeDeckFile(rel);
   fs.mkdirSync(path.dirname(path.join(DECK_DIR, rel)), { recursive: true });
   writeDeck(rel, v);
 }
@@ -310,13 +326,13 @@ function sized(url, size) {
   u.searchParams.set("height", size.height);
   return u.href;
 }
-function chrome(args, done) {
+function chrome(args, done, signal) {
   if (!CHROME) return Promise.reject(new Error(`Screenshots are not available: ${CAPS.screenshot.reason}.`));
   return new Promise((resolve, reject) => {
     // a profile per run: concurrent runs must not share one
     const profile = path.join(STATE_DIR, "chrome", `p${process.pid}-${++chromeSeq}`);
     const { size } = deckSlides();
-    const proc = spawn(CHROME, ["--headless=new", "--disable-gpu", "--hide-scrollbars", "--no-first-run",
+    const proc = spawn(CHROME, ["--headless=new", "--disable-gpu", "--hide-scrollbars", "--no-first-run", ...ROOT_ARGS,
       "--no-default-browser-check", "--disable-extensions", "--mute-audio", `--user-data-dir=${profile}`,
       `--window-size=${size.width},${size.height}`, "--force-device-scale-factor=1", "--virtual-time-budget=5000",
       ...args.map((a) => a.startsWith(ORIGIN + "/") ? chromeStart(profile, sized(a, size)) : a)]);
@@ -334,17 +350,22 @@ function chrome(args, done) {
     proc.stderr.on("data", (d) => { err += d; check(); });
     proc.on("error", (e) => finish(reject, e));
     // "close", not "exit": at exit Chrome's last output (the line saying the file is written) may still be unread
-    proc.on("close", () => (done(out, err) ? finish(resolve, out) : finish(reject, new Error("Chrome exited without output."))));
+    proc.on("close", () => (done(out, err) ? finish(resolve, out)
+      : finish(reject, new Error(`Chrome exited without output${chromeReason(err) ? `: ${chromeReason(err)}` : "."}`))));
     const timer = setTimeout(() => finish(reject, new Error("Chrome timed out.")), 25000);
+    signal?.addEventListener("abort", () => finish(reject, new Error("Stopped.")), { once: true });
   });
 }
 const deckUrl = (mode, params = {}) =>
-  `${ORIGIN}${DECK_PAGE}?` + new URLSearchParams({ editor: mode, showHiddenSlides: "true", ...params });
-async function takeShot(slide) {
-  const pins = state.pins.filter((p) => p.slide.eid === slide.eid).map((p) => ({ n: p.n, eid: p.eid, at: p.at, point: p.point }));
+  `${ORIGIN}${VIEW}${DECK_PAGE}?` + new URLSearchParams({ editor: mode, showHiddenSlides: "true", ...params });
+/* A screenshot of a slide with the pins of a message on it: those the message carries when the user asks for
+   one, those of the latest message when the assistant does (cli.mjs shot). Never pins the editor no longer
+   shows, or another tab's. */
+async function takeShot(slide, pins = state.lastPins, signal) {
+  pins = pins.filter((p) => p.slide?.eid === slide.eid).map((p) => ({ n: p.n, eid: p.eid, at: p.at, point: p.point }));
   const out = path.join(SHOT_DIR, `${slide.eid.replace(/[^\w-]/g, "_")}-${Date.now()}.png`);
   await chrome([`--screenshot=${out}`, deckUrl("shot", { slide: slide.eid, pins: JSON.stringify(pins) })],
-    (_o, err) => /bytes written to file/.test(err) && fs.existsSync(out));
+    (_o, err) => /bytes written to file/.test(err) && fs.existsSync(out), signal);
   if (!fs.existsSync(out)) throw new Error("Chrome did not write the screenshot.");
   // keep the folder small
   const old = fs.readdirSync(SHOT_DIR).map((f) => path.join(SHOT_DIR, f))
@@ -388,19 +409,20 @@ function exportPdf(kind, includeHidden = false) {
   if (!CAPS.pdfExport.available) return Promise.reject(Object.assign(new Error(`PDF export is not available: ${CAPS.pdfExport.reason}.`), { status: 501 }));
   const split = kind === "presentation";
   const name = `${DECK_NAME}-${split ? "presentation" : "handout"}.pdf`;
-  const out = path.join(DECK_DIR, "export", name);
+  const out = path.join(DECK_DIR, "export", name);   // checked when the export runs (deckPath)
   const profile = (step) => path.join(STATE_DIR, "chrome", `pdf-${process.pid}-${Date.now()}-${step}`);
   const run = async () => {
+    deckPath(`export/${name}`);
     fs.mkdirSync(path.dirname(out), { recursive: true });
     const layoutProfile = profile("layout"), printProfile = profile("print");
     const html = await printLayout(CHROME, chromeStart(layoutProfile,
-      `${ORIGIN}${DECK_PAGE}?editor=pdf&print-pdf&pdfSeparateFragments=${split}&showHiddenSlides=${!!includeHidden}`), layoutProfile);
+      `${ORIGIN}${VIEW}${DECK_PAGE}?editor=pdf&print-pdf&pdfSeparateFragments=${split}&showHiddenSlides=${!!includeHidden}`), layoutProfile);
     const id = `${process.pid}-${++snapSeq}`;
     snapshots.set(id, html);
-    try { await printPdf(CHROME, chromeStart(printProfile, `${ORIGIN}${DECK_BASE}__pindeck-print-${id}.html`), out, printProfile); }
+    try { await printPdf(CHROME, chromeStart(printProfile, `${ORIGIN}${VIEW}${DECK_BASE}__pindeck-print-${id}.html`), out, printProfile); }
     finally { snapshots.delete(id); }
     return { kind: split ? "presentation" : "handout", path: out, rel: path.relative(DECK_DIR, out),
-      url: `/deck/export/${encodeURIComponent(name)}`, bytes: fs.statSync(out).size };
+      url: `deck/export/${encodeURIComponent(name)}`, bytes: fs.statSync(out).size };
   };
   const job = exportQueue.then(run, run);
   exportQueue = job.catch(() => {});
@@ -411,13 +433,15 @@ function exportPdf(kind, includeHidden = false) {
 const CHAT_FILE = path.join(STATE_DIR, "chat.json");
 const state = {
   chat: [], seq: 0, busy: false, model: MODEL || null, switching: false, preparing: null, sessionId: null, provider: "claude", handover: "", sessionArchive: [],
-  turns: [], redo: [], turn: null, notes: [], pins: [], current: null,
+  turns: [], redo: [], turn: null, notes: [], lastPins: [], current: null,
+  conversation: 1,   // counts the conversations of this run: a new chat or another provider starts the next
   uploads: new Set(),   // files uploaded for the next message; removable until it is sent
   pdfFigures: new Set(),   // figures/ files written by pdf-figure, which it may overwrite
 };
 try {
   const saved = JSON.parse(fs.readFileSync(CHAT_FILE, "utf8"));
-  Object.assign(state, { chat: saved.chat || [], seq: saved.seq || 0, sessionId: saved.sessionId || null, provider: saved.provider || "claude", handover: saved.handover || "", sessionArchive: saved.sessionArchive || [] });
+  Object.assign(state, { chat: saved.chat || [], seq: saved.seq || 0, sessionId: saved.sessionId || null, provider: saved.provider || "claude",
+    handover: saved.handover || "", sessionArchive: saved.sessionArchive || [], saved: saved.settings || null, hasChat: true });
 } catch {}
 /* Saved shortly after the last change, in one atomic write: overlapping writes could leave a broken file. */
 let chatTimer = null;
@@ -426,7 +450,8 @@ function writeChat() {
   chatTimer = null;
   try {
     writeAtomic(CHAT_FILE, JSON.stringify({ chat: state.chat.slice(-400), seq: state.seq, sessionId: state.sessionId,
-      provider: state.provider, handover: state.handover, sessionArchive: state.sessionArchive.slice(-50) }));
+      provider: state.provider, handover: state.handover, sessionArchive: state.sessionArchive.slice(-50),
+      settings: deckSettings ?? undefined }));
   } catch (e) { console.error(e.message); }
 }
 const saveChat = () => { chatTimer ??= setTimeout(writeChat, 100); };
@@ -440,38 +465,59 @@ function addEntry(entry) {
 }
 const liveTurns = () => state.turns.filter((t) => !t.undone);
 const changeLabel = (t) => (t ? (t.kind === "manual" ? t.label : "AI change") : null);
-/* The menu persists provider, model and effort. CLI overrides apply to this run only.
-   The v3 preview uses its own state directory so v2 can keep running independently. */
+/* Provider, model and effort belong to each deck, with its conversation: saved in its chat.json when chosen
+   in the menu, so another deck's choice never moves this deck's conversation to another backend. config.json
+   holds the last choice, which a new deck starts with, and each model's preferred effort. --provider and
+   --model apply to this run only. The v3 preview uses its own state directory so v2 can keep running. */
 const CONFIG_FILE = path.join(HOME_DIR, "config.json");
-let fileConfig = {};
-try { fileConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8")); }
-catch (e) { if (e.code !== "ENOENT") console.warn(`${CONFIG_FILE} is not valid JSON; using the defaults.`); }
-const settings = migrateSettings(fileConfig);
-let effortPreferences = Object.fromEntries(Object.entries(fileConfig.effortPreferences || {}).filter(([, value]) => typeof value === "string"));
-// Preserve the legacy selection as the first model-specific preference.
-if (settings.effort) effortPreferences[`${settings.provider}:${settings.model}`] = settings.effort;
+const isObject = (o) => !!o && typeof o === "object" && !Array.isArray(o);
+function readConfig(warn = false) {
+  try {
+    const c = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+    if (isObject(c)) return c;
+    if (warn) console.warn(`${CONFIG_FILE} does not hold settings ({ ... }); using the defaults.`);
+  } catch (e) { if (warn && e.code !== "ENOENT") console.warn(`${CONFIG_FILE} is not valid JSON; using the defaults.`); }
+  return {};
+}
+const preferencesOf = (c) => Object.fromEntries(Object.entries(isObject(c.effortPreferences) ? c.effortPreferences : {}).filter(([, v]) => typeof v === "string"));
+const fileConfig = readConfig(true);
+let effortPreferences = preferencesOf(fileConfig);
+const defaults = migrateSettings(fileConfig);
+// the legacy single effort (v2): the preference of the model it was chosen for
+if (fileConfig.effort && defaults.model) effortPreferences[`${defaults.provider}:${defaults.model}`] ??= defaults.effort;
+let deckSettings = isObject(state.saved) && PROVIDERS.includes(state.saved.provider) ? migrateSettings(state.saved) : null;
+const settings = deckSettings ? { ...deckSettings }
+  // a chat saved before decks kept their own settings: its provider, with that provider's default model
+  : state.hasChat && state.provider !== defaults.provider ? { provider: state.provider, model: state.provider === "claude" ? "sonnet" : "", effort: null }
+  : { ...defaults };
+const ownSettings = { ...settings };   // without --provider and --model, which apply to this run only
+const startNotices = [];   // added to the chat once the port is bound (a failed start writes nothing)
 if (PROVIDER) {
-  if (!["claude", "codex"].includes(PROVIDER)) { console.error(`Unknown provider "${PROVIDER}": use claude or codex.\n\n${USAGE}`); process.exit(2); }
-  settings.provider = PROVIDER;
-  if (!MODEL && PROVIDER !== fileConfig.provider) settings.model = PROVIDER === "claude" ? "sonnet" : "";
+  if (!PROVIDERS.includes(PROVIDER)) { console.error(`Unknown provider "${PROVIDER}": use claude or codex.\n\n${USAGE}`); process.exit(2); }
+  if (PROVIDER !== settings.provider) Object.assign(settings, { provider: PROVIDER, model: PROVIDER === "claude" ? "sonnet" : "", effort: null });
+}
+if (MODEL && MODEL !== settings.model) Object.assign(settings, { model: MODEL, effort: null });   // this run only, not saved
+if (settings.effort == null) settings.effort = effortPreferences[`${settings.provider}:${settings.model}`] ?? null;
+// A saved conversation belongs to its provider: --provider for another one starts a new conversation, and says so
+if (state.provider !== settings.provider && (state.sessionId || state.chat.length)) {
+  if (state.sessionId) state.sessionArchive.push({ provider: state.provider, id: state.sessionId });
+  state.sessionId = null; state.handover = "";
+  const why = PROVIDER === settings.provider ? `for this run (--provider ${PROVIDER})` : "(this deck's own choice)";
+  startNotices.push({ kind: "notice", fresh: true, text: `Switched to ${providerName(settings.provider)} ${why} · New conversation.` });
 }
-if (MODEL) settings.model = MODEL;   // --model on the command line: this run only, not saved
-// A saved chat belongs to its provider, never to whichever CLI happens to be selected now.
-if (state.provider !== settings.provider) { state.sessionId = null; state.handover = ""; }
 state.provider = settings.provider;
 /* Asset roots (--asset-root, and "assetRoots" in config.json): folders outside the deck whose files the
    deck may use. The outermost one that contains the deck is served at /files/, with the deck page inside
    it, so a relative path such as ../shared/style.css reaches its file. Every file served, from the deck
    or from /files/, must really lie (after following symlinks) inside the deck folder or an asset root:
    a symlink that leads anywhere else is refused. */
-const expandHome = (p) => (p === "~" || p.startsWith("~/") ? path.join(os.homedir(), p.slice(1)) : p);
-const ASSET_ROOTS = [...assetArgs, ...(Array.isArray(fileConfig.assetRoots) ? fileConfig.assetRoots : [])].map((r) => {
-  const abs = path.resolve(expandHome(String(r)));
-  let st = null;
-  try { st = fs.statSync(abs); } catch {}
-  if (!st?.isDirectory()) { console.error(`Asset root ${abs} is not a folder.\n\n${USAGE}`); process.exit(2); }
-  return abs;
-});
+// on its own a missing one stops the start; behind the front, which lists decks only from roots that exist,
+// one that is gone since the front started is left out with a warning, so the deck still opens
+const { roots: ASSET_ROOTS, missing: missingRoots } = assetRoots(assetArgs, fileConfig);
+for (const r of missingRoots) {
+  if (!FRONT) { console.error(`Asset root ${r} is not a folder.\n\n${USAGE}`); process.exit(2); }
+  console.warn(`Asset root ${r} is not a folder (any more): left out.`);
+}
 const within = (dir, p) => p === dir || p.startsWith(dir + path.sep);
 const realOr = (p) => { try { return fs.realpathSync(p); } catch { return p; } };
 const SERVE_ROOT = ASSET_ROOTS.filter((r) => within(r, DECK_DIR)).sort((a, b) => a.length - b.length)[0] || null;
@@ -491,14 +537,22 @@ function servable(base, rel) {
   return ALLOWED_REAL.some((d) => within(d, real)) ? f : null;
 }
 
-let catalog = { claude: { models: [] }, codex: { models: [] } }, discovering = null;
+let catalog = { claude: { models: [] }, codex: { models: [] } };
 let session = null, starting = null;
-const status = () => ({ busy: state.busy, switching: state.switching, model: state.model, sessionId: state.sessionId, settings: { ...settings },
+const status = () => ({ busy: state.busy, switching: state.switching, preparing: !!state.preparing, model: state.model, sessionId: state.sessionId, settings: { ...settings },
   running: !!session?.running, provider: settings.provider, models: catalog, deck: DECK_DIR, deckFile: DECK_FILE,
   chrome: CAPS.screenshot.available, slideSelector: deckNow.selector, deckProblem: deckNow.problem,
   capabilities: publicCapabilities(CAPS), rev: deckRev(),
-  undo: changeLabel(liveTurns().at(-1)), redo: changeLabel(state.redo.at(-1)) });
-const pushStatus = () => broadcast("status", status());
+  undo: changeLabel(liveTurns().at(-1)), undoId: liveTurns().at(-1)?.id ?? null, redo: changeLabel(state.redo.at(-1)) });
+/* Pushed to the editors on every change. The model lists (both providers' catalogs) go along only when they
+   changed since the last push: the editor keeps the last ones it got. */
+let catalogSent = "";
+const pushStatus = () => {
+  const st = status(), lists = JSON.stringify(catalog);
+  if (lists === catalogSent) delete st.models;
+  catalogSent = lists;
+  broadcast("status", st);
+};
 
 const systemPrompt = fs.readFileSync(path.join(EDITOR_DIR, "lib/system-prompt.md"), "utf8")
   .replaceAll("{{CLI}}", CLI_CMD).replaceAll("{{DECK}}", DECK_FILE) + capabilityPrompt(CAPS, CLI_CMD) +
@@ -521,9 +575,50 @@ function slidesInstructions() {
    git's own files, and other decks in this folder (a named deck shares its folder with them). Deny rules
    win over allow rules; a locked file changed anyway is restored after the turn (lock 2 in finishTurn). */
 function lockedPaths() {
-  let others = [];
-  try { others = fs.readdirSync(DECK_DIR).filter((f) => /\.html?$/i.test(f) && f !== DECK_FILE); } catch {}
-  return [...LOCKED, "vendor/**", ".git/**", ...others];
+  const { files, folders } = otherDecks();
+  return [...LOCKED, "vendor/**", ".git/**", ...files, ...folders.map((f) => `${f}/**`)];
+}
+/* The other decks in this deck's folder: its other .html files, and the subfolders that hold a deck of their
+   own (as the deck menu lists them). Neither the assistant nor this deck's undo touches them. */
+function otherDecks() {
+  let files = [];
+  try { files = fs.readdirSync(DECK_DIR).filter((f) => /\.html$/i.test(f) && f !== DECK_FILE); } catch {}
+  const folders = [...new Set(listDecks([DECK_DIR]).filter((d) => !d.problem && d.dir !== DECK_DIR)
+    .map((d) => path.relative(DECK_DIR, d.dir).split(path.sep).join("/")))];
+  return { files, folders };
+}
+const scanDeck = () => { const { files, folders } = otherDecks(); return scanFiles(DECK_DIR, { skip: [...files, ...folders] }); };
+
+/* Decks that share a folder share its files (theme.css, figures/): while the assistant of one works, that of
+   another may change them too. Each deck server keeps the times of its turns in a file of its own under
+   turns/<folder>/; a turn that overlapped another deck's keeps only the files its own assistant said it wrote. */
+const TURNS_DIR = path.join(HOME_DIR, "turns", hash(DECK_DIR).slice(0, 12));
+const TURNS_FILE = path.join(TURNS_DIR, `${deckKey}.json`);
+let turnTimes = [];   // [{ start, end }] of this deck's recent turns
+function logTurnTime(t) {
+  const now = Date.now();
+  turnTimes = turnTimes.filter((x) => x === t || (x.end ?? now) > now - 3600000).slice(-20);
+  if (!turnTimes.includes(t)) turnTimes.push(t);
+  try {
+    fs.mkdirSync(TURNS_DIR, { recursive: true, mode: 0o700 });
+    writeAtomic(TURNS_FILE, JSON.stringify({ deck: DECK_FILE === "index.html" ? path.basename(DECK_DIR) : DECK_FILE, pid: process.pid, turns: turnTimes }));
+  } catch (e) { console.error(e.message); }
+}
+/* The other decks whose assistant worked in this folder at some time since start: their names */
+function othersWorkedSince(start) {
+  const now = Date.now(), names = [];
+  let files = [];
+  try { files = fs.readdirSync(TURNS_DIR).filter((f) => f.endsWith(".json") && f !== `${deckKey}.json`); } catch {}
+  for (const f of files) {
+    try {
+      const o = JSON.parse(fs.readFileSync(path.join(TURNS_DIR, f), "utf8"));
+      let alive = true;
+      try { process.kill(o.pid, 0); } catch (e) { alive = e.code === "EPERM"; }
+      // a turn still open in a server that is gone ended when that server did, at the latest
+      if (o.turns.some((x) => (x.end ?? (alive ? now : x.start)) >= start)) names.push(o.deck);
+    } catch {}
+  }
+  return names;
 }
 /* Claude Code loads no settings files (--setting-sources ""): an allow rule in the user's, the deck's
    or a parent repo's settings would let Claude run more than PinDeck grants (and the user's hooks and
@@ -594,9 +689,25 @@ function retire(agent) {
   retiring.add(stopped);
   stopped.finally(() => retiring.delete(stopped));
 }
-async function discoverModels() {
-  if (discovering) return discovering;
-  discovering = Promise.all(["claude", "codex"].map(async provider => {
+/* What each backend offers. Asking means starting a backend process, so it is done once per provider at a
+   time, and the answer is shared: through models.json in the state folder, for the other deck servers too,
+   for 10 minutes (Refresh models asks again). A message waits only for its own provider's list. */
+const MODELS_FILE = path.join(HOME_DIR, "models.json"), MODELS_TTL = 10 * 60000;
+const asking = {};   // provider -> promise of its discovery
+function cachedModels() {
+  try {
+    const c = JSON.parse(fs.readFileSync(MODELS_FILE, "utf8"));
+    return Date.now() - c.time < MODELS_TTL && c.catalog && typeof c.catalog === "object" ? c.catalog : {};
+  } catch { return {}; }
+}
+function cacheModels() {
+  const ok = Object.fromEntries(Object.entries(catalog).filter(([, c]) => c.models.length && !c.error));
+  if (!Object.keys(ok).length) return;
+  try { writeAtomic(MODELS_FILE, JSON.stringify({ time: Date.now(), catalog: { ...cachedModels(), ...ok } })); } catch {}
+}
+function discoverProvider(provider) {
+  if (asking[provider]) return asking[provider];
+  asking[provider] = (async () => {
     if (!providerAvailable(provider).available) { catalog[provider] = { models: [], error: providerAvailable(provider).reason }; return; }
     const agent = makeSession({ provider, model: "", effort: null });
     discoveryAgents.add(agent);
@@ -605,8 +716,36 @@ async function discoverModels() {
       catalog[provider] = { models: curateModels(provider, agent.models || []), error: null };
     } catch (e) { catalog[provider] = { models: [], error: e.message }; }
     finally { discoveryAgents.delete(agent); retire(agent); }
-  })).then(() => { pushStatus(); return catalog; }).finally(() => { discovering = null; });
-  return discovering;
+  })().finally(() => { delete asking[provider]; });
+  return asking[provider];
+}
+/* providers: which to ask; fresh: ask the backends even when another deck server asked lately */
+async function discoverModels({ providers = ["claude", "codex"], fresh = false } = {}) {
+  const cached = fresh ? {} : cachedModels();
+  await Promise.all(providers.map((p) => {
+    if (cached[p]?.models?.length && providerAvailable(p).available) { catalog[p] = cached[p]; return null; }
+    return discoverProvider(p);
+  }));
+  cacheModels();
+  pushStatus();
+  return catalog;
+}
+/* The model and effort as they will be used, once the backend has said what it offers: a saved or given
+   model it does not offer gives way to its default model (and the chat says so), an effort the model does
+   not offer to the model's preferred or default one. Shown before the first message is sent. */
+function settle() {
+  const { models, error } = catalog[settings.provider];
+  if (!models.length || error) return;   // discovery failed: its error answers the next message
+  let model = models.find((m) => m.id === settings.model);
+  if (!model) {
+    model = models.find((m) => m.isDefault) || models.find((m) => m.curated) || models[0];
+    if (settings.model) addEntry({ kind: "notice", text: `The model "${settings.model}" is not available from ${providerName(settings.provider)} now: using ${model.label} instead.` });
+    Object.assign(settings, { model: model.id, effort: null });
+  }
+  if (!model.efforts.includes(settings.effort)) {
+    const preferred = effortPreferences[`${settings.provider}:${model.id}`];
+    settings.effort = model.efforts.includes(preferred) ? preferred : model.defaultEffort ?? null;
+  }
 }
 async function ensureSession() {
   if (starting) return starting;
@@ -614,17 +753,37 @@ async function ensureSession() {
   const available = providerAvailable(settings.provider);
   if (!available.available) throw new Error(available.reason);
   starting = (async () => {
-    if (!catalog[settings.provider].models.length) await discoverModels();
+    if (!catalog[settings.provider].models.length) await discoverModels({ providers: [settings.provider] });
+    settle();
     Object.assign(settings, selectModel(catalog, settings, {}));
+    // a deck without a choice of its own keeps the one its conversation starts with, not the next one another
+    // deck saves in config.json; a run-only --provider or --model is not kept
+    if (!deckSettings) {
+      deckSettings = PROVIDER || MODEL ? { ...ownSettings } : { provider: settings.provider, model: settings.model, effort: settings.effort };
+      saveChat();
+    }
     const agent = makeSession({ ...settings });
     session = agent;
-    try { await agent.start(state.sessionId); if (session === agent) pushStatus(); }
+    try {
+      await agent.start(state.sessionId);
+      // the session's own start lists the models too: the freshest list there is
+      if (agent.models?.length) { catalog[settings.provider] = { models: curateModels(settings.provider, agent.models), error: null }; cacheModels(); }
+      if (session === agent) pushStatus();
+    }
     catch (e) { retire(agent); throw e; }
   })().finally(() => { starting = null; });
   return starting;
 }
+function providerName(p) { return p === "codex" ? "OpenAI / ChatGPT" : "Claude"; }
+/* config.json as it is now (another deck may have written it since this one started), with this choice and
+   its effort preferences merged in, in one atomic write */
+function saveConfig(choice, preferences) {
+  const now = readConfig();
+  writeAtomic(CONFIG_FILE, JSON.stringify({ ...now, ...choice, effortPreferences: { ...preferencesOf(now), ...preferences } }, null, 2) + "\n");
+}
 async function changeSettings(requested) {
   if (state.busy || starting) throw new Error("Wait until the current request finishes before switching.");
+  effortPreferences = { ...effortPreferences, ...preferencesOf(readConfig()) };   // as other decks left them
   const choice = selectModel(catalog, settings, requested, effortPreferences);
   if (Object.keys(choice).every(k => choice[k] === settings[k])) return;
   const changingProvider = choice.provider !== settings.provider;
@@ -639,21 +798,22 @@ async function changeSettings(requested) {
     if (!candidate.running) throw new Error("The new backend stopped before it was ready.");
     const summary = changingProvider && requested.handover === "summary" ? handoverSummary(state.chat) : "";
     if (changingProvider && state.sessionId) state.sessionArchive.push({ provider: state.provider, id: state.sessionId });
-    const nextPreferences = { ...effortPreferences };
-    if (settings.effort) nextPreferences[`${settings.provider}:${settings.model}`] = settings.effort;
-    if (choice.effort) nextPreferences[`${choice.provider}:${choice.model}`] = choice.effort;
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...fileConfig, ...choice, effortPreferences: nextPreferences }, null, 2) + "\n");
-    effortPreferences = nextPreferences;
+    const changed = {};   // only the preferences this choice sets: the model left, and the model chosen
+    if (settings.effort) changed[`${settings.provider}:${settings.model}`] = settings.effort;
+    if (choice.effort) changed[`${choice.provider}:${choice.model}`] = choice.effort;
+    try { saveConfig(choice, changed); } catch (e) { console.error(e.message); }
+    effortPreferences = { ...effortPreferences, ...changed };
     Object.assign(settings, choice);
+    deckSettings = { ...choice };
     state.provider = choice.provider;
-    if (changingProvider) { state.sessionId = candidate.sessionId || null; state.handover = summary; state.model = null; }
+    if (changingProvider) { state.sessionId = candidate.sessionId || null; state.handover = summary; state.model = null; state.conversation++; }
     if (reuse) candidate.settings = choice;
     session = candidate;
     if (!reuse && candidate.initialEvent()) handleEvent(candidate.initialEvent());
     if (!reuse) retire(old);
     saveChat();
-    addEntry({ kind: "notice", text: changingProvider
-      ? `Switched to ${choice.provider === "codex" ? "OpenAI / ChatGPT" : "Claude"} · ${summary ? "Conversation summary will be shared" : "New conversation"}.`
+    addEntry({ kind: "notice", ...(changingProvider && !summary ? { fresh: true } : {}), text: changingProvider
+      ? `Switched to ${providerName(choice.provider)} · ${summary ? "Conversation summary will be shared" : "New conversation"}.`
       : `Model: ${choice.model}${choice.effort ? ` · ${choice.effort} effort` : ""}. The conversation continues.` });
   } catch (e) { if (session !== candidate) retire(candidate); throw e; }
   finally { state.busy = false; state.switching = false; pushStatus(); }
@@ -666,11 +826,13 @@ function toolSummary(name, input = {}) {
     const r = path.relative(DECK_DIR, p);
     return !r || r.startsWith("..") ? path.basename(p) : r;
   };
+  // a picture in the screenshots folder: the chat shows it
+  const shotOf = (p) => (p && realOr(path.dirname(path.resolve(p))) === realOr(SHOT_DIR) && SHOT_NAME.test(path.basename(p)) ? { shot: path.basename(p) } : {});
   switch (name) {
-    case "pindeck_read": return { name: "Read", detail: base(input.path) };
+    case "pindeck_read": return { name: "Read", detail: base(input.path), ...shotOf(input.path) };
     case "pindeck_edit": case "pindeck_write": return { name: "Edit", detail: base(input.path) };
     case "pindeck_command": return { name: input.command || "Command", detail: (input.args || []).join(" ") };
-    case "Read": return { name: "Read", detail: base(input.file_path) };
+    case "Read": return { name: "Read", detail: base(input.file_path), ...shotOf(input.file_path) };
     case "Edit": case "MultiEdit": case "Write": return { name: "Edit", detail: base(input.file_path) };
     case "Bash": {
       // a PinDeck command only when the whole command is one: a script that ends in `cli.mjs layout`
@@ -686,6 +848,15 @@ function toolSummary(name, input = {}) {
   }
 }
 const toolEntries = new Map(); // tool_use_id -> entry
+// the tools that write a file, and the argument that names it (Claude's, then those of PinDeck's Codex bridge)
+const WRITES = { Edit: "file_path", MultiEdit: "file_path", Write: "file_path", NotebookEdit: "notebook_path",
+  pindeck_edit: "path", pindeck_write: "path" };
+const DECK_REAL = realOr(DECK_DIR);
+const deckRel = (p) => {
+  const abs = path.resolve(DECK_DIR, p);
+  const rel = path.relative(abs.startsWith(DECK_REAL + path.sep) ? DECK_REAL : DECK_DIR, abs);
+  return rel.split(path.sep).join("/");
+};
 function handleEvent(ev) {
   if (ev.type === "system" && ev.subtype === "init") {
     state.model = ev.model || state.model;
@@ -695,7 +866,11 @@ function handleEvent(ev) {
   } else if (ev.type === "assistant" && state.turn) {
     for (const b of ev.message?.content || []) {
       if (b.type === "text" && b.text.trim()) addEntry({ kind: "assistant", text: b.text.trim() });
-      if (b.type === "tool_use") toolEntries.set(b.id, addEntry({ kind: "tool", ...toolSummary(b.name, b.input) }));
+      if (b.type === "tool_use") {
+        toolEntries.set(b.id, addEntry({ kind: "tool", ...toolSummary(b.name, b.input) }));
+        const file = WRITES[b.name] && b.input?.[WRITES[b.name]];
+        if (typeof file === "string") state.turn.touched.add(deckRel(file));
+      }
     }
   } else if (ev.type === "user" && state.turn) {
     for (const b of ev.message?.content || []) {
@@ -717,7 +892,9 @@ function handleEvent(ev) {
 function startTurn(promptText, userEntry) {
   // every deck file as it is now: the assistant may change any of them (not brand.css or vendor/), and undo
   // takes back all it changed
-  state.turn = { id: userEntry.id, before: snapshot([...EDITABLE, ...LOCKED]), scan: scanFiles(DECK_DIR) };
+  state.turn = { id: userEntry.id, before: snapshot([...EDITABLE, ...LOCKED]), gitConfig: readDeck(".git/config"), scan: scanDeck(), touched: new Set(),
+    time: { start: Date.now(), end: null } };
+  logTurnTime(state.turn.time);
   state.busy = true;
   pushStatus();
   const turn = state.turn;
@@ -744,9 +921,26 @@ function finishTurn({ error, cost, duration, denials = [] }) {
     else fs.rmSync(path.join(DECK_DIR, f), { force: true });   // a locked file that the assistant created
     restored.push(f);
   }
+  // .git/config can make git run commands (filters, fsmonitor), and PinDeck runs git after the id pass: an
+  // assistant must not change it, by whatever path or spelling it got there
+  if (readDeck(".git/config") !== turn.gitConfig) {
+    try {
+      if (turn.gitConfig == null) fs.rmSync(path.join(DECK_DIR, ".git/config"), { force: true });
+      else fs.writeFileSync(path.join(DECK_DIR, ".git/config"), turn.gitConfig);
+      restored.push(".git/config");
+    } catch (e) { console.error(e.message); }
+  }
   toolEntries.clear();
   const eid = runEidPass();
-  const { changed, tooLarge } = scanChanges(turn.scan, scanFiles(DECK_DIR));
+  const found = scanChanges(turn.scan, scanDeck());
+  // another deck's assistant worked in this folder meanwhile: only what this one wrote (and its deck file)
+  const others = othersWorkedSince(turn.time.start);
+  turn.time.end = Date.now();
+  logTurnTime(turn.time);
+  const ours = (rel) => !others.length || rel === DECK_FILE || turn.touched.has(rel);
+  const changed = Object.fromEntries(Object.entries(found.changed).filter(([rel]) => ours(rel)));
+  const tooLarge = found.tooLarge.filter(ours);
+  const notOurs = [...Object.keys(found.changed), ...found.tooLarge].filter((rel) => !ours(rel));
   const before = {}, after = {};
   for (const [rel, c] of Object.entries(changed)) { before[rel] = c.before; after[rel] = c.after; }
   // the deck file and theme.css first, then the rest by name
@@ -762,11 +956,14 @@ function finishTurn({ error, cost, duration, denials = [] }) {
     deletedFiles.push({ rel, data: fs.readFileSync(abs) });
     fs.rmSync(abs, { force: true });
   }
-  const t = { id: turn.id, kind: "agent", provider: settings.provider, before, after, files, deletedFiles, undone: false };
+  const t = { id: turn.id, kind: "agent", provider: settings.provider, conversation: state.conversation, before, after, files, deletedFiles, undone: false };
   if (files.length) { state.turns.push(t); state.redo = []; }
   addEntry({ kind: "turn", turnId: files.length ? t.id : null, files, error, cost, duration,
     denials, restored, newIds: eid.assigned.length });
   if (deletedFiles.length) addEntry({ kind: "notice", text: `Removed ${deletedFiles.map((f) => f.rel).join(", ")}: replaced, and no longer used.` });
+  if (notOurs.length) addEntry({ kind: "notice", text: `${notOurs.join(", ")} changed during this turn while the assistant of ` +
+    `${others.join(", ")} was working in this folder too, and the assistant here did not say it wrote ${notOurs.length > 1 ? "them" : "it"}: ` +
+    `not part of this change (Undo leaves ${notOurs.length > 1 ? "them" : "it"} as ${notOurs.length > 1 ? "they are" : "it is"}).` });
   if (tooLarge.length) addEntry({ kind: "notice", text: `${tooLarge.join(", ")} changed in this turn but ${tooLarge.length > 1 ? "are" : "is"} ` +
     `too large to keep a copy of (over 2 MB): Undo leaves ${tooLarge.length > 1 ? "them" : "it"} as ${tooLarge.length > 1 ? "they are" : "it is"}.` });
   pushStatus();
@@ -812,7 +1009,7 @@ function formatAttachment(a) {
 const formatDrop = (a) => (a.droppedAt?.slide ? ` Dropped onto slide ${a.droppedAt.slide.index + 1} (${a.droppedAt.slide.eid}) at ` +
   `x=${a.droppedAt.point.x} y=${a.droppedAt.point.y}${a.droppedAt.eid ? `, over ${a.droppedAt.eid}` : ""}: probably where the user wants it.` : "");
 
-function buildPrompt({ text: userText, pins = [], selection, layouts = [], current, screenshot, attachments = [] }) {
+function buildPrompt({ text: userText, pins = [], selection, layouts = [], current, screenshot, shotFailed, attachments = [] }) {
   const ctx = [];
   if (current) ctx.push(`The user is looking at slide ${current.index + 1} (${current.eid}).`);
   if (state.notes.length) {
@@ -825,7 +1022,9 @@ function buildPrompt({ text: userText, pins = [], selection, layouts = [], curre
     `box x=${selection.box.x} y=${selection.box.y} w=${selection.box.w} h=${selection.box.h} on slide ${selection.slide.index + 1}.`);
   if (pins.length) ctx.push("Pins (numbered clicks; the user refers to them by number):\n" + pins.map(formatPin).join("\n"));
   for (const L of layouts) ctx.push("Layout:\n" + formatLayout(L));
-  if (screenshot) ctx.push(`Screenshot of slide ${screenshot.slide} with the pin markers: ${screenshot.path} (Read it).`);
+  if (screenshot) ctx.push(`Screenshot of slide ${screenshot.slide}${screenshot.pins ? " with the pin markers" : ""}: ${screenshot.path} (Read it).`);
+  if (shotFailed) ctx.push(`The user asked for a screenshot of slide ${shotFailed.slide}, but it could not be taken (${shotFailed.error}). ` +
+    `Take one with \`${CLI_CMD} shot ${shotFailed.slide}\` if you need to see the slide.`);
   if (attachments.length) ctx.push("Attached files (the user added them to this message; they are saved in the deck folder, " +
     `use these paths relative to ${DECK_FILE}):\n` + attachments.map((a) => formatAttachment(a) + formatDrop(a)).join("\n"));
   return (ctx.length ? `<editor-context>\n${ctx.join("\n\n")}\n</editor-context>\n\n` : "") + userText;
@@ -837,9 +1036,11 @@ function buildPrompt({ text: userText, pins = [], selection, layouts = [], curre
 async function pdfFigure({ file = "", page = "1", box = "", out = "", width = "", cancelled = () => false }) {
   const bad = (t, status = 400) => ({ status, text: t });
   if (!CAPS.pdfPages.available) return bad(CAPS.pdfPages.reason, 501);
+  // compared by real path: the Codex bridge names files by theirs, and the deck's path may go through a
+  // symlink (~/Dropbox, /tmp on macOS)
   const abs = [path.isAbsolute(file) ? file : path.join(DECK_DIR, file), path.join(PDF_DIR, path.basename(file))]
     .map((f) => path.resolve(f)).find((f) => /\.pdf$/i.test(f) && fs.existsSync(f) &&
-      [DECK_DIR, PDF_DIR].some((d) => f.startsWith(d + path.sep)));
+      [DECK_DIR, PDF_DIR].map(realOr).some((d) => realOr(f).startsWith(d + path.sep)));
   if (!abs) return bad(`No PDF "${file}": use the path from the attached files, or a .pdf in the deck folder.`, 404);
   const info = await pdfInfo(abs, STATE_DIR);
   const n = Number(page);
@@ -894,13 +1095,19 @@ function scheduleFlush() {
     if (external) {
       state.notes = [...new Set([...state.notes,
         "The deck files changed outside this chat since your last turn (edited by hand or by another tool). Re-read before editing."])];
-      // new elements from a hand edit get ids once the file is quiet: unchanged for 800 ms and present
+      // new elements from a hand edit get ids once the file is quiet: present, and unchanged since (see pass)
       clearTimeout(eidTimer);
       const seen = hash(readDeck(DECK_FILE) ?? "");
+      // a program that writes the file in pieces, with a pause, must not find it replaced halfway (its rest
+      // would go to the old file): unchanged for 2 s, and complete (ending in </html>, if the deck did)
       const pass = () => {
         if (state.busy) return;
         const now = readDeck(DECK_FILE);
         if (now == null || hash(now) !== seen) return;   // still being written; its own event comes
+        let age = 0;
+        try { age = Date.now() - fs.statSync(path.join(DECK_DIR, DECK_FILE)).mtimeMs; } catch { return; }
+        if (age < 2000) { eidTimer = setTimeout(pass, 2000 - age); return; }
+        if (ENDS_HTML.test(deckAtStart) && !ENDS_HTML.test(now)) return;   // incomplete: its next save comes
         runEidPass();
       };
       eidTimer = setTimeout(pass, 800);
@@ -986,22 +1193,40 @@ function recordHandEdit(before, html, label, note, { manual = true, deletedFiles
 }
 
 /* What deleting an element would remove, and which of its files nothing else uses. Files outside the
-   deck folder, in vendor/, or still referenced elsewhere (index.html, theme.css) are never offered. */
+   deck folder, in vendor/, or still referenced elsewhere (the rest of the deck, theme.css, brand.css, or
+   another deck in the folder or one folder down, which may share figures/) are never offered. */
 function deletePlan(eid) {
   const html = readDeck(DECK_FILE);
   const target = deleteTarget(html, eid);
   if (!target) return null;
   const rest = removeElement(html, target.eid);
   const css = (readDeck("theme.css") || "") + (readDeck("brand.css") || "");
+  const others = otherDeckRefs();
   const files = fileRefs(target.outer).flatMap((ref) => {
     const abs = path.resolve(DECK_DIR, ref);
     const rel = path.relative(DECK_DIR, abs).split(path.sep).join("/");
     if (rel.startsWith("..") || rel.startsWith("vendor/") || !fs.existsSync(abs) || !fs.statSync(abs).isFile()) return [];
-    const usedElsewhere = fileRefs(rest).some((r) => path.resolve(DECK_DIR, r) === abs) || css.includes(ref) || css.includes(rel);
-    return [{ rel, bytes: fs.statSync(abs).size, usedElsewhere }];
+    try { deckPath(rel); } catch { return []; }   // through a symlink out of the deck: never offered
+    const usedBy = others.filter((o) => o.uses(abs)).map((o) => o.name);
+    const usedElsewhere = fileRefs(rest).some((r) => path.resolve(DECK_DIR, r) === abs) || css.includes(ref) || css.includes(rel) || usedBy.length > 0;
+    return [{ rel, bytes: fs.statSync(abs).size, usedElsewhere, usedBy }];
   });
   return { ...target, html: rest, files };
 }
+/* The other decks of this folder and one folder down, each with a test of whether it refers to a file: in its
+   HTML (relative to its own folder), or in the stylesheets beside it */
+function otherDeckRefs() {
+  const own = path.join(DECK_DIR, DECK_FILE);
+  const decks = [...fs.readdirSync(DECK_DIR).filter((f) => /\.html$/i.test(f)).map((f) => ({ dir: DECK_DIR, file: f })),
+    ...listDecks([DECK_DIR]).filter((d) => d.dir !== DECK_DIR)].filter((d) => path.join(d.dir, d.file) !== own);
+  return decks.map(({ dir, file }) => {
+    const read = (f) => { try { return fs.statSync(f).size <= 5e6 ? fs.readFileSync(f, "utf8") : ""; } catch { return ""; } };
+    const refs = new Set(fileRefs(read(path.join(dir, file))).map((r) => { try { return path.resolve(dir, decodeURI(r)); } catch { return path.resolve(dir, r); } }));
+    const css = dir === DECK_DIR ? "" : read(path.join(dir, "theme.css")) + read(path.join(dir, "brand.css"));
+    return { name: path.relative(DECK_DIR, path.join(dir, file)).split(path.sep).join("/"),
+      uses: (abs) => refs.has(abs) || (!!css && css.includes(path.relative(dir, abs).split(path.sep).join("/"))) };
+  });
+}
 
 /* ---- Undo (assistant turns and hand edits share one history) ---------------------------------------
    Undo puts back the files as they were before a change, Redo as they were after it. Both first check that
@@ -1016,6 +1241,8 @@ function undoConflicts(t, direction) {
   // ones (which must be unchanged); redo the other way round
   const comeBack = direction === "undo" ? t.deletedFiles || [] : t.addedFiles || [];
   const go = direction === "undo" ? t.addedFiles || [] : t.deletedFiles || [];
+  // a file to bring back or remove through a symlink out of the deck: not done (deckPath), so not begun
+  for (const { rel } of [...comeBack, ...go]) { try { deckPath(rel); } catch { files.push(rel); } }
   for (const { rel, data } of comeBack) {
     const abs = path.join(DECK_DIR, rel);
     if (fs.existsSync(abs) && !sameContent(abs, data)) files.push(rel);
@@ -1031,6 +1258,13 @@ function conflict(res, direction, files) {
     error: `${files.join(", ")} changed since then (edited outside PinDeck?), so ${direction === "undo" ? "Undo" : "Redo"} was not done: ` +
       `it would overwrite those changes. Reload to see the files as they are.` });
 }
+/* The chat entry of a change keeps whether it is undone: the undo history ends with the run, the chat does not */
+function markUndone(t) {
+  const e = state.chat.find((x) => x.turnId === t.id && (x.kind === "turn" || x.kind === "edit"));
+  if (e) { e.undone = t.undone; saveChat(); }
+}
+// an assistant turn made in the conversation going on now (not before a new chat or a provider switch)
+const byThisChat = (t) => t.conversation === state.conversation;
 function undo(res) {
   if (state.busy) return json(res, 409, { error: "Wait until the assistant has finished." });
   const t = liveTurns().at(-1);
@@ -1039,12 +1273,15 @@ function undo(res) {
   if (diverged.length) return conflict(res, "undo", diverged);
   for (const rel of changeFiles(t)) if (!isAs(rel, t.before[rel])) putDeckFile(rel, t.before[rel] ?? null);   // null: the change created it
   for (const { rel, data } of t.deletedFiles || []) writeDeckFile(rel, data, false);   // files deleted with an element come back too
-  for (const { rel } of t.addedFiles || []) fs.rmSync(path.join(DECK_DIR, rel), { force: true });   // imported figures go
+  for (const { rel } of t.addedFiles || []) removeDeckFile(rel);   // imported figures go
   t.undone = true;
+  markUndone(t);
   state.redo.push(t);
+  const names = t.files.map((f) => f.file);
   state.notes.push(t.kind === "manual"
     ? `The user undid their hand edit (${t.label}); ${DECK_FILE} is back to the state before it.`
-    : `The user undid your change from turn ${t.id}; ${t.files.map((f) => f.file).join(" and ")} are back to the state before it. Re-read before editing.`);
+    : `The user undid ${byThisChat(t) ? "your change from turn" : "a change made before this conversation began, in turn"} ${t.id}; ` +
+      `${names.join(" and ")} ${names.length > 1 ? "are" : "is"} back to the state before it. Re-read before editing.`);
   broadcast("undone", { turnId: t.id, undone: true });
   pushStatus();
   return json(res, 200, {});
@@ -1053,7 +1290,7 @@ function undo(res) {
 /* ---- PowerPoint import -----------------------------------------------------------------------------
    Upload: the file is read at once (slide list for the dialog); in the background PowerPoint or Keynote
    makes a PDF of it, from which come the thumbnails and, on import, the pictures of diagrams.
-   Only the latest upload is kept, in ~/.pindeck/decks/<deck>/imports/. */
+   Only the latest upload is kept, in ~/.pindeck-v3/decks/<deck>/imports/. */
 const IMPORT_DIR = path.join(STATE_DIR, "imports");
 const IMPORT_MAX = 500 * 1024 * 1024;
 let lastImport = null;   // { id, name, dir, model, render: Promise<pdf path | null>, renderError }
@@ -1161,80 +1398,40 @@ async function refineImport(imp, pdf, plans, eids, first) {
 
 /* ---- HTTP ------------------------------------------------------------------------------------- */
 const BRIDGE_TAG = `<script src="/editor/bridge.js"></script>\n</body>`;
-/* Pages opened as 127.0.0.1 or localhost only, on any port: an SSH tunnel may use another local port.
-   Another site's name pointed at 127.0.0.1 (DNS rebinding) must not read the editor page, its token or the deck. */
-const goodHost = (h) => /^(127\.0\.0\.1|localhost)(:\d{1,5})?$/.test(h);
-
-/* Who may read the editor, the deck and the API. The token never appears in a page or on a command line,
-   where other users of a shared server could read it (ps, curl). A browser logs in once with a one-time
-   code (printed at start, or by `pindeck login`) and then holds the token in an HttpOnly cookie; the CLI
-   and Claude send it in a header. Browsers share cookies across all ports of a host, so the cookie name
-   carries this server's port. */
-const loginCodes = new Map();   // code -> expiry (ms)
-function loginCode(ttl) {
-  const now = Date.now();
-  for (const [c, exp] of loginCodes) if (exp < now) loginCodes.delete(c);
-  const code = crypto.randomBytes(16).toString("hex");
-  loginCodes.set(code, now + ttl);
-  return code;
-}
-const loginUrl = (code, next = "/") => `${ORIGIN}/login?` + new URLSearchParams({ code, ...(next !== "/" ? { next } : {}) });
-const cookieName = () => `pindeck-${PORT}`;
-const sameSecret = (a) => typeof a === "string" && a.length === TOKEN.length &&
-  crypto.timingSafeEqual(Buffer.from(a), Buffer.from(TOKEN));
-function cookie(req, name) {
-  for (const part of String(req.headers.cookie || "").split(";")) {
-    const i = part.indexOf("=");
-    if (i > 0 && part.slice(0, i).trim() === name) return part.slice(i + 1).trim();
-  }
-  return null;
-}
-const authed = (req) => sameSecret(req.headers["x-editor-token"]) || sameSecret(cookie(req, cookieName()));
-const LOGIN_PAGE = `<!doctype html><meta charset="utf-8"><title>PinDeck</title>
-<body style="font:16px system-ui,sans-serif;max-width:36em;margin:4em auto;padding:0 1em">
-<h1>Log in to PinDeck</h1><p>Open the login link that PinDeck printed when it started. Links work once;
-for a new one, run <code>pindeck login</code> in the deck folder (or <code>node server.mjs login</code> in a
-PinDeck checkout).</p>`;
-/* A one-time code: set the cookie, then go on with a same-origin navigation (a redirect from a cross-site
-   start, such as a file:// page or a link in a terminal, would not carry a SameSite=Strict cookie). */
-function login(res, url) {
-  const code = url.searchParams.get("code") || "";
-  const exp = loginCodes.get(code);
-  loginCodes.delete(code);
-  if (!exp || exp < Date.now()) {
-    res.writeHead(403, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
-    return res.end(LOGIN_PAGE.replace("<p>", "<p>This login link has expired or was used already. "));
-  }
-  let next = url.searchParams.get("next") || "/";
-  if (!next.startsWith("/") || next.startsWith("//") || next.includes("\\")) next = "/";
-  res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store",
-    "set-cookie": `${cookieName()}=${TOKEN}; HttpOnly; SameSite=Strict; Path=/` });
-  const to = JSON.stringify(next).replace(/</g, "\\u003c");
-  res.end(`<!doctype html><meta charset="utf-8"><title>PinDeck</title><script>location.replace(${to})</script>`);
-}
+/* Who may read the editor, the deck and the API: see lib/login.mjs. Behind the front, browsers log in
+   there, and the front sends this server's token in a header. */
+const { loginCode, loginUrl, authed, login } = createLogin({ token: TOKEN, port: () => PORT, origin: () => ORIGIN });
 /* Headless Chrome gets a start page in its own profile folder (0700) instead of a URL with a secret on
-   its command line: the page sends it to a one-time login code, which leads on to the target. */
+   its command line. It never logs in: its targets are the deck's pages under /v/, which need no cookie, so a
+   deck's script there has no way to the API. Chrome's command-line screenshot, DOM dump and print do not
+   work on a page with a sandbox policy, so the page it asks for is served without one, once: the target
+   carries a key that works for one request (headlessKeys). */
+const headlessKeys = new Set();
 function chromeStart(profile, target) {
   fs.mkdirSync(profile, { recursive: true, mode: 0o700 });
   const start = path.join(profile, "pindeck-start.html");
-  const to = loginUrl(loginCode(120000), target.slice(ORIGIN.length)).replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+  const key = crypto.randomBytes(16).toString("hex"), u = new URL(target);
+  headlessKeys.add(key);
+  setTimeout(() => headlessKeys.delete(key), 120000).unref();
+  u.searchParams.set("headless", key);
+  const to = u.href.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
   fs.writeFileSync(start, `<!doctype html><meta http-equiv="refresh" content="0;url=${to}">`, { mode: 0o600 });
   return pathToFileURL(start).href;
 }
 
 /* Files with a length and byte ranges: Safari plays audio and video only from servers that answer a
    Range request with 206, and seeking needs it everywhere. Transformed (HTML) files are sent whole. */
-function serveFile(res, file, transform, req) {
+function serveFile(res, file, transform, req, extra = {}) {
   const type = MIME[path.extname(file).slice(1).toLowerCase()] || "application/octet-stream";
   if (transform) return fs.readFile(file, (err, data) => {
     if (err) return text(res, 404, "Not found");
     const out = Buffer.from(transform(String(data)));
-    res.writeHead(200, { "content-type": type, "content-length": out.length, "cache-control": "no-store" });
+    res.writeHead(200, { "content-type": type, "content-length": out.length, "cache-control": "no-store", ...extra });
     res.end(out);
   });
   fs.stat(file, (err, st) => {
     if (err || !st.isFile()) return text(res, 404, "Not found");
-    const headers = { "content-type": type, "accept-ranges": "bytes", "cache-control": "no-store" };
+    const headers = { "content-type": type, "accept-ranges": "bytes", "cache-control": "no-store", ...extra };
     let start = 0, end = st.size - 1, code = 200;
     const range = /^bytes=(\d*)-(\d*)$/.exec(String(req?.headers.range || "").trim());   // one range only
     if (range && (range[1] || range[2])) {
@@ -1258,14 +1455,29 @@ function serveFile(res, file, transform, req) {
 }
 
 let ready = false;
+const NEEDS_DECK = /^\/api\/(message|slides|layout|shot|pdf|pdf-figure|edit|text|split|remove|notes|delete|delete-info|source|slide-hidden|move-slide|add-slide|import-apply|export)$/;
+const CLI_ROUTES = /^\/api\/(slides|layout|shot|pdf|pdf-figure)$/;   // answered as text, for cli.mjs
+/* Scriptable files (HTML, SVG) from the deck get the sandbox, wherever they are asked for. Under /v/ they are
+   read by documents of that sandboxed origin, so fonts and module scripts need CORS; the path is the secret. */
+const SCRIPTABLE = /\.(html|svg|xml)$/i;
+const deckHeaders = (f, viewing) => ({ ...(SCRIPTABLE.test(f) ? { "content-security-policy": SANDBOX } : {}),
+  ...(viewing ? { "access-control-allow-origin": "*" } : {}) });
 const server = http.createServer(async (req, res) => {
   if (!ready) return text(res, 503, "PinDeck is starting. Reload in a moment.");
   const host = String(req.headers.host || "").toLowerCase();
   if (!goodHost(host)) return text(res, 403, "Bad host");
-  const url = new URL(req.url, ORIGIN);
-  const p = url.pathname;
   try {
+    const url = new URL(req.url, ORIGIN);
+    let p = url.pathname;
     if (req.method === "GET" && p === "/login") return login(res, url);
+    // /v/<token>/deck/... and /v/<token>/files/...: the deck's pages and files, read-only, nothing else
+    let viewing = false;
+    if (p.startsWith("/v/")) {
+      if (!p.startsWith(VIEW + "/") || (req.method !== "GET" && req.method !== "HEAD")) return text(res, 403, "Forbidden");
+      p = p.slice(VIEW.length);
+      if (!p.startsWith("/deck/") && !p.startsWith("/files/")) return text(res, 404, "Not found");
+      viewing = true;
+    }
     // UI and deck files (read-only); the editor's own scripts and styles hold nothing secret
     const ok = authed(req);
     if (req.method === "GET" && (p === "/" || p === "/index.html")) {
@@ -1276,18 +1488,26 @@ const server = http.createServer(async (req, res) => {
       const f = safeJoin(path.join(EDITOR_DIR, "public"), p.slice(8));
       return f ? serveFile(res, f, null, req) : text(res, 403, "Forbidden");
     }
-    if ((p.startsWith("/deck/") || p.startsWith("/files/")) && !ok) return text(res, 403, "Not logged in");
+    if ((p.startsWith("/deck/") || p.startsWith("/files/")) && !ok && !viewing) return text(res, 403, "Not logged in");
     let snap;
     if (req.method === "GET" && (snap = p.match(/^\/(?:deck|files)\/(?:.*\/)?__pindeck-print-([\w-]+)\.html$/))) {
       const html = snapshots.get(snap[1]);
       if (!html) return text(res, 404, "Not found");
-      res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+      // a static print layout (its scripts were removed): no scripts at all, instead of the sandbox Chrome cannot print
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", ...deckHeaders(".css", viewing),
+        "content-security-policy": "script-src 'none'" });
       return res.end(html);
     }
-    // /deck/: the deck folder; /deck/ alone is the deck page. With an asset root the page lives under
-    // /files/, so that ../ paths reach the root: /deck/ alone redirects there.
+    // A deck page asked for outside /v/ (the editor's frames ask for deck/?editor=main, Present for deck/):
+    // sent there, with a relative redirect that stays under the front's /d/<deck>/. /deck/ alone is the deck
+    // page; with an asset root that page lives under /files/, so that ../ paths reach the root.
+    const toView = (target) => {
+      res.writeHead(302, { location: "../".repeat(p.split("/").length - 2) + VIEW.slice(1) + target + url.search, "cache-control": "no-store" });
+      res.end();
+    };
     if (req.method === "GET" && p === "/deck/" && SERVE_ROOT) {
-      res.writeHead(302, { location: DECK_PAGE + url.search, "cache-control": "no-store" });
+      if (!viewing) return toView(DECK_PAGE);
+      res.writeHead(302, { location: ".." + DECK_PAGE + url.search, "cache-control": "no-store" });
       return res.end();
     }
     const deckPath = req.method === "GET" && (p.startsWith("/deck/") ? servable(DECK_DIR, p.slice(6) || DECK_FILE)
@@ -1295,8 +1515,9 @@ const server = http.createServer(async (req, res) => {
     if (deckPath === null) return text(res, 403, "Forbidden");
     if (deckPath) {
       const f = deckPath;
+      if (!viewing && /\.html$/i.test(f)) return toView(p);
       const mode = url.searchParams.get("editor");
-      if (!mode || !/\.html?$/i.test(f)) return serveFile(res, f, null, req);
+      if (!mode || !/\.html$/i.test(f)) return serveFile(res, f, null, req, deckHeaders(f, viewing));
       return serveFile(res, f, (s) => {
         // headless runs must not stream media, or Chrome never finishes the page
         if (mode === "shot" || mode === "dump" || mode === "pdf") s = s.replace(/\bpreload="(auto|metadata)"/g, 'preload="none"');
@@ -1306,7 +1527,20 @@ const server = http.createServer(async (req, res) => {
           return slideSelector(parse(s)) ? s.replace(/<\/body>/i, BRIDGE_TAG) : s;
         }
         return s.replace(/<\/body>/i, BRIDGE_TAG);
-      });
+      }, req, ["shot", "dump", "pdf"].includes(mode) && headlessKeys.delete(url.searchParams.get("headless"))
+        ? deckHeaders(".css", viewing) : deckHeaders(f, viewing));   // headless Chrome's page, once (see chromeStart)
+    }
+    if (viewing) return text(res, 404, "Not found");
+
+    // /shots/: a screenshot for the chat, a PNG directly in the screenshots folder (no subfolder, no symlink out)
+    if (req.method === "GET" && p.startsWith("/shots/")) {
+      if (!ok) return text(res, 403, "Not logged in");
+      const name = decodeURIComponent(p.slice(7));
+      if (!SHOT_NAME.test(name)) return text(res, 403, "Forbidden");
+      const f = path.join(SHOT_DIR, name);
+      let real;
+      try { real = fs.realpathSync(f); } catch { return text(res, 404, "Not found"); }
+      return path.dirname(real) === realOr(SHOT_DIR) ? serveFile(res, f, null, req) : text(res, 403, "Forbidden");
     }
 
     // API: token required (header or login cookie); POSTs must come from the editor page itself
@@ -1324,11 +1558,16 @@ const server = http.createServer(async (req, res) => {
       req.on("close", () => clients.delete(res));
       return;
     }
+    // the deck file gone (moved, renamed, deleted) while PinDeck runs: say so, instead of failing on it
+    if (NEEDS_DECK.test(p) && readDeck(DECK_FILE) == null) {
+      const why = `${path.join(DECK_DIR, DECK_FILE)} is not there any more (moved, renamed or deleted). Put it back, ` +
+        `or start PinDeck for the deck where it is now.`;
+      return CLI_ROUTES.test(p) ? text(res, 409, why) : json(res, 409, { code: "deck-gone", error: why });
+    }
     if (p === "/api/ping") return json(res, 200, { ok: true });
     if (p === "/api/login-link") return json(res, 200, { url: loginUrl(loginCode(3600000)) });
     if (p === "/api/status") return json(res, 200, status());
     if (p === "/api/current" && req.method === "POST") { state.current = await body(req); return json(res, 200, {}); }
-    if (p === "/api/pins" && req.method === "POST") { state.pins = (await body(req)).pins || []; return json(res, 200, {}); }
     if (p === "/api/measure-result" && req.method === "POST") {
       const b = await body(req);
       const w = pending.get(b.id);
@@ -1350,26 +1589,34 @@ const server = http.createServer(async (req, res) => {
       if (!placed(b.selection)) b.selection = null;
       if (!Array.isArray(b.layouts)) b.layouts = [];
       if (b.current && !Number.isInteger(b.current.index)) b.current = null;
-      const preparation = { cancelled: false };
+      const preparation = { cancelled: false, controller: new AbortController() };
       state.preparing = preparation;
       state.busy = true; pushStatus();
       try {
-        let screenshot = null;
+        let screenshot = null, shotFailed = null;
         const shotSlide = typeof b.screenshot === "object" && b.screenshot?.eid ? b.screenshot : b.screenshot ? b.current : null;
         if (shotSlide) {
-          try { screenshot = { slide: shotSlide.index + 1, path: await takeShot(shotSlide) }; }
-          catch (e) { addEntry({ kind: "notice", text: "Screenshot failed: " + e.message }); }
+          const pins = b.pins.filter((p) => p.slide.eid === shotSlide.eid);
+          try { screenshot = { slide: shotSlide.index + 1, pins: pins.length, path: await takeShot(shotSlide, pins, preparation.controller.signal) }; }
+          catch (e) { shotFailed = { slide: shotSlide.index + 1, error: e.message }; }
+        }
+        if (preparation.cancelled) {
+          if (screenshot) fs.rmSync(screenshot.path, { force: true });
+          return json(res, 409, { code: "stopped", error: "Stopped before sending the message." });
         }
-        if (preparation.cancelled) return json(res, 409, { error: "Stopped before sending the message." });
         const label = (p) => (p.tag?.startsWith("footer") ? "footer" : p.eid === p.slide.eid ? "slide" : p.eid.replace(/^[^/]+\//, ""));
         // only files PinDeck itself stored can be attached
         b.attachments = (b.attachments || []).filter((a) => a && state.uploads.has(a.path) && fs.existsSync(uploadFile(a.path)));
         b.attachments.forEach((a) => { state.uploads.delete(a.path); if (a.waveform) state.uploads.delete(a.waveform); });
-        const entry = addEntry({ kind: "user", text: b.text, screenshot: !!screenshot,
+        state.lastPins = b.pins;
+        state.preparing = null;
+        const entry = addEntry({ kind: "user", text: b.text,
+          screenshot: screenshot && { file: path.basename(screenshot.path), slide: screenshot.slide },
           attachments: b.attachments.map((a) => ({ path: a.path, kind: a.kind, name: a.name })),
           selection: b.selection ? { eid: b.selection.eid, label: b.selection.eid.replace(/^[^/]+\//, ""), slide: b.selection.slide.index + 1 } : null,
           pins: (b.pins || []).map((p) => ({ n: p.n, eid: p.eid, label: label(p), slide: p.slide.index + 1 })) });
-        startTurn(buildPrompt({ ...b, screenshot }), entry);
+        if (shotFailed) addEntry({ kind: "notice", text: `Screenshot of slide ${shotFailed.slide} failed: ${shotFailed.error}` });
+        startTurn(buildPrompt({ ...b, screenshot, shotFailed }), entry);
         return json(res, 200, { id: entry.id });
       } finally { state.preparing = null; if (!state.turn) { state.busy = false; pushStatus(); } }
     }
@@ -1396,9 +1643,9 @@ const server = http.createServer(async (req, res) => {
         return json(res, 200, { path: abs, kind, bytes: buf.length, pages: info?.pages, pageSize: info?.sizes[0] });
       }
       const rel = attachPath(original);
-      writeDeckFile(rel, buf);
+      try { writeDeckFile(rel, buf); } catch (e) { return json(res, e.status || 500, { error: e.message }); }
       state.uploads.add(rel);
-      return json(res, 200, { path: rel, kind, bytes: buf.length, url: `/deck/${rel}` });
+      return json(res, 200, { path: rel, kind, bytes: buf.length, url: `deck/${rel}` });
     }
     if (p === "/api/upload-remove" && req.method === "POST") {
       const b = await body(req);
@@ -1409,7 +1656,7 @@ const server = http.createServer(async (req, res) => {
       }
       return json(res, 200, {});
     }
-    if (p === "/api/models" && req.method === "GET") return json(res, 200, await discoverModels());
+    if (p === "/api/models" && req.method === "GET") return json(res, 200, await discoverModels({ fresh: true }));   // Refresh models
     if (p === "/api/settings" && req.method === "POST") {
       const b = await body(req);
       if (state.busy || starting) return json(res, 409, { error: "Wait until the current request finishes before switching." });
@@ -1500,7 +1747,7 @@ const server = http.createServer(async (req, res) => {
       catch (e) { console.error(e); return json(res, 500, { error: String(e.message || e) }); }
     }
     if (p === "/api/stop" && req.method === "POST") {
-      if (state.preparing) { state.preparing.cancelled = true; return json(res, 200, {}); }
+      if (state.preparing) { state.preparing.cancelled = true; state.preparing.controller.abort(); return json(res, 200, {}); }
       if (state.busy && state.turn) {
         const interruptedTurn = state.turn;
         interruptedTurn.cancelled = true;
@@ -1515,7 +1762,9 @@ const server = http.createServer(async (req, res) => {
     if (p === "/api/new-chat" && req.method === "POST") {
       if (state.busy || starting) return json(res, 409, { error: "Stop the current request before starting a new chat." });
       session?.stop();
-      Object.assign(state, { chat: [], sessionId: null, handover: "", turns: [], redo: [], turn: null, busy: false, notes: [] });
+      // the conversation starts anew; the slides, and their undo and redo, stay as they are
+      if (state.sessionId) state.sessionArchive.push({ provider: state.provider, id: state.sessionId });
+      Object.assign(state, { chat: [], sessionId: null, handover: "", turn: null, busy: false, notes: [], conversation: state.conversation + 1 });
       saveChat();
       broadcast("reset", { chat: [] });
       ensureSession().catch(e => addEntry({ kind: "notice", text: e.message }));
@@ -1542,11 +1791,13 @@ const server = http.createServer(async (req, res) => {
       if (diverged.length) return conflict(res, "redo", diverged);
       state.redo.pop();
       for (const rel of changeFiles(t)) if (!isAs(rel, t.after[rel])) putDeckFile(rel, t.after[rel] ?? null);
-      for (const { rel } of t.deletedFiles || []) fs.rmSync(path.join(DECK_DIR, rel), { force: true });
+      for (const { rel } of t.deletedFiles || []) removeDeckFile(rel);
       for (const { rel, data } of t.addedFiles || []) writeDeckFile(rel, data, false);
       t.undone = false;
+      markUndone(t);
       state.notes.push(t.kind === "manual" ? `The user redid their hand edit: ${t.label}.`
-        : `The user redid your change from turn ${t.id} after undoing it.`);
+        : byThisChat(t) ? `The user redid your change from turn ${t.id} after undoing it.`
+        : `The user redid a change made before this conversation began (turn ${t.id}): ${t.files.map((f) => f.file).join(" and ")} as that change left ${t.files.length > 1 ? "them" : "it"}. Re-read before editing.`);
       broadcast("undone", { turnId: t.id, undone: false });
       pushStatus();
       return json(res, 200, {});
@@ -1573,7 +1824,7 @@ const server = http.createServer(async (req, res) => {
       const turnId = recordHandEdit(before, plan.html, label,
         `The user deleted ${plan.eid} (${plan.tag}) by hand` + (deletedFiles.length ? `, together with the file(s) ${deletedFiles.map((f) => f.rel).join(", ")}` : "") + ".",
         { manual: false, deletedFiles });
-      for (const f of deletedFiles) fs.rmSync(path.join(DECK_DIR, f.rel), { force: true });
+      for (const f of deletedFiles) removeDeckFile(f.rel);
       return json(res, 200, { turnId, deleted: plan.eid, files: deletedFiles.map((f) => f.rel) });
     }
 
@@ -1592,7 +1843,9 @@ const server = http.createServer(async (req, res) => {
       return json(res, 200, { turnId });
     }
     if (p === "/api/source") {
-      const html = getInner(readDeck(DECK_FILE), url.searchParams.get("eid"), JSON.parse(url.searchParams.get("path") || "[]"));
+      let where = [];
+      try { where = JSON.parse(url.searchParams.get("path") || "[]"); } catch {}
+      const html = getInner(readDeck(DECK_FILE), url.searchParams.get("eid"), where);
       return html == null ? json(res, 404, { error: "Element not found in the file." }) : json(res, 200, { html });
     }
     // Speaker notes of a slide: read for the notes field, saved as a hand edit
@@ -1638,9 +1891,11 @@ const server = http.createServer(async (req, res) => {
       const before = snapshot(EDITABLE);
       const r1 = setInner(before[DECK_FILE], b.eid, [], String(b.html ?? ""));
       if (!r1) return json(res, 404, { error: `No element ${b.eid} in ${DECK_FILE}.` });
-      const r2 = insertAfter(r1.html, b.eid, { tag: "li", cls: b.cls || "", inner: String(b.newHtml ?? ""), newEid: b.newEid });
+      // the new bullet's elements get ids of their own: never a copy of one from the bullet it was split from
+      const inner = String(b.newHtml ?? "").replace(/\sdata-eid="[^"]*"/g, "");
+      const r2 = insertAfter(r1.html, b.eid, { tag: "li", cls: b.cls || "", inner, newEid: b.newEid });
       const short = (e) => e.replace(/^[^/]+\//, "/");
-      const turnId = recordHandEdit(before, r2.html, `New bullet after ${short(b.eid)}`,
+      const turnId = recordHandEdit(before, assignEids(r2.html).html, `New bullet after ${short(b.eid)}`,
         `The user added a bullet (${r2.eid}) after ${b.eid} by pressing Enter while editing; ${b.eid} now reads "${String(b.text || "").slice(0, 200)}".`);
       return json(res, 200, { turnId, eid: r2.eid });
     }
@@ -1695,9 +1950,11 @@ const server = http.createServer(async (req, res) => {
     return text(res, 404, "Not found");
   } catch (e) {
     // malformed JSON or %-encoding in a request is the caller's mistake, not a server error
-    const bad = e instanceof SyntaxError || e instanceof URIError || e.message === "body too large";
-    if (!bad) console.error(e);
-    if (!res.headersSent) text(res, bad ? 400 : 500, String(e.message || e));
+    const large = e.message === "body too large", bad = large || e instanceof SyntaxError || e instanceof URIError;
+    if (!bad && !e.status) console.error(e);
+    // the rest of a body too large is not read: the connection is not used again
+    if (large && !res.headersSent) res.setHeader("connection", "close");
+    if (!res.headersSent) text(res, e.status || (large ? 413 : bad ? 400 : 500), String(e.message || e));
   }
 });
 
@@ -1722,25 +1979,26 @@ server.listen(PORT, "127.0.0.1", () => {
     if (first.changed) console.log(`Added ${first.assigned.length} element ids to ${DECK_FILE} (backup in ${path.join(STATE_DIR, "backups")}).`);
     startWatcher();
   } catch (e) {
-    console.error(`PinDeck could not open the deck: ${e.message}`);
+    console.error(e.plain ? e.message : `PinDeck could not open the deck: ${e.message}`);
     removeServerInfo();
     process.exit(1);
   }
   ready = true;
-  console.log(`PinDeck: ${loginUrl(loginCode(3600000))}`);
-  console.log("  (a one-time login link, valid for an hour; for a new one: pindeck login)");
-  console.log(`Deck: ${DECK_DIR}`);
-  console.log(`Server: ${CAPS.label}`);
-  for (const [name, c] of Object.entries(publicCapabilities(CAPS)))
-    if (c && c.available === false) console.log(`  ${name}: off (${c.reason})`);
-  discoverModels().then(() => {
-    if (!settings.model) {
-      const models = catalog[settings.provider].models;
-      const first = models.find(m => m.isDefault) || models[0];
-      if (first) { settings.model = first.id; settings.effort = first.defaultEffort; }
-    }
-    pushStatus();
-  });
+  if (FRONT) {
+    // the front prints the login link and the capabilities; it ends this server when it goes, even killed
+    process.send({ ready: { url: ORIGIN, token: TOKEN } });
+    process.on("disconnect", () => { if (!quitting) quit(); });   // a second quit() would exit at once
+  } else {
+    console.log(`PinDeck: ${loginUrl(loginCode(3600000))}`);
+    console.log("  (a one-time login link, valid for an hour; for a new one: pindeck login)");
+    openOnEnter(() => loginUrl(loginCode(3600000)));
+    console.log(`Deck: ${DECK_DIR}`);
+    console.log(`Server: ${CAPS.label}`);
+    for (const [name, c] of Object.entries(publicCapabilities(CAPS)))
+      if (c && c.available === false) console.log(`  ${name}: off (${c.reason})`);
+  }
+  for (const n of startNotices) addEntry(n);
+  discoverModels().then(() => { settle(); pushStatus(); });
 });
 /* Ctrl+C or SIGTERM: stop taking requests, let the backend end (it gets end of input, then SIGTERM, then
    SIGKILL), then exit. At most 6 s; a second Ctrl+C exits at once. A running turn is not resumed later. */