@songsid/agend 2.3.0-beta.9 → 2.3.1

package/dist/web-api.js

@@ -1,3 +1,5 @@
+import { canvasWorkerEnabled, CANVAS_WORKER_EXPERIMENTAL_MESSAGE } from "./web-experimental.js";
+import { isCanvasWorkerHttpPath } from "./web-experimental-http.js";
 import { webHumanOrigin } from "./human-delivery-receipts.js";
 import { classifyWebPeer, confirmAfterBody, noAuthority } from "./authority/web-authority.js";
 import { guestChatRefusal, guestCommandText, guestDeliveries, guestFrameData, guestHistory, guestMessages, guestPollBody, guestPrefs, guestRequestOf, guestSeesMessage, guestStatus } from "./web-guest-access.js";
@@ -5,6 +7,8 @@ import { withSpawnHoldReply } from "./spawn-hold-reply.js";
 import { binaryProbe } from "./binary-probe.js";
 import { settingsRequestExecution, settingsWrite, isSettingsReplay } from "./settings-request-capability.js";
 import { readBoundedWebBody } from "./web-body.js";
+import { APP_ICON_MAX_BYTES } from "./web-app-icon.js";
+import { withAppIconLinks } from "./web-icons.js";
 import { MOD_MAX_BYTES } from "./web-mod-bundle.js";
 import { buildModBundle } from "./web-mod-export.js";
 import { AGENT_WIDGET_SLOTS, checkWidgetData, checkWidgetSpec } from "./web-widget.js";
@@ -12,6 +16,7 @@ import { checkOwnerCss, ownerCssAssetRefs } from "./web-owner-css.js";
 import { canonicalText } from "./web-theme.js";
 import { EFFECT_WIRE_LIMIT } from "./web-effect-upload.js";
 import { gatewayRequestContext } from "./web-request-context.js";
+import { crossInstanceVisibility } from "./cross-instance-notice.js";
 import { permitWebContinuation } from "./web-continuation.js";
 /**
  * Web UI HTTP API handler.
@@ -21,7 +26,8 @@ import { formatWebChannelEcho } from "./web-channel-echo.js";
 import { t } from "./locale.js";
 import { isSafeInstanceName } from "./web-shell-routes.js";
 import { MAX_COMMAND_ARGS } from "./web-commands.js";
-import { sendPanelHtml } from "./web-host-guard.js";
+import { ROUTE_WORKER_CSP, ROUTE_WORKER_PATH, sendPanelHtml } from "./web-host-guard.js";
+import { libavoidFile } from "./web-libavoid.js";
 import { shellRoute } from "./web-shell-routes.js";
 import { createReadStream, createWriteStream, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -29,11 +35,12 @@ import { fileURLToPath } from "node:url";
 import { CreateInstanceArgs, CreateScheduleArgs, UpdateScheduleArgs, validateArgs } from "./outbound-schemas.js";
 import { scheduleView } from "./web-schedules.js";
 import { DEFAULT_SCHEDULER_CONFIG } from "./scheduler/index.js";
+import { CARD_PRIORITIES, CARD_SIZES, CARD_STATUSES, TaskBoardError } from "./scheduler/task-board.js";
 import { readStatuslineModel, resolveInstanceContext } from "./topic-commands.js";
 import { z } from "zod";
 import { evaluateWebRequest, isPassiveWebRead, isSecureRequest, isWebRequestAuthorized, WEB_TOKEN_INVALID_MESSAGE } from "./web-auth.js";
 import { dashboardOriginFor } from "./web-preview.js";
-import { newWebMessageId, parseLastEventId } from "./web-chat-history.js";
+import { WEB_CHAT_CARDS_OVERFLOW, newWebMessageId, parseLastEventId, webChatReplyRef, webChatReplyText } from "./web-chat-history.js";
 import { attachmentDelivery, createPartFile, displayName, fileTooLargeText, INLINE_MIME, isFileId, MEDIA_RANGE_MAX, publicAttachment, UPLOAD_LIMITS, UPLOAD_MAX_MS, UPLOAD_STALL_MS, UploadSniffer, uploadLimits, wellFormed } from "./web-upload.js";
 import { getAgendHome } from "./paths.js";
 import { OPERATOR, isOwnerEffectKey } from "./web-prefs.js";
@@ -44,6 +51,9 @@ import { authorizeExplicitInstanceRemoval } from "./instance-removal.js";
 import { measureSyncWork } from "./sync-work-attribution.js";
 import { resolveTz } from "./tz-utils.js";
 import { filesPlayInChat } from "./web-effect.js";
+import { QUERY_MAX_CHARS, RESULT_MAX, SEARCH_SOURCES } from "./search/search-store.js";
+import { xmsgShown } from "./search/search-docs.js";
+import { WebSendDedupe } from "./web-send-dedupe.js";
 // ── Strict public-facing schemas ────────────────────────────────────────────
 // web-api endpoints must reject unknown fields so the dashboard cannot inject
 // internal-only flags that would reach handleCreate/scheduler/config writers.
@@ -58,11 +68,79 @@ const TaskUpdateSchema = z.object({
     action: z.enum(["claim", "complete", "update"]).optional(),
     assignee: z.string().max(128).optional(),
     result: z.string().max(MAX_TEXT).optional(),
-    status: z.string().max(64).optional(),
+    // A status the task board knows: each carries its rules now (scheduler/task-board.ts).
+    status: z.enum(CARD_STATUSES).optional(),
     title: z.string().max(512).optional(),
     description: z.string().max(MAX_TEXT).optional(),
     priority: z.string().max(64).optional(),
 }).strict();
+// The task board (scheduler/task-board.ts). Coarse bounds here; the board checks each field's own limit.
+const BOARD_TEXT = 8_192;
+const CardRef = z.string().min(1).max(64);
+/** Who handed a card out: an instance, the person writing ({ kind: "person" }), or nobody. */
+const DispatcherSchema = z.union([z.object({ kind: z.literal("instance"), name: z.string().min(1).max(128) }).strict(), z.object({ kind: z.literal("person") }).strict()]).nullable();
+const CardCreateSchema = z.object({
+    kind: z.enum(["main", "sub"]).optional(),
+    project: z.union([z.number().int(), z.string().max(256)]).nullable().optional(),
+    parent: CardRef.nullable().optional(),
+    title: z.string().max(512),
+    goal: z.string().max(BOARD_TEXT).optional(),
+    scope: z.string().max(BOARD_TEXT).optional(),
+    acceptance: z.array(z.string().max(1024)).max(50).optional(),
+    context: z.string().max(BOARD_TEXT).optional(),
+    size: z.enum(CARD_SIZES).nullable().optional(),
+    priority: z.enum(CARD_PRIORITIES).optional(),
+    dependsOn: z.array(CardRef).max(50).optional(),
+    assignee: z.string().max(128).nullable().optional(),
+    dispatcher: DispatcherSchema.optional(),
+    needsReview: z.boolean().optional(),
+}).strict();
+const CardPatchSchema = z.object({
+    version: z.number().int().optional(),
+    title: z.string().max(512).optional(),
+    goal: z.string().max(BOARD_TEXT).optional(),
+    scope: z.string().max(BOARD_TEXT).optional(),
+    context: z.string().max(BOARD_TEXT).optional(),
+    state: z.string().max(BOARD_TEXT).optional(),
+    result: z.string().max(BOARD_TEXT).optional(),
+    blockedReason: z.string().max(BOARD_TEXT).optional(),
+    size: z.enum(CARD_SIZES).nullable().optional(),
+    priority: z.enum(CARD_PRIORITIES).optional(),
+    assignee: z.string().max(128).nullable().optional(),
+    dispatcher: DispatcherSchema.optional(),
+    needsReview: z.boolean().optional(),
+    dependsOn: z.array(CardRef).max(50).optional(),
+    acceptance: z.array(z.string().max(1024)).max(50).optional(),
+    addAcceptance: z.array(z.string().max(1024)).max(50).optional(),
+    check: z.array(z.number().int()).max(50).optional(),
+    uncheck: z.array(z.number().int()).max(50).optional(),
+    projectId: z.number().int().nullable().optional(),
+    log: z.string().max(BOARD_TEXT).optional(),
+    comment: z.string().max(MAX_TEXT).optional(),
+}).strict();
+const CardMoveSchema = z.object({
+    to: z.enum(CARD_STATUSES),
+    reason: z.string().max(BOARD_TEXT).optional(),
+    result: z.string().max(BOARD_TEXT).optional(),
+    comment: z.string().max(MAX_TEXT).optional(),
+    version: z.number().int().optional(),
+}).strict();
+const CardReorderSchema = z.object({ after: CardRef.nullable().optional(), before: CardRef.nullable().optional() }).strict();
+const ProjectCreateSchema = z.object({ name: z.string().max(256), description: z.string().max(BOARD_TEXT).optional(), leadInstance: z.string().max(256).nullable().optional() }).strict();
+/** #2352: a project's lead must be one of the fleet's instances now (the board keeps any name, as for an assignee). */
+function checkLeadIsInstance(ctx, lead) {
+    const name = lead?.trim();
+    if (name && !(ctx.fleetConfig?.instances && Object.hasOwn(ctx.fleetConfig.instances, name))) {
+        throw new TaskBoardError("invalid", `"${name.slice(0, 64)}" is not one of the fleet's instances`, "lead_not_instance");
+    }
+}
+const ProjectPatchSchema = z.object({
+    name: z.string().max(256).optional(),
+    description: z.string().max(BOARD_TEXT).optional(),
+    archived: z.boolean().optional(),
+    /** #2352: the instance whose channel lists the project's waiting cards (null or "": General). */
+    leadInstance: z.string().max(256).nullable().optional(),
+}).strict();
 const TeamCreateSchema = z.object({
     name: z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/),
     members: z.array(z.string().min(1).max(256)).min(1).max(256),
@@ -90,6 +168,11 @@ const SendMessageSchema = z.object({
     message: z.string().max(MAX_TEXT),
     /** Ids from POST /ui/upload, for this instance, not yet sent. */
     attachments: z.array(z.string().regex(/^[0-9a-f]{32}$/)).max(UPLOAD_LIMITS.maxFiles).optional(),
+    /** #2272: the message of this chat this one replies to — its row only; the server reads what it quotes. */
+    replyTo: z.object({ boot: z.string().regex(/^[0-9a-f]{1,32}$/), id: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER) }).strict().optional(),
+    /** The sending page's own id for its pending bubble: echoed on the live event only (never recorded), so that page
+     *  swaps its "sending" bubble for the real one even when the stream beats this answer. */
+    clientId: z.string().regex(/^[A-Za-z0-9_-]{8,64}$/).optional(),
 }).strict().refine(v => v.message.trim().length > 0 || (v.attachments?.length ?? 0) > 0, { message: "a message or at least one file", path: ["message"] });
 /** An instance name that is safe as one path segment (no separator, no NUL, not a dot name). */
 const safeInstanceSegment = (name) => /^[^\\/\x00]+$/.test(name) && name !== "." && name !== "..";
@@ -101,6 +184,68 @@ const safeInstanceSegment = (name) => /^[^\\/\x00]+$/.test(name) && name !== "."
  */
 /** #1920 phase 1b: the open streams that are a guest's, and whose — each event is projected for them (guestFrameData). */
 const streamGuests = new WeakMap();
+/**
+ * The task board's rule over the public link: an instance kept out of sight (cross_instance_visibility: hidden) is not
+ * shown, nor a card that names one as its assignee, creator or dispatcher. Off the link nothing is hidden. Read when
+ * asked: the fleet's config as it is now.
+ */
+function boardHiding(ctx, gateway) {
+    const fleet = ctx.fleetConfig;
+    const hiddenName = (n) => gateway && typeof n === "string" && !!n && !!ctx.fleetConfig?.instances?.[n] && crossInstanceVisibility(fleet, n) === "hidden";
+    const hidden = (c) => [c.assignee, c.createdBy, c.dispatcher?.name].some(hiddenName);
+    return { hiddenName, hidden };
+}
+/**
+ * Chat history as the public link may see it (#2341 review): a status line that names board cards (the daily summary)
+ * is withheld while one of them is hidden there now — or no longer on the board — read when asked, so a card hidden
+ * after the line was written is withheld too. Off the link, as is. The cards are read in one query per answer.
+ */
+function visibleMessages(ctx, gateway, messages) {
+    if (!gateway)
+        return messages;
+    // #2341 review r2: a line that named too many cards to keep them all is withheld whole.
+    messages = messages.filter((m) => !(m.cards ?? []).includes(WEB_CHAT_CARDS_OVERFLOW));
+    const named = [...new Set(messages.flatMap((m) => m.cards ?? []))];
+    if (!named.length)
+        return messages;
+    const board = ctx.scheduler?.db.board;
+    const { hidden } = boardHiding(ctx, true);
+    let found;
+    try {
+        found = new Map((board ? board.cardsByCode(named) : []).map((c) => [c.code, c]));
+    }
+    catch {
+        found = new Map();
+    }
+    const withheld = new Set(named.filter((code) => { const c = found.get(code); return !c || hidden(c); }));
+    return messages.filter((m) => !(m.cards ?? []).some((code) => withheld.has(code)));
+}
+/**
+ * Needs you as the public link may see it (#2306 review): a task item whose card the board hides there — or a card
+ * the board no longer has — is left out, with its title and question; everything else as listed. Off the link, as is.
+ * The link reads Needs you by /ui/poll only: its page has no stream (/ui/events answers it 404).
+ */
+function visibleNeeds(ctx, gateway, items) {
+    if (!gateway)
+        return items;
+    const board = ctx.scheduler?.db.board;
+    const { hidden } = boardHiding(ctx, true);
+    return items.filter((i) => {
+        const item = i;
+        if (item.type !== "task")
+            return true;
+        const code = item.card?.code;
+        if (!board || typeof code !== "string")
+            return false;
+        try {
+            const card = board.findCard(code);
+            return !!card && !hidden(card);
+        }
+        catch {
+            return false;
+        }
+    });
+}
 /**
  * #1920 §5.2: one event for the guests' streams only, each as projected for it — a message that has just become what
  * its channel saw (an admin's page already has it, unchanged).
@@ -173,10 +318,21 @@ async function parseBody(req) {
 }
 /** Send JSON response. */
 function json(res, status, data) {
+    jsonText(res, status, JSON.stringify(data));
+}
+/** A JSON answer already serialized (a body kept for reuse). */
+function jsonText(res, status, body) {
     res.setHeader("Content-Type", "application/json");
     res.writeHead(status);
-    res.end(JSON.stringify(data));
+    res.end(body);
 }
+/**
+ * #2296: the last dashboard board read, serialized, per board: its key (revision, done=all, minute) and body. One per
+ * board (the newest revision replaces the previous), so it holds one board's JSON at most.
+ */
+const boardBodies = new WeakMap();
+/** #2316 review: the same for who works on what (GET /ui/tasks/work), per (revision, names asked for). */
+const workBodies = new WeakMap();
 /**
  * #1630 (#1635 review): an answer that waited on something (a list, a download) is sent only if the request is still
  * allowed — the session not revoked meanwhile, a public link's exposure still current. Otherwise 401, and nothing.
@@ -189,6 +345,108 @@ function stillAuthorized(req, res, url, ctx) {
     json(res, 401, { error: WEB_TOKEN_INVALID_MESSAGE });
     return false;
 }
+/**
+ * #2308: the app icon. GET: its state, for the settings card (a signed-in person's session). PUT (one PNG, at most
+ * 5 MiB) and DELETE (back to the bundled icon): a signed-in admin's session only — never the CLI's token, a read-only
+ * session, a guest or the public link; checked again once the body has arrived.
+ */
+/** An app icon refusal as the page reads it: its code, the English detail and, when named, the detail's key (#2390). */
+function appIconRefusal(r) {
+    return { error: r.error, ...(r.detail ? { detail: r.detail } : {}), ...(r.detail_key ? { detail_key: r.detail_key } : {}), ...(r.detail_args ? { detail_args: r.detail_args } : {}) };
+}
+function handleAppIcon(req, res, url, ctx, method) {
+    const store = ctx.appIcon;
+    if (!store) {
+        json(res, 404, { error: "app_icon_not_kept", detail: "The app icon is not kept on this fleet" });
+        return true;
+    }
+    const reading = method === "GET" || method === "HEAD";
+    if (!reading && method !== "PUT" && method !== "DELETE") {
+        res.setHeader("Allow", "GET, PUT, DELETE");
+        json(res, 405, { error: "method not allowed" });
+        return true;
+    }
+    if (gatewayRequestContext(req)) {
+        json(res, reading ? 404 : 403, { error: "app_icon_not_over_public_link" });
+        return true;
+    }
+    const who = () => {
+        const verdict = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
+        if (verdict.kind !== "allow")
+            return { status: 401, error: WEB_TOKEN_INVALID_MESSAGE };
+        if (verdict.via !== "session" || !verdict.session || verdict.session.tier === "guest")
+            return { status: 403, error: "app_icon_needs_a_signed_in_person" };
+        if (!reading && verdict.session.tier !== "admin")
+            return { status: 403, error: "app_icon_admin_only" };
+        return { person: webPersonKey(verdict.session.owner) };
+    };
+    const first = who();
+    if ("status" in first) {
+        json(res, first.status, { error: first.error });
+        return true;
+    }
+    const state = () => { const s = store.current(); return s ? { custom: true, version: s.version, updatedAt: s.updatedAt } : { custom: false, version: "default", updatedAt: null }; };
+    if (reading) {
+        json(res, 200, state());
+        return true;
+    }
+    if (method === "DELETE") {
+        const reset = store.reset();
+        if (!reset.ok) {
+            json(res, reset.status, appIconRefusal(reset));
+            return true;
+        }
+        json(res, 200, state());
+        return true;
+    }
+    // Still allowed, still answering, the store still open: asked after each await (the body; the conversion).
+    const again = () => {
+        if (!permitWebContinuation(req, res, ctx))
+            return null;
+        if (res.destroyed)
+            return null;
+        const now = who();
+        if ("status" in now) {
+            json(res, now.status, { error: now.error });
+            return null;
+        }
+        return now.person;
+    };
+    (async () => {
+        let bytes;
+        try {
+            bytes = await readBoundedWebBody(req, APP_ICON_MAX_BYTES);
+        }
+        catch {
+            json(res, 413, { error: "app_icon_too_large", detail: "at most 5 MiB", detail_key: "max_size", detail_args: [5] });
+            return;
+        }
+        if (!again())
+            return;
+        // #2308 review: decoding and making the sizes is seconds of CPU at worst — a worker thread's, not the fleet loop's.
+        const prepared = await store.prepare(bytes);
+        if (!prepared.ok) {
+            json(res, prepared.status, appIconRefusal(prepared));
+            return;
+        }
+        const person = again();
+        if (!person)
+            return;
+        const saved = store.commit(prepared.prepared, person);
+        if (!saved.ok) {
+            json(res, saved.status, appIconRefusal(saved));
+            return;
+        }
+        json(res, 200, state());
+    })().catch((err) => {
+        ctx.logger.error({ err: err.message }, "App icon request failed");
+        try {
+            json(res, 500, { error: "app_icon_failed", detail: "App icon request failed" });
+        }
+        catch { /* already answered */ }
+    });
+    return true;
+}
 /**
  * #1629 r4 §3: the owner-CSS routes (see their call site). `who()`, asked first and again after any body: the person a
  * signed-in human session is, or the status to answer.
@@ -280,7 +538,7 @@ function handleOwnerCss(req, res, url, ctx, path, method) {
         json(res, removed.ok ? 200 : removed.status, removed.ok ? { ok: true } : { error: removed.error });
         return true;
     }
-    if (method !== "POST" || !["/ui/owner-css", "/ui/owner-css/keep", "/ui/owner-css/revert", "/ui/owner-css/restore", "/ui/owner-css/asset"].includes(path)) {
+    if (method !== "POST" || !["/ui/owner-css", "/ui/owner-css/shown", "/ui/owner-css/keep", "/ui/owner-css/revert", "/ui/owner-css/restore", "/ui/owner-css/asset"].includes(path)) {
         json(res, 404, { error: "not found" });
         return true;
     }
@@ -329,6 +587,17 @@ function handleOwnerCss(req, res, url, ctx, path, method) {
             announce();
             json(res, 200, { sha: saved.sha, previous: saved.previous, trial: saved.trial });
         }
+        else if (path === "/ui/owner-css/shown") {
+            // #2198: this page shows the trial (its stylesheet loaded): an agent's waiting trial starts its keep window now.
+            const shown = store.shown(person, body.trial);
+            if (!shown.ok) {
+                json(res, shown.status, { error: shown.error });
+                return;
+            }
+            if (shown.started)
+                announce(); // the person's other devices take the new deadline
+            json(res, 200, { remaining_ms: shown.remaining_ms });
+        }
         else if (path === "/ui/owner-css/keep") {
             const kept = store.keep(person, body.trial);
             if (!kept.ok) {
@@ -475,6 +744,10 @@ function handleEffectTrials(req, res, url, ctx, path, method) {
             json(res, now.status, { error: now.error });
             return;
         }
+        if (!canvasWorkerEnabled(ctx.fleetConfig?.web)) {
+            json(res, 403, { error: "canvas_worker_experimental", message: CANVAS_WORKER_EXPERIMENTAL_MESSAGE });
+            return;
+        }
         if (now.record !== first.record || now.sessions !== first.sessions || now.actor.sessionHash !== first.actor.sessionHash
             || now.actor.person !== first.actor.person || now.actor.epoch !== first.actor.epoch) {
             json(res, 409, { error: "trials_person_changed" });
@@ -509,6 +782,104 @@ function handleEffectTrials(req, res, url, ctx, path, method) {
     catch { /* response ended */ } });
     return true;
 }
+/**
+ * #2233: signing a backend in from the dashboard (web-backend-login.ts). A signed-in admin session on the local surface
+ * only — never the CLI's header token (an agent's), a guest, a read session or the public link (refused before the body
+ * is read, and again after it). Every answer is no-store: the starter's view carries the terminal's access code.
+ */
+function handleBackendLogin(req, res, url, ctx, path, method) {
+    res.setHeader("Cache-Control", "private, no-store");
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    const reading = method === "GET";
+    if (gatewayRequestContext(req)) {
+        json(res, reading ? 404 : 403, { error: "sign_in_not_over_public_link" });
+        return true;
+    }
+    const who = () => {
+        const v = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
+        if (v.kind !== "allow")
+            return { error: WEB_TOKEN_INVALID_MESSAGE, status: 401 };
+        if (v.via !== "session" || v.session.tier !== "admin" || v.session.surface !== "local")
+            return { error: "sign_in_needs_a_local_admin", status: 403 };
+        return { handle: v.session.handle, label: v.session.label };
+    };
+    const first = who();
+    if ("error" in first) {
+        json(res, first.status, { error: first.error });
+        return true;
+    }
+    const logins = ctx.webBackendLogins;
+    if (!logins) {
+        json(res, 404, { error: "sign_in_unavailable" });
+        return true;
+    }
+    const action = /^\/ui\/backend-login\/(check|start|cancel)$/.exec(path)?.[1];
+    if (reading && path === "/ui/backend-login" && [...url.searchParams.keys()].length === 0) {
+        json(res, 200, { login: logins.view(first.handle), targets: ctx.backendSignInTargets?.() ?? [] });
+        return true;
+    }
+    if (method !== "POST" || !action) {
+        json(res, 404, { error: "not_found" });
+        return true;
+    }
+    (async () => {
+        let bytes;
+        try {
+            bytes = await readBoundedWebBody(req, 4 * 1024);
+        }
+        catch {
+            json(res, 413, { error: "sign_in_body_bound" });
+            return;
+        }
+        if (!permitWebContinuation(req, res, ctx))
+            return;
+        const now = who();
+        if ("error" in now) {
+            json(res, now.status, { error: now.error });
+            return;
+        }
+        if (now.handle !== first.handle) {
+            json(res, 409, { error: "sign_in_session_changed" });
+            return;
+        }
+        let body;
+        try {
+            body = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        }
+        catch {
+            json(res, 400, { error: "sign_in_json" });
+            return;
+        }
+        if (action === "check") {
+            const parsed = z.strictObject({ backend: z.string().regex(/^[a-z][a-z0-9-]{0,31}$/i), profile: z.string().min(1).max(64).optional() }).safeParse(body);
+            if (!parsed.success) {
+                json(res, 400, { error: "sign_in_args" });
+                return;
+            }
+            json(res, 200, await logins.check(now, parsed.data.backend, parsed.data.profile));
+        }
+        else if (action === "start") {
+            const parsed = z.strictObject({ confirm: z.string().regex(/^[0-9a-f]{32}$/), tunnel: z.boolean().optional() }).safeParse(body);
+            if (!parsed.success) {
+                json(res, 400, { error: "sign_in_args" });
+                return;
+            }
+            const result = await logins.begin(now, parsed.data.confirm, parsed.data.tunnel === true);
+            json(res, "error" in result ? 409 : 200, result);
+        }
+        else {
+            if (!z.strictObject({}).safeParse(body).success) {
+                json(res, 400, { error: "sign_in_args" });
+                return;
+            }
+            json(res, 200, { message: await logins.cancel() });
+        }
+    })().catch(() => { try {
+        json(res, 500, { error: "sign_in_request_failed" });
+    }
+    catch { /* response ended */ } });
+    return true;
+}
 /** #1629 B2: effect routes require a human session; route bodies never supply an actor or reference holder. */
 function handleEffects(req, res, url, ctx, path, method) {
     res.setHeader("Cache-Control", "private, no-store");
@@ -612,6 +983,10 @@ function handleEffects(req, res, url, ctx, path, method) {
             json(res, now.status, { error: now.error });
             return;
         }
+        if (!canvasWorkerEnabled(ctx.fleetConfig?.web)) {
+            json(res, 403, { error: "canvas_worker_experimental", message: CANVAS_WORKER_EXPERIMENTAL_MESSAGE });
+            return;
+        }
         if (now.person !== first.person || now.epoch !== first.epoch) {
             json(res, 409, { error: "effects_person_changed" });
             return;
@@ -733,6 +1108,10 @@ function handleMods(req, res, url, ctx, path, method) {
         // So the export ACL judges what the file carries, not what was installed: it downloads only when this person may
         // read every effect in it (their own claim on that content, or a shared one). A file without effects is any admin's.
         const fx = mods.bundleEffects(fileMatch[1]);
+        if (!canvasWorkerEnabled(ctx.fleetConfig?.web) && (fx === "unknown" || (fx?.length ?? 0) > 0)) {
+            json(res, 403, { error: "canvas_worker_experimental", message: CANVAS_WORKER_EXPERIMENTAL_MESSAGE });
+            return true;
+        }
         if (fx === "unknown" || (fx ?? []).some(id => !ctx.modPlacedEffect?.(first.person, id))) {
             json(res, 403, { error: "mod_effects_not_yours", detail: "this mod's file carries effects that are not yours to share: export your own look instead" });
             return true;
@@ -863,7 +1242,7 @@ export function exportMod(ctx, person, body) {
             // The effects the theme places travel with it, as the library keeps them (a person may export what is placed).
             // Only effects this person may carry away travel (Sol's ACL); the rest are counted, never packaged.
             // #2017: an older placement of an effect that doesn't play in chat stays out (a mod can't place it): counted.
-            const effects = rec.placements.effects.flatMap(p => { const e = ctx.modPlacedEffect?.(person, p.id); if (!e || !filesPlayInChat(e.files)) {
+            const effects = (canvasWorkerEnabled(ctx.fleetConfig?.web) ? rec.placements.effects : []).flatMap(p => { const e = ctx.modPlacedEffect?.(person, p.id); if (!e || !filesPlayInChat(e.files)) {
                 omitted++;
                 return [];
             } return [{ name: e.name, files: e.files, params: p.params ?? {} }]; });
@@ -929,13 +1308,71 @@ function webAuthorityOf(req, url, ctx, instance) {
         return { authority: noAuthority(0), refusal: "not_session" };
     const v = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
     return ctx.webAuthority({ session: v.kind === "allow" && v.via === "session" ? v.session : null, gateway: !!gatewayRequestContext(req),
-        peer: classifyWebPeer(req), ...(instance !== undefined ? { instance } : {}) });
+        peer: webPeerOf(req), ...(instance !== undefined ? { instance } : {}) });
+}
+/**
+ * #1939 §3.4 / #2453 §0.2: where this request came from — the admin's named link by the gateway's own provenance (its
+ * exact hostname), else what the TCP peer and Host say (a quick tunnel's request is `lan`, and refused as public_link).
+ */
+export function webPeerOf(req) {
+    return gatewayRequestContext(req)?.named === true ? "named_link" : classifyWebPeer(req);
 }
 /**
  * #2122: what let this request in, asked now — its session (by handle, under the token it was signed in with) or the
  * header token; null when nothing does any more (the gate also refuses a public link that is no longer the current
  * one). Equal before and after an await: the same admission still holds. Never touches the session.
  */
+/** #2293: an admin's admission — the header token or an admin session — else null (a guest's or a read-only session's). */
+function adminAdmissionOf(req, url, ctx) {
+    const v = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
+    if (v.kind !== "allow" || (v.via === "session" && v.session.tier !== "admin"))
+        return null;
+    return admissionOf(req, url, ctx);
+}
+const SEARCH_LIMIT_DEFAULT = 50;
+/**
+ * #2293: GET /ui/search's parameters: q (1–QUERY_MAX_CHARS), instance (repeated), team (its members join `instance`),
+ * source (repeated: chat, xmsg, task), since / until (epoch ms), mine=1, limit (1–RESULT_MAX).
+ */
+function parseSearchQuery(url, ctx) {
+    const p = url.searchParams;
+    const q = (p.get("q") ?? "").trim();
+    if (!q || q.length > QUERY_MAX_CHARS)
+        return { error: `q required (1-${QUERY_MAX_CHARS} chars)` };
+    const instances = new Set(p.getAll("instance").filter(n => n.length > 0 && n.length <= 128));
+    const team = p.get("team");
+    if (team) {
+        const def = ctx.fleetConfig?.teams && Object.hasOwn(ctx.fleetConfig.teams, team) ? ctx.fleetConfig.teams[team] : undefined;
+        if (!def)
+            return { error: "unknown team" };
+        for (const member of def.members ?? [])
+            instances.add(member);
+        if (!instances.size)
+            return { error: "team has no members" };
+    }
+    const sources = p.getAll("source");
+    if (sources.some(s => !SEARCH_SOURCES.includes(s)))
+        return { error: `source must be one of: ${SEARCH_SOURCES.join(", ")}` };
+    const time = (name) => {
+        const raw = p.get(name);
+        if (raw === null || raw === "")
+            return undefined;
+        const n = Number(raw);
+        return Number.isSafeInteger(n) && n >= 0 ? n : null;
+    };
+    const since = time("since"), until = time("until");
+    if (since === null || until === null)
+        return { error: "since/until must be epoch milliseconds" };
+    const limitRaw = p.get("limit");
+    const limit = limitRaw === null ? SEARCH_LIMIT_DEFAULT : Number(limitRaw);
+    if (!Number.isInteger(limit) || limit < 1 || limit > RESULT_MAX)
+        return { error: `limit must be 1-${RESULT_MAX}` };
+    return {
+        filters: { q, limit, ...(instances.size ? { instances: [...instances] } : {}), ...(sources.length ? { sources: sources } : {}),
+            ...(since !== undefined ? { since } : {}), ...(until !== undefined ? { until } : {}) },
+        mine: p.get("mine") === "1",
+    };
+}
 function admissionOf(req, url, ctx) {
     const gateway = gatewayRequestContext(req);
     const v = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
@@ -951,18 +1388,122 @@ function webPersonOr401(req, res, url, ctx) {
         json(res, 401, { error: WEB_TOKEN_INVALID_MESSAGE });
     return p;
 }
+/**
+ * Who a dashboard request acts as on the task board. The person only through a signed-in local session: the header
+ * token is the CLI's or a script's (any agent on this machine can read the token file), and the temporary public link
+ * carries no verified authority (docs/web-dashboard.md) — either is a script, held to the rules an instance is held to,
+ * so neither confirms work waiting for the person.
+ */
+function boardActor(req, url, ctx, p) {
+    if (gatewayRequestContext(req))
+        return { kind: "script", name: "public-link" };
+    const v = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
+    return v.kind === "allow" && v.via === "session" ? { kind: "person", name: p.name } : { kind: "script", name: "web-token" };
+}
+/**
+ * A board refusal as the dashboard reads it: the board's sentence, its code and the status that fits, and — when the
+ * person can meet it — the key and values the page says it with in its own language.
+ */
+function boardError(res, err) {
+    if (res.headersSent)
+        return;
+    if (err instanceof TaskBoardError) {
+        const status = err.code === "not_found" ? 404 : err.code === "forbidden" ? 403 : err.code === "conflict" ? 409 : 400;
+        json(res, status, { error: err.message, code: err.code, ...(err.key ? { key: err.key, args: err.args } : {}) });
+        return;
+    }
+    json(res, 400, { error: err.message });
+}
+/**
+ * One board write from the dashboard: the body read and checked, the request still allowed, the person asked for
+ * again now the body is in (#1827), then the write as that person. The board's own routes take a signed-in session
+ * only (instances use their task tool, scripts the old /ui/tasks routes).
+ */
+function boardWrite(req, res, url, ctx, board, schema, write) {
+    void (async () => {
+        try {
+            const body = await parseBody(req);
+            if (!permitWebContinuation(req, res, ctx))
+                return;
+            const parsed = parseOrReject(schema, body, res);
+            if (!parsed)
+                return;
+            const person = webPersonOr401(req, res, url, ctx);
+            if (!person)
+                return;
+            const actor = boardActor(req, url, ctx, person);
+            if (actor.kind !== "person") {
+                json(res, 403, { error: "The task board takes changes from a signed-in dashboard", code: "forbidden", key: "signed_in_only" });
+                return;
+            }
+            json(res, 200, write(parsed, actor));
+        }
+        catch (err) {
+            boardError(res, err);
+        }
+    })();
+}
 /** #1827: what the page's profile card reads — the name they chose (or null), the one in use, and how agents know them. */
 function profileBody(p) {
     return { name: p.set ? p.name : null, shown: p.name, id: p.userId, bound: p.bound, ...(p.platformName !== undefined ? { platform_name: p.platformName } : {}) };
 }
 /** #1823: an SSE frame with the server's clock (no id: it is not a message, and a reconnect gets a fresh one). */
 function sseClock() { return `event: clock\ndata: ${JSON.stringify({ now: Date.now() })}\n\n`; }
-/**
- * Handle a Web UI request. Returns true if handled, false to pass through.
- */
+const statusTicks = new WeakMap();
+function subscribeStatusTick(ctx, stream) {
+    let tick = statusTicks.get(ctx);
+    if (!tick)
+        statusTicks.set(ctx, tick = { streams: new Set(), timer: null });
+    const t = tick;
+    t.streams.add(stream);
+    t.timer ??= setInterval(() => statusTick(ctx, t), ctx.sseHeartbeatMs ?? SSE_HEARTBEAT_MS);
+    return () => {
+        t.streams.delete(stream);
+        if (!t.streams.size && t.timer) {
+            clearInterval(t.timer);
+            t.timer = null;
+        }
+    };
+}
+function statusTick(ctx, t) {
+    const live = [...t.streams].filter((s) => s.alive());
+    if (!live.length)
+        return;
+    let status, admin = null;
+    const guests = new Map();
+    try {
+        status = measureSyncWork("web.sseStatus", () => ctx.getUiStatus());
+    }
+    catch {
+        return;
+    } // nothing to send this tick; the next one tries again
+    const frameFor = (s) => {
+        if (!s.scope)
+            return admin ??= `event: status\ndata: ${JSON.stringify(status)}\n\n`;
+        const scope = s.scope(), key = [...scope].sort().join("\u0000");
+        let frame = guests.get(key);
+        if (frame === undefined)
+            guests.set(key, frame = `event: status\ndata: ${JSON.stringify(guestStatus(status, scope))}\n\n`);
+        return frame;
+    };
+    for (const s of live) {
+        let frame;
+        try {
+            frame = frameFor(s);
+        }
+        catch {
+            continue;
+        }
+        s.write(frame);
+    }
+}
 export function handleWebRequest(req, res, url, ctx) {
     const path = url.pathname;
     const method = req.method ?? "GET";
+    if (!canvasWorkerEnabled(ctx.fleetConfig?.web) && isCanvasWorkerHttpPath(path)) {
+        json(res, 403, { error: "canvas_worker_experimental", message: CANVAS_WORKER_EXPERIMENTAL_MESSAGE });
+        return true;
+    }
     // Auth check for all /ui routes. Defence in depth behind the fleet-manager
     // gate: the same session cookie or header token, and an unset token closes
     // the panel instead of comparing null against a missing credential.
@@ -1010,6 +1551,9 @@ export function handleWebRequest(req, res, url, ctx) {
         try {
             const js = readFileSync(join(__dirname, "ui", fileName), "utf-8");
             res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+            // #2182: the route worker's own, narrower-reaching policy (ROUTE_WORKER_CSP); every other file keeps the page's.
+            if (path === ROUTE_WORKER_PATH)
+                res.setHeader("Content-Security-Policy", ROUTE_WORKER_CSP);
             res.writeHead(200);
             res.end(js);
         }
@@ -1018,6 +1562,19 @@ export function handleWebRequest(req, res, url, ctx) {
         }
         return true;
     }
+    // #2182: libavoid (libavoid-js, LGPL-2.1-or-later) — the npm package's own two files, unmodified, at a versioned path.
+    const vendor = method === "GET" ? libavoidFile(path) : null;
+    if (vendor) {
+        try {
+            const body = readFileSync(vendor.file);
+            res.writeHead(200, { "Content-Type": vendor.type, "Cache-Control": "private, max-age=31536000, immutable" });
+            res.end(body);
+        }
+        catch {
+            json(res, 404, { error: "File not found" });
+        }
+        return true;
+    }
     // ── Backend detection ─────────────────────────────────
     // #2072: the model a Settings field offers — the cached catalog of that backend (that instance's account's). Read only.
     if (method === "GET" && path === "/ui/models") {
@@ -1080,30 +1637,31 @@ export function handleWebRequest(req, res, url, ctx) {
         const after = url.searchParams.get("after");
         const fresh = after === null || after === ""; // a cursor that is not ours in shape still gets nothing
         if (guest) {
-            // #2085 review: and what became the channel's after its cursor (an older row, its copy sent since), once each.
+            // #2085 review: with what became the channel's after its cursor (an older row, its copy sent since), once each —
+            // replayFor counts a row where it was seen (seenSeq), as for every reader (#1774).
             json(res, 200, guestPollBody(ctx.getUiStatus(), guest.scope(), Date.now(), guest, after, () => {
                 if (!history)
                     return [];
-                if (fresh)
-                    return history.after(0);
-                const cursor = parseLastEventId(after);
-                const rows = [...history.replayFor(cursor), ...history.seenAfter(cursor)];
-                return rows.filter((m, i) => rows.findIndex((x) => x.boot === m.boot && x.id === m.id) === i);
+                return fresh ? history.after(0) : history.replayFor(parseLastEventId(after));
             }));
             return true;
         }
         json(res, 200, {
             status: ctx.getUiStatus(),
-            messages: history ? (fresh ? history.after(0) : history.replayFor(parseLastEventId(after))) : [],
+            // #2341 review: over the public link, without a summary line that names a card hidden there.
+            messages: history ? visibleMessages(ctx, !!gatewayRequestContext(req), fresh ? history.after(0) : history.replayFor(parseLastEventId(after))) : [],
             // The ticks too, so polling never has to re-read a chat's history — that read would count as the person's
             // activity; this poll does not (isPassiveWebRead).
             deliveries: history ? history.deliveries() : [],
             // #1266: a reply's buttons that ended after the page saw the reply (the message itself is not sent again).
             reply_buttons: history ? history.buttonStates() : [],
+            // #2305: the instance's reactions, likewise (a reaction is no new message).
+            reactions: history ? history.reactionStates() : [],
             // And the fleet prompts open on the dashboard (C4): prompt events are stream-only too.
             prompts: ctx.listWebPrompts?.() ?? [],
-            // #1386: "Needs you" rides the passive channels only — no endpoint of its own to poll.
-            needs: ctx.needsYouItems?.() ?? [],
+            // #1386: "Needs you" rides the passive channels only — no endpoint of its own to poll. Over the public link,
+            // without the task board's hidden cards (#2306 review).
+            needs: visibleNeeds(ctx, !!gatewayRequestContext(req), ctx.needsYouItems?.() ?? []),
             // #1577: the newest message this answer accounts for — after a restart, the last restored one until this process
             // records its own (`<boot>-0` would be after(0): the whole restored history again on every poll).
             cursor: history ? history.pollCursor() : null,
@@ -1160,13 +1718,17 @@ export function handleWebRequest(req, res, url, ctx) {
         if (!guest && ctx.needsYouItems)
             res.write(`event: needs\ndata: ${JSON.stringify({ items: ctx.needsYouItems() })}\n\n`);
         ctx.sseClients.add(res);
-        const interval = setInterval(() => {
+        // #1956: the heartbeat's status comes from the one build every open stream shares each tick (statusTick), with
+        // this stream's own projection; this stream's checks stay its own.
+        const unsubscribe = subscribeStatusTick(ctx, {
             // A stream authorized once must not outlive the authorization. Re-checked
             // without counting as activity, or an open tab would keep an idle session
             // alive forever; a revoked, expired or rotated-away session ends here.
             // #2049 review: a guest's stream also needs the exact session that opened it — another cookie on the same request
             // still authenticating does not keep a revoked device's stream (with its scope) alive.
-            if (!isWebRequestAuthorized(req, url, ctx.webToken, ctx.webSessions, { touch: false }) || (guest && !guest.current())) {
+            alive: () => {
+                if (isWebRequestAuthorized(req, url, ctx.webToken, ctx.webSessions, { touch: false }) && (!guest || guest.current()))
+                    return true;
                 // Close the connection too, not just the response: an ended response leaves the socket idle in
                 // keep-alive, still held open by whoever's session just ended.
                 const socket = req.socket;
@@ -1175,23 +1737,23 @@ export function handleWebRequest(req, res, url, ctx) {
                 }
                 catch { /* already closed */ }
                 cleanup();
-                return;
-            }
-            try {
-                // Every open dashboard tab, every 10 s: the status of every instance, serialized on the fleet's loop (#1235).
-                res.write(measureSyncWork("web.sseStatus", statusFrame) + sseClock());
+                return false;
+            },
+            scope: guest ? () => guest.scope() : null,
+            write: (frame) => { try {
+                res.write(frame + sseClock());
             }
             catch {
                 cleanup();
-            }
-        }, ctx.sseHeartbeatMs ?? SSE_HEARTBEAT_MS);
+            } },
+        });
         let cleanedUp = false;
         const cleanup = () => {
             if (cleanedUp)
                 return;
             cleanedUp = true;
             ctx.sseClients.delete(res);
-            clearInterval(interval);
+            unsubscribe();
         };
         // The *response's* `close` is the one that means the stream is over: it fires when the connection
         // goes away or the response is finished. The request's `close` means "the request has been read"
@@ -1215,7 +1777,8 @@ export function handleWebRequest(req, res, url, ctx) {
         }
         // #1920 §5.2: a guest gets what the channel showed of it, and its own messages (the gate checked the scope).
         const guest = guestRequestOf(req);
-        const messages = !ctx.webChatHistory ? [] : guest ? guestHistory(ctx.webChatHistory, instance, limit, guest, guest.scope()) : ctx.webChatHistory.list(instance, limit);
+        const messages = !ctx.webChatHistory ? [] : guest ? guestHistory(ctx.webChatHistory, instance, limit, guest, guest.scope())
+            : visibleMessages(ctx, !!gatewayRequestContext(req), ctx.webChatHistory.list(instance, limit));
         json(res, 200, { messages, boot: ctx.webChatHistory?.boot ?? null, lastId: ctx.webChatHistory?.lastId ?? 0 });
         return true;
     }
@@ -1417,6 +1980,100 @@ export function handleWebRequest(req, res, url, ctx) {
         });
         return true;
     }
+    // ── Fleet → Org chart → Office: the offices people made (web-offices.json, web-office-store.ts) ──
+    // GET /ui/offices: { rev, offices, readable } for whoever may open the org chart (the public link too: it reads the
+    // chart; a guest's routes do not include it). PUT /ui/offices { offices, rev? }: a person's change, as a theme's reset
+    // or lock is — an admin session only, never the CLI token, never the public link (absent from its manifest, and
+    // refused here too); asked again once the body is in. Every page hears `offices` on the stream and reads again.
+    if (method === "GET" && path === "/ui/offices") {
+        const store = ctx.officeStore;
+        if (!store) {
+            json(res, 404, { error: "Offices are not kept on this fleet" });
+            return true;
+        }
+        json(res, 200, store.list());
+        return true;
+    }
+    if (method === "PUT" && path === "/ui/offices") {
+        const store = ctx.officeStore;
+        if (!store) {
+            json(res, 404, { error: "Offices are not kept on this fleet" });
+            return true;
+        }
+        if (gatewayRequestContext(req)) {
+            json(res, 403, { error: "offices_not_over_public_link" });
+            return true;
+        }
+        // The person (an admin session's account), or the status that refuses the request.
+        const who = () => {
+            const verdict = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
+            if (verdict.kind !== "allow")
+                return { status: 401 };
+            return verdict.via === "session" && verdict.session?.tier === "admin" ? { person: verdict.session.owner ? webPersonKey(verdict.session.owner) : "admin-session" } : { status: 403 };
+        };
+        const refuse = (status) => json(res, status, { error: status === 401 ? WEB_TOKEN_INVALID_MESSAGE : "offices_need_an_admin_session" });
+        const first = who();
+        if ("status" in first) {
+            refuse(first.status);
+            return true;
+        }
+        (async () => {
+            let body;
+            try {
+                body = await parseBody(req);
+            }
+            catch {
+                json(res, 400, { error: "Invalid JSON" });
+                return;
+            }
+            if (!permitWebContinuation(req, res, ctx))
+                return;
+            const now = who();
+            if ("status" in now) {
+                refuse(now.status);
+                return;
+            }
+            if (!body || typeof body !== "object" || Array.isArray(body)) {
+                json(res, 400, { error: "offices required" });
+                return;
+            }
+            const extra = Object.keys(body).find(k => k !== "offices" && k !== "rev");
+            if (extra !== undefined) {
+                json(res, 400, { error: "offices_invalid", detail: `unknown key "${extra}"` });
+                return;
+            }
+            // Office review: the rev the page read is required — a save without one would overwrite another person's unseen.
+            if (body.rev === undefined) {
+                json(res, 428, { error: "offices_rev_required", detail: "send the rev you read (GET /ui/offices)" });
+                return;
+            }
+            if (!Number.isSafeInteger(body.rev)) {
+                json(res, 400, { error: "offices_invalid", detail: "rev: an integer" });
+                return;
+            }
+            const limiter = ctx.officeWrites, allowed = limiter ? limiter.check(now.person) : { ok: true };
+            if (!allowed.ok) {
+                res.setHeader("Retry-After", String(allowed.retry_after_s));
+                json(res, 429, { error: "offices_rate_limited", retry_after_s: allowed.retry_after_s });
+                return;
+            }
+            const r = store.replace(body.offices, body.rev);
+            if (!r.ok) {
+                json(res, r.status, { error: r.error, ...(r.detail ? { detail: r.detail } : {}) });
+                return;
+            }
+            limiter?.record(now.person);
+            ctx.emitSseEvent("offices", { rev: r.rev });
+            json(res, 200, { rev: r.rev, offices: r.offices });
+        })().catch(err => {
+            ctx.logger.error({ err: err.message }, "Saving offices failed");
+            try {
+                json(res, 500, { error: "Saving offices failed" });
+            }
+            catch { /* already answered */ }
+        });
+        return true;
+    }
     // ── #1630: avatars and Discord server emoji, same-origin (the page never loads a platform's CDN; img-src stays 'self') ──
     const imageMatch = path.match(/^\/ui\/img\/(bot|avatar|emoji)\/([^/]+)$/);
     if (method === "GET" && imageMatch) {
@@ -1709,6 +2366,10 @@ export function handleWebRequest(req, res, url, ctx) {
                 return;
             }
             const personal = [...parsed.patch.keys()].some(isOwnerEffectKey);
+            if (personal && !canvasWorkerEnabled(ctx.fleetConfig?.web)) {
+                json(res, 403, { error: "canvas_worker_experimental", message: CANVAS_WORKER_EXPERIMENTAL_MESSAGE });
+                return;
+            }
             if (personal && now.person === null) {
                 json(res, 403, { error: "prefs_need_a_signed_in_person" });
                 return;
@@ -1748,6 +2409,9 @@ export function handleWebRequest(req, res, url, ctx) {
     if (path === "/ui/owner-css.css" || path === "/ui/owner-css" || path.startsWith("/ui/owner-css/")) {
         return handleOwnerCss(req, res, url, ctx, path, method);
     }
+    // #2308: the app icon (handleAppIcon: its state for a signed-in person; changing it, an admin's session only).
+    if (path === "/ui/app-icon")
+        return handleAppIcon(req, res, url, ctx, method);
     // #1629 r4-5: mods — a person's import, uninstall and export (handleMods: sessions only, never the public link).
     if (path === "/ui/mods" || path.startsWith("/ui/mods/"))
         return handleMods(req, res, url, ctx, path, method);
@@ -1757,6 +2421,9 @@ export function handleWebRequest(req, res, url, ctx) {
     // Canvas effects are absent from the public gateway manifest and independently refused above.
     if (path === "/ui/effect-trials" || path.startsWith("/ui/effect-trials/"))
         return handleEffectTrials(req, res, url, ctx, path, method);
+    // #2233: backend sign-in — absent from the public manifest and the guest table, and refused here too.
+    if (path === "/ui/backend-login" || path.startsWith("/ui/backend-login/"))
+        return handleBackendLogin(req, res, url, ctx, path, method);
     if (path === "/ui/effects" || path.startsWith("/ui/effects/"))
         return handleEffects(req, res, url, ctx, path, method);
     // #1386: Acknowledge a "Needs you" delivery item — a session write (CSRF, checked by the gate) or the CLI's header
@@ -1808,7 +2475,7 @@ export function handleWebRequest(req, res, url, ctx) {
     if (path === "/ui/authorization" && (method === "GET" || method === "POST")) {
         const judge = () => {
             const v = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
-            return { session: v.kind === "allow" && v.via === "session" ? v.session : null, gateway: !!gatewayRequestContext(req), peer: classifyWebPeer(req) };
+            return { session: v.kind === "allow" && v.via === "session" ? v.session : null, gateway: !!gatewayRequestContext(req), peer: webPeerOf(req) };
         };
         res.setHeader("Cache-Control", "no-store");
         if (method === "GET") {
@@ -1908,7 +2575,7 @@ export function handleWebRequest(req, res, url, ctx) {
             return true;
         }
         // Own keys only: "constructor" is in every object and names no instance.
-        const known = (ctx.fleetConfig ? Object.hasOwn(ctx.fleetConfig.instances, name) : false) || ctx.daemons.has(name);
+        const known = registeredChatInstance(ctx, name) || ctx.daemons.has(name);
         if (!ctx.cancelInstance || !known) {
             json(res, 404, { error: `Instance not found: ${name}` });
             return true;
@@ -1958,7 +2625,7 @@ export function handleWebRequest(req, res, url, ctx) {
         (async () => {
             let held = false;
             try {
-                await withSpawnHoldReply(async (message) => { held = true; json(res, 202, { held: true, message, instance: name }); }, () => ctx.startInstance(name, config, topicMode ?? false));
+                await withSpawnHoldReply(async (message) => { held = true; json(res, 202, { held: true, message, instance: name }); }, () => ctx.startInstance(name, config, topicMode ?? false, "fleet-topic", true));
                 ctx.emitSseEvent("status", ctx.getUiStatus());
                 if (!held)
                     json(res, 200, { started: name });
@@ -2141,6 +2808,11 @@ export function handleWebRequest(req, res, url, ctx) {
         json(res, 200, { tasks });
         return true;
     }
+    // #2246: the public link writes no task — the old list's create and update are board writes now (see below).
+    if (method === "POST" && (path === "/ui/tasks" || /^\/ui\/tasks\/[^/]+$/.test(path)) && gatewayRequestContext(req)) {
+        json(res, 403, { error: "task_board_not_over_public_link", code: "forbidden", key: "not_over_public_link" });
+        return true;
+    }
     if (method === "POST" && path === "/ui/tasks") {
         if (!ctx.scheduler) {
             json(res, 500, { error: "Scheduler not initialized" });
@@ -2163,7 +2835,7 @@ export function handleWebRequest(req, res, url, ctx) {
                     priority: parsed.priority,
                     assignee: parsed.assignee,
                     created_by: person.name, // #1827
-                });
+                }, boardActor(req, url, ctx, person));
                 json(res, 200, task);
             }
             catch (err) {
@@ -2172,15 +2844,183 @@ export function handleWebRequest(req, res, url, ctx) {
         })();
         return true;
     }
+    // ── Task board (scheduler/task-board.ts) ──────────────
+    // Reads are the session's; every write is the signed-in person's, through the same rules an instance's tools use.
+    if (path === "/ui/tasks/board" || path === "/ui/tasks/search" || path === "/ui/tasks/work" || path.startsWith("/ui/tasks/cards") || path.startsWith("/ui/tasks/projects")) {
+        const board = ctx.scheduler?.db.board;
+        if (!board) {
+            json(res, 503, { error: "The task board is not available", code: "unavailable", key: "unavailable" });
+            return true;
+        }
+        // The temporary public link reads the board and changes nothing on it: confirming, sending back, cancelling and
+        // assigning are the person's authority, which the public link never carries (docs/web-dashboard.md).
+        const gateway = gatewayRequestContext(req);
+        if (gateway && method !== "GET") {
+            json(res, 403, { error: "task_board_not_over_public_link", code: "forbidden", key: "not_over_public_link" });
+            return true;
+        }
+        // …nor shows the cards of instances kept out of sight (cross_instance_visibility: hidden).
+        const { hiddenName, hidden } = boardHiding(ctx, !!gateway);
+        // #2303 review: what a visible card shows of the cards around it follows the same rule — its children, its main
+        // task (a search hit's too) — and so do the words and the history a hidden instance left on it.
+        // …and a hidden instance's words on a visible card are not counted, named or found there (#2304 review).
+        const scope = { leaveOutAuthors: gateway ? Object.keys(ctx.fleetConfig?.instances ?? {}).filter(hiddenName) : [] };
+        const hiddenRef = (ref) => { const c = ref ? board.findCard(ref) : undefined; return !!c && hidden(c); };
+        const mentionsHidden = (v) => (typeof v === "string" ? hiddenName(v) : !!v && typeof v === "object" && Object.values(v).some(mentionsHidden));
+        const shown = (d) => !gateway ? d : {
+            ...d,
+            parent: d.card.parentId && hiddenRef(d.card.parentId) ? null : d.parent,
+            children: d.children.filter((c) => !hidden(c)),
+            comments: d.comments.filter((e) => !hiddenName(e.author)),
+            logs: d.logs.filter((e) => !hiddenName(e.author)),
+            history: d.history.filter((e) => !hiddenName(e.actor) && !mentionsHidden(e.data)),
+        };
+        const card = /^\/ui\/tasks\/cards\/([^/]+)(?:\/(move|reorder))?$/.exec(path);
+        const project = /^\/ui\/tasks\/projects\/(\d+)$/.exec(path);
+        try {
+            const ref = card ? decodeURIComponent(card[1]) : "";
+            if (method === "GET" && path === "/ui/tasks/board") {
+                // A page that has this revision already is told so, not sent the board again.
+                const rev = board.revision();
+                if (url.searchParams.get("rev") === String(rev)) {
+                    json(res, 200, { rev, unchanged: true });
+                    return true;
+                }
+                const allDone = url.searchParams.get("done") === "all";
+                // #2296: every open Tasks tab reads the board again after each change; on the dashboard they all get the same
+                // board for a revision, so it is built once per (revision, done=all, minute) — the minute for the 14-day
+                // window. The public link's reads are filtered per request (hidden instances) and are built each time.
+                const key = gateway ? null : `${rev}:${allDone ? 1 : 0}:${Math.floor(Date.now() / 60_000)}`;
+                const kept = key ? boardBodies.get(board) : undefined;
+                if (kept && kept.key === key) {
+                    jsonText(res, 200, kept.body);
+                    return true;
+                }
+                const cards = board.boardCards(undefined, allDone).filter((c) => !hidden(c));
+                // #2352: over the public link a hidden lead is not named (the project reads as having none).
+                const projects = board.listProjects(true).map((p) => (p.leadInstance && hiddenName(p.leadInstance) ? { ...p, leadInstance: null } : p));
+                // #2355 review: the names a project's lead may be — the fleet's instances (a Classic-only room is not one); over the
+                // public link, not a hidden one.
+                const leads = Object.keys(ctx.fleetConfig?.instances ?? {}).filter((n) => !hiddenName(n)).sort();
+                const body = JSON.stringify({ rev, cards: board.views(cards, scope), projects, leads, stats: board.projectStats() });
+                if (key)
+                    boardBodies.set(board, { key, body });
+                jsonText(res, 200, body);
+                return true;
+            }
+            if (method === "GET" && path === "/ui/tasks/work") {
+                // #2246 step 3: each instance's work on the board — what its `task mine` reads (myWork) — for the board's
+                // Instance list and an instance's Details page (`?instance=`): the fleet's instances and anyone else a live
+                // card is assigned to. Over the public link, not those kept out of sight, nor a card that names one. Every
+                // name's work is one workOf() read and the cards one views() read, whatever the number of instances (#2316
+                // review); on the dashboard the answer is built once per board revision and the names asked for, and shared
+                // by every open drawer (the public link's is filtered per request, as the board's).
+                const only = url.searchParams.get("instance");
+                const names = (only ? [only] : [...new Set([...Object.keys(ctx.fleetConfig?.instances ?? {}), ...board.liveAssignees()])]).filter((n) => !hiddenName(n));
+                const key = gateway ? null : `${board.revision()}:${only === null ? "*" : `=${only}`}:${names.join("\u0000")}`;
+                const kept = key ? workBodies.get(board) : undefined;
+                if (kept && kept.key === key) {
+                    jsonText(res, 200, kept.body);
+                    return true;
+                }
+                const byName = board.workOf(names);
+                const works = names.map((name) => ({ name, w: byName.get(name) }));
+                const all = new Map();
+                for (const { w } of works)
+                    for (const c of [...w.doing, ...w.blocked, ...w.review, ...w.ready, ...w.waiting.map((x) => x.card), ...w.mains.map((x) => x.card)])
+                        if (!hidden(c))
+                            all.set(c.uuid, c);
+                const viewOf = new Map(board.views([...all.values()], scope).map((v) => [v.uuid, v]));
+                const drawn = (cards) => cards.flatMap((c) => (viewOf.has(c.uuid) ? [viewOf.get(c.uuid)] : []));
+                const codes = (cards) => cards.filter((x) => all.has(x.card.uuid)).map((x) => x.card.code);
+                const body = JSON.stringify({ instances: works.map(({ name, w }) => ({
+                        name,
+                        doing: drawn(w.doing), blocked: drawn(w.blocked), review: drawn(w.review), ready: drawn(w.ready),
+                        waiting: drawn(w.waiting.map((x) => x.card)), mains: drawn(w.mains.map((x) => x.card)),
+                        sentBack: codes(w.sentBack), newComments: codes(w.newComments),
+                    })) });
+                if (key)
+                    workBodies.set(board, { key, body });
+                jsonText(res, 200, body);
+                return true;
+            }
+            if (method === "GET" && path === "/ui/tasks/search") {
+                const names = new Map(board.listProjects(true).map((p) => [p.id, p.name]));
+                const hits = board.search(url.searchParams.get("q") ?? "", Number(url.searchParams.get("limit")) || 20, scope).filter((h) => !hidden(h.card));
+                const views = board.views(hits.map((h) => h.card), scope);
+                const results = hits.map(({ card: c, match }, i) => ({
+                    card: views[i],
+                    match,
+                    project: c.projectId === null ? null : names.get(c.projectId) ?? null,
+                    parentTitle: c.parent && !hiddenRef(c.parent) ? board.findCard(c.parent)?.title ?? null : null,
+                }));
+                json(res, 200, { results });
+                return true;
+            }
+            if (method === "GET" && card && !card[2]) {
+                const found = board.getCard(ref);
+                if (hidden(found)) {
+                    json(res, 404, { error: "no such card", code: "not_found" });
+                    return true;
+                }
+                json(res, 200, shown(board.detail(ref, scope)));
+                return true;
+            }
+            if (method === "POST" && path === "/ui/tasks/cards") {
+                boardWrite(req, res, url, ctx, board, CardCreateSchema, (spec, person) => {
+                    const { cards, said } = board.createCards(person, { cards: [spec] });
+                    return { card: board.view(cards[0]), notes: said };
+                });
+                return true;
+            }
+            if (method === "POST" && card) {
+                if (card[2] === "move") {
+                    boardWrite(req, res, url, ctx, board, CardMoveSchema, ({ to, ...move }, person) => {
+                        const { card: moved, said } = board.moveCard(person, ref, to, move);
+                        return { card: board.view(moved), notes: said };
+                    });
+                }
+                else if (card[2] === "reorder") {
+                    boardWrite(req, res, url, ctx, board, CardReorderSchema, ({ after, before }, person) => ({ card: board.view(board.reorder(person, ref, after ?? null, before ?? null)) }));
+                }
+                else {
+                    boardWrite(req, res, url, ctx, board, CardPatchSchema, (patch, person) => {
+                        const { card: updated, said } = board.updateCard(person, ref, patch);
+                        return { card: board.view(updated), notes: said };
+                    });
+                }
+                return true;
+            }
+            if (method === "POST" && path === "/ui/tasks/projects") {
+                boardWrite(req, res, url, ctx, board, ProjectCreateSchema, (input, person) => { checkLeadIsInstance(ctx, input.leadInstance); return { project: board.createProject(person, input) }; });
+                return true;
+            }
+            if (method === "POST" && project) {
+                boardWrite(req, res, url, ctx, board, ProjectPatchSchema, (patch, person) => { checkLeadIsInstance(ctx, patch.leadInstance); return { project: board.updateProject(person, Number(project[1]), patch) }; });
+                return true;
+            }
+        }
+        catch (err) {
+            // A malformed %-escape in the card's address is the caller's mistake, not the server's.
+            if (err instanceof URIError) {
+                json(res, 400, { error: "bad card reference", code: "invalid" });
+                return true;
+            }
+            boardError(res, err);
+            return true;
+        }
+        json(res, 404, { error: "Not found" });
+        return true;
+    }
     const taskMatch = path.match(/^\/ui\/tasks\/(.+)$/);
     if (method === "POST" && taskMatch) {
         if (!ctx.scheduler) {
             json(res, 500, { error: "Scheduler not initialized" });
             return true;
         }
-        const id = decodeURIComponent(taskMatch[1]);
         (async () => {
             try {
+                const id = decodeURIComponent(taskMatch[1]);
                 const body = await parseBody(req);
                 if (!permitWebContinuation(req, res, ctx))
                     return;
@@ -2188,19 +3028,22 @@ export function handleWebRequest(req, res, url, ctx) {
                 if (!parsed)
                     return;
                 let result;
+                // #1827: the person, who is also the default assignee of a claim; the task board's review gate needs to know
+                // a person (not an instance) made the move.
+                const person = webPersonOr401(req, res, url, ctx);
+                if (!person)
+                    return;
+                const by = boardActor(req, url, ctx, person);
                 if (parsed.action === "claim") {
-                    const person = parsed.assignee ? null : webPersonOr401(req, res, url, ctx); // #1827: the default is the person
-                    if (!parsed.assignee && !person)
-                        return;
-                    result = ctx.scheduler.db.claimTask(id, parsed.assignee || person.name);
+                    result = ctx.scheduler.db.claimTask(id, parsed.assignee || person.name, by);
                 }
                 else if (parsed.action === "complete") {
-                    result = ctx.scheduler.db.completeTask(id, parsed.result);
+                    result = ctx.scheduler.db.completeTask(id, parsed.result, by);
                 }
                 else {
                     // Strip action before passing remaining fields to updateTask
                     const { action: _a, ...rest } = parsed;
-                    result = ctx.scheduler.db.updateTask(id, rest);
+                    result = ctx.scheduler.db.updateTask(id, rest, by);
                 }
                 json(res, 200, result);
             }
@@ -2328,6 +3171,90 @@ export function handleWebRequest(req, res, url, ctx) {
         }
         return true;
     }
+    // #2293: global search — an admin's only: the header token or an admin session. Never a guest (not in GUEST_ROUTES).
+    // #2478 (the user's request): over the public link too, unless web.search.public_link is false. Asked on arrival and
+    // again before the answer is sent.
+    if (method === "GET" && (path === "/ui/search" || path === "/ui/search/context")) {
+        const refusal = () => {
+            if (gatewayRequestContext(req) && ctx.fleetConfig?.web?.search?.public_link === false)
+                return [404, "search_not_over_public_link"];
+            if (guestRequestOf(req))
+                return [403, "guest_forbidden"];
+            if (ctx.fleetConfig?.web?.search?.enabled === false || !ctx.searchIndex || ctx.searchIndex.status() === "unavailable")
+                return [404, "search_unavailable"];
+            return null;
+        };
+        const first = refusal();
+        if (first) {
+            json(res, first[0], { error: first[1] });
+            return true;
+        }
+        const admitted = adminAdmissionOf(req, url, ctx);
+        if (!admitted) {
+            json(res, 401, { error: WEB_TOKEN_INVALID_MESSAGE });
+            return true;
+        }
+        const index = ctx.searchIndex;
+        // cross_instance_visibility "hidden" (fleet-traffic's rule): a message to or from such a name is not found.
+        const visibility = () => ctx.searchVisibility?.() ?? { hidden: [] };
+        const shown = (doc) => xmsgShown(doc, visibility());
+        const finish = (status, body) => {
+            const now = refusal();
+            if (now)
+                return json(res, now[0], { error: now[1] });
+            if (adminAdmissionOf(req, url, ctx) !== admitted)
+                return json(res, 401, { error: WEB_TOKEN_INVALID_MESSAGE });
+            json(res, status, body);
+        };
+        const failed = (reason) => finish(reason === "timeout" || reason === "busy" ? 503 : 404, { error: `search_${reason}` });
+        if (path === "/ui/search/context") {
+            const key = url.searchParams.get("key") ?? "";
+            if (!key || key.length > 300) {
+                json(res, 400, { error: "key required" });
+                return true;
+            }
+            void index.context(key).then(r => {
+                if (!r.ok)
+                    return failed(r.reason);
+                const doc = r.value?.doc;
+                // A message to or from an instance that is hidden now is not shown, as in the search itself.
+                if (!doc || !shown(doc))
+                    return finish(404, { error: "not_found" });
+                finish(200, { ...r.value, building: r.building });
+            }, () => failed("unavailable"));
+            return true;
+        }
+        const parsed = parseSearchQuery(url, ctx);
+        if ("error" in parsed) {
+            json(res, 400, { error: parsed.error });
+            return true;
+        }
+        if (parsed.mine) {
+            const person = webPersonOf(req, url, ctx);
+            if (!person) {
+                json(res, 401, { error: WEB_TOKEN_INVALID_MESSAGE });
+                return true;
+            }
+            parsed.filters.mine = [person.voterKey];
+        }
+        const v = visibility();
+        if ("hidden" in v)
+            parsed.filters.hidden = v.hidden;
+        else
+            parsed.filters.xmsgAmong = v.among;
+        void index.query(parsed.filters).then(r => {
+            if (!r.ok)
+                return failed(r.reason);
+            // A chat row still in the history opens in place (#m=); one that has left it opens as the index's copy.
+            const history = ctx.webChatHistory;
+            // The visibility as it is now (#2295 review): a name hidden while the query ran is left out too.
+            const now = visibility();
+            const hits = r.value.hits.filter(h => xmsgShown(h, now)).map(h => h.source !== "chat" ? h
+                : { ...h, live: !!history?.find(h.instance, String(h.ref.boot ?? ""), Number(h.ref.id)) });
+            finish(200, { hits, limited: r.value.limited, building: r.building });
+        }, () => failed("unavailable"));
+        return true;
+    }
     // #2122: the usage report. Signed-in sessions by default (guests never: not in GUEST_ROUTES); hidden with the rest of
     // usage by web.usage_panel: false; over the public link only when web.usage_report_on_public_link is true. Answered
     // from the ledgers and rollups as they are; a catch-up runs behind. The page's CSV is built from this same answer.
@@ -2570,6 +3497,17 @@ export function handleWebRequest(req, res, url, ctx) {
     json(res, 404, { error: "not found" });
     return true;
 }
+/**
+ * #2272: the line a web reply's channel copy opens with — the quoted sender and first words when that message reached
+ * the channel (its members saw it); a web-only one is only named, never copied out to the channel.
+ */
+export function webReplyEchoLine(quoted) {
+    if (!quoted.channel)
+        return t("web.echo_reply_web_only");
+    const ref = webChatReplyRef(quoted);
+    const words = ref.text.slice(0, 120) || (ref.media === "photo" ? "[photo]" : ref.media ? "[file]" : "");
+    return t("web.echo_reply", quoted.sender.slice(0, 80), words);
+}
 /** Keep the echo in a single platform message, including its attachment names. */
 function webEchoPreview(message, names) {
     const text = wellFormed(message.slice(0, 500));
@@ -2578,7 +3516,36 @@ function webEchoPreview(message, names) {
     const truncated = message.length > 500 || preview.length > 1400;
     return wellFormed(preview.slice(0, 1400)) + (truncated ? ` … (${t("web.echo_full_text")})` : "");
 }
+/** Registration and liveness are different: a paused CLI may have neither daemon nor IPC. */
+function registeredChatInstance(ctx, name) {
+    return (!!ctx.fleetConfig && Object.hasOwn(ctx.fleetConfig.instances, name)) || ctx.isClassicInstance?.(name) === true;
+}
+function uploadRecipient(ctx, name) {
+    return registeredChatInstance(ctx, name)
+        && (ctx.instanceIpcClients.has(name) || ctx.getInstanceStatus?.(name) === "paused");
+}
+/** Closed, path-free explanations; arbitrary launch errors stay in the host log. */
+function webDeliveryFailure(err) {
+    const message = err instanceof Error ? err.message : "";
+    if (/No warm slot is free/.test(message))
+        return { reason: "wake_capacity", error: "No slot is free to wake this instance. Retry when another instance is idle." };
+    if (/login|log in|sign in|\bauth(?:entication|orization)?\b|credential|api.?key/i.test(message))
+        return { reason: "wake_credentials", error: "The instance could not sign in. Check its account on the host, then retry." };
+    if (/timed? out|timeout/i.test(message))
+        return { reason: "wake_timeout", error: "The instance did not become ready in time. Retry, or check its status on the host." };
+    if (/Cannot wake stopped|no longer configured/.test(message))
+        return { reason: "instance_stopped", error: "This instance was stopped or removed. Start it on the host before retrying." };
+    return { reason: "delivery_unavailable", error: "The instance could not receive this message. Check its status on the host, then retry." };
+}
 /** Handle POST /ui/send — extracted for readability. */
+/** Each web server's own memory of the sends it accepted by clientId (web-send-dedupe.ts). */
+const webSendDedupes = new WeakMap();
+function webSendDedupeOf(ctx) {
+    let d = webSendDedupes.get(ctx);
+    if (!d)
+        webSendDedupes.set(ctx, d = new WebSendDedupe());
+    return d;
+}
 function handleSendMessage(req, res, ctx) {
     const arrival = webAuthorityOf(req, new URL(req.url ?? "/", "http://localhost"), ctx); // #1939 §3: again after the body
     let body = "";
@@ -2595,6 +3562,9 @@ function handleSendMessage(req, res, ctx) {
     req.on("end", async () => {
         if (!permitWebContinuation(req, res, ctx))
             return;
+        // A claimed clientId is settled however this ends: with the messageId once accepted, else forgotten.
+        let claim;
+        let acceptedId = null;
         try {
             const raw = JSON.parse(body);
             const parsed = SendMessageSchema.safeParse(raw);
@@ -2603,7 +3573,7 @@ function handleSendMessage(req, res, ctx) {
                 json(res, 400, { error: `${issue.path.join(".") || "body"}: ${issue.message}` });
                 return;
             }
-            const { instance, message: typed, attachments = [] } = parsed.data;
+            const { instance, message: typed, attachments = [], replyTo, clientId } = parsed.data;
             // #1920 step 2b: a guest writes only to an in-scope instance, while guests may chat, and never a command.
             const guest = guestRequestOf(req);
             const refused = guestChatRefusal(guest, instance);
@@ -2615,11 +3585,48 @@ function handleSendMessage(req, res, ctx) {
                 json(res, 403, { error: "guest_no_commands" });
                 return;
             }
-            const ipc = ctx.instanceIpcClients.get(instance);
-            if (!ipc) {
+            // #2272: a reply names a message this chat still keeps — and, for a guest, one it may see. What it quotes is read
+            // from that row here, never taken from the page.
+            let quoted;
+            if (replyTo) {
+                quoted = ctx.webChatHistory?.find(instance, replyTo.boot, replyTo.id);
+                if (!quoted || quoted.effectTrial || (guest && !guestSeesMessage(quoted, guest, guest.scope()))) {
+                    json(res, 409, { error: t("web.reply_gone"), reason: "reply_gone" });
+                    return;
+                }
+            }
+            const registered = registeredChatInstance(ctx, instance);
+            if (!registered && !ctx.instanceIpcClients.has(instance)) {
                 json(res, 404, { error: `Instance not found: ${instance}` });
                 return;
             }
+            // #1827: who is writing — the name agents and chats see, and the id they tell people apart by. Asked now that the
+            // body is in: a session revoked meanwhile sends nothing (not as the operator).
+            const person = webPersonOf(req, new URL(req.url ?? "/", "http://localhost"), ctx);
+            if (!person) {
+                json(res, 401, { error: WEB_TOKEN_INVALID_MESSAGE });
+                return;
+            }
+            // #2438 follow-up: the page's Retry of a send that already went (its answer and the live copy lost) is that send:
+            // answered with its messageId, delivered once. One still going is waited for; one that failed is sent anew.
+            if (clientId) {
+                const key = WebSendDedupe.key(person.key, instance, clientId);
+                for (;;) {
+                    const seen = webSendDedupeOf(ctx).claim(key);
+                    if (seen.kind === "going") {
+                        await seen.settled;
+                        if (res.destroyed)
+                            return;
+                        continue;
+                    }
+                    if (seen.kind === "accepted") {
+                        json(res, 200, { sent: true, messageId: seen.messageId, repeated: true });
+                        return;
+                    }
+                    claim = seen;
+                    break;
+                }
+            }
             let files = [];
             if (attachments.length > 0) {
                 const taken = ctx.webFiles?.takeForMessage(instance, attachments);
@@ -2639,15 +3646,13 @@ function handleSendMessage(req, res, ctx) {
                 json(res, 403, { error: t("web.raw_public_refused") });
                 return;
             }
+            // Recheck the same admission all the way through a wake, before the facade's actual IPC handoff.
+            const requestUrl = new URL(req.url ?? "/", "http://localhost");
+            const admission = admissionOf(req, requestUrl, ctx);
+            const stillCurrent = () => !res.destroyed && admission !== null && admissionOf(req, requestUrl, ctx) === admission
+                && (!guest || (guest.current() && !guestChatRefusal(guest, instance)))
+                && (registered ? registeredChatInstance(ctx, instance) : ctx.instanceIpcClients.has(instance));
             const message = typed;
-            // #1827: who is writing — the name agents and chats see, and the id they tell people apart by. Asked now that the
-            // body is in: a session revoked meanwhile sends nothing (not as the operator).
-            const person = webPersonOf(req, new URL(req.url ?? "/", "http://localhost"), ctx);
-            if (!person) {
-                ctx.webFiles?.release(files);
-                json(res, 401, { error: WEB_TOKEN_INVALID_MESSAGE });
-                return;
-            }
             // #1939 S1: what the receipt records about who authorized it (observe only: agents still read web as recognition).
             const { authority } = confirmAfterBody(arrival, webAuthorityOf(req, new URL(req.url ?? "/", "http://localhost"), ctx, instance));
             const ts = new Date().toISOString();
@@ -2662,15 +3667,23 @@ function handleSendMessage(req, res, ctx) {
             const topicId = ctx.fleetConfig?.instances[instance]?.topic_id;
             const canEcho = ctx.fleetConfig?.web?.echo_to_channel !== false
                 && !ctx.isClassicInstance?.(instance) && syncAdapter && groupId && topicId != null;
-            // Add no runtime credentials or local attachment paths to the display copy.
-            const preview = webEchoPreview(message, files.map(f => f.name));
+            // Add no runtime credentials or local attachment paths to the display copy. A reply opens with the line it
+            // answers (#2272) — quoted only if that message reached the channel; a web-only one is named, never copied out.
+            const quoteLine = quoted ? webReplyEchoLine(quoted) : "";
+            const plainPreview = webEchoPreview(message, files.map(f => f.name));
+            const preview = (quoteLine ? `${quoteLine}\n` : "") + plainPreview;
+            // #2281: where the quoted message is on a platform. An echo to the same place is a native reply to it there, and
+            // then needs no quoted line; anywhere else (or a message with no known post) keeps the line, as before.
+            const quotedPosts = quoted ? ctx.webChatHistory?.postsOf(quoted) ?? [] : [];
+            const echoText = (p) => formatWebChannelEcho(person.name, p, t("web.echo_full_text"), { guest: !!guest });
             // ClassicBot echo (#1320 part B): same ordering lane, each room's setting (#2054: on unless it says false, or
             // the fleet-wide switch is off for a room that is unset) resolved at send time inside sendClassicWebEcho.
             const canClassicEcho = ctx.isClassicInstance?.(instance) === true && !!ctx.sendClassicWebEcho;
             const settleClassicEcho = canClassicEcho ? ctx.reserveWebChannelEcho?.(instance, async () => {
-                const posted = await ctx.sendClassicWebEcho(instance, formatWebChannelEcho(person.name, preview, t("web.echo_full_text"), { guest: !!guest }), person.name);
+                const copies = [];
+                const posted = await ctx.sendClassicWebEcho(instance, echoText(preview), person.name, copies, quotedPosts.length ? { posts: quotedPosts, text: echoText(plainPreview) } : undefined);
                 if (posted > 0)
-                    ctx.webMessageInChannel?.(instance, messageId); // #1920 §5.2: the room saw it
+                    ctx.webMessageInChannel?.(instance, messageId, copies); // #1920 §5.2: the room saw it (#2305: its copies)
             }) : undefined;
             const settleEcho = canEcho ? ctx.reserveWebChannelEcho?.(instance, async () => {
                 // A replacement adapter or edited binding is not the route we reserved.
@@ -2678,15 +3691,20 @@ function handleSendMessage(req, res, ctx) {
                     || (ctx.getGroupIdForInstance?.(instance) ?? String(ctx.fleetConfig?.channel?.group_id ?? "")) !== groupId
                     || ctx.fleetConfig?.instances[instance]?.topic_id !== topicId)
                     return;
-                const sent = await syncAdapter.sendText(String(groupId), formatWebChannelEcho(person.name, preview, t("web.echo_full_text"), { guest: !!guest }), { threadId: String(topicId), format: "text", allowedMentions: { parse: [] } });
-                ctx.webMessageInChannel?.(instance, messageId); // #1920 §5.2: the topic saw it
+                const native = quotedPosts.find(p => p.adapterId === syncAdapter.id && p.chatId === String(groupId) && (p.threadId ?? "") === String(topicId));
+                const sent = await syncAdapter.sendText(String(groupId), echoText(native ? plainPreview : preview), { threadId: String(topicId), format: "text", allowedMentions: { parse: [] }, ...(native ? { replyTo: native.messageId } : {}) });
+                const copyId = sent && typeof sent === "object" && typeof sent.messageId === "string" ? sent.messageId : "";
+                // #1920 §5.2: the topic saw it. #2305: and where it is, for a reaction to the web message (#2281: and a reply).
+                const reacting = syncAdapter;
+                ctx.webMessageInChannel?.(instance, messageId, copyId
+                    ? [{ adapter: reacting, adapterId: syncAdapter.id, chatId: String(groupId), threadId: String(topicId), messageId: copyId }] : []);
                 return sent;
             }) : undefined;
             let delivered;
             try {
                 const deliver = (name, payload) => ctx.deliverHumanToInstance
-                    ? ctx.deliverHumanToInstance(name, payload, webHumanOrigin(false, authority), typed)
-                    : ctx.deliverToInstance(name, payload);
+                    ? ctx.deliverHumanToInstance(name, payload, webHumanOrigin(false, authority), typed, { stillCurrent })
+                    : ctx.deliverToInstance(name, payload, { stillCurrent });
                 delivered = await deliver(instance, {
                     type: "fleet_inbound",
                     content: delivery.text,
@@ -2701,6 +3719,8 @@ function handleSendMessage(req, res, ctx) {
                         ...(guest ? { web_guest: "1" } : {}), // #1920: "[user:… via web (guest), id:…]" (authority none)
                         adapter_id: syncAdapter?.id,
                         ...delivery.meta,
+                        // #2272: `(reply_to: "…")`, as a Discord or Telegram reply gives the agent.
+                        ...(quoted ? { reply_to_text: webChatReplyText(quoted) } : {}),
                     },
                 });
             }
@@ -2712,7 +3732,7 @@ function handleSendMessage(req, res, ctx) {
                 settleClassicEcho?.(false);
                 ctx.webFiles?.release(files); // not delivered: the same ids can be sent again
                 ctx.logger.error({ err, instance }, "Web message delivery failed");
-                json(res, 503, { error: "Instance delivery failed" });
+                json(res, 503, webDeliveryFailure(err));
                 return;
             }
             if (delivered === false) {
@@ -2720,9 +3740,12 @@ function handleSendMessage(req, res, ctx) {
                 settleClassicEcho?.(false);
                 ctx.webFiles?.release(files);
                 ctx.logger.error({ instance }, "Web message not delivered (the instance went away or restarted)");
-                json(res, 503, { error: "Instance delivery failed" });
+                json(res, 503, { reason: "delivery_changed", error: "The session or instance changed before this message was sent. Sign in again if needed, then retry." });
                 return;
             }
+            // The agent has it: from here on a repeat of this clientId is this send, whatever fails after (the echo, the
+            // stream's copy) — a Retry then gets this messageId, never a second delivery.
+            acceptedId = messageId;
             settleEcho?.(true);
             settleClassicEcho?.(true);
             // #1666: the same cancel/progress bubble a platform inbound starts, in the topic the echo went to — a second turn
@@ -2736,11 +3759,20 @@ function handleSendMessage(req, res, ctx) {
             ctx.lastInboundUser.set(instance, person.name);
             ctx.eventLog?.logActivity("message", person.name, (message || `[${files.length} file(s)]`).slice(0, 200), instance);
             // #1920: the account that wrote it (a guest sees its own); channel-visible once its copy was sent (above).
-            ctx.emitSseEvent("message", { instance, sender: person.name, role: "user", text: message, ts, attachments: files.map(publicAttachment), messageId, ...(person.bound ? { from: person.voterKey } : {}) });
+            ctx.emitSseEvent("message", { instance, sender: person.name, role: "user", text: message, ts, attachments: files.map(publicAttachment), messageId, ...(person.bound ? { from: person.voterKey } : {}),
+                ...(quoted ? { replyTo: webChatReplyRef(quoted) } : {}), ...(clientId ? { clientId } : {}) });
             json(res, 200, { sent: true, messageId });
         }
         catch {
-            json(res, 400, { error: "Invalid JSON" });
+            // A failure after the agent has it is no failed send: the page is told it went (a Retry would only find it).
+            if (res.headersSent) { /* answered already: the failure was in or after the answer */ }
+            else if (acceptedId)
+                json(res, 200, { sent: true, messageId: acceptedId });
+            else
+                json(res, 400, { error: "Invalid JSON" });
+        }
+        finally {
+            claim?.settle(acceptedId);
         }
     });
 }
@@ -2767,7 +3799,7 @@ function handleUpload(req, res, url, ctx) {
         json(res, guestRefused.status, { error: guestRefused.error });
         return;
     }
-    if (!instance || instance.length > 128 || !safeInstanceSegment(instance) || !ctx.instanceIpcClients.has(instance)) {
+    if (!instance || instance.length > 128 || !safeInstanceSegment(instance) || !uploadRecipient(ctx, instance)) {
         json(res, 404, { error: `Instance not found: ${instance}` });
         return;
     }
@@ -2830,11 +3862,9 @@ function handleUpload(req, res, url, ctx) {
     req.on("error", () => drop()); // the client went away
     req.on("close", () => { if (!over && req.complete === false)
         drop(); });
-    // The instance is checked again now the whole body is here: it may have been deleted (and its files
-    // forgotten) or stopped while the upload streamed in; storing now would bring its id back (#1252 review).
-    // Still deliverable means: its IPC is up (a paused one is woken by the send) and it is still registered —
-    // in fleet.yaml, or as a ClassicBot room in classicBot.yaml. Asked when the body ends and again just before storing.
-    const deliverable = () => ctx.instanceIpcClients.has(instance) && (!!ctx.fleetConfig?.instances?.[instance] || ctx.isClassicInstance?.(instance) === true);
+    // Recheck registration and delivery readiness after both waits. A paused recipient may have no IPC;
+    // staging a file never wakes it. A stopped or deleted recipient must not regain an upload id.
+    const deliverable = () => uploadRecipient(ctx, instance);
     const gone = () => drop(() => json(res, 404, { error: `Instance not found: ${instance}` }));
     req.on("end", () => {
         if (over)
@@ -3026,6 +4056,7 @@ function shellBodyTag(req, ctx, mode, viewer) {
         + ` data-usage-panel="${ctx.fleetConfig?.web?.usage_panel === false || viewer?.guest ? "0" : "1"}"`
         // #1218: whether the Log tab is on (web.log_tab; off by default): the tab says so and offers to turn it on.
         + ` data-log-tab="${ctx.fleetConfig?.web?.log_tab === true ? "1" : "0"}"`
+        + ` data-canvas-worker="${canvasWorkerEnabled(ctx.fleetConfig?.web) ? "1" : "0"}"`
         // #1937: the upload limits in force for this page (the config's; the public link's own cap on it) — what the chat
         // checks before sending a file, and the numbers its words say. The server checks again on every upload.
         + ` data-upload-limits="${attr(JSON.stringify(uploadLimits(ctx.fleetConfig?.web, { publicLink: gatewayRequestContext(req) !== undefined })))}"`
@@ -3035,6 +4066,8 @@ function shellBodyTag(req, ctx, mode, viewer) {
         + ` data-owner-css-state="${ownerCssState}"${ownerCss ? ` data-owner-css="${attr(ownerCss)}"` : ""}`
         // #1589: the public link shows attachments as downloads only (no inline text or media): its scope is unchanged.
         + `${gatewayRequestContext(req) ? ' data-public-link="1"' : ""}`
+        // #2478: search is offered over the public link unless web.search.public_link is false (the page then shows no entry).
+        + `${gatewayRequestContext(req) && ctx.fleetConfig?.web?.search?.public_link === false ? ' data-search-link="0"' : ""}`
         // #1920 phase 3: a guest's page — the shell shows only what a guest may use, and who it is signed in as.
         + `${mode === "full" && viewer?.guest && viewer.owner ? guestBodyAttrs(ctx, viewer.owner, attr) : ""}>`;
 }
@@ -3057,7 +4090,7 @@ export function serveAppShell(req, res, ctx, mode) {
         const effectOrigin = gatewayRequestContext(req)?.expectedOrigin ?? dashboardOriginFor(typeof req.headers.host === "string" ? req.headers.host : undefined, isSecureRequest(req));
         const effectFrame = shellEffect(req, ctx, mode) && effectOrigin ? `${effectOrigin}/effect-bootstrap` : null;
         const frameSrc = [previewFrames, effectFrame].filter(Boolean).join(" ");
-        sendPanelHtml(res, html.replace('<html lang="en">', shellHtmlTag(ctx, mode, viewer)).replace("<body>", shellBodyTag(req, ctx, mode, viewer)), 200, {}, { ...(frameSrc ? { frameSrc } : {}), mediaSrc });
+        sendPanelHtml(res, withAppIconLinks(html).replace('<html lang="en">', shellHtmlTag(ctx, mode, viewer)).replace("<body>", shellBodyTag(req, ctx, mode, viewer)), 200, {}, { ...(frameSrc ? { frameSrc } : {}), mediaSrc });
     }
     catch {
         json(res, 500, { error: "app.html not found" });