slidemind 0.3.19 → 0.4.0

package/src/workspace/routes.mjs

@@ -0,0 +1,1331 @@
+// The workspace API (contracts §3) on server.mjs's `handle` seam.
+//
+// Every deck route resolves a REGISTRY id — a path never travels in a URL.
+// Reads need a credential (CLI bearer or browser cookie); mutations also need
+// the CSRF token plus same-origin evidence (auth.mjs). Bodies are JSON ≤ 2 MiB.
+// Network work answers 202 + a job id; nothing here blocks a save on the wire.
+//
+// Seams the other lanes fill (`deps`, each lazily imported when absent):
+//   tasks   src/workspace/tasks.mjs   listTasks / requestTask / getTask / respondTask
+//   edit    src/workspace/edit.mjs    savePlanLocal
+//   remote  the wave-3 lanes replace the 501 placeholders below
+
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { previewBuiltFrom } from "../builders/build.mjs";
+import { MIME } from "../builders/gate-server.mjs";
+import { isEditRouteDeck } from "../builders/edit-route.mjs";
+import { OVERLAY_PATH as REVIEW_OVERLAY_PATH, brandAssetsDirForDeck, injectReview, loadReviewState, normalizeReviewComments, previewHash, reviewLogoFile, routeBrandAssets } from "../builders/review.mjs";
+import { splitPlanFrontmatter } from "../builders/resolve-skill.mjs";
+import { deckFormat, planPageOwner, previewPath, resolveWorkspace } from "../lib/deck-paths.mjs";
+import { pidAlive, readBusy } from "../lib/revision.mjs";
+import { dispatchAdapter, resolveWorkspaceAdapter } from "./adapters.mjs";
+import { deriveTaskSubject, invokeTaskAction, respondTaskAction, taskActionsFor, taskActor, taskEvidenceVerifier } from "./task-actions.mjs";
+import { readJob, skip as skipDir, startDiscovery } from "./discovery.mjs";
+import { openFile as defaultOpenFile, pickFolder as defaultPickFolder, revealFolder as defaultRevealFolder, trashFolder as defaultTrashFolder } from "./pick-folder.mjs";
+import { events as defaultEvents } from "./events.mjs";
+import { pasteMessage, receiveCommand, viewOf } from "./handback.mjs";
+import { readOperationIntent, runDeckOperation } from "./operations.mjs";
+// The async twins, not the spinning ones: this server has one event loop and a
+// synchronous wait for the registry lock stalls SSE and every long poll with it.
+import { addDeckAsync, getDeck, listDecks, listRoots, removeDeckAsync } from "./registry.mjs";
+import { sendError, sendJson } from "./server.mjs";
+
+export const PREFIX = "/api/v1";
+export const MAX_BODY_BYTES = 2 * 1024 * 1024;
+export const UI_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "ui");
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const ACTION_METHOD = { "plan.validate": "validate", "workbook.import": "import-workbook" };
+const STATUS = {
+  unauthorized: 401,
+  csrf_required: 403,
+  cross_origin: 403,
+  outside_roots: 403,
+  unknown_deck: 404,
+  unknown_task: 404,
+  unknown_job: 404,
+  not_found: 404,
+  missing_path: 404,
+  method_not_allowed: 405,
+  deck_busy: 409,
+  local_conflict: 409,
+  remote_conflict: 409,
+  stale_subject: 409,
+  already_answered: 409,
+  operation_mismatch: 409,
+  registry_busy: 409,
+  path_registered: 409,
+  payload_too_large: 413,
+  bad_request: 400,
+  bad_job_id: 400,
+  not_a_deck: 422,
+  unsupported_format: 409,
+  validation_failed: 422,
+  extension_missing: 424,
+  extension_incompatible: 424,
+  approval_requires_sync: 409,
+  approval_in_progress: 409,
+  conflict_requires_resolve: 409,
+  outcome_unknown: 409,
+  recovery_required: 423,
+  not_implemented: 501,
+  // remote association (thrown by remote-links / remote-status outside a job)
+  selection_expired: 410,
+  name_exists: 409,
+  cross_tenant: 409,
+  dirty_target: 409,
+  already_bound: 409,
+  backend_ambiguous: 409,
+  login_required: 401,
+  access_denied: 403,
+  remote_missing: 404,
+  not_a_folder: 422,
+  unsupported_link: 422,
+  trash_unavailable: 422,
+  offline: 503,
+};
+const RETRYABLE = new Set(["deck_busy", "registry_busy"]);
+
+export class RouteError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+}
+const fail = (code, message, details) => new RouteError(code, message, details);
+
+/** One JSON body, ≤ MAX_BODY_BYTES, or a typed failure. */
+export function readJson(req, limit = MAX_BODY_BYTES) {
+  return new Promise((resolve, reject) => {
+    const declared = Number(req.headers["content-length"] ?? 0);
+    if (declared > limit) {
+      req.resume();
+      return reject(fail("payload_too_large", `body exceeds ${limit} bytes`));
+    }
+    const chunks = [];
+    let bytes = 0;
+    req.on("data", (c) => {
+      bytes += c.length;
+      if (bytes > limit) {
+        req.destroy();
+        reject(fail("payload_too_large", `body exceeds ${limit} bytes`));
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("error", reject);
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      if (!raw.trim()) return resolve({});
+      try {
+        const v = JSON.parse(raw);
+        if (!v || typeof v !== "object" || Array.isArray(v)) throw new Error("not an object");
+        resolve(v);
+      } catch (err) {
+        reject(fail("bad_request", `invalid JSON body: ${err.message}`));
+      }
+    });
+  });
+}
+
+const sha256 = (text) => `sha256:${createHash("sha256").update(text, "utf8").digest("hex")}`;
+
+/** A file under `root`, by realpath containment; false when it is not one. */
+export function serveContained(root, rel, res) {
+  let base;
+  try {
+    base = fs.realpathSync(root);
+  } catch {
+    return false;
+  }
+  const candidate = path.resolve(base, String(rel).replace(/^\/+/, ""));
+  let real;
+  try {
+    real = fs.realpathSync(candidate);
+    if (!fs.statSync(real).isFile()) return false;
+  } catch {
+    return false;
+  }
+  if (real !== base && !real.startsWith(base + path.sep)) return false;
+  res.writeHead(200, { "Content-Type": MIME[path.extname(real).toLowerCase()] || "application/octet-stream", "Cache-Control": "no-store" });
+  res.end(fs.readFileSync(real));
+  return true;
+}
+
+const lazy = (spec) => {
+  let mod;
+  return async () => {
+    if (mod !== undefined) return mod;
+    try {
+      mod = await import(spec);
+    } catch (err) {
+      if (err?.code !== "ERR_MODULE_NOT_FOUND") throw err;
+      mod = null;
+    }
+    return mod;
+  };
+};
+
+function resolveDeck(id) {
+  if (!UUID.test(String(id))) throw fail("unknown_deck", "deck ids are registry UUIDs");
+  const deck = getDeck(id);
+  if (!deck) throw fail("unknown_deck", `no registered deck ${id}`);
+  if (!fs.existsSync(deck.path)) throw fail("missing_path", `${deck.path} is not there any more`, { deckId: id, path: deck.path, name: deck.name ?? null });
+  return { ...deck, workspaceDir: resolveWorkspace(deck.path) };
+}
+
+/** The installed adapter a deck's plan owner names, or the blocker. Core-owned decks: null adapter. */
+function deckAdapter(deck) {
+  const owner = planPageOwner(deck.workspaceDir);
+  if (owner.owner === "core") return { id: "core", entry: null, owner };
+  const resolved = resolveWorkspaceAdapter(owner.owner === "extension" ? null : owner.owner);
+  return { ...resolved, owner };
+}
+
+function adapterResult(r) {
+  if (r.status === "ok") return r.data;
+  throw fail(r.error?.code ?? (r.status === "blocked" ? "deck_busy" : "extension_incompatible"), r.error?.message ?? "adapter failed", r.error?.details);
+}
+
+function mapCode(err) {
+  const code = err?.code && STATUS[err.code] ? err.code : null;
+  return { status: code ? STATUS[code] : 500, code: code ?? "internal", retryable: RETRYABLE.has(code) };
+}
+
+/**
+ * Preview freshness for the deck view. `hash` is the source hash the last
+ * review round recorded, `sourceHash` what the slides hash to now; `stale`
+ * compares presentation.html's mtime with the newest source file, so a
+ * rebuilt-but-unreviewed preview still reads fresh.
+ */
+/**
+ * One stat walk over the reviewed sources (slides/, assets/): the newest mtime,
+ * and a signature of every name, size and time. Cheap — no file is read.
+ */
+function previewScan(ws) {
+  let newest = 0;
+  const parts = [];
+  const walk = (dir, rel) => {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => (a.name < b.name ? -1 : 1))) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) walk(p, `${rel}/${e.name}`);
+      else if (e.isFile()) {
+        const st = fs.statSync(p);
+        newest = Math.max(newest, st.mtimeMs);
+        parts.push(`${rel}/${e.name}:${st.size}:${st.mtimeMs}`);
+      }
+    }
+  };
+  for (const sub of ["slides", "assets"]) walk(path.join(ws, sub), sub);
+  return { newest, sig: parts.join("|") };
+}
+
+// The content hash reads every slide and asset; a page polls every 2 s. It is
+// recomputed only when a stat signature moved. Display paths only — every
+// decision hashes fresh (subjectOf, respondPreview).
+const previewHashMemo = new Map(); // ws → { sig, hash }
+function previewHashCached(ws, scan = previewScan(ws)) {
+  const memo = previewHashMemo.get(ws);
+  if (memo && memo.sig === scan.sig) return memo.hash;
+  const hash = previewHash(ws);
+  previewHashMemo.set(ws, { sig: scan.sig, hash });
+  return hash;
+}
+
+function previewState(ws, { scan = null, sourceHash: known = null } = {}) {
+  const file = previewPath(ws, "presentation.html");
+  let builtAt = null;
+  try {
+    builtAt = fs.statSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  const seen = scan ?? previewScan(ws);
+  const newest = seen.newest;
+  const reviewed = loadReviewState(ws).deckHash;
+  let sourceHash = known;
+  if (!sourceHash) {
+    try {
+      sourceHash = previewHashCached(ws, seen);
+    } catch {
+      // no bundle resolvable: freshness by mtime only
+    }
+  }
+  // The stamp the build wrote (the hash it was built from) is the truth when
+  // present — a deleted or renamed slide keeps no newer mtime; file times are the
+  // fallback for a preview built before stamps existed.
+  const builtFrom = previewBuiltFrom(ws);
+  const stale = builtFrom && sourceHash ? builtFrom !== sourceHash : newest > builtAt;
+  return { hash: reviewed ? `sha256:${reviewed}` : null, sourceHash, builtFrom, builtAt: new Date(builtAt).toISOString(), newestSourceAt: newest, stale };
+}
+
+/**
+ * The deck's built .pptx (absolute path), or null. `<name>.pptx` wins; a deck
+ * that holds several takes the newest, which is what a build just wrote.
+ */
+function deckPptx(deck) {
+  let names = [];
+  try {
+    names = fs.readdirSync(deck.path).filter((f) => /\.pptx$/i.test(f) && !f.startsWith("~$"));
+  } catch {
+    return null;
+  }
+  if (!names.length) return null;
+  const preferred = names.find((f) => f.toLowerCase() === `${String(deck.name ?? "").toLowerCase()}.pptx`);
+  const pick =
+    preferred ??
+    names.sort((a, b) => fs.statSync(path.join(deck.path, b)).mtimeMs - fs.statSync(path.join(deck.path, a)).mtimeMs)[0];
+  return path.join(deck.path, pick);
+}
+
+/** Unsettled local work: an operation intent on disk or a queue with work pending. */
+function dirtyState(ws, sync) {
+  const intent = readOperationIntent(ws);
+  return Boolean(intent) || Boolean(sync && !sync.synced && sync.exists);
+}
+
+/**
+ * `createRoutes({ auth, deps })` → `handle(req, res, ctx)` for createServer.
+ *   auth   from auth.mjs
+ *   deps   { tasks?, edit?, events?, track?, restart?, uiRoot?, adapter? }
+ *          tasks/edit default to the sibling modules when they exist;
+ *          adapter(deck) overrides deckAdapter (tests); track(promise) holds the
+ *          drain; restart() is the daemon's re-exec.
+ */
+export function createRoutes({ auth, deps = {} } = {}) {
+  const loadTasks = deps.tasks ? async () => deps.tasks : lazy("./tasks.mjs");
+  const loadEdit = deps.edit ? async () => deps.edit : lazy("./edit.mjs");
+  // remote association (remote-links / remote-status); `deps.remote` is the
+  // override bag those modules take (a mock provider session in tests)
+  const loadLinks = lazy("./remote-links.mjs");
+  const loadStatus = lazy("./remote-status.mjs");
+  // autosync + the approval/conflict coordinator (sync.mjs: drainOnce, refreshOnce,
+  // resolveConflict, activateDestination, approvalInProgress, syncStatus);
+  // `deps.syncModule` injects a fake (`deps.sync` is the daemon loop's bag)
+  const loadSync = deps.syncModule ? async () => deps.syncModule : lazy("./sync.mjs");
+  const remoteDeps = deps.remote ?? {};
+  // a task answer: the coordinator entry point, or the injected fake store's respondTask
+  const respond = deps.tasks
+    ? (deckRoot, id, req, { adapter, owner, verify }) =>
+        deps.tasks.respondTask(deckRoot, id, req, { owner, verify, invoke: (task, response, { token }) => invokeTaskAction({ deckRoot, adapter, task, response, token, payload: req.payload ?? {} }) })
+    : respondTaskAction;
+
+  /** One export of a lazily loaded module, or a typed 501 when this build lacks it. */
+  const fn = async (loader, name, what) => {
+    const mod = await loader();
+    if (!mod || typeof mod[name] !== "function") throw fail("not_implemented", `${what} is not available in this build`);
+    return mod[name];
+  };
+  const syncCard = async (ws) => {
+    const s = await loadSync();
+    if (!s || typeof s.syncStatus !== "function") return null;
+    try {
+      return s.syncStatus(ws);
+    } catch (err) {
+      return { state: "recovery_required", synced: false, exists: true, lastError: { code: err.code ?? "recovery_required", message: err.message } };
+    }
+  };
+  const remoteCard = async (deck) => {
+    const st = await loadStatus();
+    const remote = st ? await st.remoteStatus(deck.path, remoteDeps) : null;
+    const sync = await syncCard(deck.workspaceDir);
+    if (!remote) return { remote: null, sync };
+    // the queue is the authority on "blocked": a conflict or an unknown outcome overrides the disk-only card
+    const blocked = sync && (sync.conflict || ["blocked", "outcome-unknown", "recovery_required"].includes(sync.state));
+    const plan = remote.plan.state === "shared" && blocked ? { ...remote.plan, state: "blocked", reason: sync.lastError?.code ?? (sync.conflict ? "remote_conflict" : sync.state), lastConfirmedAt: sync.lastConfirmedAt ?? remote.plan.lastConfirmedAt } : remote.plan;
+    return { remote: { ...remote, plan, sync }, sync };
+  };
+  const events = deps.events ?? defaultEvents;
+  const track = deps.track ?? ((p) => p);
+  const uiRoot = deps.uiRoot ?? UI_ROOT;
+  const adapterOf = deps.adapter ?? deckAdapter;
+
+  const need = async (loader, name) => {
+    const mod = await loader();
+    if (!mod) throw fail("not_implemented", `${name} is not available in this build`);
+    return mod;
+  };
+
+  /** A store without waitTask (an injected fake): poll it until the task settles. */
+  async function pollTask(tasksMod, deckRoot, taskId, timeoutMs, signal) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+      const task = (await tasksMod.listTasks(deckRoot, {})).find((t) => t.id === taskId);
+      if (!task) throw fail("stale_subject", `no task ${taskId} on this deck`);
+      if (task.status !== "pending") return { task, pending: false };
+      if (signal.aborted || Date.now() >= deadline) return { task, pending: true };
+      await new Promise((r) => setTimeout(r, 200));
+    }
+  }
+
+  async function describe(deck) {
+    const a = adapterOf(deck);
+    if (a.blocker || !a.entry) return { adapter: a, views: null, actions: [] };
+    const data = adapterResult(await dispatchAdapter(a.entry, { method: "describe", deckRoot: deck.path }));
+    return { adapter: a, views: data?.views ?? null, actions: Array.isArray(data?.actions) ? data.actions : [], record: data?.record ?? null };
+  }
+
+  async function readPlan(deck) {
+    const a = adapterOf(deck);
+    if (a.blocker) throw fail(a.blocker.code, a.blocker.message);
+    if (!a.entry) {
+      const file = path.join(deck.workspaceDir, "plan.md");
+      let value = null;
+      try {
+        value = fs.readFileSync(file, "utf8");
+      } catch {
+        // a deck without a plan yet
+      }
+      return { value, hash: value === null ? null : sha256(value), format: "markdown", adapterId: "core", capabilities: { save: true }, sync: null };
+    }
+    const data = adapterResult(await dispatchAdapter(a.entry, { method: "read", deckRoot: deck.path }));
+    return { format: "json", adapterId: a.id, capabilities: {}, sync: null, ...data };
+  }
+
+  // GET /decks/:id/preview/<file>, the preview page's media and GET /ui/<file>.
+  // The page's `<base href="../">` resolves the deck's own `./assets/…` (engine
+  // downloads, converted pictures) to /decks/:id/assets/, and previewPageHtml
+  // points the brand's at /decks/:id/brand/assets/ — the two roots `slidemind
+  // review` serves the same page from. Nothing else of the workspace is served.
+  function serveFiles(pathname, res) {
+    const ui = pathname.match(/^\/ui\/(.+)$/);
+    if (ui) return serveContained(uiRoot, decodeURIComponent(ui[1]), res);
+    const pv = pathname.match(/^\/api\/v1\/decks\/([^/]+)\/(preview|assets|brand\/assets)\/(.+)$/);
+    if (pv) {
+      const ws = resolveDeck(pv[1]).workspaceDir;
+      const root = pv[2] === "preview" ? previewPath(ws) : pv[2] === "assets" ? path.join(ws, "assets") : brandAssetsDirForDeck(ws);
+      return !!root && serveContained(root, decodeURIComponent(pv[3]), res);
+    }
+    return false;
+  }
+
+  /** presentation.html as this server serves it: the bundle's file: URLs answered by the deck's brand route. */
+  function previewPageHtml(deck) {
+    const html = fs.readFileSync(previewPath(deck.workspaceDir, "presentation.html"), "utf8");
+    return routeBrandAssets(html, brandAssetsDirForDeck(deck.workspaceDir), `${PREFIX}/decks/${deck.id}/brand/assets`);
+  }
+
+  // The route table: [method, regex, handler(params, ctx)] → body | { status, body }
+  const pickFolder = deps.pickFolder ?? defaultPickFolder;
+  const revealFolder = deps.revealFolder ?? defaultRevealFolder;
+  const openFile = deps.openFile ?? defaultOpenFile;
+  const trashFolder = deps.trashFolder ?? defaultTrashFolder;
+  // The embedded gates (plan.html / the preview review inside the workspace
+  // page) POST their decision without the page's CSRF header: each rendered
+  // page carries a token in its endpoint URL instead, minted per deck. With a
+  // persisted auth (auth.gateTokenFor) the token outlives a daemon restart, so
+  // a page left open keeps working; the local map is the in-memory fallback.
+  const gateTokens = new Map(); // token → deckId
+  const gateTokenFor = (deckId) => {
+    if (typeof auth?.gateTokenFor === "function") return auth.gateTokenFor(deckId);
+    for (const [t, id] of gateTokens) if (id === deckId) return t;
+    const t = createHash("sha256").update(`${deckId}:${Math.random()}:${Date.now()}`).digest("base64url");
+    gateTokens.set(t, deckId);
+    return t;
+  };
+  const gateTokenValid = (token, deckId) =>
+    typeof auth?.gateTokenValid === "function" ? auth.gateTokenValid(token, deckId) : gateTokens.get(token) === deckId;
+
+  // Scripts waiting on a task (`slidemind tasks wait` long-polls GET …/wait; no
+  // agent does — every hand-back is a paste, doc 21). The page says nothing
+  // about them: whether some process happens to wait never changes what the
+  // user sees. Two things still read them: the daemon does not restart into new
+  // code under an open wait, and a wait's owner token lets the answer to THAT
+  // task re-enter the script's edit session instead of meeting deck_busy.
+  const waiters = new Map(); // "<deckId>:<taskId>" → { open, owner }
+  const ownerOn = (deckId, taskId) => {
+    const w = taskId ? waiters.get(`${deckId}:${taskId}`) : null;
+    return w && w.open > 0 && w.owner ? w.owner : null;
+  };
+  const openWaits = () => [...waiters.values()].reduce((n, w) => n + w.open, 0);
+  // questions an open page was told about: asking the same question again
+  // (the user said "continue" before answering) does not announce it twice
+  const attended = new Set();
+  /** Pending tasks of one kind, newest first. */
+  const pendingOf = async (deck, kind) => {
+    const tasksMod = await loadTasks();
+    return tasksMod ? (await tasksMod.listTasks(deck.path, { status: "pending" })).filter((t) => t.kind === kind).sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt))) : [];
+  };
+  /** Every task of one kind, newest first. */
+  const tasksOf = async (deck, kind) => {
+    const tasksMod = await loadTasks();
+    return tasksMod ? (await tasksMod.listTasks(deck.path, {})).filter((t) => t.kind === kind).sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt))) : [];
+  };
+  /** The round a gate page belongs to: the reviewed content plus the task waiting on it. */
+  // The round = the reviewed content + the NEWEST task of that kind, whatever its
+  // status: answering a task must not read as a new round (the page would reload
+  // and drop its "agent revising" state), a fresh request on the same content must.
+  const gateRound = async (deck, kind, subjectHash) => {
+    const newest = (await tasksOf(deck, kind))[0] ?? null;
+    return createHash("sha256").update(`${subjectHash}|${newest?.id ?? ""}`).digest("hex").slice(0, 16);
+  };
+  const subjectOf = async (deck, kind) => {
+    if (kind === "preview-review") return previewHash(deck.workspaceDir);
+    const { planSubjectHash } = await import("../builders/plan.mjs");
+    return planSubjectHash(deck.workspaceDir);
+  };
+  /** Who holds the deck right now — an agent's edit session or a running command — or null. */
+  const busyOf = (deck) => {
+    let b = null;
+    try {
+      b = readBusy(deck.workspaceDir);
+    } catch {
+      return null;
+    }
+    if (!b) return null;
+    if (b.kind !== "session" && (b.pid === process.pid || !b.pid || !pidAlive(b.pid))) return null;
+    return { since: b.startedAt ?? null, command: b.command ?? null, session: b.kind === "session" };
+  };
+  /** When the agent last changed what this gate shows: plan.md, or the slides/assets and the built preview. */
+  const activityOf = (deck, kind, scan = null) => {
+    const ws = deck.workspaceDir;
+    let newest = 0;
+    const stat = (p) => {
+      try {
+        newest = Math.max(newest, fs.statSync(p).mtimeMs);
+      } catch {
+        // not there
+      }
+    };
+    stat(path.join(ws, "plan.md"));
+    if (kind === "preview-review" && scan) {
+      stat(previewPath(ws, "presentation.html"));
+      newest = Math.max(newest, scan.newest);
+    } else if (kind === "preview-review") {
+      stat(previewPath(ws, "presentation.html"));
+      for (const sub of ["slides", "assets"]) {
+        let names = [];
+        try {
+          names = fs.readdirSync(path.join(ws, sub));
+        } catch {
+          continue;
+        }
+        for (const n of names) stat(path.join(ws, sub, n));
+      }
+    }
+    return newest ? new Date(newest).toISOString() : null;
+  };
+  const approvedNow = async (deck, kind, subjectHash) => {
+    if (kind === "preview-review") {
+      const s = loadReviewState(deck.workspaceDir);
+      return s.decision === "approve" && `sha256:${s.deckHash}` === subjectHash;
+    }
+    const { planApprovedExactly } = await import("../builders/plan.mjs");
+    return planApprovedExactly(deck.workspaceDir);
+  };
+  /** What an embedded gate's heartbeat carries (contract: heartbeat). */
+  const gateBeat = async (deck, kind, service, subjectHash, { scan = null } = {}) => {
+    const all = await tasksOf(deck, kind);
+    const pending = all.find((t) => t.status === "pending") ?? null;
+    const done = all.find((t) => t.status === "completed") ?? null;
+    return {
+      service,
+      round: createHash("sha256").update(`${subjectHash}|${all[0]?.id ?? ""}`).digest("hex").slice(0, 16),
+      taskId: pending?.id ?? null,
+      subject: subjectHash,
+      approved: await approvedNow(deck, kind, subjectHash),
+      answered: done ? { taskId: done.id, action: done.response?.action ?? null, at: done.response?.at ?? null, pickedUpAt: done.pickedUpAt ?? null, subject: done.subject?.hash ?? null } : null,
+      busy: busyOf(deck),
+      activityAt: activityOf(deck, kind, scan),
+      ...(kind === "preview-review" ? { previewStale: previewState(deck.workspaceDir, { scan, sourceHash: subjectHash })?.stale === true } : {}),
+    };
+  };
+
+  /**
+   * The plan the human edited inside the gate, committed BEFORE the answer, the
+   * way the Markdown editor's save commits it (PUT /plan): under the deck lock,
+   * with the stale-base check, and the pending plan task FOLLOWS the edit — so
+   * the answer is about exactly the plan the human approved, the agent learns
+   * it was edited (`subject.requestedHash`), and the task can complete. Writing
+   * the edit inside the answer instead left the task pending with a hash that
+   * no longer matched (the agent's wait never returned).
+   */
+  async function commitGateEdit(deck, adapter, expectedHash, editedBody, owner) {
+    const file = path.join(deck.workspaceDir, "plan.md");
+    let text;
+    try {
+      text = fs.readFileSync(file, "utf8");
+    } catch {
+      throw fail("stale_subject", "this deck has no plan any more");
+    }
+    const current = sha256(text);
+    const { frontmatterRaw, body } = splitPlanFrontmatter(text);
+    if (editedBody === body) return null;
+    if (expectedHash && expectedHash !== current) {
+      throw fail("stale_subject", "your agent changed the plan while you were editing it", { current });
+    }
+    const syncMod = await loadSync();
+    if (syncMod?.approvalInProgress?.(deck.workspaceDir)) throw fail("approval_in_progress", "an approval of this plan is in flight; your edits are kept and can be saved once it settles");
+    const edit = await need(loadEdit, "plan editing");
+    const result = await edit.savePlanLocal({ workspaceDir: deck.workspaceDir, adapter, operationId: randomUUID(), base: { hash: current, value: text }, value: frontmatterRaw + editedBody, owner });
+    if (result?.code) throw fail(result.code, result.message ?? result.code, result);
+    // The agent wrote plan.md between our read and the lock: the save merged onto
+    // a plan the human never saw. Their edit is kept (a later version can show it),
+    // but this answer is not about what they looked at.
+    if (result?.ok && result.previous !== current) {
+      events.invalidate({ type: "plan", deckId: deck.id });
+      throw fail("stale_subject", "your agent changed the plan while you were editing it", { current: result.hash });
+    }
+    const tasksMod = await loadTasks();
+    if (result?.ok && result.previous !== result.hash) await tasksMod?.followPlanEdit?.(deck.path, { from: result.previous, to: result.hash }, { owner });
+    events.invalidate({ type: "plan", deckId: deck.id });
+    return { from: result.previous, to: result.hash };
+  }
+
+  const gateNoun = (kind) => (kind === "plan-approval" ? "plan" : "slides");
+  const gateCommand = (kind, deck) => `slidemind ${kind === "plan-approval" ? "plan" : "review"} ${JSON.stringify(deck.path)}`;
+
+  /**
+   * A decision posted by an embedded gate. Every answer lands on a TASK about
+   * exactly the content the human looked at (`expectedHash`): the pending one
+   * the agent asked, or — when the agent has not asked about this version (it
+   * never asked, or asked about an older one) — one asked on the human's behalf.
+   * The agent's next `slidemind plan|review` run hands it over — the command
+   * the ack's `message` names, which the page copies for the user to paste.
+   */
+  async function gateDecision(deck, kind, body) {
+    const adapter = adapterOf(deck);
+    if (adapter.blocker) throw fail(adapter.blocker.code, adapter.blocker.message);
+    const tasksMod = await need(loadTasks, "tasks");
+    const decision = body.decision === "comments" ? "comments" : "approve";
+    const operationId = UUID.test(String(body.operationId ?? "")) ? String(body.operationId) : randomUUID();
+    let expected = typeof body.expectedHash === "string" && /^sha256:[a-f0-9]{64}$/.test(body.expectedHash) ? body.expectedHash : null;
+    const all = await tasksOf(deck, kind);
+    // the same attempt again (a retry after a dropped response): the recorded answer, nothing new
+    const replay = all.find((t) => t.response?.operationId === operationId);
+    if (replay) return gateAck(deck, kind, replay, { decision: replay.response.action === "approve" ? "approve" : "comments", replayed: true });
+    const pending = all.find((t) => t.status === "pending") ?? null;
+    const owner = ownerOn(deck.id, pending?.id) ?? false;
+    let edited = false;
+    if (kind === "plan-approval" && !adapter.entry && typeof body.editedPlan === "string") {
+      const moved = await commitGateEdit(deck, adapter, expected, body.editedPlan, owner);
+      if (moved) {
+        edited = true;
+        expected = moved.to;
+      }
+    }
+    const current = await subjectOf(deck, kind);
+    // A preview older than its slides shows something other than what an approval would cover.
+    // a decision judges freshness on a FRESH hash, never the heartbeat's cached one
+    if (kind === "preview-review" && decision === "approve" && previewState(deck.workspaceDir, { sourceHash: current })?.stale === true) {
+      throw fail("stale_subject", "your agent changed the slides after this preview was made — it will show you the new version for review", { current, previewStale: true });
+    }
+    const fresh = (await tasksOf(deck, kind)).find((t) => t.status === "pending") ?? null;
+    if (expected && expected !== current) {
+      // the human's own earlier edits are theirs; anything else moved under the page
+      const own = fresh && fresh.subject?.hash === current && (fresh.subject?.followed ?? []).includes(expected);
+      if (!own) throw fail("stale_subject", `your agent changed the ${gateNoun(kind)} after this page was opened`, { current });
+    }
+    let task = fresh && fresh.subject?.hash === current ? fresh : null;
+    if (!task) {
+      // Already answered (another tab, a page left open): one answer per version. A
+      // new question about the same content (the agent asked again) is pending, so
+      // it does not land here.
+      const done = (await tasksOf(deck, kind)).find((t) => t.status === "completed" && (t.subject?.hash === current || t.evidence?.hash === current));
+      if (done) throw fail("already_answered", `this version of the ${gateNoun(kind)} was already answered`, { action: done.response?.action ?? null, at: done.response?.at ?? null, taskId: done.id });
+      // Nobody asked about exactly this version: ask now, on the human's behalf.
+      // A pending task about an older version is superseded by it; an agent
+      // waiting on that one re-asks and receives this answer at once.
+      const { adapterId, subject } = await deriveTaskSubject({ deckRoot: deck.path, adapter, kind });
+      if (subject.hash !== current) throw fail("stale_subject", `your agent changed the ${gateNoun(kind)} after this page was opened`, { current: subject.hash });
+      const asked = await tasksMod.requestTask(deck.path, { kind, adapterId, subject }, { owner, verify: taskEvidenceVerifier({ deckRoot: deck.path, adapter }) });
+      task = asked?.task ?? asked;
+    }
+    const comments = decision === "comments" ? (Array.isArray(body.comments) ? body.comments : []) : [];
+    // a design picked at the gate is applied with the answer (respondPlan)
+    const design = kind === "plan-approval" && !adapter.entry && typeof body.design === "string" ? body.design : null;
+    const payload = { comments, ...(edited ? { edited: true } : {}), ...(design ? { design } : {}) };
+    const action = decision === "comments" ? (task.actions ?? []).find((a) => a !== "approve") ?? "comment" : "approve";
+    const { actor, selfDeclared } = taskActor(payload);
+    const verify = taskEvidenceVerifier({ deckRoot: deck.path, adapter });
+    let answered;
+    try {
+      answered = await track(respond(deck.path, task.id, { operationId, expectedHash: task.subject?.hash ?? current, action, payload, actor, selfDeclared }, { adapter, owner: ownerOn(deck.id, task.id) ?? owner, verify }));
+    } catch (err) {
+      if (err?.code === "stale_subject" && err.details?.supersede) {
+        await tasksMod.supersedeTask?.(deck.path, task.id, { owner: false }).catch(() => {});
+        events.invalidate({ type: "tasks", deckId: deck.id, taskId: task.id });
+        throw fail("stale_subject", `your agent changed the ${gateNoun(kind)} after this page was opened`, { current: await subjectOf(deck, kind).catch(() => null) });
+      }
+      throw err;
+    }
+    events.invalidate({ type: "tasks", deckId: deck.id, taskId: task.id });
+    events.invalidate({ type: kind === "plan-approval" ? "plan" : "preview", deckId: deck.id });
+    return gateAck(deck, kind, answered?.task ?? task, { decision, edited, replayed: false });
+  }
+  /**
+   * The decision ack (contract): the message the page copies for the user to
+   * paste into their chat — the decision plus the one command that receives it,
+   * so it works in the same chat, after a summarization and in a new one.
+   */
+  function gateAck(deck, kind, task, { decision, edited = false, replayed }) {
+    const receive = gateCommand(kind, deck);
+    const message = pasteMessage({ kind, action: decision === "comments" ? "request-changes" : "approve", receive });
+    return { decided: decision, task: task?.id ?? null, receive, message, edited, replayed };
+  }
+  const realDir = (p) => {
+    const abs = path.resolve(p);
+    try {
+      return fs.realpathSync(abs);
+    } catch {
+      throw fail("missing_path", `${abs} does not exist`);
+    }
+  };
+  const routes = [
+    ["POST", /^\/bootstrap$/, async (_, { who }) => {
+      if (who?.kind !== "cli") throw fail("unauthorized", "only the CLI hands out sign-in links");
+      // the link key: the same in every link, valid every time it is clicked
+      return auth.linkToken();
+    }],
+    ["POST", /^\/restart$/, async (_, { res }) => {
+      if (!deps.restart) throw fail("not_implemented", "this workspace cannot restart itself");
+      res.on("finish", () => deps.restart());
+      return { status: 202, body: { restarting: true } };
+    }],
+    ["GET", /^\/decks$/, async (_, { url }) => {
+      const limit = Math.min(Math.max(Number(url.searchParams.get("limit")) || 100, 1), 100);
+      const offset = Math.max(Number(url.searchParams.get("cursor")) || 0, 0);
+      const { decks, total } = listDecks({ q: url.searchParams.get("q") ?? "", limit, offset });
+      const tasksMod = await loadTasks();
+      const st = await loadStatus();
+      const rows = [];
+      for (const d of decks) {
+        let taskCount = 0;
+        let remote = null;
+        if (!d.missing) {
+          try {
+            taskCount = tasksMod ? (await tasksMod.listTasks(d.path, { status: "pending" })).length : 0;
+          } catch {
+            taskCount = null; // a malformed store shows as unknown, the deck view says why
+          }
+          try {
+            const card = st ? await st.remoteStatus(d.path, remoteDeps) : null;
+            // a deck is "on SharePoint" when its plan, its PPTX or a destination folder lives there
+            const on = card && (card.plan.state !== "none" || card.pptx.state !== "none" || (card.destination && !card.destination.malformed));
+            remote = on ? { plan: { state: card.plan.state }, pptx: { state: card.pptx.state }, link: card.pptx.link ?? card.plan.link ?? card.destination?.webUrl ?? null } : null;
+          } catch {
+            remote = null;
+          }
+        }
+        let built = false;
+        if (!d.missing) {
+          try {
+            built = fs.readdirSync(d.path).some((f) => /\.pptx$/i.test(f));
+          } catch {
+            built = false;
+          }
+        }
+        rows.push({ ...d, taskCount, remote, built });
+      }
+      return { decks: rows, total, nextCursor: offset + decks.length < total ? String(offset + decks.length) : null, scanning: deps.scanning ? deps.scanning() : [], roots: listRoots(), home: process.env.HOME || os.homedir() };
+    }],
+    ["POST", /^\/decks$/, async (_, { body, who }) => {
+      if (typeof body.path !== "string" || !body.path) throw fail("bad_request", "path is required");
+      const entry = await addDeckAsync(realDir(body.path));
+      return { deckId: entry.id, deck: entry };
+    }],
+    // POST /fs/pick — open the OS folder dialog on this machine and answer the choice.
+    ["POST", /^\/fs\/pick$/, async () => {
+      let chosen;
+      try {
+        chosen = await pickFolder();
+      } catch (err) {
+        throw fail(err.code === "picker_unavailable" ? "picker_unavailable" : "picker_failed", err.message);
+      }
+      return { path: chosen ? realDir(chosen) : null };
+    }],
+    // POST /decks/:id/reveal — show the deck folder in the OS file manager.
+    // `parent: true` shows the folder ABOVE it: that is what the sidebar's group
+    // heading points at, and keying it to a registered deck keeps the reveal
+    // confined to paths the registry already knows (no bare path in a body).
+    ["POST", /^\/decks\/([^/]+)\/reveal$/, async ([id], { body }) => {
+      const deck = resolveDeck(id);
+      const dir = body?.parent ? path.dirname(deck.path) : deck.path;
+      try {
+        await revealFolder(dir);
+      } catch (err) {
+        throw fail(err.code === "reveal_unavailable" ? "reveal_unavailable" : "reveal_failed", err.message);
+      }
+      return { revealed: dir };
+    }],
+    // POST /decks/:id/open-pptx — hand the built deck to PowerPoint on this machine
+    ["POST", /^\/decks\/([^/]+)\/open-pptx$/, async ([id]) => {
+      const deck = resolveDeck(id);
+      const file = deckPptx(deck);
+      if (!file) throw fail("not_found", "this deck has no .pptx yet");
+      try {
+        await openFile(file);
+      } catch (err) {
+        throw fail(err.code === "open_unavailable" ? "open_unavailable" : "open_failed", err.message);
+      }
+      return { opened: file };
+    }],
+    ["POST", /^\/discovery$/, async (_, { body }) => {
+      if (typeof body.root !== "string" || !body.root) throw fail("bad_request", "root is required");
+      const { jobId, done } = startDiscovery(body.root);
+      track(done.then(() => events.invalidate({ type: "library" })));
+      return { status: 202, body: { jobId } };
+    }],
+    ["GET", /^\/decks\/([^/]+)$/, async ([id]) => {
+      const deck = resolveDeck(id);
+      const d = await describe(deck);
+      const tasksMod = await loadTasks();
+      const tasks = tasksMod ? await tasksMod.listTasks(deck.path, {}) : [];
+      const { remote, sync } = await remoteCard(deck);
+      // where the deck stands (the same ladder `slidemind ready <deck>` prints): intake → plan gate →
+      // concepts → sourcing → authoring → draft check → review → deliver; a read of the disk, never a guess
+      let stage = null;
+      try {
+        const { deckStage } = await import("../cli/status.mjs");
+        const st = await deckStage(deck.workspaceDir);
+        stage = { name: st.name, next: st.next, plan: st.plan, slides: st.slides, draftCheck: st.draftCheck, review: st.review, route: st.route };
+      } catch {
+        stage = null;
+      }
+      return {
+        deck: { id: deck.id, name: deck.name, path: deck.path, missing: false, lastSeenAt: deck.lastSeenAt, format: deckFormat(deck.path) },
+        adapter: { id: d.adapter.id, blocker: d.adapter.blocker ?? null, owner: d.adapter.owner.owner },
+        views: d.views,
+        actions: d.actions,
+        tasks,
+        stage,
+        dirty: dirtyState(deck.workspaceDir, sync),
+        preview: previewState(deck.workspaceDir),
+        pptx: (() => {
+          const f = deckPptx(deck);
+          return f ? path.basename(f) : null;
+        })(),
+        remote,
+        sync,
+      };
+    }],
+    // Drop the library entry only; the deck's files are never touched.
+    // DELETE /decks/:id — drop the registry entry. `files: "trash"` also moves the
+    // deck folder to the OS trash: destructive, so it takes the deck's OWN realpath
+    // from the registry (never a path from the page), refuses a filesystem root or
+    // the home dir, and runs as a deck operation so a live agent session answers
+    // `deck_busy` instead of losing its work. Nothing here ever calls fs.rm.
+    ["DELETE", /^\/decks\/([^/]+)$/, async ([id], { body }) => {
+      if (!UUID.test(String(id))) throw fail("unknown_deck", "deck ids are registry UUIDs");
+      if (body?.files !== "trash") return { removed: await removeDeckAsync(id) };
+      const deck = getDeck(id);
+      if (!deck) throw fail("unknown_deck", `no registered deck ${id}`);
+      if (!fs.existsSync(deck.path)) return { removed: await removeDeckAsync(id), trashed: null };
+      const real = fs.realpathSync(deck.path);
+      if (path.dirname(real) === real || real === os.homedir()) throw fail("not_a_deck", `${real} is not a deck folder`);
+      await runDeckOperation(resolveWorkspace(real), { kind: "trash-deck", command: "workspace delete", owner: false }, () => trashFolder(real));
+      return { removed: await removeDeckAsync(id), trashed: real };
+    }],
+    ["GET", /^\/decks\/([^/]+)\/plan$/, async ([id]) => readPlan(resolveDeck(id))],
+    // The pack's plan page for the sandboxed frame: HTML from the installed template only.
+    ["GET", /^\/decks\/([^/]+)\/render\/plan$/, async ([id], { res }) => {
+      const deck = resolveDeck(id);
+      const a = adapterOf(deck);
+      if (a.blocker) throw fail(a.blocker.code, a.blocker.message);
+      if (!a.entry) {
+        // Core-owned deck: the page IS the deck's plan.html, re-rendered from
+        // plan.md so it never lags a save. The gate's read-only banner names a
+        // CLI command; here the Markdown editor sits next to the page, so it goes.
+        const { writePlanPage, withPlanWriteChannel, resolvePlanLayouts, planDesignOptions, loadPlanState, normalizePlanComments, planSubjectHash, planApprovedExactly } = await import("../builders/plan.mjs");
+        const out = writePlanPage(deck.workspaceDir);
+        if (!out) throw fail("not_found", "this deck has no plan yet");
+        // the same live write channel `slidemind plan` hands the page, pointed at this daemon
+        const html = withPlanWriteChannel(fs.readFileSync(out, "utf8"), {
+          embedded: true,
+          endpoint: `${PREFIX}/decks/${deck.id}/plan-review?t=${gateTokenFor(deck.id)}`,
+          heartbeat: `${PREFIX}/decks/${deck.id}/plan-heartbeat`,
+          round: await gateRound(deck, "plan-approval", planSubjectHash(deck.workspaceDir)),
+          // the version this page shows: a decision names it, so an answer never covers a plan the human did not see
+          subjectHash: planSubjectHash(deck.workspaceDir),
+          deckName: deck.name ?? path.basename(deck.path),
+          deckId: deck.id,
+          // the picker's chrome thumbnails come off this daemon, not the gate's port
+          layouts: resolvePlanLayouts(deck.workspaceDir).layouts.map((l) => ({ ...l, previewUrl: l.previewUrl ? `${PREFIX}/decks/${deck.id}${l.previewUrl}` : null })),
+          // the design picker: every cached design, its palette's thumbnails off this daemon too;
+          // the rest of the menu (designs the backend serves) loads after the page does
+          designs: planDesignOptions(deck.workspaceDir, { mapUrl: (u) => `${PREFIX}/decks/${deck.id}${u}` }),
+          designsUrl: `${PREFIX}/decks/${deck.id}/plan-designs`,
+          designsGate: gateTokenFor(deck.id),
+          logoMark: null,
+          ledgerSeed: normalizePlanComments(loadPlanState(deck.workspaceDir).comments || []),
+          // this exact plan.md is approved (hash-bound): the gate mutes Approve and says so
+          approved: planApprovedExactly(deck.workspaceDir) ? { at: loadPlanState(deck.workspaceDir).at ?? null, by: loadPlanState(deck.workspaceDir).actor ?? null } : null,
+          // has the agent asked for this review? (a pending task) — before that, approving is premature
+          asked: (await pendingOf(deck, "plan-approval"))[0]?.id ?? null,
+        });
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+        res.end(html);
+        return null;
+      }
+      const data = adapterResult(await dispatchAdapter(a.entry, { method: "render", deckRoot: deck.path, payload: { viewId: "plan" } }));
+      if (typeof data?.html !== "string") throw fail("extension_incompatible", "the adapter returned no html for the plan view");
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+      res.end(data.html);
+      return null;
+    }],
+    // The embedded gates' wire (the standalone gates' /plan-review, /review and
+    // their heartbeats, deck-scoped): a decision lands on the waiting task.
+    ["POST", /^\/decks\/([^/]+)\/plan-review$/, async ([id], { body }) => gateDecision(resolveDeck(id), "plan-approval", body)],
+    // The plan gate's design picker: the whole menu (cached designs + every design
+    // a connected backend serves), and a picked one this machine has not
+    // downloaded yet — materialized here, outside any agent sandbox.
+    ["GET", /^\/decks\/([^/]+)\/plan-designs$/, async ([id]) => {
+      const deck = resolveDeck(id);
+      const { listPlanDesigns } = await import("../builders/plan.mjs");
+      return { designs: await listPlanDesigns(deck.workspaceDir, { mapUrl: (u) => `${PREFIX}/decks/${deck.id}${u}`, listBrands: deps.designs?.listBrands ?? null }) };
+    }],
+    ["POST", /^\/decks\/([^/]+)\/plan-designs\/([^/]+)$/, async ([id, presFP]) => {
+      const deck = resolveDeck(id);
+      const fp = decodeURIComponent(presFP);
+      if (!/^[A-Za-z0-9_-]{1,128}$/.test(fp)) throw fail("bad_request", "not a design id");
+      const { downloadPlanDesign } = await import("../builders/plan.mjs");
+      try {
+        return { design: await downloadPlanDesign(deck.workspaceDir, fp, { mapUrl: (u) => `${PREFIX}/decks/${deck.id}${u}`, materialize: deps.designs?.materialize ?? null }) };
+      } catch (err) {
+        if (err?.code === "unknown_design") throw fail("not_found", err.message);
+        throw err;
+      }
+    }],
+    ["POST", /^\/decks\/([^/]+)\/review$/, async ([id], { body }) => gateDecision(resolveDeck(id), "preview-review", body)],
+    // layout chrome thumbnails for the embedded plan gate (the gate's /brand/chrome/<file>,
+    // another cached design's with `?design=` for the design picker)
+    ["GET", /^\/decks\/([^/]+)\/brand\/chrome\/([^/]+)$/, async ([id, name], { res, url }) => {
+      const deck = resolveDeck(id);
+      const { planChromeDir } = await import("../builders/plan.mjs");
+      const chromeDir = planChromeDir(deck.workspaceDir, url.searchParams.get("design"));
+      const file = path.basename(name);
+      if (!chromeDir || !/^chrome-[\w-]+\.(png|webp|jpe?g)$/i.test(file)) throw fail("not_found", "no such chrome image");
+      let data;
+      try {
+        data = fs.readFileSync(path.join(chromeDir, file));
+      } catch {
+        throw fail("not_found", "no such chrome image");
+      }
+      res.writeHead(200, { "Content-Type": MIME[path.extname(file).toLowerCase()] ?? "application/octet-stream", "Cache-Control": "no-store" });
+      res.end(data);
+      return null;
+    }],
+    ["GET", /^\/decks\/([^/]+)\/plan-heartbeat$/, async ([id]) => {
+      const deck = resolveDeck(id);
+      const { planSubjectHash } = await import("../builders/plan.mjs");
+      return gateBeat(deck, "plan-approval", "slidemind-plan", planSubjectHash(deck.workspaceDir));
+    }],
+    ["GET", /^\/decks\/([^/]+)\/preview-heartbeat$/, async ([id]) => {
+      const deck = resolveDeck(id);
+      const scan = previewScan(deck.workspaceDir);
+      return gateBeat(deck, "preview-review", "slidemind-review", previewHashCached(deck.workspaceDir, scan), { scan });
+    }],
+    // GET /decks/:id/tasks/:taskId/wait?timeout=<s> — `slidemind tasks wait` (scripts) long-polls
+    // here; the response is the saved task once it settles. A CLI wait may carry its edit
+    // session's owner token (`X-Slidemind-Owner`): the answer to this task then re-enters that session.
+    ["GET", /^\/decks\/([^/]+)\/tasks\/([^/]+)\/wait$/, async ([id, taskId], { url, req, res, who }) => {
+      const deck = resolveDeck(id);
+      const tasksMod = await need(loadTasks, "tasks");
+      const asked = Number(url.searchParams.get("timeout"));
+      // 0 is a real answer ("tell me now"), not "use the default"
+      const timeoutMs = Math.min(Math.max(url.searchParams.has("timeout") && Number.isFinite(asked) ? asked : 45, 0), 3600) * 1000;
+      const key = `${deck.id}:${taskId}`;
+      const owner = who?.kind === "cli" && typeof req.headers["x-slidemind-owner"] === "string" ? req.headers["x-slidemind-owner"] : null;
+      const bump = (d) => {
+        const w = waiters.get(key) ?? { open: 0, owner: null };
+        w.open = Math.max(0, w.open + d);
+        if (d > 0 && owner) w.owner = owner;
+        if (w.open === 0) w.owner = null;
+        waiters.set(key, w);
+      };
+      const ac = new AbortController();
+      req.on("close", () => ac.abort());
+      bump(1);
+      let out;
+      try {
+        out = typeof tasksMod.waitTask === "function" ? await tasksMod.waitTask(deck.path, taskId, { timeoutMs, signal: ac.signal }) : await pollTask(tasksMod, deck.path, taskId, timeoutMs, ac.signal);
+      } catch (err) {
+        bump(-1);
+        throw err;
+      }
+      bump(-1);
+      if (ac.signal.aborted || res.writableEnded) return null;
+      sendJson(res, 200, { ok: true, task: out.task, pending: out.pending });
+      return null;
+    }],
+    ["PUT", /^\/decks\/([^/]+)\/plan$/, async ([id], { body }) => {
+      const deck = resolveDeck(id);
+      if (!body.operationId || !body.base || typeof body.base.hash !== "string" || body.value === undefined) {
+        throw fail("bad_request", "operationId, base:{hash,value} and value are required");
+      }
+      const edit = await need(loadEdit, "plan editing");
+      const adapter = adapterOf(deck);
+      if (adapter.blocker) throw fail(adapter.blocker.code, adapter.blocker.message);
+      const syncMod = await loadSync();
+      if (syncMod?.approvalInProgress?.(deck.workspaceDir)) throw fail("approval_in_progress", "an approval of this plan is in flight; your edits are kept and can be saved once it settles");
+      const result = await edit.savePlanLocal({ workspaceDir: deck.workspaceDir, adapter, operationId: body.operationId, base: body.base, value: body.value, owner: false });
+      if (result?.code) throw fail(result.code, result.message ?? result.code, result);
+      events.invalidate({ type: "plan", deckId: deck.id });
+      // An edit made here, on exactly the version the editor loaded, is the
+      // reviewer's own: a pending plan task follows it rather than going stale.
+      if (result?.ok && result.previous === body.base.hash) {
+        const tasksMod = await loadTasks();
+        const moved = (await tasksMod?.followPlanEdit?.(deck.path, { from: result.previous, to: result.hash }, { owner: false })) ?? [];
+        if (moved.length) events.invalidate({ type: "tasks", deckId: deck.id });
+      }
+      return result;
+    }],
+    ["POST", /^\/decks\/([^/]+)\/actions\/([^/]+)$/, async ([id, action], { body }) => {
+      const deck = resolveDeck(id);
+      const d = await describe(deck);
+      if (d.adapter.blocker) throw fail(d.adapter.blocker.code, d.adapter.blocker.message);
+      if (!d.actions.includes(action)) throw fail("not_found", `${action} is not an action this deck offers`);
+      const method = ACTION_METHOD[action];
+      if (!method) throw fail("not_implemented", `${action} has no workspace binding yet`);
+      const result = await track(
+        runDeckOperation(deck.workspaceDir, { operationId: body.operationId, kind: action, expected: body.expectedHash ?? null, owner: false }, (op) =>
+          dispatchAdapter(d.adapter.entry, {
+            method,
+            deckRoot: deck.path,
+            payload: { expectedHash: body.expectedHash ?? null, ...(body.payload ?? {}) },
+            operationId: op.intent.id,
+            ownerToken: op.token,
+          }),
+        ),
+      );
+      events.invalidate({ type: "plan", deckId: deck.id });
+      return { result: adapterResult(result) };
+    }],
+    ["GET", /^\/tasks$/, async (_, { url }) => {
+      const tasksMod = await need(loadTasks, "tasks");
+      const status = url.searchParams.get("status") ?? undefined;
+      const deckId = url.searchParams.get("deck");
+      const decks = deckId ? [resolveDeck(deckId)] : listDecks({ limit: 100 }).decks.filter((d) => !d.missing);
+      const tasks = [];
+      for (const d of decks) for (const t of await tasksMod.listTasks(d.path, { status })) tasks.push({ ...t, deckId: d.id, deckName: d.name ?? null, deckPath: d.path });
+      return { tasks };
+    }],
+    ["POST", /^\/decks\/([^/]+)\/tasks$/, async ([id], { body, url }) => {
+      const deck = resolveDeck(id);
+      if (!taskActionsFor(body.kind)) throw fail("bad_request", "kind is required (plan-edit, plan-approval, preview-review, sync-conflict)");
+      if (deckFormat(deck.path) === "legacy") throw fail("unsupported_format", "this deck still uses the pre-workspace layout — its migration into .slidemind/ failed, see the workspace log");
+      const tasksMod = await need(loadTasks, "tasks");
+      const adapter = adapterOf(deck);
+      if (adapter.blocker) throw fail(adapter.blocker.code, adapter.blocker.message);
+      const { adapterId, subject } = await deriveTaskSubject({ deckRoot: deck.path, adapter, kind: body.kind });
+      const out = await tasksMod.requestTask(deck.path, { kind: body.kind, adapterId, subject }, { owner: false, verify: taskEvidenceVerifier({ deckRoot: deck.path, adapter }) });
+      const task = out?.task ?? out;
+      events.invalidate({ type: "tasks", deckId: deck.id, taskId: task?.id });
+      return { task, existing: out?.existing ?? false, url: `${url.origin}/deck/${deck.id}/${viewOf(task?.kind)}` };
+    }],
+    // POST /decks/:id/attention — the agent just asked (`slidemind plan|review`, `tasks request`):
+    // tell an open page (SSE) so it shows the question. Nothing opens a browser: the user
+    // follows the link the agent posted (doc 21).
+    ["POST", /^\/decks\/([^/]+)\/attention$/, async ([id], { body, who }) => {
+      if (who?.kind !== "cli") throw fail("unauthorized", "only the CLI announces a question");
+      const deck = resolveDeck(id);
+      // `slidemind workspace <deck>` with a page already open: show that deck there
+      if (body.focus === true) {
+        events.invalidate({ type: "focus", deckId: deck.id });
+        return { pages: events.clientCount ?? 0, focused: true };
+      }
+      const kind = body.kind === "preview-review" ? "preview-review" : "plan-approval";
+      const taskId = typeof body.taskId === "string" ? body.taskId : null;
+      events.invalidate({ type: "tasks", deckId: deck.id, taskId });
+      // The same question asked again (the user said "continue" before answering)
+      // is told to the page once (it switches tab / shows a toast), never again.
+      const key = taskId ?? deck.id;
+      const first = !attended.has(key);
+      if (first) {
+        attended.add(key);
+        events.invalidate({ type: "attention", deckId: deck.id, kind, taskId });
+      }
+      return { pages: events.clientCount ?? 0, first };
+    }],
+    // Put a question away without answering it: the human says it no longer applies.
+    // "cancelled", not "superseded" — nothing replaced it, someone dismissed it.
+    ["POST", /^\/decks\/([^/]+)\/tasks\/([^/]+)\/dismiss$/, async ([id, taskId]) => {
+      const deck = resolveDeck(id);
+      const tasksMod = await need(loadTasks, "tasks");
+      const task = await tasksMod.cancelTask(deck.path, taskId, { owner: false });
+      events.invalidate({ type: "tasks", deckId: deck.id, taskId });
+      return { task };
+    }],
+    ["POST", /^\/decks\/([^/]+)\/tasks\/([^/]+)\/respond$/, async ([id, taskId], { body }) => {
+      const deck = resolveDeck(id);
+      if (!body.operationId || typeof body.action !== "string") throw fail("bad_request", "operationId and action are required");
+      const tasksMod = await need(loadTasks, "tasks");
+      const adapter = adapterOf(deck);
+      if (adapter.blocker) throw fail(adapter.blocker.code, adapter.blocker.message);
+      const payload = body.payload ?? {};
+      const { actor, selfDeclared } = taskActor(payload);
+      const verify = taskEvidenceVerifier({ deckRoot: deck.path, adapter });
+      let result;
+      try {
+        result = await track(respond(deck.path, taskId, { operationId: body.operationId, expectedHash: body.expectedHash ?? null, action: body.action, payload, actor, selfDeclared }, { adapter, owner: ownerOn(deck.id, taskId) ?? false, verify }));
+      } catch (err) {
+        // the content moved on under the task: void it and tell the page to ask again about what is there now
+        if (err?.code === "stale_subject" && err.details?.supersede) {
+          await tasksMod.supersedeTask?.(deck.path, taskId, { owner: false });
+          events.invalidate({ type: "tasks", deckId: deck.id, taskId });
+        }
+        throw err;
+      }
+      events.invalidate({ type: "tasks", deckId: deck.id, taskId });
+      // what the page copies for the user to paste: the answer plus the command that receives it
+      const answered = result?.task ?? null;
+      const receive = receiveCommand({ kind: answered?.kind, adapterId: answered?.adapterId, deckPath: deck.path, taskId });
+      const message = answered ? pasteMessage({ kind: answered.kind, action: body.action, receive }) : null;
+      return { ...result, receive, message };
+    }],
+    ["GET", /^\/jobs\/([^/]+)$/, async ([id]) => {
+      const job = readJob(id);
+      if (!job) throw fail("unknown_job", `no job ${id}`);
+      return { job };
+    }],
+    ["GET", /^\/events$/, async (_, { req, res }) => {
+      events.subscribe(req, res);
+      return null;
+    }],
+    // wave 3 (remote association / autosync) replaces these; the shapes are the contract
+    // Link intake: every network step is a job (202 + id); the page polls GET /jobs/:id.
+    ["POST", /^\/remote\/resolve$/, async (_, { body }) => {
+      if (typeof body.url !== "string" || !body.url) throw fail("bad_request", "url is required");
+      if (body.deckId) resolveDeck(body.deckId);
+      const links = await need(loadLinks, "remote links");
+      const job = await track(links.resolveRemoteLink({ url: body.url, backendURL: body.backendURL ?? null, deckId: body.deckId ?? null }, remoteDeps));
+      if (job.result?.deckId) events.invalidate({ type: "library" });
+      return { status: 202, body: { jobId: job.id, job } };
+    }],
+    ["GET", /^\/remote\/children$/, async (_, { url }) => {
+      const selectionId = url.searchParams.get("selection");
+      if (!selectionId) throw fail("bad_request", "selection is required");
+      const links = await need(loadLinks, "remote links");
+      return links.listSelectionChildren({ selectionId, cursor: url.searchParams.get("cursor") }, remoteDeps);
+    }],
+    ["POST", /^\/jobs\/([^/]+)\/select$/, async ([id], { body }) => {
+      if (!body.selectionId || !body.choiceId) throw fail("bad_request", "selectionId and choiceId are required");
+      if (body.localTarget) resolveDeck(body.localTarget);
+      const links = await need(loadLinks, "remote links");
+      const job = await track(links.selectChoice(id, { selectionId: body.selectionId, choiceId: body.choiceId, localTarget: body.localTarget ?? null }, remoteDeps));
+      if (job.result?.deckId) events.invalidate({ type: "library" });
+      return { status: 202, body: { jobId: job.id, job } };
+    }],
+    ["POST", /^\/decks\/([^/]+)\/remote\/connect$/, async ([id], { body }) => {
+      const deck = resolveDeck(id);
+      if (!body.folderRef || (typeof body.folderRef !== "string" && !(body.folderRef.driveId && body.folderRef.itemId))) {
+        throw fail("bad_request", "folderRef is a link or {driveId,itemId}");
+      }
+      const st = await need(loadStatus, "remote destinations");
+      const result = await track(st.connectDestination({ deckRoot: deck.path, folderRef: body.folderRef, pptxName: body.pptxName ?? null, backendURL: body.backendURL ?? null }, remoteDeps));
+      events.invalidate({ type: "plan", deckId: deck.id });
+      // an editable plan with writes enabled: the record is created in the background (7.7)
+      let activation = null;
+      if (result.shouldCreatePlan) {
+        const syncMod = await loadSync();
+        if (typeof syncMod?.activateDestination === "function") {
+          activation = { started: true };
+          track(syncMod.activateDestination(deck.workspaceDir, { adapter: adapterOf(deck), owner: false }).then(() => events.invalidate({ type: "plan", deckId: deck.id })));
+        }
+      }
+      // a deck built before its folder was connected: that build goes up now;
+      // every later build publishes itself (build-pptx)
+      let upload = null;
+      if (result.shouldPublish && typeof st.uploadToDestination === "function") {
+        upload = { started: true };
+        track(st.uploadToDestination(deck.path, remoteDeps).then(() => events.invalidate({ type: "plan", deckId: deck.id })));
+      }
+      return { ...result, activation, upload, remote: (await remoteCard(deck)).remote };
+    }],
+    // autosync: every network step is a 202; the page re-GETs the deck for the outcome
+    ["POST", /^\/decks\/([^/]+)\/remote\/sync$/, async ([id]) => {
+      const deck = resolveDeck(id);
+      const drainOnce = await fn(loadSync, "drainOnce", "plan synchronization");
+      track(drainOnce(deck.workspaceDir, { adapter: adapterOf(deck), owner: false }).then(() => events.invalidate({ type: "plan", deckId: deck.id })));
+      return { status: 202, body: { sync: await syncCard(deck.workspaceDir) } };
+    }],
+    ["POST", /^\/decks\/([^/]+)\/remote\/refresh$/, async ([id]) => {
+      const deck = resolveDeck(id);
+      const refreshOnce = await fn(loadSync, "refreshOnce", "shared plan refresh");
+      track(refreshOnce(deck.workspaceDir, { adapter: adapterOf(deck), owner: false }).then(() => events.invalidate({ type: "plan", deckId: deck.id })));
+      return { status: 202, body: { sync: await syncCard(deck.workspaceDir) } };
+    }],
+    ["POST", /^\/decks\/([^/]+)\/remote\/activate$/, async ([id]) => {
+      const deck = resolveDeck(id);
+      const activateDestination = await fn(loadSync, "activateDestination", "shared plan creation");
+      // a published PPTX without a saved folder implies one: its parent (one provider round, needs a session)
+      const st = await loadStatus();
+      if (st?.ensureDestination) {
+        try {
+          await st.ensureDestination(deck.path, {}, remoteDeps);
+        } catch (err) {
+          if (!err?.code) throw err;
+          throw fail(err.code, err.message, err.details);
+        }
+      }
+      track(activateDestination(deck.workspaceDir, { adapter: adapterOf(deck), owner: false }).then(() => events.invalidate({ type: "plan", deckId: deck.id })));
+      return { status: 202, body: { sync: await syncCard(deck.workspaceDir) } };
+    }],
+    ["POST", /^\/decks\/([^/]+)\/conflicts\/resolve$/, async ([id], { body }) => {
+      const deck = resolveDeck(id);
+      if (typeof body.conflictId !== "string" || typeof body.expectedHash !== "string" || body.value === undefined) {
+        throw fail("bad_request", "conflictId, expectedHash and value are required");
+      }
+      const resolveConflict = await fn(loadSync, "resolveConflict", "conflict resolution");
+      const result = await track(resolveConflict(deck.workspaceDir, { adapter: adapterOf(deck), owner: false, conflictId: body.conflictId, expectedHash: body.expectedHash, value: body.value }));
+      if (result?.ok === false || result?.code) throw fail(result.code, result.message ?? result.code, { ...result, supersede: result.supersede === true });
+      events.invalidate({ type: "plan", deckId: deck.id });
+      events.invalidate({ type: "tasks", deckId: deck.id });
+      return { ...result, sync: await syncCard(deck.workspaceDir) };
+    }],
+  ];
+
+  const handle = async function handle(req, res, { url }) {
+    const pathname = url.pathname;
+    // Static surfaces (authenticated like everything else).
+    const who = auth.authenticate(req);
+    // The session slides inside authenticate() on ANY request — the page shell and
+    // its assets included — so the cookie is re-sent right here, whatever answers:
+    // an active user is never signed out on a date fixed at their first sign-in.
+    if (who?.kind === "browser" && typeof auth.renewalHeader === "function") {
+      const renew = auth.renewalHeader(req);
+      if (renew) res.setHeader("Set-Cookie", renew);
+    }
+    const isApi = pathname.startsWith(PREFIX);
+    if (!isApi) {
+      if (req.method !== "GET") return false;
+      // the app shell: `/`, `/deck/<id>…` — unauthenticated, it only holds the link-key exchange
+      if (pathname === "/" || pathname.startsWith("/deck/")) return serveContained(uiRoot, "index.html", res) || false;
+      if (!pathname.startsWith("/ui/")) return false;
+      // the stylesheet is linked before the bootstrap exchange; it carries nothing private
+      if (!who && pathname !== "/ui/styles.css") return sendError(res, 401, "unauthorized", "sign in through `slidemind workspace`"), true;
+      return serveFiles(pathname, res);
+    }
+    const rel = pathname.slice(PREFIX.length) || "/";
+    try {
+      if (rel === "/session" && req.method === "POST") {
+        const s = auth.exchange((await readJson(req)).bootstrap);
+        if (!s) throw fail("unauthorized", "the link carries no key of this workspace");
+        res.setHeader("Set-Cookie", auth.cookieHeader(s.cookie));
+        return sendJson(res, 200, { ok: true, csrfToken: s.csrfToken }), true;
+      }
+      // A tab that holds the cookie but not this tab's CSRF token (a second tab,
+      // a reload after sessionStorage was cleared) asks for it here; only the
+      // cookie holder can read the answer, so nothing new is exposed.
+      if (rel === "/session" && req.method === "GET") {
+        if (who?.kind !== "browser") throw fail("unauthorized", "no browser session");
+        return sendJson(res, 200, { ok: true, csrfToken: who.csrfToken }), true;
+      }
+      if (!who) throw fail("unauthorized", "missing or invalid credential");
+      const previewPage = rel.match(/^\/decks\/([^/]+)\/preview\/presentation\.html$/);
+      if (previewPage && req.method === "GET") {
+        const deck = resolveDeck(previewPage[1]);
+        let pageHtml;
+        try {
+          pageHtml = previewPageHtml(deck);
+        } catch {
+          return sendError(res, 404, "not_found", "no preview built yet"), true;
+        }
+        if (url.searchParams.has("thumb")) {
+          // the rail's per-slide frames: the same page, without the gate
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+          res.end(pageHtml);
+          return true;
+        }
+        // the deck's own preview page, handed the live review gate (pins,
+        // approve, comments) exactly as `slidemind review` serves it
+        const logo = reviewLogoFile(deck.workspaceDir);
+        const html = injectReview(
+          pageHtml,
+          {
+            embedded: true,
+            deck: deck.name ?? deck.id,
+            ledgerSeed: normalizeReviewComments(loadReviewState(deck.workspaceDir).comments || []),
+            endpoint: `${PREFIX}/decks/${deck.id}/review?t=${gateTokenFor(deck.id)}`,
+            heartbeat: `${PREFIX}/decks/${deck.id}/preview-heartbeat`,
+            // the deck passed its one review: the gate mutes Approve and says later changes go straight into the .pptx
+            // (an adopted deck never needed one: settled the same way, never worded as an approval)
+            approved: ((a) => (a ? { at: a.at, by: a.actor } : isEditRouteDeck(deck.workspaceDir) ? { at: null, by: null, notNeeded: true } : null))(loadReviewState(deck.workspaceDir).approval),
+            asked: (await pendingOf(deck, "preview-review"))[0]?.id ?? null,
+            // the version this page shows: a decision names it, so an approval never covers slides nobody saw
+            subjectHash: previewBuiltFrom(deck.workspaceDir) ?? previewHash(deck.workspaceDir),
+            deckName: deck.name ?? path.basename(deck.path),
+            deckId: deck.id,
+            // the slides changed after this preview was built: what the page shows is not what would be approved
+            previewStale: previewState(deck.workspaceDir)?.stale === true,
+          },
+          fs.readFileSync(REVIEW_OVERLAY_PATH, "utf8"),
+          logo ? `${PREFIX}/decks/${deck.id}/brand/assets/${logo}` : null,
+          await gateRound(deck, "preview-review", previewHash(deck.workspaceDir)),
+        );
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+        res.end(html);
+        return true;
+      }
+      if (rel.match(/^\/decks\/[^/]+\/(?:preview|assets|brand\/assets)\//)) return serveFiles(pathname, res) || (sendError(res, 404, "not_found", "no such file"), true);
+      let matched = null;
+      let params = null;
+      let methodSeen = false;
+      for (const [method, re, fn] of routes) {
+        const m = rel.match(re);
+        if (!m) continue;
+        methodSeen = true;
+        if (method !== req.method) continue;
+        matched = fn;
+        params = m.slice(1);
+        break;
+      }
+      if (!matched) {
+        if (methodSeen) throw fail("method_not_allowed", `${req.method} not allowed here`);
+        return false;
+      }
+      const mutation = req.method !== "GET" && req.method !== "HEAD";
+      const gateToken = url.searchParams.get("t");
+      // Both halves must be REAL: an unknown `t` reads back undefined, and off the
+      // two gate routes the captured deck id is undefined too — `undefined === undefined`
+      // would wave any junk `?t=` past both the CSRF and the origin check on every
+      // mutation route, so the deck id is required to exist before it can match.
+      const gatedDeck = (rel.match(/^\/decks\/([^/]+)\/(?:plan-review|review|plan-designs\/[^/]+)$/) ?? [])[1];
+      const gated = !!gateToken && gatedDeck !== undefined && gateTokenValid(gateToken, gatedDeck);
+      if (mutation && !gated) {
+        const denied = auth.allowMutation(req, who, `http://${req.headers.host}`);
+        if (denied) throw fail(denied, denied === "csrf_required" ? "X-CSRF-Token missing or wrong" : "the request did not come from this workspace's page");
+      }
+      const body = mutation ? await readJson(req) : {};
+      const out = await matched(params, { body, req, res, url: new URL(pathname + url.search, `http://${req.headers.host}`), who });
+      if (out === null) return true; // the handler owns the response (SSE)
+      if (out && typeof out === "object" && "status" in out && "body" in out && Object.keys(out).length === 2) {
+        return sendJson(res, out.status, { ok: true, ...out.body }), true;
+      }
+      return sendJson(res, 200, { ok: true, ...out }), true;
+    } catch (err) {
+      if (res.headersSent) return true;
+      const { status, code, retryable } = mapCode(err);
+      const body = { ok: false, error: { code, message: err?.message ?? "internal error", retryable } };
+      if (err?.details && typeof err.details === "object") body.error.details = err.details;
+      // who holds the deck, so the page can say "your agent is working on it since …" and retry
+      if (code === "deck_busy" && err?.busy && typeof err.busy === "object") {
+        body.error.details = { ...(body.error.details ?? {}), since: err.busy.startedAt ?? null, command: err.busy.command ?? null, session: err.busy.kind === "session" };
+      }
+      sendJson(res, status, body);
+      return true;
+    }
+  };
+  // Every module a route imports lazily, loaded NOW: a background `npm install -g`
+  // that swaps the package files under a running daemon cannot leave a route
+  // half-loaded (ENOENT, or new code against old dependencies) — the daemon keeps
+  // serving the code it started with until it restarts itself onto the new one.
+  handle.preload = async () => {
+    await Promise.all([loadTasks(), loadEdit(), loadLinks(), loadStatus(), loadSync(), import("../cli/status.mjs"), import("../builders/plan.mjs")].map((p) => Promise.resolve(p).catch(() => null)));
+  };
+  /** Agent waits open right now — the daemon restarts itself onto new code only when this is 0. */
+  handle.openWaits = openWaits;
+  return handle;
+}