@loompad/cli 0.1.0 → 1.1.1

package/dist/daemon/server.js

@@ -1,149 +1,78 @@
-/**
- * The Loom daemon — one process, many projects, one API for every surface
- * (CLI today, iOS app next). REST for commands, WebSocket for the live
- * event stream.
- */
-import { execFile } from "node:child_process";
+import { ClientDelivery } from "./delivery.js";
+import express from "express";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import http from "node:http";
-import { createRequire } from "node:module";
+import { configureHttpServer } from "../core/http-server.js";
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-import express from "express";
-import QRCode from "qrcode";
-import { WebSocketServer, WebSocket } from "ws";
-import { NotHolderError } from "../core/baton.js";
-import { retrieve } from "../core/brain-index.js";
-import { RouteActiveError } from "../core/routes.js";
-import { ADES, buildDefaultRoutes, defaultAgentConfigs, detectAdes } from "../core/ades.js";
+import { WebSocketServer } from "ws";
+import { setApprovalBroker } from "../core/approvals.js";
 import { logbook } from "../core/logbook.js";
-import { searchChats, searchCode } from "../core/search.js";
-import { addWorktree as gitAddWorktree, branches as gitBranches, checkout as gitCheckout, commit as gitCommit, discard as gitDiscard, fileDiff as gitFileDiff, GitError, init as gitInit, listWorktrees as gitListWorktrees, log as gitLog, push as gitPush, removeWorktree as gitRemoveWorktree, stage as gitStage, stagedDiff as gitStagedDiff, status as gitStatus, unstage as gitUnstage, } from "../core/git.js";
-import { claudeText } from "../core/claude-cli.js";
-import { setupReport } from "../core/setup.js";
-import { ensureDaemonConfig, findProject, listProjects, readDaemonConfig, readProjectConfig, registerProject, writeDaemonConfig, writeProjectConfig, } from "../core/registry.js";
-import { APP_HTML, APP_MANIFEST } from "./app-page.js";
-import { GEIST_WOFF2 } from "./geist-font.js";
+import { hostedTarget } from "../core/hosted.js";
+import { ensureDaemonConfig, ensureLoomHome, findProject, listProjects, loomHome, readDaemonConfig, registerProject, unregisterProject, writeDaemonConfig } from "../core/registry.js";
+import { packCredentials, toB64 } from "../core/relay-protocol.js";
+import { CHECK_TTL_MS, latestRelease, newerThan } from "../core/updater.js";
+import { VERSION } from "../version.js";
+import { recordAgentEvent } from "../observability/index.js";
+import { recentAgentErrors } from "../observability/insights.js";
 import { AuthManager, bearerToken } from "./auth.js";
-import { PUSH_KINDS, pushContent, sendExpoPush } from "./push.js";
+import { pushCategory, pushContent, sendExpoPush, wantsPush } from "./push.js";
+import { ensureCredentials, readCloudSettings, RelayBridge, supabaseTarget, supabaseTransport, writeCloudSettings, } from "./relay.js";
+import { registerAgentDiscoveryRoutes } from './routes/agent-discovery.js';
+import { registerAgentSettingsRoutes } from './routes/agent-settings.js';
+import { registerAgentsRoutes } from './routes/agents.js';
+import { registerAlertsRoutes } from './routes/alerts.js';
+import { registerApprovalsRoutes } from './routes/approvals.js';
+import { registerAssetsRoutes } from './routes/assets.js';
+import { registerBoardRoutes } from './routes/board.js';
+import { registerBrainRoutes } from './routes/brain.js';
+import { registerChatsRoutes } from './routes/chats.js';
+import { registerClientsRoutes } from './routes/clients.js';
+import { registerCloudRoutes } from './routes/cloud.js';
+import { registerConfigRoutes } from './routes/config.js';
+import { registerPreviewPublic, registerPreviewRoutes } from "./routes/preview.js";
+import { registerFilesRoutes } from './routes/files.js';
+import { registerGitRoutes } from './routes/git.js';
+import { registerHistoryRoutes } from './routes/history.js';
+import { registerIntegrationsProjectRoutes } from './routes/integrations-project.js';
+import { registerIntegrationsRoutes } from './routes/integrations.js';
+import { registerLogsRoutes } from './routes/logs.js';
+import { registerMessagesRoutes } from './routes/messages.js';
+import { registerObservabilityRoutes } from './routes/observability.js';
+import { registerOrchestraRoutes } from './routes/orchestra.js';
+import { registerPairingRoutes } from './routes/pairing.js';
+import { registerProjectActionsRoutes } from './routes/project-actions.js';
+import { registerProjectTeamRoutes } from './routes/project-team.js';
+import { registerProjectsRoutes } from './routes/projects.js';
+import { registerPromptsRoutes } from './routes/prompts.js';
+import { registerProvidersRoutes } from './routes/providers.js';
+import { registerPublicRoutes } from './routes/public.js';
+import { registerQueueRoutes } from './routes/queue.js';
+import { registerRoutingRoutes } from './routes/routing.js';
+import { createRuntimeHandler } from './routes/runtime-handler.js';
+import { registerSearchRoutes } from './routes/search.js';
+import { registerServersRoutes } from './routes/servers.js';
+import { registerSetupRoutes } from './routes/setup.js';
+import { registerSpecsRoutes } from './routes/specs.js';
+import { registerTaskDeliveryRoutes } from './routes/task-delivery.js';
+import { registerTeamRoutes } from './routes/team.js';
+import { registerTerminalsRoutes } from './routes/terminals.js';
+import { registerToolsRoutes } from './routes/tools.js';
+import { registerUpdatesRoutes } from './routes/updates.js';
+import { registerVoiceRoutes } from './routes/voice.js';
 import { ProjectRuntime } from "./runtime.js";
-import { buildBoard } from "./board.js";
-import { ghAuthStatus, ghProjectItems, ghProjects, listTasks, prReview, prView, runGh, } from "./tasks.js";
-import { linearCreateIssue, linearTeams, listLinearIssues } from "./linear.js";
-import { TerminalManager, TooManySessionsError } from "./terminals.js";
-export const DEFAULT_PORT = 7420;
-/**
- * Fingerprint every built file the daemon can load, as one hash.
- *
- * The walk is what makes it honest. This used to hash exactly two files —
- * server.js and app-page.js — which meant a change anywhere else (an adapter,
- * the router, core/registry.ts) left the rev identical. `loom up` said "daemon
- * already running", the shell agreed it was current, and a daemon kept serving
- * the old code from memory. A correct fix looked like it did nothing, which
- * sends you debugging code that is already right.
- *
- * Content-based on purpose: mtimes are unreliable across runtimes on some
- * filesystems (exFAT drives skew them by the local timezone offset). Names are
- * hashed alongside contents so a rename or a deletion moves the rev too.
- *
- * Reading ~39 files (about half a megabyte) costs a couple of milliseconds at
- * import, once. A stale daemon costs an afternoon.
- *
- * The desktop shell has a twin of this in desktop/loom-app.js — it can't import
- * this module without pulling express into Electron's main process. They must
- * agree byte for byte; test/desktop-app.test.ts compares them against the real
- * built output so a drift fails there rather than in the field.
- */
-export function fingerprintBuild(root) {
-    const rels = [];
-    const walk = (dir) => {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory())
-                walk(full);
-            else if (entry.name.endsWith(".js"))
-                rels.push(path.relative(root, full));
-        }
-    };
-    walk(root);
-    if (rels.length === 0)
-        return null;
-    rels.sort(); // readdir order is filesystem-dependent; the hash must not be
-    const hash = crypto.createHash("sha256");
-    for (const rel of rels) {
-        hash.update(rel);
-        hash.update(fs.readFileSync(path.join(root, rel)));
-    }
-    return hash.digest("hex").slice(0, 16);
-}
-/**
- * This build's rev. "dev" when there's nothing compiled to hash — running from
- * source under tsx, where the tree is .ts and the walk finds no .js at all.
- */
-export const BUILD_REV = (() => {
-    try {
-        // dist/daemon/server.js → dist: everything this process can import.
-        const me = fileURLToPath(import.meta.url);
-        return fingerprintBuild(path.dirname(path.dirname(me))) ?? "dev";
-    }
-    catch {
-        return "dev";
-    }
-})();
-/**
- * Loom's own install root — the directory to ask "am I behind my remote?".
- *
- * Walks up from this module looking for a .git directory (a source checkout or
- * a cloned install). null when Loom was installed some other way (a package),
- * in which case "check for updates" honestly says there's no git tree to check.
- */
-function loomRoot() {
-    try {
-        let dir = path.dirname(fileURLToPath(import.meta.url));
-        for (let i = 0; i < 6; i++) {
-            if (fs.existsSync(path.join(dir, ".git")))
-                return dir;
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-    }
-    catch {
-        /* fall through */
-    }
-    return null;
-}
-const TERM_MARK = "
__LOOM_END__";
-/**
- * Just enough to give a pasted attachment a sensible extension.
- */
-const MIME_EXT = {
-    "image/png": "png",
-    "image/jpeg": "jpg",
-    "image/gif": "gif",
-    "image/webp": "webp",
-    "image/svg+xml": "svg",
-    "text/markdown": "md",
-    "text/plain": "txt",
-    "application/pdf": "pdf",
-};
-/**
- * Paths from an HTTP body, as strings and nothing else.
- *
- * These reach `git checkout --` and `git clean -fd`, which delete things. A
- * body is whatever the caller felt like sending, so anything that isn't a
- * string is dropped here rather than stringified into a path somewhere deeper.
- * This is the shape check; core/git.ts does the safety check, resolving every
- * one of them against the project root.
- */
-function asPaths(v) {
-    if (!Array.isArray(v))
-        return [];
-    return v.filter((x) => typeof x === "string" && x.length > 0).slice(0, 500);
-}
+import { SpecRunner } from "./specs.js";
+import { BUILD_REV, DEFAULT_PORT, tailscaleIp } from './system.js';
+import { TeamLink } from "./team.js";
+import { Onboarding } from "./onboard.js";
+import { addProjectAt } from "./routes/projects.js";
+import { registerCrewsRoutes } from "./routes/crews.js";
+import { registerProofRoutes } from "./routes/proof.js";
+import { registerShiftRoutes } from "./routes/shift.js";
+import { registerOnboardRoutes } from "./routes/onboard.js";
+import { TerminalManager } from "./terminals.js";
+export { BUILD_REV, DEFAULT_PORT, fingerprintBuild, isLoopback, isLoopbackHost, lanIp, listModelsForKind, tailscaleFunnel, tailscaleIp, tailscaleState, tailscaleUp } from './system.js';
 export class LoomDaemon {
     app = express();
     server = null;
@@ -151,6 +80,9 @@ export class LoomDaemon {
     auth;
     runtimes = new Map();
     sockets = new Map();
+    delivery = new ClientDelivery(this.sockets, (socket) => socket.terminate());
+    /** In-flight self-heal recheck timers, cleared on close. */
+    healTimers = new Set();
     /** Terminal shells — a real pty when node-pty loaded, else plain pipes. */
     terminals = new TerminalManager({
         onData: (projectId, term, chunk) => this.broadcastTerm(projectId, { type: "term", term, chunk }),
@@ -160,8 +92,10 @@ export class LoomDaemon {
             this.broadcastTerm(projectId, { type: "term", term, closed: true });
         },
         onTitle: (projectId, term, title) => this.broadcastTerm(projectId, { type: "term", term, title }),
-    });
+    }, 12, path.join(ensureLoomHome(), "scrollback"));
     unstreamLogs = null;
+    /** Playwright runs, one per project at a time. See specs.ts. */
+    specRunner = new SpecRunner();
     host;
     port;
     /**
@@ -172,7 +106,100 @@ export class LoomDaemon {
      * localhost listener ever being disturbed.
      */
     extra = new Map();
+    /** Tool uses waiting on a human, from agents in "always ask" mode. */
+    approvals = new Map();
+    /**
+     * Put a tool use in front of a person and wait.
+     *
+     * One implementation for every caller — CLI adapters and model agents all
+     * ask from inside this process (core/approvals.ts registers this as the
+     * broker). The card, the
+     * thread entry, the timeout and the audit trail are the same either way,
+     * because "who is asking" should not change what you are shown.
+     */
+    async askHuman(req) {
+        if (req.signal?.aborted)
+            return { behavior: "deny", message: "The agent stopped waiting." };
+        const rt = await this.runtime(req.project).catch(() => null);
+        if (!rt)
+            return { behavior: "deny", message: "project not open" };
+        const id = crypto.randomBytes(6).toString("hex");
+        const tool = req.tool.slice(0, 120);
+        const preview = (req.summary ?? JSON.stringify(req.input ?? {})).slice(0, 4000);
+        const chat = rt.chatOf(req.agent);
+        rt.log.append({
+            kind: "approval",
+            agentId: req.agent,
+            ...(chat ? { chat } : {}),
+            payload: { phase: "requested", approvalId: id, tool, input: preview, ...(req.sessionOption ? { sessionOption: true } : {}) },
+        });
+        return new Promise((resolve) => {
+            const abandoned = () => settle({ behavior: "deny", message: "The agent stopped waiting." });
+            const settle = (d) => {
+                clearTimeout(timer);
+                req.signal?.removeEventListener("abort", abandoned);
+                if (!this.approvals.delete(id))
+                    return;
+                rt.log.append({
+                    kind: "approval",
+                    agentId: req.agent,
+                    ...(chat ? { chat } : {}),
+                    payload: { phase: "decided", approvalId: id, tool, behavior: d.behavior, ...(d.scope === "session" ? { scope: "session" } : {}), ...(d.message ? { message: d.message } : {}) },
+                });
+                resolve(d);
+            };
+            const timer = setTimeout(() => settle({ behavior: "deny", message: "No answer within 30 minutes — denied." }), 30 * 60_000);
+            this.approvals.set(id, {
+                id,
+                projectId: req.project,
+                agent: req.agent,
+                tool,
+                input: req.input ?? {},
+                ...(req.sessionOption ? { sessionOption: true } : {}),
+                createdAt: Date.now(),
+                settle,
+            });
+            // An agent whose turn ended has stopped waiting; don't hold the card open.
+            req.signal?.addEventListener("abort", abandoned, { once: true });
+        });
+    }
+    /** Loom Cloud relay, when enabled. See daemon/relay.ts. */
+    relay = null;
+    relayError = null;
+    relayTransportFactory;
+    /** Loom Teams: this daemon on a Team Hub. See daemon/team.ts. */
+    team;
+    /** One-link onboarding: joining a team, its repo and its crews from an invite. See daemon/onboard.ts. */
+    onboarding;
+    gh;
     constructor(opts = {}) {
+        this.team = new TeamLink({
+            runtimes: () => [...this.runtimes.values()],
+            broadcast: (frame) => {
+                this.delivery.publish(frame, { kind: "admin" });
+            },
+            ...(opts.hubFactory ? { hubFactory: opts.hubFactory } : {}),
+            ...(opts.runnerExec ? { runnerExec: opts.runnerExec } : {}),
+            ...(opts.gh ? { gh: opts.gh } : {}),
+            // Phase 5: a runner opens each goal's fresh clone as its own project, and drops it after.
+            openProject: async (dir, name) => this.runtime(registerProject(dir, name).id),
+            closeProject: async (rt) => {
+                await rt.close().catch(() => { });
+                this.runtimes.delete(rt.info.id);
+                unregisterProject(rt.info.id);
+            },
+        });
+        this.onboarding = new Onboarding({
+            team: this.team,
+            projects: () => listProjects(),
+            addProject: async (dir, name) => (await addProjectAt(dir, name)).info,
+            runtime: (id) => this.runtime(id),
+            broadcast: (frame) => this.delivery.publish(frame, { kind: "admin" }),
+            ...(opts.gh ? { gh: opts.gh } : {}),
+            ...opts.onboard,
+        });
+        this.gh = opts.gh;
+        this.relayTransportFactory = opts.relayTransport;
         this.host = opts.host ?? "127.0.0.1";
         this.port = opts.port ?? DEFAULT_PORT;
         const cfg = ensureDaemonConfig({ host: this.host, port: this.port });
@@ -183,8 +210,55 @@ export class LoomDaemon {
     // HTTP routes
     // -------------------------------------------------------------------------
     routes() {
+        const daemon = this;
+        const ctx = {
+            get terminals() { return daemon.terminals; },
+            get auth() { return daemon.auth; },
+            askHuman: (...args) => this.askHuman(...args),
+            cachedRelease: (...args) => this.cachedRelease(...args),
+            get updating() { return daemon.updating; },
+            set updating(value) { daemon.updating = value; },
+            close: (...args) => this.close(...args),
+            exposedIps: (...args) => this.exposedIps(...args),
+            get host() { return daemon.host; },
+            get port() { return daemon.port; },
+            expose: (...args) => this.expose(...args),
+            cloudLinkParams: (...args) => this.cloudLinkParams(...args),
+            get team() { return daemon.team; },
+            get runtimes() { return daemon.runtimes; },
+            cloudStatus: (...args) => this.cloudStatus(...args),
+            startCloud: (...args) => this.startCloud(...args),
+            stopCloud: (...args) => this.stopCloud(...args),
+            pushTokens: (...args) => this.pushTokens(...args),
+            runtime: (...args) => this.runtime(...args),
+            get specRunner() { return daemon.specRunner; },
+            startHealLoop: (...args) => this.startHealLoop(...args),
+            broadcastTerm: (...args) => this.broadcastTerm(...args),
+            get approvals() { return daemon.approvals; },
+        };
         const app = this.app;
-        app.use(express.json({ limit: "2mb" }));
+        app.disable("x-powered-by");
+        // Headers every response carries. No full CSP: the app shell is one
+        // inline document by design. What it does get: no MIME sniffing, no
+        // referrer leaking a token-bearing URL to a site you click through to,
+        // and only Loom itself may frame the app (the Browser tab's previews
+        // are same-origin, so they keep working).
+        app.use((req, res, next) => {
+            res.setHeader("X-Content-Type-Options", "nosniff");
+            res.setHeader("Referrer-Policy", "no-referrer");
+            res.setHeader("Permissions-Policy", "geolocation=(), payment=(), usb=(), serial=(), bluetooth=()");
+            if (req.path === "/app" || req.path === "/") {
+                res.setHeader("X-Frame-Options", "SAMEORIGIN");
+                res.setHeader("Content-Security-Policy", "frame-ancestors 'self'");
+            }
+            next();
+        });
+        // 2 MB for every JSON body but an attachment: a 12 MB file is ~16 MB as
+        // base64, and the global cap used to refuse a retina screenshot at 413
+        // before the route's own 12 MB check ever ran.
+        const smallJson = express.json({ limit: "2mb" });
+        const attachmentJson = express.json({ limit: "17mb" });
+        app.use((req, res, next) => (/^\/api\/projects\/[^/]+\/attachments$/.test(req.path) ? attachmentJson : smallJson)(req, res, next));
         // CORS for same-machine browser origins only (the Expo web dev server running
         // on another localhost port, etc.). Scoped to loopback so it can't be abused
         // cross-site; the bearer wall below still guards every data route. Preflight
@@ -194,1221 +268,141 @@ export class LoomDaemon {
             if (origin && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) {
                 res.setHeader("Access-Control-Allow-Origin", origin);
                 res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
-                res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+                // PUT and PATCH belong here: toggling a skill, switching an agent on or
+                // off, and updating an MCP server all use them, and a cross-origin
+                // client (the Expo web build, a paired browser on another port) had
+                // those requests refused at the preflight while the same-origin console
+                // worked — which makes it look like the feature is broken only on
+                // mobile.
+                res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
                 res.setHeader("Vary", "Origin");
                 if (req.method === "OPTIONS")
                     return void res.sendStatus(204);
             }
             next();
         });
-        // Public: the phone app shell (its API calls are bearer-authed),
-        // health, and the pairing claim (the pairing token IS the auth).
-        app.get("/", (_req, res) => res.redirect("/app"));
-        app.get("/app", (_req, res) => {
-            // Never cache the shell: a redeployed daemon must serve its own UI.
-            res.type("html").setHeader("Cache-Control", "no-store").send(APP_HTML);
-        });
-        app.get("/app/manifest.webmanifest", (_req, res) => {
-            res
-                .type("application/manifest+json")
-                .setHeader("Cache-Control", "no-store")
-                .send(JSON.stringify(APP_MANIFEST));
-        });
-        // The UI sans (Geist, SIL OFL 1.1) — embedded so the app works offline
-        // on the tailnet with no CDN. Immutable: cache hard.
-        app.get("/app/fonts/geist.woff2", (_req, res) => {
-            res
-                .type("font/woff2")
-                .setHeader("Cache-Control", "public, max-age=31536000, immutable")
-                .send(GEIST_WOFF2);
-        });
-        // xterm.js and its addons, served straight from node_modules — the app has
-        // no build step and must work offline on a tailnet, so no bundler, no CDN.
-        // These are plain UMD files the browser loads with <script>.
-        const vendor = {
-            "xterm.js": ["@xterm/xterm/lib/xterm.js", "application/javascript"],
-            "xterm.css": ["@xterm/xterm/css/xterm.css", "text/css"],
-            "addon-fit.js": ["@xterm/addon-fit/lib/addon-fit.js", "application/javascript"],
-            "addon-web-links.js": [
-                "@xterm/addon-web-links/lib/addon-web-links.js",
-                "application/javascript",
-            ],
-        };
-        app.get("/app/vendor/:file", (req, res) => {
-            const entry = vendor[String(req.params.file)];
-            if (!entry)
-                return void res.status(404).end();
-            try {
-                res
-                    .type(entry[1])
-                    .setHeader("Cache-Control", "public, max-age=31536000, immutable")
-                    .send(fs.readFileSync(createRequire(import.meta.url).resolve(entry[0])));
-            }
-            catch {
-                res.status(404).end();
-            }
-        });
-        app.get("/api/health", (_req, res) => {
-            res.json({
-                ok: true,
-                name: "loom",
-                version: "0.1.0",
-                rev: BUILD_REV,
-                terminal: this.terminals.mode,
-            });
-        });
-        app.post("/api/pair/claim", (req, res) => {
-            const { token, name } = (req.body ?? {});
-            if (!token)
-                return void res.status(400).json({ error: "missing token" });
-            const claimed = this.auth.claim(token, name ?? "device");
-            if (!claimed)
-                return void res.status(403).json({ error: "invalid or expired pairing token" });
-            res.json(claimed);
-        });
-        /**
-         * The local admin console bootstraps here — before the bearer wall, gated by
-         * the socket being loopback. A same-machine caller gets the admin token (it
-         * lives in a config file they can already read), which is what lets the web
-         * app served on localhost mint pairing codes and open phone access. Everyone
-         * else — a phone on the tailnet, anything past localhost — is turned away and
-         * pairs like any other device. Admin-ness stays a property of the *token*,
-         * so a paired client is never an admin no matter where it connects from.
-         */
-        app.get("/api/bootstrap", (req, res) => {
-            // Both must hold: the TCP peer is loopback (can't be spoofed by a header),
-            // AND the Host is a loopback literal (defeats DNS rebinding, where the
-            // socket is loopback but the browser sends the attacker's hostname).
-            if (!isLoopback(req.socket.remoteAddress) || !isLoopbackHost(req.headers.host)) {
-                return void res.status(403).json({ error: "not a local request" });
-            }
-            res.json({ token: this.auth.adminToken(), admin: true });
-        });
+        registerAssetsRoutes(app);
+        registerPublicRoutes(app, ctx);
+        registerPreviewPublic(app);
         // Everything else requires a bearer token.
         app.use((req, res, next) => {
+            // Inbound alert webhooks can't carry the admin bearer token — an
+            // Alertmanager-style sender has no Loom token to present — so they
+            // authenticate with their own LOOM_WEBHOOK_SECRET instead. Set that
+            // secret whenever the daemon binds past localhost.
+            if (req.path.startsWith("/api/webhooks/")) {
+                next();
+                return;
+            }
             const token = bearerToken(req.headers.authorization);
             if (!this.auth.isAuthorized(token)) {
                 res.status(401).json({ error: "unauthorized" });
                 return;
             }
+            // Admin is the admin token, and only the admin token. A same-machine
+            // caller becomes admin by *fetching* that token from /api/bootstrap
+            // (above) — which is what the local console does — never by virtue of
+            // the socket it arrived on. Trusting loopback here would silently
+            // promote every paired client that happens to connect over it, and a
+            // revoked phone would keep working for as long as it stayed local.
             req.isAdmin = this.auth.isAdmin(token);
+            req.projectScope =
+                this.auth.allowedProjects(token);
             next();
         });
-        /**
-         * What this machine still needs — the same answer `loom doctor` gives.
-         *
-         * Behind the auth wall on purpose: it enumerates which agents you have
-         * installed and which GUI apps are open, a small inventory of your machine
-         * and none of a stranger's business — which matters the moment the daemon
-         * binds past localhost (--host, Tailscale).
-         *
-         * Probing GUI bridges means a couple of HTTP round trips to their debug
-         * ports, so this is a request you make when you open Settings, not something
-         * the app polls.
-         */
-        app.get("/api/setup", (_req, res) => {
-            void setupReport()
-                .then((report) => res.json(report))
-                .catch((err) => res.status(500).json({ error: String(err?.message ?? err) }));
+        // Cheap liveness: HEAD answers with no body, for probes that only ask "is
+        // it up" — a monitor hitting GET /api/health every second serialises the
+        // whole health payload to throw it away.
+        app.head("/api/health", (_req, res) => {
+            res.status(200).end();
         });
-        /**
-         * `loom doctor`, over HTTP — the env checks always, plus one project's
-         * checks when a ?project is given. Dynamically imported so doctor.js (which
-         * pulls BUILD_REV back out of this file) doesn't create an import cycle at
-         * module-init time.
-         */
-        app.get("/api/doctor", (req, res) => {
-            void (async () => {
-                try {
-                    const { envChecks, projectChecks } = await import("../cli/doctor.js");
-                    const checks = await envChecks();
-                    const projId = req.query.project;
-                    if (projId) {
-                        const info = findProject(projId);
-                        if (info)
-                            checks.push(...projectChecks(info.dir));
-                    }
-                    res.json({ checks });
-                }
-                catch (err) {
-                    res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
-                }
-            })();
-        });
-        /**
-         * Is this Loom current? Version + build rev, and — when Loom itself is a git
-         * checkout — how many commits its own tree is behind its remote. Honest about
-         * the two different "updates" that matter: a newer daemon build waiting to be
-         * restarted (rev), and newer code waiting to be pulled (behind).
-         */
-        app.get("/api/updates", (_req, res) => {
-            void (async () => {
-                const root = loomRoot();
-                let git = null;
-                if (root) {
-                    const { remoteBehind } = await import("../core/git.js");
-                    git = await remoteBehind(root).catch(() => null);
-                }
-                res.json({ version: "0.1.0", rev: BUILD_REV, root, git });
-            })();
-        });
-        /**
-         * Is `gh` logged in, and as whom — machine-wide, so no project needed. The
-         * whole GitHub half of Loom (board PRs, Projects, review) rides on this; the
-         * status bar shows it and offers Connect when it's false.
-         */
-        app.get("/api/github/status", (_req, res) => {
-            void ghAuthStatus()
-                .then((s) => res.json(s))
-                .catch((err) => res.status(500).json({ error: err instanceof Error ? err.message : String(err) }));
-        });
-        /**
-         * LoomPad connectivity — proxies the voice backend's /health so the web app
-         * can show a live "LoomPad connected" pill without a cross-origin fetch. The
-         * backend (orchestrator-pad) does STT -> agent -> TTS for the physical pad;
-         * when it's up, the pad gets its spoken replies. Best-effort: an unreachable
-         * backend just returns { up:false } (the pill goes grey), never an error.
-         */
-        app.get("/api/loompad/health", (_req, res) => {
-            const base = (process.env.LOOMPAD_BACKEND_URL || "http://127.0.0.1:8080").replace(/\/+$/, "");
-            const ctl = new AbortController();
-            const timer = setTimeout(() => ctl.abort(), 2500);
-            void fetch(base + "/health", { signal: ctl.signal })
-                .then(async (r) => {
-                clearTimeout(timer);
-                if (!r.ok)
-                    return void res.json({ up: false, backend: base, status: r.status });
-                const body = (await r.json().catch(() => ({})));
-                res.json({ up: true, backend: base, ...body });
-            })
-                .catch(() => {
-                clearTimeout(timer);
-                res.json({ up: false, backend: base });
-            });
-        });
-        /**
-         * The two networks a phone could use to reach this daemon — the LAN and the
-         * tailnet — with, for each, the address and whether the phone can actually
-         * get here on it *right now*. It can't when we're bound to localhost, which
-         * is the default; `reachable:false` is the modal's cue to offer "enable
-         * phone access" (expose) before showing a QR that wouldn't resolve.
-         */
-        app.get("/api/pair/networks", (req, res) => {
-            if (!req.isAdmin) {
-                return void res.status(403).json({ error: "admin only" });
-            }
-            void (async () => {
-                const exposed = this.exposedIps();
-                const reach = (ip) => Boolean(ip) && (this.host === "0.0.0.0" || this.host === ip || exposed.includes(ip));
-                const lan = lanIp();
-                let ts = null;
-                try {
-                    ts = await tailscaleIp();
-                }
-                catch {
-                    ts = null;
-                }
-                res.json({
-                    port: this.port,
-                    boundHost: this.host,
-                    exposed,
-                    localnet: { ip: lan, reachable: reach(lan) },
-                    tailnet: ts
-                        ? { ip: ts, available: true, reachable: reach(ts) }
-                        : {
-                            ip: null,
-                            available: false,
-                            reachable: false,
-                            reason: "Tailscale isn't logged in on this machine (run `tailscale up`)",
-                        },
-                });
-            })();
-        });
-        /**
-         * Make a phone-reachable address go live — a phone can't reach a
-         * localhost-only daemon. We add a second listener on the requested LAN or
-         * tailnet IP (never touching localhost), so this is safe to await and report
-         * on directly. Explicit and user-driven (you clicked "connect a phone"), and
-         * behind the token wall the whole time.
-         */
-        app.post("/api/pair/expose", (req, res) => {
-            if (!req.isAdmin) {
-                return void res.status(403).json({ error: "admin only" });
-            }
-            void (async () => {
-                const wanted = typeof req.body?.host === "string" ? req.body.host.trim() : "";
-                let ts = null;
-                try {
-                    ts = await tailscaleIp();
-                }
-                catch {
-                    ts = null;
-                }
-                // Only ever bind an address that is genuinely ours (LAN or tailnet).
-                const allowed = new Set([lanIp(), ts].filter(Boolean));
-                if (!wanted || !allowed.has(wanted)) {
-                    return void res.status(400).json({ error: "not a local or tailnet address of this machine" });
-                }
-                try {
-                    await this.expose(wanted);
-                    res.json({ ok: true, ip: wanted, port: this.port, exposed: this.exposedIps() });
-                }
-                catch (err) {
-                    logbook.error("daemon", `could not open phone access on ${wanted}`, err);
-                    res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
-                }
-            })();
-        });
-        app.post("/api/pair/new", (req, res) => {
-            if (!req.isAdmin) {
-                return void res.status(403).json({ error: "admin only" });
-            }
-            void (async () => {
-                // The QR must point at the address the phone will actually use, so the
-                // caller may ask for the LAN or tailnet host — but only those. An
-                // arbitrary host from the client never reaches the link.
-                const wanted = typeof req.body?.host === "string" ? req.body.host.trim() : "";
-                let ts = null;
-                try {
-                    ts = await tailscaleIp();
-                }
-                catch {
-                    ts = null;
-                }
-                const allowed = new Set([this.host, lanIp(), ts].filter(Boolean));
-                const host = wanted && allowed.has(wanted) ? wanted : this.host;
-                const { token, expiresAt } = this.auth.newPairingToken();
-                const url = `http://${host}:${this.port}`;
-                // Deep link: scanning it with any camera opens the app, which claims the
-                // single-use token from the URL fragment and pairs itself.
-                const link = `${url}/app#pair=${token}`;
-                let qrSvg;
-                try {
-                    qrSvg = await QRCode.toString(link, {
-                        type: "svg",
-                        margin: 1,
-                        errorCorrectionLevel: "M",
-                    });
-                }
-                catch (err) {
-                    // The link still works even if the QR doesn't render — degrade, don't fail.
-                    logbook.warn("pair", "QR render failed — the copy link still works", err);
-                }
-                res.json({ token, expiresAt, url, link, ...(qrSvg ? { qrSvg } : {}) });
-            })();
-        });
-        app.get("/api/pair/clients", (_req, res) => {
-            res.json({ clients: this.auth.clients() });
-        });
-        app.delete("/api/pair/clients/:clientId", (req, res) => {
-            if (!req.isAdmin) {
-                return void res.status(403).json({ error: "admin only" });
-            }
-            const revoked = this.auth.revoke(String(req.params.clientId));
-            if (!revoked)
-                return void res.status(404).json({ error: "unknown client" });
-            res.json({ revoked: true });
-        });
-        // A paired device registers (or clears) its Expo push token.
-        app.post("/api/push/register", (req, res) => {
-            const me = this.auth.clientFor(bearerToken(req.headers.authorization));
-            if (!me)
-                return void res.status(403).json({ error: "device tokens only — pair first" });
-            const { token, platform } = (req.body ?? {});
-            if (!token?.trim())
-                return void res.status(400).json({ error: "missing token" });
-            this.auth.setPushToken(me.id, token.trim(), platform);
-            res.json({ registered: true });
-        });
-        app.delete("/api/push/register", (req, res) => {
-            const me = this.auth.clientFor(bearerToken(req.headers.authorization));
-            if (!me)
-                return void res.status(403).json({ error: "device tokens only" });
-            this.auth.setPushToken(me.id, null);
-            res.json({ registered: false });
-        });
-        // Admin: fire a test push at every registered device.
-        app.post("/api/push/test", (req, res) => {
-            if (!req.isAdmin) {
-                return void res.status(403).json({ error: "admin only" });
-            }
-            const tokens = this.pushTokens();
-            void sendExpoPush(tokens, {
-                title: "Loom",
-                body: "test notification — pairing works ✓",
-            });
-            res.json({ sent: tokens.length });
-        });
-        app.get("/api/projects", (_req, res) => {
-            void (async () => {
-                const projects = [];
-                for (const info of listProjects()) {
-                    try {
-                        const rt = await this.runtime(info.id);
-                        projects.push(await rt.status());
-                    }
-                    catch (err) {
-                        projects.push({
-                            id: info.id,
-                            name: info.name,
-                            dir: info.dir,
-                            holder: null,
-                            agents: [],
-                            lastEvent: null,
-                            needsInput: false,
-                            error: String(err instanceof Error ? err.message : err),
-                        });
-                    }
-                }
-                res.json({ projects });
-            })();
-        });
-        app.post("/api/projects", (req, res) => {
-            void (async () => {
-                const { dir, name } = (req.body ?? {});
-                if (!dir)
-                    return void res.status(400).json({ error: "missing dir" });
-                const resolved = path.resolve(dir);
-                if (!fs.existsSync(resolved)) {
-                    return void res.status(400).json({ error: `no such directory: ${resolved}` });
-                }
-                let config = readProjectConfig(resolved);
-                if (!config) {
-                    // Every ADE Loom can drive, probed in parallel — see core/ades.ts.
-                    // This used to name claude and opencode by hand, which is how the list
-                    // of what Loom actually drives drifted from the list of logos it ships.
-                    const availability = await detectAdes();
-                    const agents = defaultAgentConfigs(availability);
-                    const routes = buildDefaultRoutes(agents);
-                    config = {
-                        name: name ?? path.basename(resolved),
-                        agents,
-                        ...(routes ? { routes } : {}),
-                    };
-                    writeProjectConfig(resolved, config);
-                }
-                const info = registerProject(resolved, config.name);
-                res.json({ project: info, config });
-            })();
-        });
-        const withRuntime = (handler) => {
-            return (req, res) => {
-                void (async () => {
-                    try {
-                        const rt = await this.runtime(String(req.params.id));
-                        await handler(rt, req, res);
-                    }
-                    catch (err) {
-                        if (err instanceof NotHolderError) {
-                            res.status(409).json({
-                                error: "not_holder",
-                                holder: err.holder,
-                                agentId: err.agentId,
-                                message: err.message,
-                            });
-                            return;
-                        }
-                        if (err instanceof RouteActiveError) {
-                            res.status(409).json({ error: "route_active", message: err.message });
-                            return;
-                        }
-                        // A 500 used to be a sentence for one caller and nothing else: no
-                        // stack, no record, gone the moment the fetch resolved. Now the
-                        // Console gets it with the stack and the route that produced it.
-                        logbook.error("api", `${req.method} ${req.path} failed: ${err instanceof Error ? err.message : String(err)}`, err, String(req.params.id ?? ""));
-                        res.status(500).json({ error: String(err instanceof Error ? err.message : err) });
-                    }
-                })();
-            };
-        };
-        app.get("/api/projects/:id", withRuntime(async (rt, _req, res) => {
-            res.json({ project: await rt.status() });
-        }));
-        app.get("/api/projects/:id/events", withRuntime(async (rt, req, res) => {
-            const since = req.query.since ? Number(req.query.since) : undefined;
-            const limit = req.query.limit ? Number(req.query.limit) : 200;
-            // no ?chat= means the whole project — old clients keep seeing the
-            // whole thread, which is what they've always shown
-            const chat = req.query.chat ? String(req.query.chat) : undefined;
-            res.json({ events: rt.log.list({ since, limit, ...(chat ? { chat } : {}) }) });
-        }));
-        app.post("/api/projects/:id/messages", withRuntime(async (rt, req, res) => {
-            const { text, agentId, chat } = (req.body ?? {});
-            if (!text?.trim())
-                return void res.status(400).json({ error: "missing text" });
-            const result = await rt.sendMessage(text, agentId, chat ? { chat } : {});
-            res.json(result);
-        }));
-        /**
-         * Drive a GUI agent: type into Antigravity's or Kiro's own chat and read
-         * back what appeared.
-         *
-         * Separate from /messages because it is a different act. /messages hands a
-         * turn to something that can hold the baton; this types into an app you're
-         * signed into and waits for its panel to settle. The bridge never takes the
-         * lock, so an adapter mid-turn is untouched.
-         *
-         * It blocks for as long as the app takes to answer — minutes, for a real
-         * task. That's why it's its own route: nothing else here is allowed to be
-         * this slow, and the client needs to know to wait.
-         */
-        app.post("/api/projects/:id/bridge/:agentId/ask", withRuntime(async (rt, req, res) => {
-            const { text, chat } = (req.body ?? {});
-            const agentId = String(req.params.agentId);
-            if (!text?.trim())
-                return void res.status(400).json({ error: "missing text" });
-            try {
-                const result = await rt.askBridge(agentId, text, chat ? { chat } : {});
-                res.json(result);
-            }
-            catch (err) {
-                // 409, not 500: "log into Antigravity" is a state you can fix, not a
-                // bug in the daemon, and the message is the whole value of the reply.
-                res.status(409).json({ error: err instanceof Error ? err.message : String(err) });
-            }
-        }));
-        app.post("/api/projects/:id/handoff", withRuntime(async (rt, req, res) => {
-            const { to } = (req.body ?? {});
-            if (!to)
-                return void res.status(400).json({ error: "missing to" });
-            const result = await rt.handoff(to);
-            res.json({ ...result, to });
-        }));
-        // Chats — several conversations inside one project. They share the brain,
-        // the baton and the working tree; only the talking is separate.
-        app.get("/api/projects/:id/chats", withRuntime(async (rt, _req, res) => {
-            res.json({ chats: rt.chats() });
-        }));
-        app.post("/api/projects/:id/chats", withRuntime(async (rt, req, res) => {
-            const { title } = (req.body ?? {});
-            res.json({ chat: rt.createChat(String(title ?? "")) });
-        }));
-        app.post("/api/projects/:id/chats/:chatId/rename", withRuntime(async (rt, req, res) => {
-            const { title } = (req.body ?? {});
-            if (!title?.trim())
-                return void res.status(400).json({ error: "missing title" });
-            const chat = rt.renameChat(String(req.params.chatId), title);
-            if (!chat)
-                return void res.status(400).json({ error: "cannot rename that chat" });
-            res.json({ chat });
-        }));
-        app.delete("/api/projects/:id/chats/:chatId", withRuntime(async (rt, req, res) => {
-            if (!rt.deleteChat(String(req.params.chatId))) {
-                return void res.status(400).json({ error: "cannot delete that chat" });
-            }
-            res.json({ deleted: true });
-        }));
-        // Rename an agent's role. It's free text — your project decides what jobs
-        // exist, not us. Writes .loom/config.json, which is the source of truth.
-        app.post("/api/projects/:id/agents/:agentId/role", withRuntime(async (rt, req, res) => {
-            const { role } = (req.body ?? {});
-            if (typeof role !== "string")
-                return void res.status(400).json({ error: "missing role" });
-            const clean = role.trim().slice(0, 40);
-            if (!clean)
-                return void res.status(400).json({ error: "role cannot be empty" });
-            const updated = rt.setAgentRole(String(req.params.agentId), clean);
-            if (!updated)
-                return void res.status(404).json({ error: "unknown agent" });
-            res.json(updated);
-        }));
-        // The Settings screen reads its editable knobs here — brain extractor,
-        // projection mode, default agent — with the roster the picker chooses from.
-        app.get("/api/projects/:id/config", withRuntime(async (rt, _req, res) => {
-            res.json(rt.settings());
-        }));
-        // The Settings screen's editable knobs: the brain extractor, the projection
-        // mode, the default agent. Everything is read live from config, so a merge
-        // here lands on the next turn/handoff with no restart. Partial — send only
-        // what changed. Returns the full config so the screen can re-render.
-        app.patch("/api/projects/:id/config", withRuntime(async (rt, req, res) => {
-            const body = (req.body ?? {});
-            try {
-                const cfg = rt.patchConfig({
-                    brain: body.brain,
-                    projection: body.projection,
-                    defaultAgent: body.defaultAgent,
-                });
-                res.json({
-                    brain: cfg.brain ?? {},
-                    projection: cfg.projection ?? {},
-                    defaultAgent: cfg.defaultAgent ?? "",
-                });
-            }
-            catch (err) {
-                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
-            }
-        }));
-        // ---- search -----------------------------------------------------------
-        // Finding a file by name was the whole of search, which is its least useful
-        // half: you remember a line, not a filename. And the thread — where a
-        // project's actual reasoning lives — wasn't searchable at all.
-        app.get("/api/projects/:id/grep", withRuntime(async (rt, req, res) => {
-            res.json(await searchCode(rt.info.dir, String(req.query.q ?? "")));
-        }));
-        app.get("/api/projects/:id/chats/search", withRuntime(async (rt, req, res) => {
-            res.json(searchChats(rt.log, String(req.query.q ?? ""), {
-                ...(req.query.chat ? { chat: String(req.query.chat) } : {}),
-            }));
-        }));
-        // ---- source control ---------------------------------------------------
-        // Reading the working tree has been possible since the Explorer landed;
-        // doing anything about it has not. These are the writes, and they're the
-        // only endpoints in Loom that can destroy work — hence the path checks in
-        // core/git.ts and the noise in the log when you discard.
-        app.get("/api/projects/:id/git/status", withRuntime(async (rt, _req, res) => {
-            res.json(await gitStatus(rt.info.dir));
-        }));
-        const gitWrite = (fn) => withRuntime(async (rt, req, res) => {
-            try {
-                res.json(await fn(rt.info.dir, (req.body ?? {})));
-            }
-            catch (err) {
-                // git's own words, not ours: "nothing to commit, working tree clean"
-                // beats anything we'd invent about an exit code.
-                const message = err instanceof Error ? err.message : String(err);
-                logbook.warn("git", message, err instanceof GitError ? err.stderr : err, rt.info.id);
-                res.status(400).json({ error: message });
-            }
-        });
-        app.post("/api/projects/:id/git/stage", gitWrite((dir, b) => gitStage(dir, asPaths(b.paths))));
-        app.post("/api/projects/:id/git/unstage", gitWrite((dir, b) => gitUnstage(dir, asPaths(b.paths))));
-        app.post("/api/projects/:id/git/discard", gitWrite((dir, b) => gitDiscard(dir, asPaths(b.paths), asPaths(b.untracked))));
-        app.post("/api/projects/:id/git/commit", gitWrite((dir, b) => gitCommit(dir, String(b.message ?? ""))));
-        // init / push / checkout — all write, all through the same error surface.
-        app.post("/api/projects/:id/git/init", gitWrite((dir) => gitInit(dir)));
-        app.post("/api/projects/:id/git/push", gitWrite((dir) => gitPush(dir)));
-        app.post("/api/projects/:id/git/checkout", gitWrite((dir, b) => gitCheckout(dir, String(b.ref ?? ""))));
-        // read-only: the commit log, one file's diff, and the branch list
-        app.get("/api/projects/:id/git/log", withRuntime(async (rt, req, res) => {
-            const limit = Number(req.query.limit) || 30;
-            res.json({ commits: await gitLog(rt.info.dir, limit) });
-        }));
-        app.get("/api/projects/:id/git/diff", withRuntime(async (rt, req, res) => {
-            const p = String(req.query.path ?? "");
-            if (!p)
-                return void res.status(400).json({ error: "missing path" });
-            try {
-                res.json({ path: p, patch: await gitFileDiff(rt.info.dir, p) });
-            }
-            catch (err) {
-                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
-            }
-        }));
-        app.get("/api/projects/:id/git/branches", withRuntime(async (rt, _req, res) => {
-            res.json(await gitBranches(rt.info.dir));
-        }));
-        // Draft a commit message from the staged diff, via the logged-in Claude CLI
-        // — the "Generate" affordance. No key; a no-op-ish 400 when Claude isn't
-        // there, so the field just stays empty and the user types their own.
-        app.post("/api/projects/:id/git/suggest-message", withRuntime(async (rt, _req, res) => {
-            const diff = await gitStagedDiff(rt.info.dir).catch(() => "");
-            if (!diff.trim())
-                return void res.status(400).json({ error: "nothing to describe — stage or edit some files first" });
-            try {
-                const prompt = "Write a single-line Conventional Commit subject (type(scope): summary, imperative mood, <72 chars) " +
-                    "for this diff. Reply with ONLY the subject line, no quotes, no body.\n\n" +
-                    diff;
-                const out = (await claudeText(prompt, { model: "haiku", timeoutMs: 30_000 })).trim();
-                const message = out.split("\n")[0]?.replace(/^["'`]|["'`]$/g, "").trim().slice(0, 120) ?? "";
-                if (!message)
-                    return void res.status(502).json({ error: "Claude returned nothing — type a message instead" });
-                res.json({ message });
-            }
-            catch {
-                // claudeText's raw "claude exited N" helps no one at the commit box.
-                res.status(502).json({ error: "couldn't reach Claude to draft a message — type one instead" });
-            }
-        }));
-        // ---- the Console ------------------------------------------------------
-        // Everything that went wrong, for the tab next to the terminal. Until this
-        // existed an error's only home was ~/.loom/daemon.log, which you have to
-        // know about, find, and tail — so in practice errors reached nobody.
-        app.get("/api/logs", (req, res) => {
-            const since = req.query.since === undefined ? undefined : Number(req.query.since);
-            const level = req.query.level;
+        // What exactly is running: build rev, node, uptime, platform. /api/health
+        // carries rev for staleness checks; this is the fuller "loom health"
+        // answer, and it's behind the wall because build details are inventory.
+        app.get("/api/version", (_req, res) => {
             res.json({
-                logs: logbook.list({
-                    ...(Number.isFinite(since) ? { since } : {}),
-                    ...(level ? { level } : {}),
-                    ...(req.query.project ? { project: String(req.query.project) } : {}),
-                }),
-            });
-        });
-        app.delete("/api/logs", (_req, res) => {
-            logbook.clear();
-            res.json({ ok: true });
-        });
-        /**
-         * The window reporting its own errors — a failed fetch, a thrown render, an
-         * unhandled rejection. Client-side failures used to die in the browser
-         * console where no one was looking; now they land in the same Console tab as
-         * the daemon's, streamed to every window and kept in the ring buffer.
-         */
-        app.post("/api/logs", (req, res) => {
-            const b = (req.body ?? {});
-            const level = b.level === "error" || b.level === "warn" ? b.level : "info";
-            const message = String(b.message ?? "").slice(0, 500);
-            if (!message)
-                return void res.status(400).json({ error: "missing message" });
-            const scope = (b.scope ? String(b.scope) : "app").slice(0, 40);
-            const rec = logbook.add(level, scope, message, b.detail, b.project ? String(b.project) : undefined);
-            res.json({ ok: true, id: rec.id });
-        });
-        // Which agents Loom can drive on this machine, and which are already in
-        // this project. The UI needs both to offer you the difference.
-        app.get("/api/projects/:id/agents/available", withRuntime(async (rt, _req, res) => {
-            const availability = await detectAdes();
-            const inProject = new Set(rt.config.agents.map((a) => a.kind));
-            res.json({
-                ades: ADES.map((a) => ({
-                    kind: a.kind,
-                    label: a.label,
-                    tier: a.tier,
-                    // Bridges are never "installed" — they're an app you launch with a
-                    // debug port, so presence is a live question, not a lookup.
-                    installed: a.tier === "adapter" ? Boolean(availability[a.kind]) : null,
-                    inProject: inProject.has(a.kind),
-                    models: a.models ?? [],
-                })),
-            });
-        }));
-        // Add an agent to a project. A roster used to be frozen at creation: install
-        // a new ADE and your existing projects never heard of it.
-        app.post("/api/projects/:id/agents", withRuntime(async (rt, req, res) => {
-            const { kind, id, role } = (req.body ?? {});
-            if (!kind?.trim())
-                return void res.status(400).json({ error: "missing kind" });
-            try {
-                res.json(rt.addAgent(kind.trim(), { id, role }));
-            }
-            catch (err) {
-                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
-            }
-        }));
-        app.delete("/api/projects/:id/agents/:agentId", withRuntime(async (rt, req, res) => {
-            try {
-                res.json(rt.removeAgent(String(req.params.agentId)));
-            }
-            catch (err) {
-                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
-            }
-        }));
-        // Point an agent at a different model. Empty string clears the override.
-        app.post("/api/projects/:id/agents/:agentId/model", withRuntime(async (rt, req, res) => {
-            const { model } = (req.body ?? {});
-            try {
-                const cfg = rt.setAgentModel(String(req.params.agentId), model ?? "");
-                res.json({ agent: cfg });
-            }
-            catch (err) {
-                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
-            }
-        }));
-        app.post("/api/projects/:id/interrupt", withRuntime(async (rt, _req, res) => {
-            res.json(await rt.interrupt());
-        }));
-        app.post("/api/projects/:id/decisions", withRuntime(async (rt, req, res) => {
-            const { text } = (req.body ?? {});
-            if (!text?.trim())
-                return void res.status(400).json({ error: "missing text" });
-            const event = rt.log.append({ kind: "decision", payload: { text } });
-            // Also a memory. The decision event stays because the projection and
-            // forty other things read it; the memory is the addressable copy — the
-            // one that can be retrieved by what it's about, corrected, and
-            // forgotten. Seeding the brain from the surface people already use
-            // beats asking them to fill a second box.
-            rt.brain.add({
-                kind: "decision",
-                text,
-                provenance: { agentId: "user", eventId: event.id, ts: event.ts },
-            });
-            res.json({ event });
-        }));
-        // --- the brain ---------------------------------------------------------
-        app.get("/api/projects/:id/brain", withRuntime(async (rt, req, res) => {
-            const q = req.query;
-            const memories = rt.brain.list({
-                ...(q.kind ? { kind: q.kind } : {}),
-                ...(q.chat ? { chat: q.chat } : {}),
-                ...(q.includeExpired === "1" ? { includeExpired: true } : {}),
-                ...(q.limit ? { limit: Math.min(500, Number(q.limit) || 100) } : {}),
-            });
-            res.json({ memories, stats: rt.brain.stats() });
-        }));
-        app.get("/api/projects/:id/brain/search", withRuntime(async (rt, req, res) => {
-            const q = req.query;
-            const files = q.files ? q.files.split(",").filter(Boolean) : [];
-            if (!q.q?.trim() && !files.length) {
-                return void res.status(400).json({ error: "missing q or files" });
-            }
-            const hits = retrieve(rt.brain, {
-                ...(q.q ? { query: q.q } : {}),
-                ...(files.length ? { files } : {}),
-                ...(q.chat ? { chat: q.chat } : {}),
-                ...(q.agent ? { agent: q.agent } : {}),
-                limit: Math.min(50, Number(q.limit) || 12),
-                explain: q.explain === "1",
-            });
-            res.json({ hits });
-        }));
-        app.post("/api/projects/:id/brain", withRuntime(async (rt, req, res) => {
-            const body = (req.body ?? {});
-            if (!body.text?.trim())
-                return void res.status(400).json({ error: "missing text" });
-            try {
-                const { memory, created } = rt.brain.add({
-                    kind: body.kind ?? "fact",
-                    text: body.text,
-                    ...(body.entities ? { entities: body.entities } : {}),
-                    ...(body.chat ? { scope: { chat: body.chat } } : {}),
-                    ...(body.confidence !== undefined ? { confidence: body.confidence } : {}),
-                    provenance: { agentId: "user", eventId: rt.log.lastId(), ts: Date.now() },
-                });
-                res.json({ memory, created });
-            }
-            catch (err) {
-                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
-            }
-        }));
-        app.patch("/api/projects/:id/brain/:mid", withRuntime(async (rt, req, res) => {
-            try {
-                res.json({ memory: rt.brain.update(String(req.params.mid), (req.body ?? {}), "user") });
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                res.status(/no such memory/.test(msg) ? 404 : 400).json({ error: msg });
-            }
-        }));
-        app.delete("/api/projects/:id/brain/:mid", withRuntime(async (rt, req, res) => {
-            const reason = String(req.query.reason ?? "").trim();
-            if (!reason)
-                return void res.status(400).json({ error: "forgetting needs a reason" });
-            const forgot = rt.brain.forget(String(req.params.mid), reason, "user");
-            if (!forgot)
-                return void res.status(404).json({ error: "no such memory" });
-            res.json({ forgot: true });
-        }));
-        app.get("/api/projects/:id/brain/:mid/history", withRuntime(async (rt, req, res) => {
-            res.json({ history: rt.brain.history(String(req.params.mid)) });
-        }));
-        app.post("/api/projects/:id/route", withRuntime(async (rt, req, res) => {
-            const { task, spec, router, maxHops } = (req.body ?? {});
-            if (!task?.trim())
-                return void res.status(400).json({ error: "missing task" });
-            const route = await rt.startRoute({
-                task,
-                ...(spec !== undefined ? { spec } : {}),
-                ...(router ? { router } : {}),
-                ...(maxHops ? { maxHops: Number(maxHops) } : {}),
-            });
-            res.json({ route });
-        }));
-        app.get("/api/projects/:id/route", withRuntime(async (rt, _req, res) => {
-            res.json({ route: rt.routeState() });
-        }));
-        app.get("/api/projects/:id/costs", withRuntime(async (rt, _req, res) => {
-            res.json({ costs: rt.costSummary() });
-        }));
-        app.get("/api/projects/:id/tree", withRuntime(async (rt, _req, res) => {
-            res.json({ tree: await rt.workingTree() });
-        }));
-        app.get("/api/projects/:id/memory", withRuntime(async (rt, _req, res) => {
-            res.json({ memory: rt.unifiedMemory() });
-        }));
-        app.post("/api/projects/:id/memory/import", withRuntime(async (rt, _req, res) => {
-            res.json(rt.importMemories());
-        }));
-        app.delete("/api/projects/:id/route", withRuntime(async (rt, _req, res) => {
-            res.json({ route: await rt.abortRoute() });
-        }));
-        // Terminal: one long-lived shell per tab. A real pty when node-pty is
-        // available (echo, job control, vim), otherwise a pipe-backed shell — see
-        // terminals.ts. Output streams over the project WebSocket; input arrives
-        // there too, because a tty needs a round-trip per keystroke. Bearer auth +
-        // the tailnet are the trust boundary, same as the agents the daemon runs.
-        app.post("/api/projects/:id/term/open", (req, res) => {
-            const info = findProject(String(req.params.id));
-            if (!info)
-                return void res.status(404).json({ error: "unknown project" });
-            const { term, cols, rows } = (req.body ?? {});
-            const termId = String(term ?? "t1");
-            const existing = this.terminals.get(info.id, termId);
-            if (existing) {
-                // A reload rejoins the session it left, and gets replayed what it missed.
-                return void res.json({
-                    term: termId,
-                    cwd: existing.cwd,
-                    mode: existing.mode,
-                    reused: true,
-                    scrollback: existing.scrollback(),
-                });
-            }
-            try {
-                const sess = this.terminals.open(info.id, termId, info.dir, cols ?? 80, rows ?? 24);
-                res.json({ term: termId, cwd: sess.cwd, mode: sess.mode, reused: false, scrollback: "" });
-            }
-            catch (err) {
-                // only the cap is a 429 — a shell that won't spawn is our problem, not
-                // the client's rate
-                res.status(err instanceof TooManySessionsError ? 429 : 500).json({
-                    error: err.message,
-                });
-            }
-        });
-        app.post("/api/projects/:id/term/input", (req, res) => {
-            const info = findProject(String(req.params.id));
-            if (!info)
-                return void res.status(404).json({ error: "unknown project" });
-            const { term, data } = (req.body ?? {});
-            const termId = String(term ?? "t1");
-            try {
-                // this opens a session when none exists, so it can fail the same ways
-                // /term/open can — uncaught, Express answers a JSON client with HTML
-                const sess = this.terminals.get(info.id, termId) ?? this.terminals.open(info.id, termId, info.dir);
-                sess.write(String(data ?? ""));
-                res.json({ ok: true });
-            }
-            catch (err) {
-                res.status(err instanceof TooManySessionsError ? 429 : 500).json({
-                    error: err.message,
-                });
-            }
-        });
-        app.post("/api/projects/:id/term/signal", (req, res) => {
-            const info = findProject(String(req.params.id));
-            if (!info)
-                return void res.status(404).json({ error: "unknown project" });
-            const sess = this.terminals.get(info.id, String((req.body ?? {}).term ?? "t1"));
-            if (!sess)
-                return void res.json({ signalled: false });
-            sess.interrupt();
-            res.json({ signalled: true });
-        });
-        app.post("/api/projects/:id/term/resize", (req, res) => {
-            const info = findProject(String(req.params.id));
-            if (!info)
-                return void res.status(404).json({ error: "unknown project" });
-            const { term, cols, rows } = (req.body ?? {});
-            const sess = this.terminals.get(info.id, String(term ?? "t1"));
-            if (!sess)
-                return void res.json({ resized: false });
-            sess.resize(Number(cols) || 80, Number(rows) || 24);
-            res.json({ resized: true });
-        });
-        app.post("/api/projects/:id/term/close", (req, res) => {
-            const info = findProject(String(req.params.id));
-            if (!info)
-                return void res.status(404).json({ error: "unknown project" });
-            this.terminals.close(info.id, String((req.body ?? {}).term ?? "t1"));
-            res.json({ closed: true });
-        });
-        // The board: live agents (from us) + pull requests (from gh), sorted into
-        // working → needs you → in review → ready. See board.ts.
-        app.get("/api/projects/:id/board", async (req, res) => {
-            const info = findProject(String(req.params.id));
-            if (!info)
-                return void res.status(404).json({ error: "unknown project" });
-            try {
-                const rt = await this.runtime(info.id);
-                const status = await rt.status();
-                const blocked = status.blockedAgent ? [status.blockedAgent] : [];
-                const search = req.query.search ? String(req.query.search) : undefined;
-                res.json(await buildBoard(info.dir, status.agents, blocked, {
-                    tasks: rt.boardTasks(),
-                    ...(search ? { search } : {}),
-                }));
-            }
-            catch (err) {
-                res.status(500).json({ error: err.message });
-            }
-        });
-        // Cards you write yourself. Unlike an agent or a PR, these are ours, so a
-        // drag really moves them — the column IS the state.
-        app.post("/api/projects/:id/board/tasks", withRuntime(async (rt, req, res) => {
-            const { title, column, agent } = (req.body ?? {});
-            if (!title?.trim())
-                return void res.status(400).json({ error: "missing title" });
-            res.json({ task: rt.createTask({ title, ...(column ? { column } : {}), ...(agent ? { agent } : {}) }) });
-        }));
-        app.post("/api/projects/:id/board/tasks/:taskId", withRuntime(async (rt, req, res) => {
-            const { title, column, agent } = (req.body ?? {});
-            const task = rt.updateTask(String(req.params.taskId), {
-                ...(title !== undefined ? { title } : {}),
-                ...(column !== undefined ? { column } : {}),
-                ...(agent !== undefined ? { agent } : {}),
-            });
-            if (!task)
-                return void res.status(404).json({ error: "unknown task" });
-            res.json({ task });
-        }));
-        app.delete("/api/projects/:id/board/tasks/:taskId", withRuntime(async (rt, req, res) => {
-            if (!rt.deleteTask(String(req.params.taskId))) {
-                return void res.status(404).json({ error: "unknown task" });
-            }
-            res.json({ deleted: true });
-        }));
-        // Issues / PRs for the project's GitHub remote, read through the user's
-        // own gh CLI (see tasks.ts) — Loom holds no token of its own.
-        app.get("/api/projects/:id/tasks", async (req, res) => {
-            const info = findProject(String(req.params.id));
-            if (!info)
-                return void res.status(404).json({ error: "unknown project" });
-            const kind = String(req.query.kind ?? "issue") === "pr" ? "pr" : "issue";
-            res.json(await listTasks(info.dir, {
-                kind,
-                ...(req.query.search ? { search: String(req.query.search) } : {}),
-            }));
-        });
-        // Small async wrapper: resolve the project or 404, run the handler, and turn
-        // any throw into a 500 with its message. The GitHub/Linear/worktree reads
-        // below all share this shape.
-        const projectRoute = (fn) => (req, res) => {
-            const info = findProject(String(req.params.id));
-            if (!info)
-                return void res.status(404).json({ error: "unknown project" });
-            void fn(info.dir, req, res).catch((err) => res.status(500).json({ error: err instanceof Error ? err.message : String(err) }));
-        };
-        // ---- GitHub Projects (v2) — the owner's boards, browsed in-app ----------
-        app.get("/api/projects/:id/gh/projects", projectRoute(async (dir, _req, res) => {
-            res.json(await ghProjects(dir));
-        }));
-        app.get("/api/projects/:id/gh/projects/:num/items", projectRoute(async (dir, req, res) => {
-            res.json(await ghProjectItems(dir, Number(req.params.num)));
-        }));
-        // ---- Pull-request review — diff + approve / request-changes / comment ----
-        app.get("/api/projects/:id/prs/:num", projectRoute(async (dir, req, res) => {
-            res.json(await prView(dir, Number(req.params.num)));
-        }));
-        app.post("/api/projects/:id/prs/:num/review", projectRoute(async (dir, req, res) => {
-            const { action, body } = (req.body ?? {});
-            const allowed = ["approve", "request-changes", "comment"];
-            if (!allowed.includes(action)) {
-                return void res.status(400).json({ error: "action must be approve, request-changes, or comment" });
-            }
-            const result = await prReview(dir, Number(req.params.num), action, body ?? "");
-            if ("available" in result)
-                return void res.status(400).json({ error: result.detail });
-            res.json(result);
-        }));
-        // ---- Worktrees — open a checked-out branch from any task ----------------
-        app.get("/api/projects/:id/worktrees", projectRoute(async (dir, _req, res) => {
-            res.json({ worktrees: await gitListWorktrees(dir) });
-        }));
-        app.post("/api/projects/:id/worktrees", projectRoute(async (dir, req, res) => {
-            const b = (req.body ?? {});
-            if (b.pr) {
-                const n = Number(b.pr);
-                const wt = await gitAddWorktree(dir, { slug: "pr-" + n, detached: true });
-                try {
-                    // gh handles fork PRs (adds the remote, fetches, makes the branch)
-                    await runGh(["pr", "checkout", String(n)], wt.path);
-                }
-                catch (err) {
-                    // don't strand an empty detached worktree if the checkout fails
-                    await gitRemoveWorktree(dir, wt.path, true).catch(() => { });
-                    throw err;
-                }
-                return void res.json({ path: wt.path, source: `PR #${n}` });
-            }
-            if (b.newBranch) {
-                const wt = await gitAddWorktree(dir, {
-                    slug: b.newBranch,
-                    newBranch: String(b.newBranch),
-                    ...(b.base ? { base: String(b.base) } : {}),
-                });
-                return void res.json({ path: wt.path, branch: wt.branch });
-            }
-            if (b.branch) {
-                const wt = await gitAddWorktree(dir, { slug: String(b.branch), branch: String(b.branch) });
-                return void res.json({ path: wt.path, branch: wt.branch });
-            }
-            if (b.issue) {
-                const slug = "issue-" + Number(b.issue);
-                const wt = await gitAddWorktree(dir, { slug, newBranch: slug });
-                return void res.json({ path: wt.path, branch: wt.branch, source: `issue #${Number(b.issue)}` });
-            }
-            res.status(400).json({ error: "say which: pr, issue, branch, or newBranch" });
-        }));
-        app.delete("/api/projects/:id/worktrees", projectRoute(async (dir, req, res) => {
-            const wtPath = String((req.body ?? {}).path ?? req.query.path ?? "");
-            if (!wtPath)
-                return void res.status(400).json({ error: "which worktree? pass its path" });
-            await gitRemoveWorktree(dir, wtPath, Boolean((req.body ?? {}).force));
-            res.json({ removed: wtPath });
-        }));
-        // ---- Linear — teams + create issue, through the user's own key ----------
-        app.get("/api/projects/:id/linear/teams", projectRoute(async (_dir, _req, res) => {
-            res.json(await linearTeams());
-        }));
-        app.get("/api/projects/:id/linear/issues", projectRoute(async (_dir, req, res) => {
-            res.json(await listLinearIssues(req.query.team ? String(req.query.team) : undefined));
-        }));
-        app.post("/api/projects/:id/linear/issues", projectRoute(async (_dir, req, res) => {
-            const { teamId, title, description } = (req.body ?? {});
-            const result = await linearCreateIssue({
-                teamId: teamId ?? "",
-                title: title ?? "",
-                ...(description ? { description } : {}),
-            });
-            if (result.available)
-                return void res.json(result);
-            res.status(400).json({ error: result.detail });
-        }));
-        // Explorer: list a directory, read a file, search filenames. All strictly
-        // sandboxed to the project directory (no traversal outside it).
-        const contains = (base, target) => target === base || target.startsWith(base + path.sep);
-        /**
-         * Resolve a project-relative path, or null if it escapes the project.
-         * Two checks, because they catch different attacks: the lexical one stops
-         * `../` traversal (and works for paths that don't exist yet), and the
-         * realpath one stops a symlink *inside* the project from pointing out of
-         * it — path.resolve happily resolves through links.
-         */
-        const projectPath = (id, rel) => {
-            const info = findProject(id);
-            if (!info)
-                return null;
-            let base;
-            try {
-                base = fs.realpathSync(path.resolve(info.dir));
-            }
-            catch {
-                return null;
-            }
-            const target = path.resolve(base, rel ?? ".");
-            if (!contains(base, target))
-                return null;
-            try {
-                if (!contains(base, fs.realpathSync(target)))
-                    return null;
-            }
-            catch {
-                // doesn't exist — the lexical check above is the whole answer
-            }
-            return target;
-        };
-        const HIDE_DIRS = new Set([".git", "node_modules", "dist", "build", ".next", ".cache", "coverage"]);
-        app.get("/api/projects/:id/files", (req, res) => {
-            const dir = projectPath(String(req.params.id), req.query.dir ? String(req.query.dir) : ".");
-            if (!dir)
-                return void res.status(404).json({ error: "not found" });
-            const base = projectPath(String(req.params.id), ".");
-            fs.readdir(dir, { withFileTypes: true }, (err, ents) => {
-                if (err)
-                    return void res.status(400).json({ error: err.message });
-                const entries = ents
-                    .filter((e) => e.name !== ".git")
-                    .map((e) => ({
-                    name: e.name,
-                    path: path.relative(base, path.join(dir, e.name)),
-                    dir: e.isDirectory(),
-                }))
-                    .sort((a, b) => a.dir === b.dir ? a.name.localeCompare(b.name) : a.dir ? -1 : 1)
-                    .slice(0, 500);
-                res.json({ dir: path.relative(base, dir), entries });
-            });
-        });
-        app.get("/api/projects/:id/file", (req, res) => {
-            const file = projectPath(String(req.params.id), req.query.path ? String(req.query.path) : "");
-            if (!file)
-                return void res.status(404).json({ error: "not found" });
-            fs.stat(file, (err, st) => {
-                if (err)
-                    return void res.status(400).json({ error: err.message });
-                if (st.isDirectory())
-                    return void res.status(400).json({ error: "is a directory" });
-                const MAX = 400_000;
-                const truncated = st.size > MAX;
-                const stream = fs.createReadStream(file, { start: 0, end: Math.min(st.size, MAX) - 1, encoding: "utf8" });
-                let content = "";
-                stream.on("data", (c) => (content += c));
-                stream.on("error", (e) => res.status(400).json({ error: e.message }));
-                stream.on("end", () => {
-                    const base = projectPath(String(req.params.id), ".");
-                    res.json({ path: path.relative(base, file), content, truncated, size: st.size });
-                });
+                rev: BUILD_REV,
+                node: process.version,
+                platform: `${process.platform}-${process.arch}`,
+                uptimeSec: Math.round(process.uptime()),
+                pid: process.pid,
             });
         });
-        app.get("/api/projects/:id/find", (req, res) => {
-            const base = projectPath(String(req.params.id), ".");
-            if (!base)
-                return void res.status(404).json({ error: "not found" });
-            const q = String(req.query.q ?? "").trim().toLowerCase();
-            if (!q)
-                return void res.json({ matches: [] });
-            const matches = [];
-            let visited = 0;
-            const walk = (dir) => {
-                if (matches.length >= 200 || visited >= 20_000)
-                    return;
-                let ents;
-                try {
-                    ents = fs.readdirSync(dir, { withFileTypes: true });
-                }
-                catch {
-                    return;
-                }
-                for (const e of ents) {
-                    if (matches.length >= 200 || visited >= 20_000)
-                        return;
-                    visited++;
-                    if (e.isDirectory()) {
-                        if (HIDE_DIRS.has(e.name))
-                            continue;
-                        walk(path.join(dir, e.name));
-                    }
-                    else if (e.name.toLowerCase().includes(q)) {
-                        matches.push(path.relative(base, path.join(dir, e.name)));
-                    }
-                }
-            };
-            walk(base);
-            res.json({ matches });
-        });
-        /**
-         * Stash a pasted image or dropped file, and hand back its path.
-         *
-         * The CLIs Loom drives take text and nothing else — SendInput is { text,
-         * briefing }, no image channel. So the only honest way to "attach" an image
-         * is to write it somewhere the agent can read and reference the path in the
-         * message. Claude Code and Codex both read image files by path; for the
-         * others it's at least a real artifact on disk rather than a lie in the UI.
-         *
-         * Under .loom/attachments/ so it's inside the project (the agent's cwd) but
-         * out of the way. Name is derived from a content hash, never from the
-         * client's — a caller doesn't get to choose where in the tree this lands.
-         */
-        app.post("/api/projects/:id/attachments", (req, res) => {
-            const base = projectPath(String(req.params.id), ".");
-            if (!base)
-                return void res.status(404).json({ error: "not found" });
-            const { name, dataUrl } = (req.body ?? {});
-            const m = /^data:([\w/+.-]+);base64,(.+)$/s.exec(dataUrl ?? "");
-            if (!m)
-                return void res.status(400).json({ error: "expected a base64 data URL" });
-            const mime = m[1] ?? "application/octet-stream";
-            const buf = Buffer.from(m[2] ?? "", "base64");
-            const MAX = 12 * 1024 * 1024;
-            if (buf.length > MAX)
-                return void res.status(413).json({ error: "attachment over 12MB" });
-            // Extension from the declared type or the client's name, whichever we
-            // trust more — but only ever the extension, never the path.
-            const extFromName = typeof name === "string" ? path.extname(name).replace(/[^.\w]/g, "").slice(0, 8) : "";
-            const ext = extFromName || "." + (MIME_EXT[mime] ?? "bin");
-            const hash = crypto.createHash("sha1").update(buf).digest("hex").slice(0, 12);
-            const rel = path.join(".loom", "attachments", hash + ext);
-            const abs = projectPath(String(req.params.id), rel);
-            if (!abs)
-                return void res.status(400).json({ error: "bad attachment path" });
-            try {
-                fs.mkdirSync(path.dirname(abs), { recursive: true });
-                fs.writeFileSync(abs, buf);
-            }
-            catch (err) {
-                return void res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
-            }
-            res.json({ path: rel, bytes: buf.length, mime });
+        // The scope wall: one guard over every project route, so a scoped token
+        // cannot reach a project it wasn't paired for. Matching by resolved id —
+        // the param may be a name, and a scope you could dodge by spelling the
+        // project differently would be theatre.
+        app.use("/api/projects/:id", (req, res, next) => {
+            const scope = req.projectScope;
+            if (!scope)
+                return void next();
+            const resolved = findProject(String(req.params.id))?.id ?? String(req.params.id);
+            if (scope.includes(resolved))
+                return void next();
+            res.status(403).json({ error: "this token is not scoped to that project" });
+        });
+        registerSetupRoutes(app);
+        registerProvidersRoutes(app);
+        registerUpdatesRoutes(app, ctx);
+        registerIntegrationsRoutes(app);
+        registerPairingRoutes(app, ctx);
+        registerTeamRoutes(app, ctx);
+        registerCloudRoutes(app, ctx);
+        registerClientsRoutes(app, ctx);
+        registerProjectsRoutes(app, ctx);
+        const withRuntime = createRuntimeHandler(ctx);
+        registerObservabilityRoutes(app, withRuntime);
+        registerAlertsRoutes(app, ctx);
+        registerMessagesRoutes(app, withRuntime);
+        registerServersRoutes(app, withRuntime);
+        registerTaskDeliveryRoutes(app, withRuntime);
+        registerQueueRoutes(app, withRuntime);
+        registerChatsRoutes(app, withRuntime);
+        registerAgentSettingsRoutes(app, withRuntime);
+        registerToolsRoutes(app, withRuntime);
+        registerConfigRoutes(app, withRuntime);
+        registerSearchRoutes(app, withRuntime);
+        registerGitRoutes(app, withRuntime);
+        registerLogsRoutes(app);
+        registerAgentDiscoveryRoutes(app, withRuntime);
+        registerSpecsRoutes(app, ctx, withRuntime);
+        registerProjectActionsRoutes(app, withRuntime);
+        registerVoiceRoutes(app, withRuntime);
+        registerHistoryRoutes(app, withRuntime);
+        registerPromptsRoutes(app, ctx);
+        registerProjectTeamRoutes(app, ctx, withRuntime);
+        registerApprovalsRoutes(app, ctx, withRuntime);
+        registerOrchestraRoutes(app, withRuntime);
+        registerCrewsRoutes(app, withRuntime);
+        registerProofRoutes(app, withRuntime);
+        registerShiftRoutes(app, withRuntime);
+        registerOnboardRoutes(app, { team: this.team, onboarding: this.onboarding, ...(this.gh ? { gh: this.gh } : {}) }, withRuntime);
+        registerAgentsRoutes(app, withRuntime);
+        registerBrainRoutes(app, withRuntime);
+        registerRoutingRoutes(app, withRuntime);
+        registerTerminalsRoutes(app, ctx);
+        registerBoardRoutes(app, ctx, withRuntime);
+        registerIntegrationsProjectRoutes(app);
+        registerFilesRoutes(app);
+        registerPreviewRoutes(app);
+        // Anything under /api nobody answered: JSON, like every other API reply,
+        // not Express's HTML page.
+        app.use("/api", (_req, res) => {
+            res.status(404).json({ error: "no such endpoint" });
+        });
+        // Errors that escaped a route, and bodies that never parsed. Express's
+        // default answers these with an HTML page carrying a stack trace.
+        app.use((err, _req, res, next) => {
+            if (res.headersSent)
+                return void next(err);
+            const e = (err ?? {});
+            if (e.type === "entity.too.large")
+                return void res.status(413).json({ error: "that request is too large (the limit is 2 MB)" });
+            if (e.type === "entity.parse.failed")
+                return void res.status(400).json({ error: "that request body isn't valid JSON" });
+            logbook.error("daemon", `request failed: ${e.message ?? String(err)}`, err);
+            const status = typeof e.status === "number" && e.status >= 400 && e.status < 600 ? e.status : 500;
+            res.status(status).json({ error: status >= 500 ? "something went wrong in the daemon — the Console has the details" : e.message || "bad request" });
         });
     }
     // -------------------------------------------------------------------------
@@ -1422,6 +416,7 @@ export class LoomDaemon {
         if (existing) {
             // Hot-reload edited .loom/config.json once the project is quiet.
             if (existing.configStale() && !existing.anyBusy()) {
+                this.team.detachRuntime(info.id);
                 await existing.close();
                 this.runtimes.delete(info.id);
             }
@@ -1430,19 +425,78 @@ export class LoomDaemon {
             }
         }
         const rt = await ProjectRuntime.open(info);
-        rt.log.onEvent((e) => this.broadcast(info.id, e));
+        rt.onServerEvent((f) => {
+            this.broadcastFrame({ type: "server", projectId: info.id, ...f }, info.id);
+        });
+        rt.onQueueChange((q) => {
+            const head = q.items[0];
+            const waitingFor = head && !q.paused ? rt.queueBlocker(head) : null;
+            this.broadcastFrame({
+                type: "queue",
+                projectId: info.id,
+                queue: q.items,
+                paused: q.paused,
+                ...(q.reason ? { reason: q.reason } : {}),
+                ...(waitingFor ? { waitingFor } : {}),
+            }, info.id);
+        });
+        rt.onLiveDelta((d) => {
+            this.broadcastFrame({ type: "phase" in d ? "item" : "delta", projectId: info.id, ...d }, info.id);
+        });
+        // Replies as they're written. Deltas are coalesced per agent for a frame
+        // (~40ms), so a fast model is a few dozen socket frames a second at most,
+        // not one per token. Never logged: the finished message is the record.
+        const live = new Map();
+        let liveTimer = null;
+        const flushLive = () => {
+            liveTimer = null;
+            for (const [agentId, f] of live) {
+                this.broadcastFrame({
+                    type: "stream", projectId: info.id, agentId, chat: f.chat, text: f.text,
+                    ...(f.reasoning ? { reasoning: true } : {}),
+                    ...(f.off !== undefined ? { off: f.off } : {}),
+                }, info.id);
+            }
+            live.clear();
+        };
+        rt.onStream((f) => {
+            const key = f.agentId;
+            const have = live.get(key);
+            // A switch between thinking and answering (or thread) is a new piece.
+            if (have && (have.reasoning !== Boolean(f.reasoning) || have.chat !== f.chat))
+                flushLive();
+            const cur = live.get(key);
+            if (cur)
+                cur.text += f.text;
+            else
+                live.set(key, { chat: f.chat, text: f.text, reasoning: Boolean(f.reasoning), ...(f.off !== undefined ? { off: f.off } : {}) });
+            if (!liveTimer)
+                liveTimer = setTimeout(flushLive, 40);
+        });
+        rt.log.onEvent((e) => {
+            // A finished message supersedes its typing: send what's buffered first
+            // so the last few characters can't land after the message they belong to.
+            if (e.kind === "message" && e.agentId && live.has(e.agentId)) {
+                if (liveTimer)
+                    clearTimeout(liveTimer);
+                flushLive();
+            }
+            this.broadcast(info.id, e);
+            // The single central hook for live events — agent turns as well as
+            // API-driven handoffs, routes and memory folds. Rehydration reads through
+            // log.list(), not append(), so replaying history never re-exports it.
+            recordAgentEvent(e, { project: info.name });
+        });
         this.runtimes.set(info.id, rt);
+        this.team.attachRuntime(rt);
         return rt;
     }
+    /** One frame to everyone watching this project (or everyone, with no project). */
+    broadcastFrame(payload, projectId) {
+        this.delivery.publish(payload, { kind: "project", projectId });
+    }
     broadcast(projectId, event) {
-        const frame = JSON.stringify({ type: "event", projectId, event });
-        for (const [ws, sub] of this.sockets) {
-            if (ws.readyState !== WebSocket.OPEN)
-                continue;
-            if (sub.project && sub.project !== projectId)
-                continue;
-            ws.send(frame);
-        }
+        this.broadcastFrame({ type: "event", projectId, event }, projectId);
         // An agent's error is a thread event AND a log line. The thread shows it to
         // whoever is reading that conversation; the Console shows it to whoever is
         // wondering why nothing happened. Those are often the same person and never
@@ -1461,44 +515,63 @@ export class LoomDaemon {
      */
     streamLogs() {
         return logbook.subscribe((record) => {
-            const frame = JSON.stringify({ type: "log", record });
-            for (const [ws] of this.sockets) {
-                if (ws.readyState === WebSocket.OPEN)
-                    ws.send(frame);
-            }
+            this.delivery.publish({ type: "log", record }, { kind: "log", projectId: record.project });
         });
     }
     /** Fan a terminal frame out to every socket watching this project. */
     broadcastTerm(projectId, frame) {
-        const payload = JSON.stringify(frame);
-        for (const [ws, sub] of this.sockets) {
-            if (ws.readyState !== WebSocket.OPEN)
-                continue;
-            if (sub.project && sub.project !== projectId)
-                continue;
-            ws.send(payload);
-        }
+        this.delivery.publish(frame, { kind: "project", projectId });
     }
-    pushTokens() {
+    pushTokens(category) {
         const cfg = readDaemonConfig();
         return (cfg?.clients ?? [])
+            .filter((c) => !category || wantsPush(c.pushKinds, category))
             .map((c) => c.pushToken)
             .filter((t) => Boolean(t));
     }
     /** Fire-and-notify to phones. Route hops stay quiet; the outcome pushes. */
     maybePush(projectId, event) {
-        if (!PUSH_KINDS.has(event.kind))
+        const category = pushCategory(event);
+        if (!category)
             return;
-        if (event.kind === "run_complete" && this.runtimes.get(projectId)?.routes.isActive()) {
-            return; // a pipeline in flight buzzes once at the end, not per hop
+        const rt = this.runtimes.get(projectId);
+        let reply;
+        if (event.kind === "run_complete") {
+            if (rt?.routes.isActive())
+                return; // a pipeline in flight buzzes once at the end, not per hop
+            if (event.payload.error)
+                return; // the error event says it
+            if (rt) {
+                // a goal's or crew's own task turns stay quiet: the goal pushes when it's done
+                try {
+                    const chat = event.chat ?? "main";
+                    const g = rt.chats().find((c) => c.id === chat)?.group;
+                    if (g && g.kind !== "import")
+                        return;
+                }
+                catch { /* push anyway */ }
+                try {
+                    reply = rt.log.list({ kinds: ["message"], chat: event.chat ?? "main", before: event.id, limit: 1 })
+                        .find((m) => !m.agentId || m.agentId === event.agentId)?.payload.text;
+                }
+                catch { /* a push without the snippet */ }
+            }
         }
-        const tokens = this.pushTokens();
+        const tokens = this.pushTokens(category);
         if (!tokens.length)
             return;
         const name = listProjects().find((p) => p.id === projectId)?.name ?? "project";
         void sendExpoPush(tokens, {
-            ...pushContent(name, event),
-            data: { projectId, kind: event.kind },
+            ...pushContent(name, event, { reply }),
+            // the phone opens this project (and goal, or chat) when the alert is tapped
+            data: {
+                projectId,
+                kind: event.kind,
+                category,
+                ...(typeof event.payload.runId === "string" ? { runId: event.payload.runId } : {}),
+                ...(typeof event.payload.crewId === "string" ? { crewId: event.payload.crewId } : {}),
+                ...(event.chat ? { chat: event.chat } : {}),
+            },
         });
     }
     // -------------------------------------------------------------------------
@@ -1514,6 +587,7 @@ export class LoomDaemon {
             // resolve this as a phantom success — a daemon that prints "listening" and
             // exits 0 while another process actually holds the port.
             const server = this.app.listen(this.port, this.host);
+            configureHttpServer(server);
             this.server = server;
             let settled = false;
             server.once("error", (err) => {
@@ -1533,11 +607,58 @@ export class LoomDaemon {
         if (addr && typeof addr === "object")
             this.port = addr.port; // ephemeral port support
         this.wss = this.attachWs(this.server);
+        // Agents ask from inside the daemon (core/approvals.ts).
+        setApprovalBroker((req) => this.askHuman(req));
         // Fan every log record out to connected clients (the Console tab).
         this.unstreamLogs = this.streamLogs();
         this.writeConfig();
+        if (readCloudSettings().enabled)
+            void this.startCloud().catch(() => { });
+        void this.team.start().catch(() => { });
+        this.watchReleases();
         return { host: this.host, port: this.port };
     }
+    /**
+     * A new Loom release tells each phone once ("updates" push). The first look
+     * waits a minute so a restart doesn't hit GitHub at once, then every few
+     * hours; the version already announced is remembered across restarts.
+     */
+    watchReleases() {
+        if (process.env.LOOM_NO_UPDATE_CHECK || process.env.VITEST)
+            return;
+        const look = async () => {
+            const release = await this.cachedRelease(false);
+            if (!release || !newerThan(release.version, VERSION))
+                return;
+            const told = path.join(loomHome(), "update-announced");
+            let last = "";
+            try {
+                last = fs.readFileSync(told, "utf8").trim();
+            }
+            catch { /* never told */ }
+            if (last === release.version)
+                return;
+            const tokens = this.pushTokens("updates");
+            try {
+                fs.writeFileSync(told, release.version);
+            }
+            catch { /* tell again next time */ }
+            if (!tokens.length)
+                return;
+            void sendExpoPush(tokens, {
+                title: `Loom ${release.version} is out`,
+                body: `This computer runs ${VERSION}. Update it from Loom's Settings, or run: loom update`,
+                data: { kind: "update", category: "updates", version: release.version, url: release.url },
+            });
+        };
+        const first = setTimeout(() => void look().catch(() => { }), 60_000);
+        const every = setInterval(() => void look().catch(() => { }), CHECK_TTL_MS);
+        first.unref?.();
+        every.unref?.();
+        this.healTimers.add(first);
+        this.releaseTimer = every;
+    }
+    releaseTimer = null;
     /**
      * Attach a WebSocket server (path /ws) to an HTTP server and wire the
      * connection handler. Returned so extra phone-access listeners can track and
@@ -1545,6 +666,25 @@ export class LoomDaemon {
      */
     attachWs(server) {
         const wss = new WebSocketServer({ server, path: "/ws" });
+        const heartbeat = setInterval(() => {
+            for (const ws of wss.clients) {
+                const live = ws;
+                if (live.loomAlive === false) {
+                    try {
+                        ws.terminate();
+                    }
+                    catch { /* gone */ }
+                    continue;
+                }
+                live.loomAlive = false;
+                try {
+                    ws.ping();
+                }
+                catch { /* closing */ }
+            }
+        }, 30_000);
+        heartbeat.unref();
+        wss.on("close", () => clearInterval(heartbeat));
         wss.on("connection", (ws, req) => {
             const url = new URL(req.url ?? "/ws", `http://${this.host}:${this.port}`);
             // Prefer the token in the `Sec-WebSocket-Protocol` header (a header isn't
@@ -1567,7 +707,11 @@ export class LoomDaemon {
                 // Ensure the runtime is live so its events flow.
                 void this.runtime(project).catch(() => { });
             }
-            this.sockets.set(ws, { ...(resolvedProject ? { project: resolvedProject } : {}) });
+            const wsScope = this.auth.allowedProjects(token);
+            this.sockets.set(ws, {
+                ...(resolvedProject ? { project: resolvedProject } : {}),
+                ...(wsScope ? { scope: wsScope } : {}),
+            });
             ws.send(JSON.stringify({
                 type: "hello",
                 projects: listProjects().map((p) => p.id),
@@ -1595,6 +739,10 @@ export class LoomDaemon {
                     sess.resize(Number(msg.cols) || 80, Number(msg.rows) || 24);
                 }
             });
+            // heartbeat: a socket that misses a pong is half-open (a sleeping laptop,
+            // a phone off its network) and is dropped instead of buffering for minutes
+            ws.loomAlive = true;
+            ws.on("pong", () => { ws.loomAlive = true; });
             ws.on("close", () => this.sockets.delete(ws));
         });
         return wss;
@@ -1619,6 +767,7 @@ export class LoomDaemon {
         if (!ip || ip === this.host || this.extra.has(ip))
             return;
         const server = http.createServer(this.app);
+        configureHttpServer(server);
         await new Promise((resolve, reject) => {
             server.listen(this.port, ip, () => resolve());
             server.on("error", reject);
@@ -1631,10 +780,162 @@ export class LoomDaemon {
     exposedIps() {
         return [...this.extra.keys()];
     }
+    /**
+     * The self-heal recheck loop: after a firing alert fails the baton over, wait
+     * LOOM_HEAL_RECHECK_MS, ask the telemetry store (or the local log) whether the
+     * agent has errored since it was quarantined, and if not, hand the baton back
+     * — retrying up to LOOM_HEAL_MAX_RETRIES times before giving up. Best-effort
+     * and unref'd: a daemon restart simply forgets the loop.
+     */
+    startHealLoop(rt, agent, alert, since) {
+        if (process.env.LOOM_HEAL_DISABLED === "1")
+            return;
+        const recheckMs = Math.max(1, Number(process.env.LOOM_HEAL_RECHECK_MS) || 60_000);
+        const maxRetries = Math.max(1, Number(process.env.LOOM_HEAL_MAX_RETRIES) || 3);
+        let attempt = 0;
+        const tick = async () => {
+            attempt += 1;
+            if (!rt.quarantined()[agent])
+                return; // lifted already (a resolved alert, say)
+            const recovered = await this.agentRecovered(rt, agent, since).catch(() => false);
+            if (recovered) {
+                rt.unquarantine(agent);
+                const retried = rt.baton.holder() !== agent;
+                // A hand-back that's refused (the stand-in is mid-turn, say) is part
+                // of what happened; recording "recovered" without it reads as done.
+                let handBack;
+                if (retried)
+                    await rt.handoff(agent).catch((err) => { handBack = err instanceof Error ? err.message : String(err); });
+                rt.log.append({ kind: "status", agentId: agent, payload: { state: "alert_recovery", alert, retried, attempt, via: "recheck", ...(handBack ? { handBackFailed: handBack } : {}) } });
+                return;
+            }
+            if (attempt >= maxRetries) {
+                rt.log.append({ kind: "status", agentId: agent, payload: { state: "alert_heal_exhausted", alert, attempts: attempt } });
+                return; // stays quarantined for a human
+            }
+            schedule();
+        };
+        const schedule = () => {
+            const t = setTimeout(() => { this.healTimers.delete(t); void tick(); }, recheckMs);
+            if (typeof t.unref === "function")
+                t.unref();
+            this.healTimers.add(t);
+        };
+        schedule();
+    }
+    /** Recovered = no error spans since it was quarantined (backend first, local log fallback). */
+    async agentRecovered(rt, agent, sinceMs) {
+        try {
+            return (await recentAgentErrors(rt.info.name, agent, sinceMs)) === 0;
+        }
+        catch {
+            const errs = rt.log.list({ limit: 400 }).filter((e) => e.ts > sinceMs && e.agentId === agent &&
+                (e.kind === "error" || (e.kind === "run_complete" && e.payload.error)));
+            return errs.length === 0;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Loom Cloud
+    // -------------------------------------------------------------------------
+    /** `&relay=<channel.key>&sb=<url>&sbk=<anon key>` when the relay is on, else "". */
+    cloudLinkParams() {
+        const s = readCloudSettings();
+        const target = supabaseTarget(s);
+        if (!s.enabled || !s.channel || !s.key || !target)
+            return "";
+        const b64 = (v) => toB64(new TextEncoder().encode(v));
+        return `&relay=${packCredentials({ channel: s.channel, key: s.key })}&sb=${b64(target.url)}&sbk=${b64(target.anonKey)}`;
+    }
+    cloudStatus() {
+        const s = readCloudSettings();
+        const target = supabaseTarget(s);
+        return {
+            configured: Boolean(target || this.relayTransportFactory),
+            enabled: s.enabled,
+            connected: Boolean(this.relay),
+            clients: this.relay?.clientCount() ?? 0,
+            stats: this.relay?.stats ?? null,
+            supabaseUrl: target?.url ?? null,
+            hostedUrl: hostedTarget().supabaseUrl,
+            error: this.relayError,
+        };
+    }
+    async startCloud() {
+        const s = readCloudSettings();
+        const creds = ensureCredentials(s);
+        s.enabled = true;
+        writeCloudSettings(s);
+        await this.relay?.close().catch(() => { });
+        this.relay = null;
+        this.relayError = null;
+        try {
+            let transport;
+            if (this.relayTransportFactory)
+                transport = await this.relayTransportFactory(creds.channel);
+            else {
+                const target = supabaseTarget(s);
+                if (!target)
+                    throw new Error("no Supabase project — set LOOM_SUPABASE_URL and LOOM_SUPABASE_ANON_KEY");
+                transport = await supabaseTransport(target.url, target.anonKey, creds.channel);
+            }
+            await Promise.race([
+                transport.ready(),
+                new Promise((_, rej) => setTimeout(() => rej(new Error("timed out joining the relay channel")), 15_000)),
+            ]);
+            this.relay = new RelayBridge({
+                transport,
+                key: creds.key,
+                localBase: () => `http://127.0.0.1:${this.port}`,
+                identity: () => ({ version: BUILD_REV, name: os.hostname() }),
+            });
+            logbook.info("cloud", "Loom Cloud relay connected");
+        }
+        catch (err) {
+            this.relayError = err.message;
+            logbook.warn("cloud", "Loom Cloud relay failed to start", this.relayError);
+            throw err;
+        }
+    }
+    async stopCloud(opts = {}) {
+        await this.relay?.close().catch(() => { });
+        this.relay = null;
+        const s = readCloudSettings();
+        s.enabled = false;
+        if (opts.rotate) {
+            delete s.channel;
+            delete s.key;
+        }
+        writeCloudSettings(s);
+    }
+    /** The last release check, kept so a poll can't hammer GitHub's API. */
+    releaseSeen = null;
+    updating = false;
+    async cachedRelease(refresh) {
+        if (!refresh && this.releaseSeen && Date.now() - this.releaseSeen.at < CHECK_TTL_MS)
+            return this.releaseSeen.release;
+        const release = await latestRelease();
+        this.releaseSeen = { at: Date.now(), release };
+        return release;
+    }
     async close() {
+        // A broker pointing at a closed daemon would leave the next adapter
+        // waiting on a card nobody will ever see.
+        setApprovalBroker(null);
+        for (const a of [...this.approvals.values()]) {
+            a.settle({ behavior: "deny", message: "the daemon is shutting down" });
+        }
+        await this.team.stop().catch(() => { });
+        await this.relay?.close().catch(() => { });
+        this.relay = null;
+        for (const t of this.healTimers)
+            clearTimeout(t);
+        if (this.releaseTimer)
+            clearInterval(this.releaseTimer);
+        this.healTimers.clear();
         this.unstreamLogs?.();
         this.unstreamLogs = null;
-        this.terminals.closeAll();
+        this.specRunner.closeAll();
+        await this.terminals.closeAll();
         for (const rt of this.runtimes.values())
             await rt.close();
         this.runtimes.clear();
@@ -1643,11 +944,18 @@ export class LoomDaemon {
             await new Promise((resolve) => server.close(() => resolve()));
         }
         this.extra.clear();
+        // Close the live sockets too. wss.close() stops new connections but leaves
+        // open ones open, and server.close() waits for every keep-alive socket a
+        // browser holds — so a restart used to leave the old daemon alive forever,
+        // its port freed but the process (and everything it held) still running.
+        for (const ws of this.wss?.clients ?? [])
+            ws.terminate();
         this.wss?.close();
         await new Promise((resolve) => {
             if (!this.server)
                 return resolve();
             this.server.close(() => resolve());
+            this.server.closeAllConnections?.();
         });
         const cfg = readDaemonConfig();
         if (cfg && cfg.pid === process.pid) {
@@ -1656,73 +964,4 @@ export class LoomDaemon {
         }
     }
 }
-/** Resolve this machine's Tailscale IPv4 — the tailnet is the trust boundary. */
-export function tailscaleIp() {
-    return new Promise((resolve, reject) => {
-        execFile("tailscale", ["ip", "-4"], (err, stdout) => {
-            if (err) {
-                reject(new Error("could not resolve a Tailscale IP (is tailscale installed and up?) — refusing to bind beyond localhost"));
-                return;
-            }
-            const ip = stdout.trim().split("\n")[0];
-            if (!ip)
-                return void reject(new Error("tailscale returned no IPv4"));
-            resolve(ip);
-        });
-    });
-}
-/**
- * This machine's LAN IPv4 — the address a phone on the same Wi-Fi uses. We skip
- * loopback, link-local (169.254), and Tailscale's own 100.64/10 CGNAT range so
- * "local network" and "tailnet" stay distinct choices. Returns null when the
- * only addresses are loopback (e.g. no network) — the caller says so honestly
- * rather than minting an unreachable QR.
- */
-export function lanIp() {
-    const ifaces = os.networkInterfaces();
-    const candidates = [];
-    for (const addrs of Object.values(ifaces)) {
-        for (const a of addrs ?? []) {
-            if (a.family !== "IPv4" || a.internal)
-                continue;
-            if (a.address.startsWith("169.254."))
-                continue; // link-local, not routable
-            if (a.address.startsWith("100."))
-                continue; // Tailscale CGNAT — that's the tailnet
-            candidates.push(a.address);
-        }
-    }
-    // Prefer the common private ranges (a real LAN) over anything exotic.
-    const priv = candidates.find((ip) => ip.startsWith("192.168.") || ip.startsWith("10.") || /^172\.(1[6-9]|2\d|3[01])\./.test(ip));
-    return priv ?? candidates[0] ?? null;
-}
-/** Is this connection from the same machine? (127.0.0.1, ::1, or v4-mapped v6.) */
-export function isLoopback(remoteAddress) {
-    if (!remoteAddress)
-        return false;
-    return (remoteAddress === "127.0.0.1" ||
-        remoteAddress === "::1" ||
-        remoteAddress === "::ffff:127.0.0.1");
-}
-/**
- * Is the request's `Host` header a loopback literal? The anti-DNS-rebinding
- * check: a rebinding attacker loads a page from their own domain, so the browser
- * sends `Host: attacker.example` even after the name rebinds to 127.0.0.1 — while
- * the genuine local console is always reached at `127.0.0.1`/`localhost`. Pairing
- * the socket check with this closes the "any website → localhost token oracle"
- * path. The port is ignored; only the host is checked.
- */
-export function isLoopbackHost(hostHeader) {
-    if (!hostHeader)
-        return false;
-    let host = hostHeader.trim().toLowerCase();
-    if (host.startsWith("[")) {
-        const end = host.indexOf("]");
-        host = end > 0 ? host.slice(1, end) : host.slice(1);
-    }
-    else if ((host.match(/:/g) || []).length === 1) {
-        host = host.slice(0, host.indexOf(":")); // strip the port off host:port
-    }
-    return host === "127.0.0.1" || host === "localhost" || host === "::1";
-}
 //# sourceMappingURL=server.js.map