@songsid/agend 2.3.0-beta.8 → 2.3.0

package/dist/fleet-manager.js

@@ -1,6 +1,7 @@
+import { PUBLIC_TUNNEL_TOKEN_ENV, PUBLIC_TUNNEL_TOKEN_HINT, normalizePublicTunnelToken } from "./public-tunnel-config.js";
 import { humanOwnerObjectId, webHumanOrigin } from "./human-delivery-receipts.js";
 import { SettingsBaselines } from "./settings-baseline.js";
-import { SettingsConfirmationStore } from "./settings-confirmation.js";
+import { SettingsConfirmationStore, settingsSourceLabel } from "./settings-confirmation.js";
 import { SettingsHttpConfirmation } from "./settings-http-confirmation.js";
 import { SettingsControlServer } from "./settings-control.js";
 import { SettingsExecution, settingsRevision, noteSettingsWrite, settingsFileResource, assertSettingsLease, trySettingsLease, waitSettingsLease, settingsUndo, undoSettingsPaths } from "./settings-transaction.js";
@@ -8,10 +9,13 @@ import { performance } from "node:perf_hooks";
 import { withSpawnHoldReply } from "./spawn-hold-reply.js";
 import { gatewayRequestContext } from "./web-request-context.js";
 import { createPublicWebGateway, PUBLIC_GATEWAY_RECEIVE_MS } from "./public-web-gateway.js";
-import { handleWebIconRequest } from "./web-icons.js";
+import { handleWebIconRequest, useAppIconStore } from "./web-icons.js";
+import { AppIconStore } from "./web-app-icon.js";
 import { trackWebServer } from "./web-server-drain.js";
 import { renderPublicLinkProgress, ThrottledMessageEditor } from "./public-link-progress.js";
-import { PublicWebLink, publicLinkSettings } from "./public-web-link.js";
+import { PublicWebLink, publicLinkNamedHostname, publicLinkSettings } from "./public-web-link.js";
+import { PublicLinkAutoOpen } from "./public-link-auto-open.js";
+import { clearPublicLinkOwner, readPublicLinkOwner, writePublicLinkOwner } from "./public-link-owner.js";
 import { PUBLIC_PREVIEW_FRAME_SRC, PUBLIC_PREVIEW_TUNNEL_DIR, PublicPreview, publicPreviewWanted } from "./public-preview.js";
 import { CloudflaredProvider } from "./tunnel/cloudflared.js";
 import { TunnelPurposeLane } from "./tunnel/purpose-lane.js";
@@ -20,24 +24,27 @@ import { withinBudget } from "./monotonic-budget.js";
 import { measureSyncWork } from "./sync-work-attribution.js";
 import { RuntimeCpuProfiler, ProfileBusyError, profileDuration } from "./runtime-cpu-profile.js";
 import { ProfileControlServer } from "./profile-control.js";
-import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, realpathSync, constants as fsConstants, closeSync } from "node:fs";
+import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, realpathSync, lstatSync, constants as fsConstants, closeSync } from "node:fs";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { freemem, totalmem, cpus, homedir } from "node:os";
 import { createServer } from "node:http";
 import { Worker } from "node:worker_threads";
 import { ProbeWorkerPool } from "./probe-worker-pool.js";
-import { join, dirname, basename, delimiter, isAbsolute, resolve as resolvePath } from "node:path";
+import { join, dirname, basename, delimiter, isAbsolute, relative, resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
 import { fleetLabel } from "./fleet-label.js";
 import { beginFullRestartProgress as persistFullRestartProgress, beginUpdateProgress as persistUpdateProgress, clearUpdateMarker, isUpdateInProgress, readUpdateProgress, sameUpdateMarker, setUpdateProgressStage, updateMarkerIdentity, updateProgressOperation, updateReceiptOf, } from "./update-marker.js";
 import { formatUpdateProgress } from "./update-progress.js";
 import { sdNotify, sdNotifyBlocking, setSdNotifyWarn } from "./sd-notify.js";
+import { StartupMemoryDeadline, fleetStopConcurrency } from "./startup-memory-deadline.js";
 import { readFleetMemory } from "./process-memory.js";
 import { MemoryPressure } from "./memory-pressure.js";
 import { replyDedupText, ReplyDeduper } from "./reply-dedup.js";
 import { isMap, isScalar, parseDocument } from "yaml";
+import { changedOutside, detachForWrite } from "./yaml-shared-nodes.js";
+import { tmuxExecHelper } from "./tmux-exec-helper.js";
 import { kiroLogGate } from "./kiro-log-gate.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -71,10 +78,14 @@ import { createLogger, rotateLogIfNeeded } from "./logger.js";
 import { processAttachments } from "./channel/attachment-handler.js";
 import { routeToolCall } from "./channel/tool-router.js";
 import { Scheduler } from "./scheduler/index.js";
+import { boardActivity, boardCardLimit, boardToolAction } from "./task-board-tool.js";
+import { TaskBoardWaker } from "./task-board-waker.js";
+import { TaskBoardError, waitsForPerson, wrapUpGap } from "./scheduler/task-board.js";
 import { escapeTelegramHtml, scheduleClock, scheduleRetryLabel } from "./scheduler/retry-label.js";
 import { DEFAULT_SCHEDULER_CONFIG } from "./scheduler/index.js";
-import { TopicCommands, saveCommandForBackend, parseSaveFilename, parsePauseWakeCommand, parseCompactCommand, SAVE_FILENAME_RE, resolveInstanceContext, forgetInstanceContext, readStatuslineModel } from "./topic-commands.js";
+import { TopicCommands, saveCommandForBackend, parseSaveFilename, parsePauseWakeCommand, parseCompactCommand, SAVE_FILENAME_RE, resolveInstanceContext, forgetInstanceContext, readStatuslineJson, statuslineModel } from "./topic-commands.js";
 import { DailySummary } from "./daily-summary.js";
+import { TaskBoardSummaryClock, buildSummary, isQuiet, renderSummary, summaryMarkFile, summaryTime } from "./task-board-summary.js";
 import { WebhookEmitter } from "./webhook-emitter.js";
 import { TmuxControlClient } from "./tmux-control.js";
 import { safeHandler } from "./safe-async.js";
@@ -101,7 +112,8 @@ export const TASK_LIST_CAP = 100;
  * #1336: the non-terminal statuses a bare `list` returns by default. `done`
  * and `cancelled` are excluded unless the caller passes `filter_status`.
  */
-export const LIVE_TASK_STATUSES = ["open", "claimed", "blocked"];
+/** Not finished: `review` is done work waiting for the person (the task board), still live. */
+export const LIVE_TASK_STATUSES = ["open", "claimed", "blocked", "review"];
 /**
  * #1336 P2: shared normalization for filter_status across both task handlers
  * and the cap helper. Trims whitespace before dropping empties, so
@@ -135,15 +147,17 @@ export function applyTaskListCap(tasks, filterAssignee, filterStatus) {
     }
     return tasks;
 }
-import { handleWebRequest, broadcastSseEvent, broadcastToGuests, SSE_HEARTBEAT_MS } from "./web-api.js";
+import { handleWebRequest, webPeerOf, broadcastSseEvent, broadcastToGuests, SSE_HEARTBEAT_MS } from "./web-api.js";
 import { LogService } from "./log-service.js";
 import { WebChatHistory, WEB_CHAT_TEXT_MAX, isWebMessageId, newWebMessageId, webChatFrom } from "./web-chat-history.js";
+import { WEB_ECHO_COPIES_MAX, WEB_MIRROR_TIMEOUT_MS, webReactionEmoji, webReactionProblem } from "./web-reactions.js";
 import { WebChatDiskStore } from "./web-chat-store.js";
 import { SeenUsers, resolveMentions } from "./web-mentions.js";
 import { OPERATOR, WebPrefsStore } from "./web-prefs.js";
 import { agendVersion } from "./agent-whats-new.js";
 import { OwnerCssStore } from "./web-owner-css-store.js";
 import { ThemeStore } from "./web-theme-store.js";
+import { OfficeStore, OfficeWriteLimiter } from "./web-office-store.js";
 import { WebAppearance } from "./web-appearance.js";
 import { WebEffectLibrary } from "./web-effect-library.js";
 import { WebEffectTrials } from "./web-effect-trials.js";
@@ -159,7 +173,7 @@ import { ReplyButtonsController } from "./reply-buttons-controller.js";
 import { parsePoll } from "./reply-polls.js";
 import { isUploadRequest, limitRequestReceive, publicAttachment, sweepOrphanedUploads, UPLOAD_REQUEST_TIMEOUT_MS, uploadLimits, WebFileLedger } from "./web-upload.js";
 import { REPLY_FILES_MAX_BYTES, snapshotReplyFile, sweepReplySnapshots, webFilesDir } from "./web-reply-files.js";
-import { cardPicture, handleViewRequest, humanCards, identityColors, isViewPath, personBannerFocus, personIdentityColour, profileIdentities, resolveInstanceIdentity, setPersonBannerFocus, setPersonIdentityColour } from "./view-api.js";
+import { cardPicture, handleViewRequest, humanCards, identityColors, instanceTeams, isViewPath, personBannerFocus, personIdentityColour, profileIdentities, resolveInstanceIdentity, setPersonBannerFocus, setPersonIdentityColour } from "./view-api.js";
 import { autoIdentityColor } from "./web-identity-color.js";
 import { AppearanceTools } from "./web-appearance-tools.js";
 import { cardVersion, resolveCard } from "./web-card.js";
@@ -179,15 +193,18 @@ import { runOnLoginShell } from "./login-shell.js";
 import { tightenInstanceDirs } from "./private-dir.js";
 import { decideSlash } from "./slash-authz.js";
 import { canonicalCommand, commandSpec, decideCommand, ruleFor } from "./command-table.js";
-import { crossInstanceVisibility, runVisibilityCommand } from "./cross-instance-notice.js";
+import { crossInstanceVisibility, runVisibilityCommand, xmsgVisibility } from "./cross-instance-notice.js";
+import { SEARCH_RETENTION_DAYS, SearchIndex } from "./search/search-index.js";
+import { chatDoc, taskDoc, xmsgDoc } from "./search/search-docs.js";
 import { WebSettingsTools } from "./web-settings-tools.js";
 import { bindGuestRequest, guestRouteDecision } from "./web-guest-access.js";
 import { GUEST_ROOM_TICK_MS, GuestRoomMembership, guestGroupRooms } from "./web-guest-rooms.js";
-import { TrafficLog, trafficItem } from "./fleet-traffic.js";
+import { Delegations, TrafficLog, trafficItem } from "./fleet-traffic.js";
 import { installedChannel, updateNoticeKey } from "./update-check.js";
 import { resolveInstalledAgend } from "./update-dispatch.js";
 import { resolveUpdateLaunch, openUpdateLog, updateLogPath, watchUpdateLaunch } from "./update-launch.js";
 import { admitProfileLogin, LoginController, LOGIN_TOKEN_RESEND_PREFIX, POST_LOGIN_RECOVERY_DEADLINE_MS } from "./login-controller.js";
+import { WebBackendLogins, dashboardSignInSupported } from "./web-backend-login.js";
 import { runBeforeDeadline } from "./deadline.js";
 import { LoginWindowLock } from "./login-window-lock.js";
 import { handleSettingsRequest } from "./settings-api.js";
@@ -200,6 +217,7 @@ import { assertExplicitInstanceRemoval } from "./instance-removal.js";
 import { KNOWN_BACKENDS, validateFleetConfig } from "./config-validator.js";
 import { isRemovedBackend, removedBackendMessage } from "./backend/removed.js";
 import { presentationState, interactionSummary, sameInteractionOwner } from "./interaction-observation.js";
+import { idleGateTimeoutLog } from "./idle-gate-log.js";
 import { DEFAULT_STUCK_TIMEOUT_MS, readLastInboundAt } from "./daemon.js";
 import { clearPausedMarker, readPausedAt, readPauseReason, writePausedMarker } from "./pause-marker.js";
 import { readBackgroundWorkEndedMarker } from "./background-work-ended.js";
@@ -222,9 +240,10 @@ import { CompactWatch, launchIdentity } from "./compact-watch.js";
 import { agyLegacyAgentsFile, danglingSymlink, migrateAgyAgentsFile } from "./backend/antigravity.js";
 import { claudeConfigDirFor, claudeProjectKey } from "./backend/claude-code.js";
 import { sharedRolloutIndex } from "./rollout-index.js";
+import { TASK_BOARD_ON_NOTICE, dashboardRefusalIn, taskBoardSwitchedOn } from "./dashboard-permissions.js";
 import { mayUseTool, resolveToolSet, scheduleOpRefusal, toolForIpcType, toolRefusedMessage, } from "./tool-permissions.js";
-import { authorizeSession, decideWebGate, loadOrCreateWebToken, readWebToken } from "./web-auth.js";
-import { bypassesWebGate, handleAuthRequest, serveSigninPage } from "./auth-api.js";
+import { authorizeSession, decideWebGate, loadOrCreateWebToken, readWebToken, sessionCookieUpgrade } from "./web-auth.js";
+import { bypassesWebGate, handleAuthRequest, serveGuestRefusedPage, serveSigninPage } from "./auth-api.js";
 import { isWebPageNavigation } from "./web-shell-routes.js";
 import { guestSessionPolicy, localSessionPolicy, tokenEpoch, WebSessionStore } from "./web-session.js";
 import { authorityNow, evaluateWebAuthority, VERIFIED_SESSION_HOURS, webAuthorityPolicy } from "./authority/web-authority.js";
@@ -232,25 +251,31 @@ import { AuthorityStateStore } from "./authority/authority-state.js";
 import { SessionAuthorizations } from "./authority/session-authorizations.js";
 import { SessionAuthorizationRequests } from "./web-session-authorization.js";
 import { GuestLoginCodes, WebLoginCodes, LOGIN_CODE_TTL_MS } from "./web-login.js";
+import { decisionListAnswer } from "./decision-list.js";
 import { CodeRequestLimiter, ReturningDevices } from "./web-returning-device.js";
 import { allowedHostNames, applyWebSecurityHeaders, hostnameOf, isHostAllowed, LOOPBACK_HOST_NAMES, WEB_HOST_REJECTED_MESSAGE } from "./web-host-guard.js";
 import { createPreviewListener, normalizeOrigin, previewAvailability, previewSettings } from "./web-preview.js";
+import { canvasWorkerEnabled, isCanvasWorkerTool, CANVAS_WORKER_EXPERIMENTAL_MESSAGE } from "./web-experimental.js";
+import { isCanvasWorkerHttpPath } from "./web-experimental-http.js";
+import { bundledSkillContents } from "./bundled-skills.js";
 import { createEffectBootstrap } from "./web-effect-bootstrap.js";
 import { fleetLevelDifferences, fleetLevelSignature, appendedConnections } from "./fleet-level-config.js";
 import { checkSelfRestartAllowance, recordSelfRestartAttempt } from "./self-restart-limit.js";
 import { SecretStore } from "./secret-store.js";
 import { opaqueId, safeSecretError, SECRET_CHALLENGE_TTL_MS, } from "./connection-secrets.js";
 import { verifyDiscordToken, verifyTelegramToken } from "./provider-probe.js";
-import { PROVIDER_SECRET_SPECS, providerSecretSpec, providerRegistryEnvKeys, isReservedProviderEnvKey, verifyProviderSecret, } from "./provider-secret-registry.js";
+import { PROVIDER_SECRET_SPECS, PUBLIC_TUNNEL_SECRET_SPEC, providerSecretSpec, providerRegistryEnvKeys, isReservedProviderEnvKey, verifyProviderSecret, } from "./provider-secret-registry.js";
 /** A self-restart is a whole service restart; 120s is the apply budget, not this. */
 const SELF_RESTART_DEADLINE_MS = 300_000;
 import { APPLY_FLEET_TARGET, ApplyJobStore, viewOf, } from "./apply-job.js";
-import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialProfileLogin, credentialProfileStoreHome, credentialSwitchCarriesConversation, credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
+import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialProfileLogin, credentialProfileLoginCommand, credentialProfileStoreHome, credentialSwitchCarriesConversation, credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
 import { carryClaudeConversation } from "./backend/claude-carry.js";
 import { mergeBackendOptions, profileKey, profileName, profileOf } from "./classic-bindings.js";
 import { classifyInstanceChange, CLASSIC_HOT_CONFIG_KEYS, HOT_INSTANCE_CONFIG_KEYS, hotConfigUpdate, } from "./instance-config-impact.js";
-import { cleanupWatchVerdict, formatRestartProgressCompletion, RESTART_PROGRESS_TERMINAL_TIMEOUT_MS, RestartProgress, } from "./restart-progress.js";
+import { cleanupWatchVerdict, formatRestartProgressCompletion, RestartProgress, } from "./restart-progress.js";
+import { FleetStartup } from "./fleet-startup.js";
 import { launchFullRestartHelper } from "./full-restart.js";
+import { fullReloadExitCode } from "./service-owner.js";
 import { SYSTEMD_RESTART_INDETERMINATE_EXIT_CODE } from "./service-restart-selection.js";
 import { collectRedundantInstanceDefaultPaths } from "./fleet-yaml-slim.js";
 import { StormWindow } from "./storm-window.js";
@@ -258,6 +283,14 @@ import { SpawnGate } from "./spawn-gate.js";
 import { BackendOutageTracker } from "./backend-outage.js";
 import { canUnlockAdvancedTips, DailyTipScheduler, selectTip, visibleTipLevels, } from "./tips.js";
 import { getTmuxSession } from "./config.js";
+// Closed migration cohort: these 11 names existed immediately before the first
+// managed-skill publisher (a1ac499f; parent e267e684). Never grow this set when
+// adding a bundled skill: its new name is not proof of old AgEnD ownership.
+const PRE_MANIFEST_KIRO_SKILLS = new Set([
+    "backend-providers", "cross-instance-messaging", "fleet-config", "fleet-health",
+    "fleet-restart", "instance-lifecycle", "model-discovery", "multi-channel",
+    "scheduling", "session-management", "tui-effort",
+]);
 export function resolveReplyThreadId(argsThreadId, instanceConfig) {
     if (typeof argsThreadId === "string" && argsThreadId.length > 0) {
         return argsThreadId;
@@ -294,6 +327,41 @@ export function selectLruEvictions(warm, cap, opts) {
  * fleet.yaml. Keep in sync with `uniqueInstanceName` — every name it emits
  * must match here, or a deleted instance's CLI is left running (#1305 P2-3).
  */
+/**
+ * #2163: where `p` really is — symlinks resolved. A path that does not exist yet is resolved through its deepest
+ * existing ancestor (a missing child of a link elsewhere is elsewhere too).
+ */
+function realPathThroughAncestors(p) {
+    const missing = [];
+    let at = resolvePath(p);
+    for (;;) {
+        try {
+            return join(realpathSync(at), ...missing.reverse());
+        }
+        catch { /* not there yet: try its parent */ }
+        try {
+            lstatSync(at);
+            return null;
+        }
+        catch { /* truly absent — not a broken link whose target is unknown */ }
+        const up = dirname(at);
+        if (up === at)
+            return resolvePath(p);
+        missing.push(basename(at));
+        at = up;
+    }
+}
+/**
+ * #2163: whether `dir` is inside AgEnD's own workspaces (<AGEND_HOME>/workspaces/<name>/…), compared after resolving
+ * symlinks on both sides — including a missing folder's existing ancestors — so a link elsewhere is not inside, nor is a broken link.
+ */
+export function insideManagedWorkspaces(dir, agendHome = getAgendHome()) {
+    const root = realPathThroughAncestors(join(agendHome, "workspaces")), real = realPathThroughAncestors(dir);
+    if (root === null || real === null)
+        return false;
+    const rel = relative(root, real);
+    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
 export function isOrphanInstanceWindowName(name) {
     return /-t\d+$/.test(name) || /^classic-/.test(name);
 }
@@ -553,6 +621,8 @@ export class FleetManager {
     fleetConfig = null;
     rawFleetConfig = {};
     rawFleetDocument = null;
+    /** #2208: the paths a saveFleetConfig() wrote, for its check that nothing else changed. */
+    fleetDocumentWrites = null;
     savedFleetConfigSnapshot = null;
     adapter = null;
     worlds = new Map();
@@ -608,7 +678,8 @@ export class FleetManager {
     ]);
     logger = createLogger("info");
     /** Report each bundled skill collision once per fleet, across instance starts. */
-    skippedBundledSkills = new Set();
+    /** #2482: per skills directory, the skipped set (names + their content) last said — this process's view of the record. */
+    skippedSkillsSaid = new Map();
     topicCommands;
     // sessionName → instanceName mapping for external sessions
     sessionRegistry = new Map();
@@ -616,7 +687,11 @@ export class FleetManager {
     costGuard = null;
     statuslineWatcher;
     dailySummary = null;
+    /** #2246 step 3: the task board's daily summary for the person (task-board-summary.ts). */
+    taskBoardSummary = null;
     dailyTipScheduler = null;
+    /** The task board's wakes (step 2): an instance hears when someone else changes a card it owns or handed out. */
+    taskBoardWaker = null;
     webhookEmitter = null;
     // Topic icon + auto-archive state
     topicIcons = {};
@@ -745,7 +820,11 @@ export class FleetManager {
     // Adapter restart: prevents re-entrant restart attempts
     adapterRestarting = new Set();
     // Adapter isolation: track state per adapter for retry + visibility
+    /** #2175: this boot's progress message, whose completion may still be owed by its background retry. */
+    startupProgress = null;
+    startupDashboard = null;
     adapterState = new Map();
+    adapterRetryInFlight = new Map();
     /** Web Settings secret rotation is deliberately separate from reconnect
      * recovery: a rotation must build a fresh provider client with the new token,
      * and stale callbacks from the old client must not win. */
@@ -787,6 +866,7 @@ export class FleetManager {
     effectBootstrap = createEffectBootstrap();
     /** Fixed trusted document coherence, independent of the HTML preview listener; never a resource grant. */
     get effectBoot() { return this.effectBootstrap.boot; }
+    canvasWorkerEnabled() { return canvasWorkerEnabled(this.fleetConfig?.web); }
     healthServerDrain = null;
     /** #1306: the preview listener (health_port + 1 by default), and whether it is listening. */
     previewListener = null;
@@ -824,6 +904,7 @@ export class FleetManager {
     /** Days of event/activity history to keep. */
     static EVENT_LOG_RETENTION_DAYS = 30;
     watchdogTimer = null;
+    startupMemoryDeadline = null;
     eventLoopWatch = null;
     startedAt = 0;
     stormOpenNotifyTimer = null;
@@ -852,11 +933,35 @@ export class FleetManager {
     webChatHistory = new WebChatHistory();
     /** #1565: the web chat history's files (set at fleet start, once the home and the instances are known). */
     webChatStore = null;
+    /** #2293: the dashboard's global search (null: web.search.enabled is false, or the fleet has not started). */
+    searchIndex = null;
     /** Uploaded files and the files the dashboard may fetch back (uploads, reply attachments). */
     // #1937: the upload limits are the config's, read on each use (agend reload applies a change to the next upload).
     webFiles = new WebFileLedger({ limits: () => uploadLimits(this.fleetConfig?.web) });
     /** #1770: per instance, its last web reply still copying its files — the next one is shown after it, in order. */
     webReplyOrder = new Map();
+    /**
+     * #1774: an instance name's reply generation — moved on when a removal of it starts, so replies sent from then on (a
+     * same-name replacement's) are told from the removed instance's. `webChatRemovals`: once a removal succeeded, the
+     * generations and the daemon whose replies are no longer anyone's to show.
+     */
+    webChatGenerations = new Map();
+    webChatRemovals = new Map();
+    /** #1774: a removal under way — its replies' fate waits for its outcome (success: theirs no more; failure: theirs). */
+    webChatRemovalsPending = new Map();
+    webChatGeneration(name) { return this.webChatGenerations.get(name) ?? 0; }
+    /** #1774: who an instance's reply is from, taken when it is sent: the name's generation and its daemon then. */
+    webChatIdentity(name) { return { generation: this.webChatGeneration(name), daemon: this.daemons.get(name) }; }
+    /** #1774: the reply's instance was not removed (a removal that failed changes nothing). */
+    webChatIdentityCurrent(name, id) {
+        const removed = this.webChatRemovals.get(name);
+        return !removed || (id.generation >= removed.below && (removed.daemon === undefined || id.daemon !== removed.daemon));
+    }
+    /** #1774: the removal still deciding this reply's fate (it was sent by what is being removed), or null. */
+    webChatRemovalPending(name, id) {
+        const pending = this.webChatRemovalsPending.get(name);
+        return pending && (id.generation < pending.below || (pending.daemon !== undefined && id.daemon === pending.daemon)) ? pending.done : null;
+    }
     /** #1770: an instance's web-files byte cap (a field, so a test can make it small). */
     webReplyMaxBytes = REPLY_FILES_MAX_BYTES;
     /** #1682: the people seen on inbound messages (id → name), for the web chat's mention pills; bounded, in memory. */
@@ -942,6 +1047,11 @@ export class FleetManager {
         // r4.1 Q3 (b): the card's limits are read from fleet.yaml at each upload (a change applies without a restart).
         return (this.themeStoreInstance ??= new ThemeStore(this.dataDir, { limits: () => effectiveAppearanceLimits(this.fleetConfig?.web?.appearance).limits, effectsDropped: ids => this.effectLibrary.collectUnreferenced(ids) }));
     }
+    officeStoreInstance;
+    /** Fleet → Org chart → Office: the offices people made (web-offices.json, beside web-themes.json). */
+    get officeStore() { return (this.officeStoreInstance ??= new OfficeStore(this.dataDir)); }
+    /** How often a person may save the offices (PUT /ui/offices); memory only, as the appearance limiter. */
+    officeWrites = new OfficeWriteLimiter();
     /** #1629: the theme tools, a person's reset and lock, and the one appearance rate limiter (shared with effects). */
     get webAppearance() {
         return (this.webAppearanceService ??= new WebAppearance(this.themeStore, () => this.fleetConfig?.web ?? null, () => { try {
@@ -1031,6 +1141,7 @@ export class FleetManager {
     /** #1629 r4 §1: get_web_appearance / preview_web_appearance — the caller's own look, resolved as the page resolves it. */
     get appearanceTools() {
         return (this.appearanceToolsService ??= new AppearanceTools({
+            canvasWorkerEnabled: () => this.canvasWorkerEnabled(),
             frame: (name) => (this.getUiStatus().instances.find(i => i.name === name) ?? { name }),
             theme: (name) => {
                 const r = this.themeStore.get(name);
@@ -1075,6 +1186,7 @@ export class FleetManager {
             prefs: this.webPrefs,
             ownerCss: this.ownerCss,
             effects: this.effectLibrary,
+            canvasWorkerEnabled: () => this.canvasWorkerEnabled(),
             context: () => ({ agendVersion: agendVersion(), limits: this.themeStore.limits(), effects: cw1EffectChecker() }),
             isKnownInstance: (name) => this.isKnownInstance(name),
             prefsIdentity: OPERATOR,
@@ -1113,6 +1225,11 @@ export class FleetManager {
         const card = resolveCard(name, humanCards(this.dataDir).get(name), this.themeStore.get(name).theme.card);
         return { ...(card.tagline ? { tagline: card.tagline.text } : {}), ...(card.bio ? { bio: card.bio.text } : {}) };
     }
+    appIconStore;
+    /** #2308: the person's own app icon (Settings → Web appearance), under the state dir; none set: the bundled one. */
+    get appIcon() {
+        return (this.appIconStore ??= new AppIconStore(this.dataDir));
+    }
     ownerCssStore;
     /** #1629 r4 §3: each person's own CSS; which version is in force is their `css.active` in the web preferences. */
     get ownerCss() {
@@ -1125,6 +1242,7 @@ export class FleetManager {
      */
     get webSettings() {
         return (this.webSettingsToolsService ??= new WebSettingsTools({
+            canvasWorkerEnabled: () => this.canvasWorkerEnabled(),
             prefs: this.webPrefs, ownerCss: this.ownerCss, mods: this.mods, effects: this.effectService,
             instances: () => [...Object.keys(this.fleetConfig?.instances ?? {}),
                 ...(this.classicChannels?.getAll() ?? []).map((ch) => ch.instanceName).filter((n) => !Object.hasOwn(this.fleetConfig?.instances ?? {}, n))],
@@ -1242,9 +1360,11 @@ export class FleetManager {
                     return null;
                 const record = auth.session, sessions = this.webSessions, exposure = gatewayRequestContext(req);
                 return { id: record.idHash, label: record.label, source: exposure ? "public_link" : "web_session",
+                    localAdmin: () => record.tier === "admin" && record.surface === "local" && !exposure,
                     current: () => current() && sessions === this.webSessions && !!this.webToken
                         && sessions.isCurrent(record, tokenEpoch(this.webToken)) && (!exposure || exposure.isCurrent()) };
             }, baseline: () => baselines.read(), snapshot: () => baselines.snapshot(),
+            selfConfirm: (req, id) => this.settingsSelfConfirmation(store, req, id),
             job: async (id) => {
                 const settlement = this.settingsJobSettlements.get(id);
                 if (!settlement)
@@ -1259,6 +1379,93 @@ export class FleetManager {
         this.settingsConfirmation = gate;
         return gate;
     }
+    /**
+     * #2170: a held change confirmed by the request itself — only when ALL hold, else the chat card or the host CLI, as
+     * before:
+     *   - the session is web-verified (#1939: its account confirmed this browser on Discord or Telegram), asked now;
+     *   - the change's effect owners are known and on one platform (settingsChatAuthority — the chat card's own rule), the
+     *     verified account is on that platform and an admin of every one of them;
+     *   - a chat card could have been asked: a connected General on that platform the change does not affect (else the
+     *     change goes to the host CLI, as before) — the General that then hears of it;
+     *   - and, at execution (store.decide asks `current()` again): still web-verified under the same session and account
+     *     (not expired, revoked, signed out or the switch turned off), still those owners' admin, still a General a card
+     *     could go to, the fleet unchanged.
+     * What it rests on: the account's one confirmation of this browser (#1939), kept for the session until it is revoked,
+     * expires or signs out — not a fresh confirmation per Apply. Whoever uses that verified session (a browser left signed
+     * in, its cookie) confirms the same way. A public link never qualifies (evaluateWebAuthority refuses it). General
+     * still hears it: a notice, not a step.
+     */
+    settingsSelfConfirmation(store, req, id) {
+        const auth = authorizeSession(req, this.webToken, this.webSessions, { touch: false });
+        if (auth.kind !== "ok")
+            return null;
+        // #2453 (§0.2): never over the public link — not even a named-link session that is web-verified there.
+        if (gatewayRequestContext(req))
+            return null;
+        // …and never a change that turns the named-link option on: that one needs a General's card or the host.
+        if (!store.selfConfirmable(id))
+            return null;
+        const record = auth.session, gateway = !!gatewayRequestContext(req), peer = webPeerOf(req);
+        const verified = () => {
+            const now = this.webAuthority({ session: record, gateway, peer });
+            // A refusal carries no authority (kind "none"); the handle pins the session, and with it its one account.
+            return now.authority.kind === "web-verified" && now.authority.actor && now.authority.session?.handle === record.handle ? now.authority.actor : null;
+        };
+        const actor = verified();
+        if (!actor)
+            return null;
+        const chat = this.settingsChatAuthority(store, id);
+        if (!chat)
+            return null;
+        const channels = this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : []);
+        const own = channels.filter(ch => (ch.id ?? ch.type) === actor.adapter_id);
+        if (own.length !== 1 || own[0].type !== chat.platform || !chat.admin(actor.user_id))
+            return null;
+        const affected = [...store.affectedConnections(id)]; // read now: a finished change no longer has them
+        if (!this.settingsNoticeGenerals(affected, chat.platform).length)
+            return null;
+        const name = this.webPerson({ adapterId: actor.adapter_id, userId: actor.user_id }).name;
+        return {
+            label: t("settings_confirm.web_verified_label", name),
+            // admin() asks chat.current() too; a General a card could go to must still be there (else the host CLI's).
+            current: () => !!verified() && chat.admin(actor.user_id) && this.settingsNoticeGenerals(affected, chat.platform).length > 0,
+            done: view => this.settingsWebConfirmedNotice(view, affected, name, chat.platform),
+        };
+    }
+    /** #2170: the Generals a chat card could be posted in (promptSettingsChange's rule): connected, on the platform, unaffected. */
+    settingsNoticeGenerals(affected, platform) {
+        const excluded = new Set(affected), found = [];
+        for (const [name, config] of Object.entries(this.fleetConfig?.instances ?? {})) {
+            if (!config.general_topic || !this.daemons.get(name))
+                continue;
+            const adapterId = this.getInstanceAdapterId(name), adapter = this.getAdapterForInstance(name);
+            if (!adapterId || !adapter || excluded.has(adapterId) || adapter.type !== platform || this.adapterState.get(adapterId)?.status !== "connected")
+                continue;
+            const chatId = this.getGroupIdForInstance(name), topic = String(config.topic_id ?? "");
+            if (chatId && topic)
+                found.push({ adapterId, adapter, chatId, topic });
+        }
+        return found;
+    }
+    /**
+     * #2170: General's notice of a change confirmed from the web — the first General a chat card could have been posted
+     * in, plain text, no mentions. Information only: nothing waits on it.
+     */
+    async settingsWebConfirmedNotice(view, affected, who, platform) {
+        const outcome = view.outcome ? view.outcome.message : view.state;
+        const text = [t("settings_confirm.web_confirmed", who), t("settings_confirm.source", settingsSourceLabel(view.source)),
+            t("settings_confirm.requester", view.requested_by), ...view.summary, t("settings_confirm.outcome", outcome)].join("\n");
+        for (const { adapterId, adapter, chatId, topic } of this.settingsNoticeGenerals(affected, platform)) {
+            try {
+                await adapter.sendText(chatId, text, { threadId: topic, allowedMentions: { parse: [] } });
+                return;
+            }
+            catch {
+                this.logger.info({ id: view.id, adapterId }, "Settings web-confirmation notice unavailable; trying another General");
+            }
+        }
+        this.logger.info({ id: view.id }, "Settings change confirmed from the web: no General reachable for the notice");
+    }
     /** Exact configured effect owners; this does not depend on prompt location. */
     settingsChatAuthority(store, id) {
         const scope = store.authorityOf(id);
@@ -1329,9 +1536,10 @@ export class FleetManager {
             try {
                 const posted = this.postNonceButtonPromptOrThrow({ prefix: "settings-confirm:", alertType: "clear_confirm",
                     instanceName: name, adapterId, adapter, chatId, threadId: topic,
-                    message: `🔒 Settings change awaiting fleet-admin confirmation\nSource: ${view.source}\nRequester: ${view.requested_by}\n${view.summary.join("\n")}`,
-                    choices: [{ action: "confirm", label: "Confirm" }, { action: "reject", label: "Reject" }],
-                    expiredText: "Settings confirmation is no longer pending.", timeoutMs: view.remaining_ms,
+                    message: [t("settings_confirm.prompt_title"), t("settings_confirm.source", settingsSourceLabel(view.source)),
+                        t("settings_confirm.requester", view.requested_by), ...view.summary].join("\n"),
+                    choices: [{ action: "confirm", label: t("settings_confirm.confirm_button") }, { action: "reject", label: t("settings_confirm.reject_button") }],
+                    expiredText: t("settings_confirm.no_longer_pending"), timeoutMs: view.remaining_ms,
                     extra: { pendingChangeId: view.id, confirmationCurrent: current, confirmationAdmin: userId => current() && authority.admin(userId) },
                 });
                 void posted.then(nonce => {
@@ -1342,7 +1550,7 @@ export class FleetManager {
                         return;
                     this.pendingNonceButtons.delete(nonce);
                     clearTimeout(entry.timer);
-                    void this.retireNonceButtons(entry, entry.messageId ?? "", "Settings confirmation delivery expired.");
+                    void this.retireNonceButtons(entry, entry.messageId ?? "", t("settings_confirm.delivery_expired"));
                 }, () => { });
                 const nonce = await withinBudget(posted, postingDeadline);
                 attached = true;
@@ -1352,7 +1560,7 @@ export class FleetManager {
                         return;
                     this.pendingNonceButtons.delete(nonce);
                     clearTimeout(entry.timer);
-                    void this.retireNonceButtons(entry, entry.messageId ?? "", "Settings confirmation is no longer pending.");
+                    void this.retireNonceButtons(entry, entry.messageId ?? "", t("settings_confirm.no_longer_pending"));
                 };
                 if (!current()) {
                     retire();
@@ -1378,14 +1586,14 @@ export class FleetManager {
         const { entry, action } = result;
         try {
             const view = await this.settingsGate().store.decide(entry.pendingChangeId, action, {
-                label: `fleet admin ${data.userId}`,
+                label: t("settings_confirm.admin_label", data.userId ?? ""),
                 current: () => entry.confirmationCurrent?.() === true && this.getAdapterForInstance(entry.instanceName) === entry.adapter
                     && !!data.userId && entry.confirmationAdmin?.(data.userId) === true,
             });
-            await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, view.outcome?.message ?? "Settings change is applying.");
+            await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, view.outcome?.message ?? t("settings_confirm.applying"));
         }
         catch {
-            await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, "Settings confirmation rejected or expired.");
+            await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("settings_confirm.rejected_or_expired"));
         }
         return true;
     }
@@ -1464,6 +1672,7 @@ export class FleetManager {
         this.spawnGate = new SpawnGate({
             storm: this.stormWindow,
             memoryPressure: this.memoryPressure,
+            onStartupMemoryWait: () => this.startupMemoryDeadline?.check(),
             concurrency: () => this.spawnConcurrency(),
             staggerMs: () => this.fleetConfig?.defaults?.startup?.stagger_delay_ms ?? 500,
         });
@@ -1654,7 +1863,10 @@ export class FleetManager {
                         : t(`delivery.fleet_${row.state}`, row.targetInstance, row.operationId, row.deliveryId);
                     this.logger.error({ deliveryId: row.deliveryId, operationId: row.operationId, target: row.targetInstance, state: row.state,
                         cause: row.lastError, ...(silent ? { silentSchedule: true } : {}) }, notice);
-                    this.notifyFleetError(notice);
+                    // A self-scheduled silent heartbeat stays log-only, including the
+                    // operator alert; another source still receives the normal notice.
+                    if (!silent || row.sourceInstance !== row.targetInstance)
+                        this.notifyFleetError(notice);
                 }
             }
         });
@@ -1693,16 +1905,27 @@ export class FleetManager {
     }
     /** #1918: cross-instance traffic, as the org canvas draws it (fleet-traffic.ts). */
     trafficLog = new TrafficLog();
+    delegations = new Delegations();
     trafficMemo = null;
-    /** One delivery row's traffic item, kept for the snapshot and sent to the open pages when it is news. */
+    /**
+     * One delivery row's traffic item, kept for the snapshot and sent to the open pages when it is news; and the
+     * delegation it opens or closes (a task and its report), sent as "delegation".
+     */
     publishTraffic(row, state) {
         try {
             const item = trafficItem(row, this.fleetConfig, new Date().toISOString(), state);
             const news = item ? this.trafficLog.note(item) : null;
-            if (news) {
+            const work = news ? this.delegations.note(row, news) : [];
+            if (news || work.length)
                 this.trafficMemo = null;
+            if (news)
                 this.emitSseEvent("traffic", news);
-            }
+            // Each delegation as its two instances are seen now: one that expires or is pushed out may be older than a change
+            // to their visibility (the incoming row's own item was checked; these can be anyone's).
+            const visible = (name) => crossInstanceVisibility(this.fleetConfig, name) !== "hidden";
+            for (const d of work)
+                if (visible(d.from) && visible(d.to))
+                    this.emitSseEvent("delegation", d);
         }
         catch (err) {
             this.logger.debug({ err }, "traffic: an item was not published");
@@ -1722,7 +1945,8 @@ export class FleetManager {
             .map((r) => trafficItem(r, this.fleetConfig, r.createdAt ?? now)).filter((i) => i !== null);
         const visible = (name) => crossInstanceVisibility(this.fleetConfig, name) !== "hidden";
         const items = this.trafficLog.snapshot(pending).filter((i) => visible(i.from) && visible(i.to));
-        this.trafficMemo = { atMs: nowMs, value: { now, items } };
+        const delegations = this.delegations.snapshot().filter((d) => visible(d.from) && visible(d.to));
+        this.trafficMemo = { atMs: nowMs, value: { now, items, delegations } };
         return this.trafficMemo.value;
     }
     /** Synchronous SQLite admission; the caller may acknowledge only after this returns. */
@@ -2494,6 +2718,11 @@ export class FleetManager {
         this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
         this.warnAboutRemovedLoginMode(loaded);
         this.enforceGuestSwitch();
+        this.observeWebAuthority(); // #2453 review: a reload's web-authority switches are seen at once
+        // Child tool/guidance readers must follow this fleet's actual config, including --config.
+        // Scope the path to its owning data directory so another inherited home's override cannot enable CW.
+        process.env.AGEND_FLEET_DATA_DIR = resolvePath(this.dataDir);
+        process.env.AGEND_FLEET_CONFIG_PATH = resolvePath(configPath);
         return this.fleetConfig;
     }
     relayLoginModeWarned = false;
@@ -2673,8 +2902,17 @@ export class FleetManager {
         this.logger.info(`Received SIGUSR1, initiating full restart (process reload)... ${describeSignalSource(this.dataDir, "SIGUSR1")}`);
         this.gracefulShutdownForReload()
             .then(() => {
-            this.logger.info("Full restart: shutdown complete, exiting for reload");
-            process.exit(0);
+            // #2356: under an AgEnD systemd unit a clean exit is a stop (Restart=on-failure); exit so the unit comes back.
+            let ownCgroup = null;
+            try {
+                ownCgroup = readFileSync("/proc/self/cgroup", "utf-8");
+            }
+            catch { /* not Linux */ }
+            const code = fullReloadExitCode(ownCgroup);
+            this.logger.info(code === 0
+                ? "Full restart: shutdown complete, exiting for reload"
+                : `Full restart: shutdown complete, exiting ${code} so the systemd unit restarts the fleet (#2356)`);
+            process.exit(code);
         })
             .catch(err => {
             this.logger.error({ err }, "Full restart: graceful shutdown failed");
@@ -2693,7 +2931,7 @@ export class FleetManager {
             const chatId = String(this.getChannelConfig(adapterId)?.group_id ?? data.channelId);
             this.beginUpdateProgress(adapter, chatId, data.channelId, messageId);
         }
-        const { spawn } = await import("node:child_process");
+        const { spawn } = await import("./child-process.js");
         // Plain `agend update`: the CLI picks the channel from the version it is about to replace (a beta install
         // stays on beta). Deciding here, from the package.json next to THIS code, read a source checkout's 1.22.0 as
         // "not a beta" and sent a beta install to @latest. #1450 C5: the INSTALLED agend, verified, by absolute path.
@@ -3087,7 +3325,8 @@ export class FleetManager {
     instancePresentation(name) {
         const execution_state = this.getInstanceExecutionState(name);
         const interaction = this.getInstanceInteraction(name);
-        return { state: presentationState(execution_state, interaction), execution_state,
+        const startup_phase = !this.lifecycle.isPaused(name) ? this.startupDashboard?.phase(name) : undefined;
+        return { ...(startup_phase ? { startup_phase } : {}), state: presentationState(execution_state, interaction), execution_state,
             interaction, interaction_summary: interactionSummary(interaction) };
     }
     /**
@@ -3521,7 +3760,9 @@ export class FleetManager {
         if (this.shuttingDown || !this.deliveryCurrent(instanceName, deliveryEpoch, stillCurrent))
             return false;
         if (!idle) {
-            this.logger.warn({ instanceName, timeoutMs }, "Idle gate timed out; forcing delivery");
+            // #2482: a busy target is the normal case (its CLI queues the message): INFO; a WARN only for a likely anomaly.
+            const log = idleGateTimeoutLog(instanceName, timeoutMs, this.instanceStateCache.get(instanceName), Date.now());
+            this.logger[log.level](log.fields, log.message);
         }
         const sent = await this.sendWhenConnected(instanceName, payload, deliveryEpoch, stillCurrent);
         if (!sent)
@@ -3635,12 +3876,69 @@ export class FleetManager {
      * #1920 §5.2: a web message's channel copy was sent — it is now what the channel saw. Kept so (and on disk), and sent
      * to the guests' streams only: an admin's page already has it, and nothing about it changed for them.
      */
-    webMessageInChannel(instance, messageId) {
+    webMessageInChannel(instance, messageId, copies = []) {
+        // #2305: the copies' own message ids, so an instance's reaction to the web message is put on them too.
+        if (copies.length)
+            this.rememberWebEchoCopies(messageId, copies);
+        // #2281: and where they are, for a later web reply to this message to be a native reply there.
+        const posts = copies.flatMap(c => c.adapterId ? [{ adapterId: c.adapterId, chatId: c.chatId, ...(c.threadId ? { threadId: c.threadId } : {}), messageId: c.messageId }] : []);
+        if (posts.length)
+            this.webChatHistory.addPosts(instance, messageId, posts);
         const m = this.webChatHistory.markChannel(instance, messageId);
         if (m)
             broadcastToGuests(this.sseClients, "message", m, (err) => this.logger.debug({ err }, "SSE client write failed; evicting"));
     }
-    async sendClassicWebEcho(instance, text, sender = WEB_NAME_FALLBACK) {
+    /** #2305: a web message's channel copies (topic, ClassicBot rooms), newest WEB_ECHO_COPIES_MAX, this process only. */
+    webEchoCopies = new Map();
+    rememberWebEchoCopies(messageId, copies) {
+        const list = [...(this.webEchoCopies.get(messageId) ?? []), ...copies.filter(c => c && typeof c.adapter?.react === "function" && c.messageId)];
+        this.webEchoCopies.delete(messageId);
+        this.webEchoCopies.set(messageId, list);
+        while (this.webEchoCopies.size > WEB_ECHO_COPIES_MAX)
+            this.webEchoCopies.delete(this.webEchoCopies.keys().next().value);
+    }
+    /**
+     * #2305: an instance's reaction to a web chat message (`messageId`, the id it was handed): its minimal reply, as on
+     * the platforms. Kept on the message's row (and on disk), shown live (`reactions` on the stream), and put on the
+     * message's channel copies when this process sent them — in the background, each within WEB_MIRROR_TIMEOUT_MS, so a
+     * slow or rate-limited platform never holds the tool's answer (best effort: a copy's failure or timeout is logged,
+     * never the tool's). `mirrored`: how many copies took it, when that is known.
+     * The tool's errors: an emoji outside the web set or one of the instance's delivery marks (web-reactions.ts), or a
+     * message the chat does not have. An emoji the message already has is a success that changes nothing.
+     */
+    async reactToWebMessage(instance, messageId, raw) {
+        const problem = webReactionProblem(raw, this.statusEmojiAvoidList(instance));
+        if (problem)
+            return { ok: false, error: problem };
+        const emoji = webReactionEmoji(raw);
+        const r = this.webChatHistory.addReaction(instance, messageId, emoji);
+        if (!r)
+            return { ok: false, error: `react: ${messageId} is not a message in ${instance}'s web chat now (it left the history, or it is from before AgEnD restarted) — answer with reply instead` };
+        if (!r.added)
+            return { ok: true, mirrored: Promise.resolve(0) };
+        this.emitSseEvent("reactions", { instance, boot: r.message.boot, id: r.message.id, reactions: r.message.reactions ?? [] });
+        const mirrorOne = (copy) => {
+            let timer;
+            const timeout = new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`no answer in ${WEB_MIRROR_TIMEOUT_MS} ms`)), WEB_MIRROR_TIMEOUT_MS);
+                timer.unref?.();
+            });
+            return Promise.race([Promise.resolve().then(() => copy.adapter.react(copy.chatId, copy.messageId, reactionForm(copy.adapter.type, emoji), copy.threadId)), timeout])
+                .then(() => 1, (err) => {
+                this.logger.warn({ err, instance, adapter: copy.adapter.type }, "Reaction on a web message's channel copy failed (shown on the web)");
+                return 0;
+            })
+                .finally(() => clearTimeout(timer));
+        };
+        const mirrored = Promise.all((this.webEchoCopies.get(messageId) ?? []).map(mirrorOne)).then(n => n.reduce((a, b) => a + b, 0));
+        return { ok: true, mirrored };
+    }
+    /** #2305: `copies` collects each room's copy (its message id), for a reaction to the web message. */
+    /**
+     * `reply` (#2281): where the message a web reply quotes is on a platform. A room that has it gets the reply as a
+     * native reply to it (`reply.text`: without the quoted line); every other room gets `text`, as before.
+     */
+    async sendClassicWebEcho(instance, text, sender = WEB_NAME_FALLBACK, copies, reply) {
         const guard = this.webChannelEchoGuards.get(instance);
         const handled = new Set();
         let posted = 0;
@@ -3670,7 +3968,11 @@ export class FleetManager {
             try {
                 if (!adapter?.sendText)
                     continue;
-                await adapter.sendText(entry.channelId, text, { format: "text", allowedMentions: { parse: [] } });
+                // A Telegram room is its chat; a Discord room is the guild's channel (an inbound's thread there).
+                const native = reply?.posts.find(p => p.adapterId === adapter.id && (p.chatId === entry.channelId || p.threadId === entry.channelId));
+                const sent = await adapter.sendText(entry.channelId, native ? reply.text : text, { format: "text", allowedMentions: { parse: [] }, ...(native ? { replyTo: native.messageId } : {}) });
+                if (copies && sent && typeof sent.messageId === "string" && sent.messageId)
+                    copies.push({ adapter, adapterId: adapter.id, chatId: entry.channelId, messageId: sent.messageId });
                 ClassicChannelManager.logMessage(instance, sender, text, new Date());
                 posted++;
             }
@@ -4088,6 +4390,18 @@ export class FleetManager {
     async dispatchSlashCore(slash, adapterId, adapter) {
         // #1569: an alias (/web) is its command (/dashboard) from here on — the door, the table and the handler see one name.
         const data = { ...slash, command: canonicalCommand(slash.command) };
+        // #2359: /dashboard stays listed; prefix its reply with the deprecation notice, then run /web's handler.
+        const noteDeprecatedDashboard = () => {
+            if (slash.command !== "dashboard")
+                return;
+            const prefix = `${t("dashboard.deprecated")}\n\n`;
+            const respond = data.respond;
+            data.respond = async (text) => respond(prefix + text);
+            if (data.respondButtons) {
+                const respondButtons = data.respondButtons;
+                data.respondButtons = async (text, choices) => respondButtons(prefix + text, choices);
+            }
+        };
         const door = this.slashDoor(data, adapterId);
         if ("refusal" in door) {
             await data.respond(t(door.refusal)).catch(() => { });
@@ -4098,6 +4412,7 @@ export class FleetManager {
         // — before the table, which keeps /web for fleet admins. Per account: it touches no instance binding.
         // Decided synchronously, so an admin's /web still reaches the table with no await after the door (#1399).
         if (data.command === "dashboard" && this.isGuestWebAsk(adapterId, data.userId)) {
+            noteDeprecatedDashboard();
             await this.guestWebCommand({ adapterId, userId: data.userId, username: data.username,
                 arg: String(data.options?.action ?? "").trim().toLowerCase(), replyHere: text => data.respond(text), replyPrivately: text => data.respond(text) });
             return;
@@ -4126,6 +4441,7 @@ export class FleetManager {
             await data.respond(reply).catch(() => { });
             return;
         }
+        noteDeprecatedDashboard();
         if (data.command === "start") {
             await this.handleClassicStartSlash(data, adapterId);
         }
@@ -4694,7 +5010,7 @@ export class FleetManager {
             return;
         }
         if (this.lifecycle.isPaused(name)) {
-            this.logger.info({ name }, "Persisted paused instance — skipping startup");
+            this.logger.debug({ name }, "Persisted paused instance — skipping startup"); // #2482: every start and reload
             return;
         }
         if (this.lifecycle.daemons.has(name)) {
@@ -4713,50 +5029,92 @@ export class FleetManager {
             this.logger.info({ name }, "Instance already running, skipping");
             return;
         }
-        // An explicit start (CLI/API) begins a fresh idle window; boot and
-        // reconcile starts keep the persisted last-inbound seed (Phase 2a).
-        if (resumePaused)
-            this.lifecycle.markActivitySeedNow(name);
-        const backend = config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
-        if (config.general_topic) {
-            this.ensureGeneralInstructions(config.working_directory, backend, name);
-        }
-        else if (kind === "fleet-topic") {
-            // Workers get only role-eligible on-demand skills. Classic instances are
-            // deliberately excluded: their workspace and conversation lifecycle are
-            // managed independently from fleet-topic workers.
-            try {
-                const skillsWorkDir = this.resolveKnowledgeWorkDir(config.working_directory, backend, name);
-                measureSyncWork("fleet.workerSkills", () => this.syncRoleSkills(skillsWorkDir, backend, "worker"));
+        await this.trackStartupInstance(name, async () => {
+            // An explicit start (CLI/API) begins a fresh idle window; boot and
+            // reconcile starts keep the persisted last-inbound seed (Phase 2a).
+            if (resumePaused)
+                this.lifecycle.markActivitySeedNow(name);
+            const backend = config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
+            if (config.general_topic) {
+                this.ensureGeneralInstructions(config.working_directory, backend, name);
             }
-            catch (err) {
-                // Skill publishing is additive. A read-only or temporarily unavailable
-                // workspace must not turn an otherwise valid worker startup into a
-                // fleet outage.
-                this.logger.warn({ err, name, backend }, "Failed to sync worker skills — continuing startup");
+            else if (kind === "fleet-topic") {
+                // Workers get only role-eligible on-demand skills. Classic instances are
+                // deliberately excluded: their workspace and conversation lifecycle are
+                // managed independently from fleet-topic workers.
+                try {
+                    const skillsWorkDir = this.resolveKnowledgeWorkDir(config.working_directory, backend, name);
+                    measureSyncWork("fleet.workerSkills", () => this.syncRoleSkills(skillsWorkDir, backend, "worker"));
+                }
+                catch (err) {
+                    // Skill publishing is additive. A read-only or temporarily unavailable
+                    // workspace must not turn an otherwise valid worker startup into a
+                    // fleet outage.
+                    this.logger.warn({ err, name, backend }, "Failed to sync worker skills — continuing startup");
+                }
             }
+            else if (kind === "classic") {
+                // #2163: a Classic bot gets only the skills marked `classic` (its own look, the dashboard) — never the fleet's
+                // coordination playbooks (#557 kept those out of end-user bots) — and only into a workspace AgEnD manages: the
+                // room's own folder under <AGEND_HOME>/workspaces/. Anywhere else, nothing is written; `agend-agent skill <name>`
+                // reads any bundled skill on demand.
+                try {
+                    const skillsWorkDir = this.resolveKnowledgeWorkDir(config.working_directory, backend, name);
+                    if (insideManagedWorkspaces(skillsWorkDir))
+                        measureSyncWork("fleet.classicSkills", () => this.syncRoleSkills(skillsWorkDir, backend, "classic"));
+                    else
+                        this.logger.debug({ name, skillsWorkDir }, "Classic workspace is not AgEnD-managed — no skills published");
+                }
+                catch (err) {
+                    this.logger.warn({ err, name, backend }, "Failed to sync classic skills — continuing startup");
+                }
+            }
+            const receipt = execution ? this.classicSettingsOwners.get(execution) : undefined;
+            const identity = { kind, backend, model: this.resolveInstanceModel(name).display };
+            if (receipt) {
+                await this.lifecycle.start(name, config, topicMode, identity, transition, execution, daemon => {
+                    // Only this transition's actual publication can acquire its replacement.
+                    receipt.daemon = daemon;
+                });
+            }
+            else
+                await this.lifecycle.start(name, config, topicMode, identity, transition, execution);
+            execution?.assert();
+            // Only clear a stale process status after a real start succeeded.  Clearing
+            // it before lifecycle.start() can turn a crash-loop daemon's dead pane into
+            // a falsely running instance when lifecycle.start() returns early.
+            this.instanceProcessStatus.delete(name);
+            // Recovery intent belongs to Daemon.start. lifecycle.start can return
+            // before reaching it, so an await here is not proof the marker was read.
+            // Auto-connect IPC — daemon.start() ensures socket is ready before resolving
+            await this.connectIpcToInstance(name);
+            execution?.assert();
+            this.requestDiscordUsagePresenceRefresh();
+        });
+    }
+    /** A boot's observation cannot settle a replacement boot or a newer attempt of the same instance. */
+    async trackStartupInstance(name, start) {
+        const boot = this.startupDashboard;
+        const owner = boot?.begin(name);
+        if (owner)
+            this.publishStartupStatus();
+        let ready = false;
+        try {
+            await start();
+            ready = this.daemons.has(name);
         }
-        const receipt = execution ? this.classicSettingsOwners.get(execution) : undefined;
-        const identity = { kind, backend, model: this.resolveInstanceModel(name).display };
-        if (receipt) {
-            await this.lifecycle.start(name, config, topicMode, identity, transition, execution, daemon => {
-                // Only this transition's actual publication can acquire its replacement.
-                receipt.daemon = daemon;
-            });
+        finally {
+            if (boot && owner && this.startupDashboard === boot && boot.finish(name, owner, ready))
+                this.publishStartupStatus();
+        }
+    }
+    publishStartupStatus() {
+        try {
+            this.emitSseEvent("status", this.getUiStatus());
+        }
+        catch (err) {
+            this.logger.debug({ err }, "Startup status unavailable; the next status frame retries");
         }
-        else
-            await this.lifecycle.start(name, config, topicMode, identity, transition, execution);
-        execution?.assert();
-        // Only clear a stale process status after a real start succeeded.  Clearing
-        // it before lifecycle.start() can turn a crash-loop daemon's dead pane into
-        // a falsely running instance when lifecycle.start() returns early.
-        this.instanceProcessStatus.delete(name);
-        // Recovery intent belongs to Daemon.start. lifecycle.start can return
-        // before reaching it, so an await here is not proof the marker was read.
-        // Auto-connect IPC — daemon.start() ensures socket is ready before resolving
-        await this.connectIpcToInstance(name);
-        execution?.assert();
-        this.requestDiscordUsagePresenceRefresh();
     }
     /** Recreate a daemon for a marker-only paused instance after an explicit wake/delivery. */
     async startPersistedPausedInstance(name, transition) {
@@ -4774,8 +5132,8 @@ export class FleetManager {
     }
     /**
      * Start instances with configurable concurrency and stagger delay.
-     * Instances sharing the same working_directory are serialized within a group
-     * to avoid config file races. Stagger delay is group-to-group, not instance-to-instance.
+     * Instances sharing the same working_directory are serialized to avoid
+     * config file races. Stagger applies between outer lifecycle admissions.
      * TODO: per-instance startup timeout (existing issue, not introduced here)
      */
     async startInstancesWithConcurrency(entries, topicMode, onReady) {
@@ -4797,15 +5155,30 @@ export class FleetManager {
                 totalInstances: runnableEntries.length,
             }, "Adaptive startup concurrency");
         }
+        const startedAt = performance.now();
+        let active = 0, peakConcurrentStarts = 0, readyInstances = 0;
         await Promise.all(runnableEntries.map(([name, config]) => this.spawnGate.run({
             instanceName: name,
             workingDirectory: config.working_directory,
             reason: "startup",
             stage: "lifecycle",
         }, async () => {
-            if (await this.startInstanceUnattended(name, config, topicMode, "instance"))
-                onReady?.(name);
+            peakConcurrentStarts = Math.max(peakConcurrentStarts, ++active);
+            try {
+                if (await this.startInstanceUnattended(name, config, topicMode, "instance")) {
+                    readyInstances++;
+                    onReady?.(name);
+                }
+            }
+            finally {
+                active--;
+            }
         })));
+        this.logger.info({
+            totalInstances: runnableEntries.length, readyInstances,
+            elapsedSeconds: Math.round((performance.now() - startedAt) / 100) / 10,
+            peakConcurrentStarts,
+        }, "Fleet startup batch completed");
     }
     /**
      * Start from an UNATTENDED path (fleet startup, full restart, config
@@ -5231,34 +5604,18 @@ export class FleetManager {
         return this.adapterState.get(adapterId)?.status === "connected" ? adapter : undefined;
     }
     /** Last-resort completion after RestartProgress could not deliver to its
-     * adopted target. It stays bounded and never wakes a not-ready gateway. */
+     * adopted target (or had no message: a small fleet, a failed first post). It
+     * never wakes a not-ready gateway. #2213: an outage at fleet start no longer
+     * loses it — bounded at startup, then retried in the background once the
+     * adapter is ready again, never posted twice after an uncertain attempt. */
     async sendFleetStartCompletionFallback(chatId, text, threadId) {
         const adapterId = this.getPrimaryAdapterId();
-        const adapter = adapterId ? this.readyProgressAdapter(adapterId) : undefined;
-        if (!adapter) {
-            this.logger.error({ adapterId }, "Fleet start completion fallback skipped because the primary adapter is not ready");
+        if (!adapterId) {
+            this.logger.error({ adapterId }, "Fleet start completion fallback skipped because there is no primary adapter");
             return false;
         }
-        let timer;
-        const timeout = new Promise(resolve => {
-            timer = setTimeout(() => resolve({ status: "timeout" }), RESTART_PROGRESS_TERMINAL_TIMEOUT_MS);
-            timer.unref?.();
-        });
-        const delivery = Promise.resolve()
-            .then(() => adapter.sendText(chatId, text, { threadId }))
-            .then(() => ({ status: "sent" }), err => ({ status: "failed", err }));
-        const result = await Promise.race([delivery, timeout]);
-        if (timer)
-            clearTimeout(timer);
-        if (result.status === "sent")
-            return true;
-        if (result.status === "failed") {
-            this.logger.error({ err: result.err }, "Failed to send fleet start completion fallback");
-        }
-        else {
-            this.logger.error({ timeout_ms: RESTART_PROGRESS_TERMINAL_TIMEOUT_MS }, "Timed out sending fleet start completion fallback");
-        }
-        return false;
+        const poster = new RestartProgress(0, Date.now(), this.logger);
+        return poster.postCompletion({ resolveAdapter: () => this.readyProgressAdapter(adapterId), chatId, threadId }, text);
     }
     async stopInstance(name, transition) {
         this.explicitStopGeneration.set(name, (this.explicitStopGeneration.get(name) ?? 0) + 1);
@@ -5694,11 +6051,16 @@ export class FleetManager {
             dataDir: this.dataDir, web: () => this.fleetConfig?.web,
             permitted: owner => this.publicOwnerCurrent(owner),
             reserve: id => this.getTunnelLane().reserve("dashboard", id),
-            createGateway: (exposureId, current, open, failed) => createPublicWebGateway({ exposureId, isCurrent: current, isOpen: open, onError: failed,
+            createGateway: (exposureId, current, open, failed, named) => createPublicWebGateway({ ...named, exposureId, isCurrent: current, isOpen: open, onError: failed,
                 dispatch: (req, res) => this.dispatchWebHttp(req, res, this.fleetConfig?.health_port ?? 19280) }),
             revoke: id => {
                 this.webLoginCodes?.revokeAudience(id);
                 this.webGuestLoginCodes?.revokeAudience(id);
+                // #2453 (§0.2): the link's sessions end, and the authorizations kept for them go with them (housekeeping: their
+                // handles can never match again).
+                const ended = new Set(this.webSessions?.list(undefined, r => r.exposureId === id).map(r => r.handle) ?? []);
+                if (ended.size)
+                    this.sessionAuthorizationStore()?.prune(a => !ended.has(a.handle));
                 const result = this.webSessions?.revokeExposure(id);
                 if (result && !result.durable)
                     this.logger.warn("Public session revocation could not be saved; exposure remains closed");
@@ -5719,6 +6081,66 @@ export class FleetManager {
             },
         });
     }
+    publicLinkAutoOpen = null;
+    /**
+     * #named-link-ttl: the admin who last opened a named-tunnel link from /web, with the live binding — only while they
+     * still may own one (publicOwnerCurrent: a fleet admin of a live bot, the same General). Else null.
+     */
+    rememberedPublicOwner() {
+        const saved = readPublicLinkOwner(this.dataDir);
+        if (!saved)
+            return null;
+        const owner = { ...saved, binding: this.adapters.get(saved.adapterId) };
+        return this.publicOwnerCurrent(owner) ? owner : null;
+    }
+    /** A named-tunnel link was privately delivered: auto_open reopens it for this owner after a restart. */
+    rememberPublicLinkOwner(owner) {
+        if (!publicLinkNamedHostname(this.fleetConfig?.web))
+            return;
+        try {
+            writePublicLinkOwner(this.dataDir, owner);
+        }
+        catch (err) {
+            this.logger.warn({ err: err?.message }, "Could not remember the public link's owner; auto_open will not reopen it");
+        }
+    }
+    /** Closed on purpose (Close, /web revoke): a restart must not reopen it. The next /web remembers again. */
+    forgetPublicLinkOwner() {
+        try {
+            clearPublicLinkOwner(this.dataDir);
+        }
+        catch (err) {
+            this.logger.warn({ err: err?.message }, "Could not forget the public link's owner");
+        }
+    }
+    /**
+     * #named-link-ttl: `web.public_link.auto_open` — once per start, after the web listener and the chat connections are
+     * up. Opens the named link with nothing posted (sign-in still needs a code from /web or a returning device); a final
+     * failure goes to its owner once, by DM, drawn as a failed /web is.
+     */
+    startPublicLinkAutoOpen() {
+        this.publicLinkAutoOpen?.stop();
+        const runner = this.publicLinkAutoOpen = new PublicLinkAutoOpen({
+            web: () => this.fleetConfig?.web,
+            ready: () => !this.shuttingDown && this.healthServerListening && this.publicLinkAutoOpen === runner,
+            owner: () => this.rememberedPublicOwner(),
+            open: (owner, onProgress) => this.getPublicWebLink().openUnattended(owner, onProgress),
+            notifyFailed: async (owner, last) => {
+                const adapter = owner.binding;
+                if (this.shuttingDown || !adapter?.sendDirect || !this.publicOwnerCurrent(owner))
+                    return;
+                const outcome = t("dashboard.public_auto_failed");
+                try {
+                    await withinBudget(adapter.sendDirect(owner.userId, last ? renderPublicLinkProgress(last, performance.now(), outcome) : outcome, { disablePreview: true }), performance.now() + 5_000);
+                }
+                catch (err) {
+                    this.logDashboardDmFailure(err);
+                }
+            },
+            log: (event, fields) => this.logger.info({ event, ...fields }, "Public web link"),
+        });
+        runner.start();
+    }
     getPublicWebStatus() {
         return this.publicWebLink?.status() ?? { state: "closed" };
     }
@@ -5902,8 +6324,9 @@ export class FleetManager {
         // Show the action before any link exists. TG's Start instructions belong to confirmed DM refusal below.
         const menuText = this.topicCommands.getDashboardMenuText()
             + (publicAllowed ? "\n" + t("dashboard.public_risk") : "")
-            + (status.state !== "closed" ? "\n" + t("dashboard.public_status", status.state, status.remainingSeconds ?? 0)
-                + (status.expiresAt ? t("dashboard.public_until", formatFleetTime(status.expiresAt)) : "") : "");
+            + (status.state === "closed" ? "" : status.noExpiry ? "\n" + t("dashboard.public_status_no_expiry", status.state)
+                : "\n" + t("dashboard.public_status", status.state, status.remainingSeconds ?? 0)
+                    + (status.expiresAt ? t("dashboard.public_until", formatFleetTime(status.expiresAt)) : ""));
         const choices = [{ action: "local", label: t("dashboard.local_signin") },
             ...(publicLinkSettings(this.fleetConfig?.web).allowed ? [{ action: "public", label: t("dashboard.public_open") }] : []),
             ...(status.state !== "closed" ? [{ action: "close", label: t("dashboard.public_close") }] : [])];
@@ -5950,6 +6373,7 @@ export class FleetManager {
             if (!entry.publicExposureId)
                 return true;
             const result = await this.publicWebLink?.close("admin close", entry.publicExposureId);
+            this.forgetPublicLinkOwner();
             if (result?.confirmed === false)
                 data.ack?.(t("dashboard.public_cleanup"));
             await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("dashboard.public_closed"), data.editClicked);
@@ -5980,10 +6404,11 @@ export class FleetManager {
                 return false;
             this.initializeWebSessions();
             const issued = this.webLoginCodes.issue({ epoch: tokenEpoch(token), audience: exposureId, owner });
-            // Only a public link has a link expiry; the code's five-minute lifetime applies to either packet.
+            // Only a public link has a link expiry (null: none — a named tunnel's ttl_minutes 0); the code's five-minute
+            // lifetime applies to either packet.
             const minutes = Math.round(LOGIN_CODE_TTL_MS / 60_000);
             const text = expiresAt !== undefined
-                ? t("dashboard.private_public", url, issued.display, minutes, formatFleetTime(expiresAt))
+                ? t("dashboard.private_public", url, issued.display, minutes, expiresAt === null ? t("dashboard.public_no_expiry") : formatFleetTime(expiresAt))
                 : t("dashboard.private_local", url, issued.display, minutes);
             const deadline = performance.now() + 10_000;
             const direct = owner.binding;
@@ -6046,6 +6471,8 @@ export class FleetManager {
             // Still closes the step editor below and tells the clicker: a throw must not leave the menu refreshing.
             this.logger.warn({ err }, "Dashboard sign-in delivery failed");
         }
+        if (ok && action === "public")
+            this.rememberPublicLinkOwner(owner);
         // Only safe, static words enter General; never link, code or platform error text.
         // #1742: Telegram's failure walks through opening the DM (never a bare /start, which starts a ClassicBot agent),
         // with the "先開私訊 →" button when the bot's username is known; and for a while a bare /start there counts as
@@ -6070,6 +6497,7 @@ export class FleetManager {
     revokeWebSessions() {
         this.initializeWebSessions();
         void this.publicWebLink?.close("dashboard revoke");
+        this.forgetPublicLinkOwner();
         this.webLoginCodes.revoke();
         this.webGuestLoginCodes.revokeAll();
         this.guestRevokes++; // and every guest /web still on its way
@@ -6620,11 +7048,17 @@ export class FleetManager {
      * landed mid-edit) must not be cleared or disturbed (Prism b).
      */
     async appendCleanupWarning(target, watch, warning, cleanupCommand) {
-        const text = formatRestartProgressCompletion("update", {
-            ...watch.summary,
-            warningText: warning,
-            warningCommand: cleanupCommand,
-        }, watch.receipt.startedAt);
+        // #2175: one text per outcome, frozen at its first tick. The completion carries elapsed seconds, so a text made
+        // anew each tick would never equal the one already handed over and landed (terminalLanded compares exactly).
+        const key = JSON.stringify([warning, cleanupCommand ?? null]);
+        if (watch.frozen?.key !== key) {
+            watch.frozen = { key, text: formatRestartProgressCompletion("update", {
+                    ...watch.summary,
+                    warningText: warning,
+                    warningCommand: cleanupCommand,
+                }, watch.receipt.startedAt) };
+        }
+        const text = watch.frozen.text;
         const stopWatching = () => {
             this.updateCleanupWatch = null;
             if (this.updateProgressTimer)
@@ -6632,10 +7066,22 @@ export class FleetManager {
             this.updateProgressTimer = null;
         };
         if (text !== this.lastUpdateProgressText) {
-            const adapter = this.adapters.get(target.adapterId);
-            if (!adapter)
-                return; // retry on a later tick
-            await adapter.editMessage(target.chatId, target.messageId, text, target.threadId);
+            // #2175: while the completion is still owed by the background retry, that retry is the message's only
+            // writer — this text (the completion plus the warning) goes to it rather than racing it. Handing it over is not
+            // delivery: the receipt and this watch stay until the retry reports this exact text landed (a later tick).
+            const progress = this.startupProgress;
+            if (progress?.terminalLanded(text)) {
+                // landed through the retry
+            }
+            else if (progress?.replaceTerminalText(text)) {
+                return;
+            }
+            else {
+                const adapter = this.adapters.get(target.adapterId);
+                if (!adapter)
+                    return; // retry on a later tick
+                await adapter.editMessage(target.chatId, target.messageId, text, target.threadId);
+            }
             this.lastUpdateProgressText = text;
         }
         const verdict = cleanupWatchVerdict(readUpdateProgress(this.dataDir), watch.receipt);
@@ -6653,7 +7099,7 @@ export class FleetManager {
         if (this.updateProgressTimer)
             clearInterval(this.updateProgressTimer);
         const tick = async () => {
-            if (this.updateProgressEditRunning)
+            if (this.updateProgressEditRunning || this.shuttingDown)
                 return;
             const marker = readUpdateProgress(this.dataDir);
             if (!marker) {
@@ -6704,6 +7150,11 @@ export class FleetManager {
                     return;
                 }
             }
+            // #2476: from "starting" onward RestartProgress in the NEW process owns this
+            // message (resume → N/M → ✅ finish). A late CLI-stage edit of "installed" is
+            // what made "✅ 安裝完成" land after "啟動中 N/M". Failure still edits here.
+            if (marker.progress.stage === "starting")
+                return;
             const target = marker.progress.target;
             const adapter = this.adapters.get(target.adapterId) ?? (initialAdapter?.id === target.adapterId ? initialAdapter : undefined);
             if (!adapter)
@@ -6739,11 +7190,46 @@ export class FleetManager {
     }
     /** Start all instances from fleet config */
     async startAll(configPath) {
+        this.startupMemoryDeadline?.stop();
+        const deadline = new StartupMemoryDeadline({
+            current: () => this.startupMemoryDeadline === deadline && !this.shuttingDown,
+            waiting: () => this.spawnGate.isStartupMemoryDeferred(),
+            notify: sdNotify,
+            log: message => this.logger.info(message),
+        });
+        this.startupMemoryDeadline = deadline;
+        // A held first General must not postpone event-loop liveness monitoring.
+        // No independent heartbeat: a genuinely frozen main loop still stops pinging.
+        setSdNotifyWarn((fields, message) => this.logger.warn(fields, message));
+        if (this.watchdogTimer)
+            clearInterval(this.watchdogTimer);
+        this.watchdogTimer = setInterval(() => sdNotify("WATCHDOG=1"), 30_000);
+        this.eventLoopWatch?.stop();
+        this.eventLoopWatch = startEventLoopWatch({ logger: this.logger });
+        try {
+            await this.startAllWithinDeadline(configPath, deadline);
+        }
+        finally {
+            deadline.stop();
+            if (this.startupMemoryDeadline === deadline) {
+                this.startupMemoryDeadline = null;
+                if (!this.startupComplete) {
+                    if (this.watchdogTimer)
+                        clearInterval(this.watchdogTimer);
+                    this.watchdogTimer = null;
+                    this.eventLoopWatch?.stop();
+                    this.eventLoopWatch = null;
+                }
+            }
+        }
+    }
+    async startAllWithinDeadline(configPath, deadline) {
         this.loginWindow.reopen(); // a stopAll → startAll restart must accept login windows again
         this.loginController?.reopen();
         const startupStartedAt = Date.now();
         FleetManager.signalTarget = this;
         this.startupComplete = false;
+        this.startupDashboard = null;
         // Cleared here, not at the end of doStopAll: a stop has an async tail, and
         // anything arriving during it is still part of the stop.
         this.shuttingDown = false;
@@ -6757,6 +7243,12 @@ export class FleetManager {
             envLease.release();
         }
         this.ensureDeliveryOutbox();
+        // #1956: the spawn helper the fleet's tmux/stty commands are started by (its fork is cheap; the fleet's is not).
+        // Started here and by the fleet's own timer — never by a tool handler — and stopped with the fleet.
+        tmuxExecHelper.reopen();
+        tmuxExecHelper.start();
+        this.tmuxExecHelperTimer ??= setInterval(() => tmuxExecHelper.maintain(), 5_000);
+        this.tmuxExecHelperTimer.unref?.();
         this.rotateFleetLogs();
         const fleet = this.loadConfig(configPath);
         this.slimFleetConfigAtStartup();
@@ -6853,6 +7345,7 @@ export class FleetManager {
         // #1565: the web chat as it was before this process — the configured instances' only (fleet.yaml and ClassicBot
         // rooms), before the dashboard serves anything; from now on every change is written back (off the loop).
         this.restoreWebChat(fleet);
+        this.startSearchIndex(fleet);
         // Poll classicBot.yaml for external changes every 30s
         this.classicReloadTimer = setInterval(() => {
             // Attributes the synchronous part, up to the reload's first await (#1235).
@@ -6902,6 +7395,17 @@ export class FleetManager {
             return DailySummary.generateText(this.eventLog, instances, costMap, this.costGuard?.getFleetTotalCents() ?? 0);
         });
         this.dailySummary.start();
+        // #2246 step 3: the task board's daily summary — its own time (defaults.task_board.summary_at, read at every look),
+        // in the fleet's zone; a summary missed while the fleet was down goes out when it is back.
+        this.taskBoardSummary = new TaskBoardSummaryClock({
+            at: () => summaryTime(this.fleetConfig?.defaults?.task_board?.summary_at) ?? null,
+            zone: () => this.usageZone(),
+            now: () => new Date(),
+            mark: summaryMarkFile(join(this.dataDir, "task-board-summary.json")),
+            send: (since, until) => this.postTaskBoardSummary(since, until),
+            failed: (err) => this.logger.warn({ err }, "The task board's daily summary failed; the next minute tries again"),
+        });
+        this.taskBoardSummary.start();
         // Rotate classic channel chat logs daily (piggyback on daily summary timer)
         this.classicChannels?.rotateLogs();
         this.rotateInboxes();
@@ -6977,7 +7481,7 @@ export class FleetManager {
                 continue;
             this.logger.warn({ adapter: need.adapterId, name }, "No general instance for adapter — auto-creating");
             const generalDir = join(getAgendHome(), name);
-            mkdirSync(generalDir, { recursive: true });
+            mkdirSync(generalDir, { recursive: true, mode: 0o700 });
             const backendName = fleet.defaults.backend ?? "claude-code";
             this.ensureGeneralInstructions(generalDir, backendName, name);
             fleet.instances[name] = {
@@ -6997,7 +7501,9 @@ export class FleetManager {
             };
             this.scheduler = new Scheduler(join(this.dataDir, "scheduler.db"), (schedule, runId, retry) => this.handleScheduleTrigger(schedule, runId, retry), schedulerConfig, (name) => this.fleetConfig?.instances?.[name] != null || !!this.classicChannels?.getAll().some(ch => ch.instanceName === name), (schedule, retry, reason) => this.scheduleRetryDropped(schedule, retry, reason), this.logger);
             this.scheduler.init();
+            this.scheduler.db.onTaskChange = (task) => this.searchIndex?.record(taskDoc(task));
             this.logger.info("Scheduler initialized");
+            this.attachTaskBoard(this.scheduler.db);
             // Tips share the daily-report clock but remain an independent internal
             // job: disabling daily_summary must not disable tips (and vice versa).
             // The callback checks defaults.tips at fire time, so /tips on|off is hot.
@@ -7025,6 +7531,14 @@ export class FleetManager {
         const generals = allEntries.filter(([_, cfg]) => cfg.general_topic);
         const others = allEntries.filter(([_, cfg]) => !cfg.general_topic);
         const startupProgress = new RestartProgress(this.runnableStartupCount(fleet, topicMode), pendingUpdateProgress?.startedAt ?? startupStartedAt, this.logger, { mode: pendingProgressOperation === "full-restart" ? "reload" : pendingUpdateProgress ? "update" : "restart" });
+        this.startupProgress = startupProgress;
+        // Auth, restored chat, Classic roster and the task DB are ready. Listening is not service readiness:
+        // the dashboard observes startup, while /health and READY retain their existing completion boundary.
+        this.startupDashboard = new FleetStartup(this.configuredStartupInstanceNames(fleet, topicMode)
+            .filter(name => !this.lifecycle.isPaused(name)));
+        await this.startHealthServer(fleet.health_port ?? 19280);
+        if (this.shuttingDown)
+            return;
         if (generals.length > 0) {
             for (const [name, cfg] of generals) {
                 try {
@@ -7089,22 +7603,6 @@ export class FleetManager {
                 return startupProgress.start(this.restartProgressTarget());
             });
         }
-        // The systemd watchdog answers exactly one question: is this process still
-        // turning its event loop? Pinging from a timer proves that, and after the
-        // blocking child-process calls were made async it is a meaningful signal —
-        // a deadlocked or frozen fleet stops pinging and systemd restarts it.
-        //
-        // It deliberately does NOT gate on fleet health. "No adapter connected" or
-        // "an instance crashed" must not kill the process: the fleet would be restarted
-        // into the same broken state, and a user who has legitimately stopped every
-        // instance would get a restart loop. Those conditions surface through /health
-        // (which now returns 503) and through the General-topic notifications instead.
-        setSdNotifyWarn((fields, message) => this.logger.warn(fields, message));
-        this.watchdogTimer = setInterval(() => sdNotify("WATCHDOG=1"), 30_000);
-        // #1231: a stalled loop is what turns a slash command into "did not respond";
-        // put each long stall in the log instead of leaving it to be guessed at.
-        this.eventLoopWatch?.stop();
-        this.eventLoopWatch = startEventLoopWatch({ logger: this.logger });
         // EventLog.prune() existed but was never called, so `events` and `activity`
         // grew without bound for the life of the install. Prune once at startup and
         // daily after that; the timer is unref'd so it never holds the loop open.
@@ -7223,6 +7721,10 @@ export class FleetManager {
             // operation so an older stop never reports. No pending operation means
             // a plain boot — nothing was stopped by an operation, report nothing.
             const backgroundWorkEndedNames = this.collectBackgroundWorkEndedNames(configuredNames, pendingUpdateProgress?.startedAt ?? null);
+            // #2264: an update whose fleet comes back on another version did not land — say so in its final message (the
+            // version it aimed for, the one running, and the one repair), never just "updated".
+            const aimedAt = pendingProgressOperation === "update" ? pendingUpdateProgress?.progress.version : undefined;
+            const notLanded = aimedAt && agendVersion !== "unknown" && aimedAt !== agendVersion ? t("update.not_landed", aimedAt, agendVersion) : null;
             const completionSummary = {
                 running: started,
                 total,
@@ -7232,7 +7734,7 @@ export class FleetManager {
                 backgroundWorkEndedNames,
                 ...(cleanupOutcome && "render" in cleanupOutcome
                     ? { warningText: cleanupOutcome.render.warning, warningCommand: cleanupOutcome.render.cleanupCommand }
-                    : {}),
+                    : notLanded ? { warningText: notLanded } : {}),
             };
             const progressCompleted = await startupProgress.finish(completionSummary);
             // Armed only after the completion posted: an append racing ahead of it would be overwritten by it.
@@ -7276,9 +7778,9 @@ export class FleetManager {
             }
             // After "fleet ready", so the notice is not the first thing people see of a restart.
             void this.announceWebChatOnce(agendVersion);
+            // #named-link-ttl: a named link with auto_open comes back now — after the web listener and the chat connections.
+            this.startPublicLinkAutoOpen();
         }
-        // Health HTTP endpoint
-        this.startHealthServer(fleet.health_port ?? 19280);
         // #1266: buttons that ended while AgEnD was down (expired, or chosen before a restart) are shown as ended now.
         // #1823: and polls: a deadline that passed meanwhile closes now (results once); an open one's countdown is redrawn.
         void this.replyButtons()?.sweep().catch(err => this.logger.warn({ err }, "Reply-button sweep failed"));
@@ -7289,17 +7791,32 @@ export class FleetManager {
         }, 60 * 60 * 1000);
         const onRestart = () => this.onGracefulRestartSignal(() => process.once("SIGUSR2", onRestart));
         process.once("SIGUSR2", onRestart);
-        // SIGUSR1: full process reload (graceful stop → exit → CLI restarts)
+        // SIGUSR1: full process reload (graceful stop → exit). Nothing in this AgEnD sends it any more (#2356); an older
+        // CLI or a hand-sent signal still may, and the exit code then lets the owning manager start the next fleet.
         process.once("SIGUSR1", () => this.onFullRestartSignal());
         // A SIGHUP may arrive after the PID/general is available but before the
         // rest of startup finishes. Replay one coalesced reload only after all
         // startup-owned lifecycle work and signal handlers are in place.
+        if (this.shuttingDown || this.startupMemoryDeadline !== deadline)
+            return;
         this.finishStartup(bootUpdateMarker);
+        this.startupDashboard = null;
+        this.publishStartupStatus();
         // Tell systemd we are ready only now. This used to fire right after the
         // generals started — before adapters, classic instances, topic creation and the
         // health server — so `systemctl start` returned success while the fleet was
         // still deaf: no path existed for a user message to arrive.
         sdNotify("READY=1");
+        // #2481: this version runs — the CLI's start-failure banner stops, and this is the version to go back to later.
+        try {
+            const { ownPackage, recordStarted } = await import("./start-failure.js");
+            const version = ownPackage().version;
+            if (version)
+                recordStarted(this.dataDir, version, process.pid, Date.now());
+        }
+        catch (err) {
+            this.logger.debug({ err }, "fleet-started record not written");
+        }
         const health = this.getFleetHealth();
         if (health.status !== "ok") {
             this.logger.warn({ health }, "Fleet started with problems — see /health");
@@ -7452,48 +7969,109 @@ export class FleetManager {
                 const err = results[i].reason;
                 this.logger.error({ adapterId, err: err?.message ?? err }, "Adapter startup failed — scheduling background retry");
                 this.adapterState.set(adapterId, { status: "retrying", retryCount: 0, lastError: err?.message ?? String(err) });
-                this.scheduleAdapterRetry(adapterId, channelConfigs[i], i === 0 ? fleet : undefined);
+                this.scheduleAdapterRetry(adapterId);
                 // Notify admin via whichever adapter is already up
                 this.notifyAdapterFailure(adapterId, err?.message ?? String(err));
             }
         }
     }
-    /** Exponential backoff retry for a single failed adapter (background, non-blocking). */
-    scheduleAdapterRetry(adapterId, channelConfig, fleet) {
-        const MAX_RETRIES = 10;
+    /** Keep trying while the fleet runs, with a five-minute cap even after a long outage. */
+    scheduleAdapterRetry(adapterId) {
         const INITIAL_DELAY_MS = 5_000;
         const MAX_DELAY_MS = 5 * 60_000;
         const state = this.adapterState.get(adapterId);
-        if (!state || state.retryCount >= MAX_RETRIES) {
-            if (state) {
-                state.status = "failed";
-                this.logger.error({ adapterId, retries: state.retryCount }, "Adapter retry exhausted — giving up");
-                this.notifyAdapterFailure(adapterId, `Retry exhausted after ${state.retryCount} attempts. Check token/network and restart fleet.`);
-            }
+        if (this.shuttingDown || !state || state.retryTimer || this.adapterRetryInFlight.has(adapterId))
             return;
-        }
-        const delay = Math.min(INITIAL_DELAY_MS * Math.pow(2, state.retryCount), MAX_DELAY_MS);
+        const delay = Math.min(INITIAL_DELAY_MS * Math.pow(2, Math.min(state.retryCount, 6)), MAX_DELAY_MS);
         this.logger.info({ adapterId, attempt: state.retryCount + 1, delay_ms: delay }, "Scheduling adapter retry");
-        state.retryTimer = setTimeout(async () => {
+        const timer = setTimeout(() => {
+            const current = this.adapterState.get(adapterId);
+            if (this.shuttingDown || current?.retryTimer !== timer)
+                return;
+            current.retryTimer = undefined;
+            void this.attemptAdapterRetry(adapterId);
+        }, delay);
+        state.retryTimer = timer;
+        timer.unref?.();
+    }
+    /** One login per connection, shared by the background timer and the operator's Retry now. */
+    attemptAdapterRetry(adapterId) {
+        const pending = this.adapterRetryInFlight.get(adapterId);
+        if (pending)
+            return pending;
+        if (this.shuttingDown || !this.secureConnectionChannel(adapterId))
+            return Promise.resolve();
+        const attempt = Promise.resolve().then(async () => {
+            const channel = this.secureConnectionChannel(adapterId);
+            if (this.shuttingDown || !channel)
+                return;
+            const generation = this.settingsGeneration;
+            const binding = JSON.stringify([channel, this.getPrimaryAdapterId()]);
+            const token = process.env[channel.bot_token_env];
+            const operation = { owner: Symbol("adapter-retry"), assert: () => {
+                    if (this.shuttingDown || generation !== this.settingsGeneration
+                        || JSON.stringify([this.secureConnectionChannel(adapterId), this.getPrimaryAdapterId()]) !== binding
+                        || process.env[channel.bot_token_env] !== token)
+                        throw new Error("adapter retry superseded");
+                } };
+            const state = this.adapterState.get(adapterId) ?? { status: "retrying", retryCount: 0 };
+            state.status = "retrying";
             state.retryCount++;
+            this.adapterState.set(adapterId, state);
             try {
-                if (fleet) {
-                    await this.startSingleAdapter(fleet, channelConfig);
-                }
-                else {
-                    await this.startAdditionalAdapter(channelConfig);
-                }
-                state.status = "connected";
-                state.lastError = undefined;
+                if (this.getPrimaryAdapterId() === adapterId)
+                    await this.startSingleAdapter(this.fleetConfig, channel, undefined, operation);
+                else
+                    await this.startAdditionalAdapter(channel, true, undefined, operation);
+                if (this.shuttingDown || generation !== this.settingsGeneration)
+                    return;
+                if (!this.adapters.has(adapterId))
+                    throw new Error("Adapter token is not configured");
+                // Health events can replace the state object during login. Update its current owner.
+                const current = this.adapterState.get(adapterId);
+                current.status = "connected";
+                current.lastError = undefined;
                 this.logger.info({ adapterId, attempts: state.retryCount }, "Adapter reconnected on retry");
                 this.notifyAdapterRecovery(adapterId, state.retryCount);
             }
             catch (err) {
-                state.lastError = err?.message ?? String(err);
-                this.logger.warn({ adapterId, attempt: state.retryCount, err: state.lastError }, "Adapter retry failed");
-                this.scheduleAdapterRetry(adapterId, channelConfig, fleet);
+                if (this.shuttingDown || generation !== this.settingsGeneration)
+                    return;
+                const current = this.adapterState.get(adapterId);
+                current.status = "retrying";
+                current.lastError = err?.message ?? String(err);
+                this.logger.warn({ adapterId, attempt: state.retryCount, err: current.lastError }, "Adapter retry failed");
             }
-        }, delay);
+        }).finally(() => {
+            if (this.adapterRetryInFlight.get(adapterId) !== attempt)
+                return;
+            this.adapterRetryInFlight.delete(adapterId);
+            const channel = this.secureConnectionChannel(adapterId);
+            if (!this.shuttingDown && channel && this.adapterState.get(adapterId)?.status !== "connected") {
+                this.scheduleAdapterRetry(adapterId);
+            }
+        });
+        this.adapterRetryInFlight.set(adapterId, attempt);
+        return attempt;
+    }
+    retryAdapterNow(adapterId) {
+        if (this.shuttingDown)
+            throw new Error("The fleet is stopping");
+        if (!this.secureConnectionChannel(adapterId))
+            throw new Error("Connection not found");
+        if (this.adapterRetryInFlight.has(adapterId) || this.adapterRestarting.has(adapterId))
+            return { queued: true, already_running: true };
+        const state = this.adapterState.get(adapterId);
+        if (state?.retryTimer) {
+            clearTimeout(state.retryTimer);
+            state.retryTimer = undefined;
+        }
+        const adapter = this.adapters.get(adapterId);
+        if (adapter && this.connectionStatus(adapterId, state, this.worlds.get(adapterId)).status === "connected")
+            return { queued: false };
+        const run = adapter ? this.restartAdapter(adapter, adapterId) : this.attemptAdapterRetry(adapterId);
+        void run.catch(err => this.logger.warn({ adapterId, err }, "Requested adapter retry failed"));
+        return { queued: true };
     }
     /** Notify admin about adapter failure (uses any available adapter). */
     notifyAdapterFailure(adapterId, error) {
@@ -7548,6 +8126,7 @@ export class FleetManager {
                 : snapshot.status === "stopped" ? "failed"
                     : "retrying";
             this.adapterState.set(adapterId, {
+                ...previous,
                 status,
                 retryCount: previous?.retryCount ?? 0,
                 lastError: status === "connected" ? undefined : snapshot.lastReconnectReason ?? previous?.lastError,
@@ -7656,12 +8235,12 @@ export class FleetManager {
             return;
         }
         const accessDir = join(this.dataDir, "access");
-        mkdirSync(accessDir, { recursive: true });
+        mkdirSync(accessDir, { recursive: true, mode: 0o700 });
         const accessStatePath = join(accessDir, "access.json");
         const accessManager = new AccessManager(channelConfig.access ?? DEFAULT_OPEN_ACCESS, accessStatePath);
         this.warnIfAccessModeOverridden(accessManager, accessStatePath);
         const inboxDir = join(this.dataDir, "inbox");
-        mkdirSync(inboxDir, { recursive: true });
+        mkdirSync(inboxDir, { recursive: true, mode: 0o700 });
         const adapterId = channelConfig.id ?? channelConfig.type;
         const adapter = await createAdapter(channelConfig, {
             id: adapterId,
@@ -7807,12 +8386,12 @@ export class FleetManager {
             return;
         }
         const accessDir = join(this.dataDir, "access");
-        mkdirSync(accessDir, { recursive: true });
+        mkdirSync(accessDir, { recursive: true, mode: 0o700 });
         const accessStatePath = join(accessDir, `access-${adapterId}.json`);
         const accessManager = new AccessManager(channelConfig.access ?? DEFAULT_OPEN_ACCESS, accessStatePath);
         this.warnIfAccessModeOverridden(accessManager, accessStatePath);
         const inboxDir = join(this.dataDir, "inbox");
-        mkdirSync(inboxDir, { recursive: true });
+        mkdirSync(inboxDir, { recursive: true, mode: 0o700 });
         const adapter = await createAdapter(channelConfig, {
             id: adapterId,
             botToken,
@@ -8118,7 +8697,7 @@ export class FleetManager {
                         // means we cannot verify the pane, which is treated as dead (the same
                         // conclusion the old code reached only by throwing).
                         try {
-                            const { execFile } = await import("node:child_process");
+                            const { execFile } = await import("./child-process.js");
                             const { promisify } = await import("node:util");
                             const { getTmuxSocketName } = await import("./paths.js");
                             // Honour socket isolation: without -L this queried the user's default
@@ -8668,6 +9247,22 @@ export class FleetManager {
             this.logger.debug({ adapterId: msg.adapterId, threadId: threadId ?? null, messageId: msg.messageId, reason: drop }, "Inbound message dropped before the dedup claim — key not consumed");
             return;
         }
+        // #2246 step 3 (#2341 review r2): a reply to a Needs you Send back / Answer prompt is the card's reason or answer, not
+        // input for an instance — judged by the PROMPT's world (its admins, its instance, its room as it is now; the hub's
+        // handleReply), before the room's generic access below: in a shared group the room may be another bot's, whose
+        // policy has no say over that world's prompt. Only that exact reply, by the admin who clicked, while the prompt
+        // stands. Taken once: another bot's copy of a taken reply is dropped here. All else flows on.
+        if (!msg.isBotMessage && msg.replyTo && this.needsYou) {
+            if (this.needsYou.wasTakenReply(msg.chatId, msg.messageId)) {
+                this.logger.debug({ adapterId: msg.adapterId, messageId: msg.messageId }, "Another bot's copy of a Needs you answer already taken — dropped");
+                return;
+            }
+            if (this.needsYou.handleReply({
+                adapterId: msg.adapterId, chatId: msg.chatId, ...(threadId !== undefined ? { threadId } : {}), replyTo: msg.replyTo,
+                messageId: msg.messageId, userId: msg.userId, ...(msg.username ? { username: msg.username } : {}), text: msg.text ?? "",
+            }))
+                return;
+        }
         // Access control — classic channels are open to all, others require an allowed
         // user. This runs before the dedup claim, and is judged by the adapter that
         // owns the topic rather than the one that happened to receive the message:
@@ -8778,6 +9373,10 @@ export class FleetManager {
                 // #1920 step 4b-3: /web typed in a ClassicBot room (a group: `/web@ThisBot`) by someone who is not a fleet admin,
                 // while guest sign-in is on: their guest code, privately — as anywhere else. An admin's goes on as before.
                 if (/^\/(?:web|dashboard)(?:\s|$)/i.test(text) && msgAdapter && this.isGuestWebAsk(msg.adapterId, msg.userId)) {
+                    // #2359: this door must not skip the deprecation notice TopicCommands shows on /dashboard.
+                    if (/^\/dashboard(?:\s|$)/i.test(text)) {
+                        await msgAdapter.sendText(chatId, t("dashboard.deprecated")).catch(() => { });
+                    }
                     await this.guestWebCommand({ adapterId: msg.adapterId, userId: msg.userId, username: msg.username,
                         arg: text.replace(/^\/(?:web|dashboard)/i, "").trim().toLowerCase(), replyHere: body => msgAdapter.sendText(chatId, body) });
                     return;
@@ -9224,9 +9823,14 @@ export class FleetManager {
      * history (#1565). #1920 §5.2: said in the instance's topic, General or room, so it is that channel's, by that account.
      */
     emitPlatformInbound(instance, msg, text) {
+        // #2281: where it is on the platform — a web reply to it is then a native reply there. The platform thread it came
+        // from (#1085: a ClassicBot's `threadId` may be its registry key).
+        const thread = msg.transportThreadId ?? msg.threadId;
+        const posts = msg.adapterId && msg.chatId && msg.messageId
+            ? [{ adapterId: msg.adapterId, chatId: msg.chatId, ...(thread && thread !== msg.chatId ? { threadId: thread } : {}), messageId: msg.messageId }] : undefined;
         this.emitSseEvent("message", {
             instance, sender: msg.username, role: "user", text: text.slice(0, WEB_CHAT_TEXT_MAX), ts: new Date().toISOString(),
-            channel: true, from: webChatFrom(msg.adapterId, msg.userId),
+            channel: true, from: webChatFrom(msg.adapterId, msg.userId), ...(posts ? { posts } : {}),
         });
     }
     /** Handle outbound tool calls from a daemon instance */
@@ -9328,12 +9932,21 @@ export class FleetManager {
         }
     }
     checkToolPermission(sink, instanceName, tool) {
+        if (isCanvasWorkerTool(tool) && !this.canvasWorkerEnabled())
+            return { allowed: false, message: CANVAS_WORKER_EXPERIMENTAL_MESSAGE };
         const profile = resolveToolSet(this.fleetConfig?.instances[instanceName], instanceName);
         const allowed = mayUseTool(profile, tool);
         if (!allowed) {
             this.logger.warn({ sink, instance: instanceName, profile, tool, enforced: true }, "tool-permissions: refused");
             return { allowed: false, message: toolRefusedMessage(profile, tool) };
         }
+        // The person's dashboard switches (dashboard-permissions.ts), on top of the profile, as configured now.
+        // Its own switches, else the defaults' — a ClassicBot identity has no instances entry and runs on the defaults (#2391 review).
+        const switchedOff = dashboardRefusalIn(this.fleetConfig, instanceName, tool);
+        if (switchedOff) {
+            this.logger.warn({ sink, instance: instanceName, profile, tool, enforced: true, dashboard: true }, "tool-permissions: refused");
+            return { allowed: false, message: switchedOff };
+        }
         this.logger.debug({ sink, instance: instanceName, profile, tool, enforced: true }, "tool-permissions: allowed");
         return { allowed: true, message: "" };
     }
@@ -9341,6 +9954,9 @@ export class FleetManager {
         this.touchActivity(instanceName);
         this.setTopicIcon(instanceName, "green");
         const tool = msg.tool;
+        // #1774: who sends this — taken before anything here awaits (sticker checks, the platform send): a reply that waits
+        // must never be read as a same-name replacement's (removed and re-registered meanwhile).
+        const sentBy = tool === "reply" ? this.webChatIdentity(instanceName) : undefined;
         const args = (msg.args ?? {});
         const requestId = msg.requestId;
         const fleetRequestId = msg.fleetRequestId;
@@ -9373,6 +9989,27 @@ export class FleetManager {
             respond(null, permitted.message);
             return;
         }
+        // Fleet tools resolve their own targets. A missing chat world must not prevent local
+        // delivery, inspection or receipt lookup; only channel tools need reply routing below.
+        const handler = outboundHandlers.get(tool);
+        if (handler && !usesChannelAddress(tool)) {
+            this.eventLog?.logActivity("tool_call", senderSessionName ?? instanceName, this.summarizeToolCall(tool, args));
+            await handler(this, args, respond, {
+                instanceName, requestId, fleetRequestId, senderSessionName, operationId, sourceDaemonBootId,
+            });
+            return;
+        }
+        // #2305: a reaction to a web chat message is the web chat's own (any fleet, web-only included): never an adapter's.
+        if (tool === "react" && typeof args.message_id === "string" && isWebMessageId(args.message_id)) {
+            // The socket's own instance, never a session name the caller wrote itself (as checkToolPermission: it was not
+            // identified) — a channel tool's call from a daemon carries none anyway (#2310 review).
+            const r = await this.reactToWebMessage(instanceName, args.message_id, args.emoji);
+            if (r.ok)
+                respond("ok");
+            else
+                respond(null, r.error);
+            return;
+        }
         // A fleet with no chat platform at all is driven from the web dashboard alone: a reply has nowhere
         // else to go, and "retry shortly" would have the agent retry forever. It goes to the web chat.
         const webOnlyReply = tool === "reply" && this.worlds.size === 0 && this.isWebOnlyFleet();
@@ -9499,6 +10136,7 @@ export class FleetManager {
                     args.text = `${String(args.text)}\n\n${replyButtonsFallbackText(parsedButtons.buttons)}`;
                 }
             }
+            const replyIdentity = sentBy; // #1774: taken at the handler's entry
             const original = respond;
             const respondAndRecord = (result, error) => {
                 let buttonsView = null;
@@ -9530,12 +10168,13 @@ export class FleetManager {
                     try {
                         // #1920 §5.2: shown to the instance's guests only when it landed in the instance's own topic or room.
                         let inChannel = false;
+                        const replyAdapterId = contextAdapterId ?? this.getInstanceAdapterId(instanceName);
                         try {
                             inChannel = outAdapter !== WEB_ONLY_REPLY_SINK
-                                && this.landedInOwnChannel(instanceName, contextAdapterId ?? this.getInstanceAdapterId(instanceName), result);
+                                && this.landedInOwnChannel(instanceName, replyAdapterId, result);
                         }
                         catch { /* not known: not the channel's (fail closed), and the bookkeeping below still runs */ }
-                        void this.afterReplyRouted(instanceName, args, senderSessionName, buttonsView, inChannel);
+                        void this.afterReplyRouted(instanceName, args, senderSessionName, buttonsView, inChannel, replyAdapterId ? { adapterId: replyAdapterId, result } : undefined, replyIdentity);
                     }
                     catch (err) {
                         this.logger.warn({ err, instanceName }, "Reply delivered but post-delivery bookkeeping failed");
@@ -9564,19 +10203,14 @@ export class FleetManager {
         if (routeToolCall(outAdapter, tool, args, threadId, respond)) {
             return;
         }
-        // Log tool calls for activity visualization
-        const senderLabel = senderSessionName ?? instanceName;
-        this.eventLog?.logActivity("tool_call", senderLabel, this.summarizeToolCall(tool, args));
-        // Dispatch fleet-specific tools via handler map
-        const handler = outboundHandlers.get(tool);
         if (handler) {
+            this.eventLog?.logActivity("tool_call", senderSessionName ?? instanceName, this.summarizeToolCall(tool, args));
             await handler(this, args, respond, {
                 instanceName, requestId, fleetRequestId, senderSessionName, operationId, sourceDaemonBootId,
             });
         }
-        else {
+        else
             respond(null, `Unknown tool: ${tool}`);
-        }
     }
     /** Side effects of a routed reply: cancel-button lifecycle, logs, SSE, chat log. */
     /** No chat platform is configured at all: the web dashboard is the fleet's only surface. */
@@ -9617,7 +10251,12 @@ export class FleetManager {
             return false;
         }
     }
-    afterReplyRouted(instanceName, args, senderSessionName, buttons = null, inChannel = false) {
+    afterReplyRouted(instanceName, args, senderSessionName, buttons = null, inChannel = false, sentAs, identity = this.webChatIdentity(instanceName)) {
+        // #2281: where the reply is, when it landed in the instance's own place — a web reply to it is then a native reply
+        // there. A reply elsewhere (another chat, the web-only sink) records none.
+        const sent = (sentAs?.result && typeof sentAs.result === "object" ? sentAs.result : {});
+        const post = inChannel && sentAs && typeof sent.messageId === "string" && typeof sent.chatId === "string"
+            ? { adapterId: sentAs.adapterId, chatId: sent.chatId, ...(typeof sent.threadId === "string" && sent.threadId ? { threadId: sent.threadId } : {}), messageId: sent.messageId } : undefined;
         // A reply is NOT proof the turn is over (#410) — but it is not proof of
         // more work either. Split the difference: an instance that is clearly
         // idle loses the button now; one that looks busy keeps it (re-posted
@@ -9644,7 +10283,16 @@ export class FleetManager {
         // copies are done, and an instance's replies wait for the one before them: they reach the chat in order.
         const replyFiles = Array.isArray(args.files) ? args.files.filter((f) => typeof f === "string") : [];
         const ts = new Date().toISOString();
-        const show = (attachments) => {
+        // #1774: the instance this reply is for — removed while its files were being copied (a same-name replacement
+        // registered meanwhile included), the reply is no longer its to show: no chat made again, none of the new one's
+        // touched, and the copies made for it go. A replacement's own replies are its own.
+        // Its identity was taken when the reply was sent (identity), never re-read after the platform answered.
+        const current = () => this.webChatIdentityCurrent(instanceName, identity);
+        const show = (attachments, reserved) => {
+            if (!current()) {
+                this.webFiles.dropServed(attachments.map(a => a.id));
+                return;
+            }
             // The one place a delivered agent reply reaches the web chat: the server marks it `agent` (#1306) — the only
             // role that may get HTML preview cards. Never inferred from the sender name or the text.
             this.emitSseEvent("message", {
@@ -9654,18 +10302,25 @@ export class FleetManager {
                 ...(attachments.length ? { attachments } : {}),
                 ...(buttons ? { buttons } : {}), // #1266
                 ...(inChannel ? { channel: true } : {}), // #1920 §5.2
+                ...(post ? { posts: [post] } : {}), // #2281
+                ...(reserved !== undefined ? { reserved } : {}), // #1774
             });
         };
         const before = this.webReplyOrder.get(instanceName);
-        if (!replyFiles.length && !before) {
+        // #1774: a removal of this instance still going decides whether a reply sent before it began is shown — it waits.
+        const removal = this.webChatRemovalPending(instanceName, identity);
+        if (!replyFiles.length && !before && !removal) {
             show([]);
             return Promise.resolve();
         }
+        // #1774: its place in the chat is now — a person's message sent while the files are copied comes after it.
+        const reserved = this.webChatHistory.reserve();
         const done = (before ?? Promise.resolve())
-            .then(() => this.webReplyAttachments(instanceName, replyFiles))
+            .then(() => this.webReplyAttachments(instanceName, replyFiles, current))
+            .then(async (attachments) => { await this.webChatRemovalPending(instanceName, identity); return attachments; })
             .catch((err) => { this.logger.warn({ err, instanceName }, "Reply files could not be prepared for the web chat"); return []; })
             .then((attachments) => { try {
-            show(attachments);
+            show(attachments, reserved);
         }
         catch (err) {
             this.logger.warn({ err, instanceName }, "Reply could not be shown in the web chat");
@@ -9680,11 +10335,13 @@ export class FleetManager {
      * the copy. One the copy refuses (a symlink, not a regular file, over 50 MB, a state file, missing) is not shown;
      * one that could not be copied (I/O) is served from the agent's own path, as before — until the fleet restarts.
      */
-    async webReplyAttachments(instanceName, paths) {
+    async webReplyAttachments(instanceName, paths, current = () => true) {
         const home = getAgendHome();
         const dir = webFilesDir(home, instanceName);
         const out = [];
         for (const path of paths) {
+            if (!current())
+                break; // #1774: removed meanwhile — copy no more for it
             const id = randomBytes(16).toString("hex");
             const got = dir ? await snapshotReplyFile(path, dir, id, { stateDir: home, maxDirBytes: this.webReplyMaxBytes }) : null;
             if (got && "evicted" in got && got.evicted.length)
@@ -9996,13 +10653,14 @@ export class FleetManager {
         if (!ipc || !fleetRequestId)
             return;
         const type = String(msg.type);
-        const responseType = type.startsWith("fleet_schedule_") ? "fleet_schedule_response"
-            : type.startsWith("fleet_decision_") ? "fleet_decision_response"
-                : type === "fleet_task" ? "fleet_task_response"
-                    : type === "fleet_set_display_name" ? "fleet_display_name_response"
-                        : type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis"
-                            || type === "fleet_list_stickers" || type === "fleet_preview_stickers" ? "fleet_persona_emoji_response"
-                            : "fleet_description_response";
+        const responseType = isCanvasWorkerTool(type.replace(/^fleet_/, "")) ? "fleet_web_theme_response"
+            : type.startsWith("fleet_schedule_") ? "fleet_schedule_response"
+                : type.startsWith("fleet_decision_") ? "fleet_decision_response"
+                    : type === "fleet_task" ? "fleet_task_response"
+                        : type === "fleet_set_display_name" ? "fleet_display_name_response"
+                            : type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis"
+                                || type === "fleet_list_stickers" || type === "fleet_preview_stickers" ? "fleet_persona_emoji_response"
+                                : "fleet_description_response";
         ipc.send({ type: responseType, fleetRequestId, error: message });
     }
     dispatchTypedIpc(name, msg) {
@@ -10163,10 +10821,11 @@ export class FleetManager {
                 }
                 case "fleet_decision_list":
                     db.pruneExpiredDecisions();
-                    result = db.listDecisions(projectRoot, {
+                    // #2152: titles by default; the full text by id, or all of it with full: true.
+                    result = decisionListAnswer(db.listDecisions(projectRoot, {
                         includeArchived: payload.include_archived,
                         tags: payload.tags,
-                    });
+                    }), { id: payload.id, full: payload.full });
                     break;
                 case "fleet_decision_update": {
                     const id = payload.id;
@@ -10359,10 +11018,16 @@ export class FleetManager {
                     created_by: instance,
                 });
             }
-            case "list": return db.listDecisions(projectRoot, {
-                includeArchived: args.includeArchived === true,
-                tags: asStrArr(args.tags),
-            });
+            // #2152: titles by default (agend-agent decision-list); one decision's full text by id (decision-get <id>).
+            // The CLI sends include_archived (snake case, as the MCP tool): both spellings are read.
+            case "list":
+            case "get":
+                if (op === "get" && !asStr(args.id)?.trim())
+                    return { error: "id is required" };
+                return decisionListAnswer(db.listDecisions(projectRoot, {
+                    includeArchived: args.includeArchived === true || args.include_archived === true,
+                    tags: asStrArr(args.tags),
+                }), { id: op === "get" ? asStr(args.id) ?? "" : args.id, full: args.full });
             case "update": {
                 const id = asStr(args.id);
                 if (!id)
@@ -10387,14 +11052,20 @@ export class FleetManager {
             return (v === "low" || v === "normal" || v === "high" || v === "urgent") ? v : undefined;
         };
         const asStatus = (v) => {
-            return (v === "open" || v === "claimed" || v === "done" || v === "blocked" || v === "cancelled") ? v : undefined;
+            return (v === "open" || v === "claimed" || v === "review" || v === "done" || v === "blocked" || v === "cancelled") ? v : undefined;
         };
         // #1336 P2: use the shared normalizer — trims whitespace AND drops empties,
         // so " \t " / [" ","\t"] are treated identically to undefined.
         const asStatusFilter = normalizeStatusFilter;
         // #1336: small write ack — identifying fields only.
         const ack = (t) => ({ id: t.id, status: t.status, updated_at: t.updated_at });
+        // The board's notes for the write (a send-back reason, a comment the assignee had not seen): with the ack when any.
+        const noted = (a) => { const notes = db.board.takeNotes(); return notes.length ? { ...a, notes } : a; };
         try {
+            // The task board's own actions and fields (task-board-tool.ts); the rest is the tool's plain task, below.
+            const onBoard = boardToolAction(db, instance, args);
+            if (onBoard !== undefined)
+                return onBoard;
             switch (action) {
                 case "create": {
                     const title = asStr(args.title);
@@ -10433,24 +11104,24 @@ export class FleetManager {
                     const id = asStr(args.id);
                     if (!id)
                         return { error: "id is required" };
-                    return ack(db.claimTask(db.getTaskByPrefix(id).id, instance));
+                    return noted(ack(db.claimTask(db.getTaskByPrefix(id).id, instance, { kind: "instance", name: instance })));
                 }
                 case "done": {
                     const id = asStr(args.id);
                     if (!id)
                         return { error: "id is required" };
-                    return ack(db.completeTask(db.getTaskByPrefix(id).id, asStr(args.result)));
+                    return noted(ack(db.completeTask(db.getTaskByPrefix(id).id, asStr(args.result), { kind: "instance", name: instance })));
                 }
                 case "update": {
                     const id = asStr(args.id);
                     if (!id)
                         return { error: "id is required" };
-                    return ack(db.updateTask(db.getTaskByPrefix(id).id, {
+                    return noted(ack(db.updateTask(db.getTaskByPrefix(id).id, {
                         status: asStatus(args.status),
                         assignee: asStr(args.assignee),
                         result: asStr(args.result),
                         priority: asPriority(args.priority),
-                    }));
+                    }, { kind: "instance", name: instance })));
                 }
                 default: return { error: `Unknown task action: ${action}` };
             }
@@ -10482,6 +11153,8 @@ export class FleetManager {
     }
     /** #1629: `agend-agent theme …` — the same service as the tools; `instance` is the token's. */
     async handleWebThemeHttp(instance, tool, args) {
+        if (isCanvasWorkerTool(tool) && !this.canvasWorkerEnabled())
+            return { error: "canvas_worker_experimental", message: CANVAS_WORKER_EXPERIMENTAL_MESSAGE };
         if (WEB_EFFECT_TOOLS.has(tool)) {
             if (!this.isKnownInstance(instance))
                 return { error: "unknown_instance" };
@@ -10544,7 +11217,18 @@ export class FleetManager {
         // so " \t " / [" ","\t"] are treated identically to undefined.
         const asStatusFilter = normalizeStatusFilter;
         const ack = (t) => ({ id: t.id, status: t.status, updated_at: t.updated_at });
+        const noted = (a) => { const notes = db.board.takeNotes(); return notes.length ? { ...a, notes } : a; };
         try {
+            // The task board's own actions and fields (task-board-tool.ts); the rest is the tool's plain task, below.
+            const onBoard = boardToolAction(db, meta.instance_name || instanceName, payload);
+            if (onBoard !== undefined) {
+                ipc.send({ type: "fleet_task_response", fleetRequestId, result: onBoard });
+                // The activity log hears of board work as it does of plain tasks.
+                const what = boardActivity(payload);
+                if (what)
+                    this.eventLog?.logActivity("task_update", instanceName, what);
+                return;
+            }
             let result;
             // Full task kept for activity logging; the IPC reply uses the compact ack.
             let logTask;
@@ -10580,12 +11264,12 @@ export class FleetManager {
                     result = db.getTaskByPrefix(payload.id);
                     break;
                 case "claim":
-                    logTask = db.claimTask(db.getTaskByPrefix(payload.id).id, meta.instance_name || instanceName);
-                    result = ack(logTask);
+                    logTask = db.claimTask(db.getTaskByPrefix(payload.id).id, meta.instance_name || instanceName, { kind: "instance", name: meta.instance_name || instanceName });
+                    result = noted(ack(logTask));
                     break;
                 case "done":
-                    logTask = db.completeTask(db.getTaskByPrefix(payload.id).id, payload.result);
-                    result = ack(logTask);
+                    logTask = db.completeTask(db.getTaskByPrefix(payload.id).id, payload.result, { kind: "instance", name: meta.instance_name || instanceName });
+                    result = noted(ack(logTask));
                     break;
                 case "update":
                     logTask = db.updateTask(db.getTaskByPrefix(payload.id).id, {
@@ -10593,8 +11277,8 @@ export class FleetManager {
                         assignee: payload.assignee,
                         result: payload.result,
                         priority: payload.priority,
-                    });
-                    result = ack(logTask);
+                    }, { kind: "instance", name: meta.instance_name || instanceName });
+                    result = noted(ack(logTask));
                     break;
                 default:
                     throw new Error(`Unknown task action: ${action}`);
@@ -10909,6 +11593,7 @@ export class FleetManager {
     saveFleetConfig(explicitPatches = []) {
         this.publicWebLink?.refresh();
         this.enforceGuestSwitch(); // #1920: a Settings save turning guests off ends their sessions
+        this.observeWebAuthority(); // #2453 review: so is a web-authority switch (off is always seen)
         if (!this.fleetConfig || !this.configPath)
             return;
         if (!this.savedFleetConfigSnapshot)
@@ -10921,6 +11606,10 @@ export class FleetManager {
             throw new Error(`Refusing to overwrite invalid fleet.yaml: ${this.rawFleetDocument.errors[0].message}`);
         }
         this.rawFleetConfig = loadRawFleetConfig(this.configPath);
+        // #2208: what the file says before this save, aliases expanded — every write below is recorded, and anything that
+        // changes outside them (a place sharing a node with one written) refuses the save.
+        const fileBefore = this.rawFleetDocument.toJS({ maxAliasCount: -1 });
+        const writes = this.fleetDocumentWrites = []; // a throw below leaves it to the next save
         this.patchFleetDocument(this.rawFleetDocument, [], this.savedFleetConfigSnapshot, this.fleetConfig);
         // Settings edits are expressed against the raw config, so apply them before
         // canonicalization. A non-identity value equal to its inherited default is
@@ -10931,6 +11620,7 @@ export class FleetManager {
                 // (or a legacy scalar occupies that parent). Removing an override which
                 // is already absent is an idempotent no-op, not a failed Settings save.
                 if (this.rawFleetDocument.hasIn(patch.path)) {
+                    this.writingFleetDocument(this.rawFleetDocument, patch.path);
                     this.rawFleetDocument.deleteIn(patch.path);
                 }
             }
@@ -10942,8 +11632,10 @@ export class FleetManager {
         const rawAfterPatches = this.rawFleetDocument.toJS();
         const redundantPaths = collectRedundantInstanceDefaultPaths(rawAfterPatches);
         for (const path of redundantPaths) {
-            if (this.rawFleetDocument.hasIn(path))
+            if (this.rawFleetDocument.hasIn(path)) {
+                this.writingFleetDocument(this.rawFleetDocument, path);
                 this.rawFleetDocument.deleteIn(path);
+            }
             // Avoid leaving empty operational maps such as `terminal: {}` while
             // preserving the instance mapping itself and all surrounding comments.
             for (let depth = path.length - 1; depth > 2; depth--) {
@@ -10951,9 +11643,14 @@ export class FleetManager {
                 const parent = this.rawFleetDocument.getIn(parentPath, true);
                 if (!isMap(parent) || parent.items.length > 0)
                     break;
+                this.writingFleetDocument(this.rawFleetDocument, parentPath);
                 this.rawFleetDocument.deleteIn(parentPath);
             }
         }
+        this.fleetDocumentWrites = null;
+        const stray = changedOutside(fileBefore, this.rawFleetDocument.toJS({ maxAliasCount: -1 }), writes);
+        if (stray)
+            throw new Error(`Refusing to save fleet.yaml: this change would also change ${stray}, which shares a value with what it edits. Give each its own value in fleet.yaml.`);
         noteSettingsWrite(this.configPath, this.savedFleetConfigSnapshot, this.fleetConfig);
         const output = String(this.rawFleetDocument);
         if (redundantPaths.length > 0)
@@ -11064,11 +11761,15 @@ export class FleetManager {
             // Remove from the end so YAML sequence indexes do not shift underneath us.
             for (let i = before.length - 1; i >= after.length; i--) {
                 const itemPath = [...path, i];
-                if (document.hasIn(itemPath))
+                if (document.hasIn(itemPath)) {
+                    this.writingFleetDocument(document, itemPath);
                     document.deleteIn(itemPath);
+                }
             }
-            for (let i = shared; i < after.length; i++)
+            for (let i = shared; i < after.length; i++) {
+                this.writingFleetDocument(document, [...path, i]);
                 document.setIn([...path, i], after[i]);
+            }
             return;
         }
         const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -11084,6 +11785,7 @@ export class FleetManager {
                 if (isMap(fresh)) {
                     const list = document.createNode([]);
                     list.items.push(fresh.clone());
+                    this.writingFleetDocument(document, ["channels"]);
                     document.setIn(["channels"], list);
                 }
             }
@@ -11105,13 +11807,17 @@ export class FleetManager {
             // Effective config contains inherited objects that may not exist in the
             // raw YAML at all. yaml.deleteIn() is not idempotent for a missing nested
             // parent, so guard it explicitly.
-            if (document.hasIn(path))
+            if (document.hasIn(path)) {
+                this.writingFleetDocument(document, path);
                 document.deleteIn(path);
+            }
         }
         else if (path.length === 0) {
+            this.writingFleetDocument(document, path);
             document.contents = document.createNode(after);
         }
         else {
+            this.writingFleetDocument(document, path);
             const currentNode = document.getIn(path, true);
             if (isScalar(currentNode) && (after === null || typeof after !== "object")) {
                 currentNode.value = after;
@@ -11126,6 +11832,15 @@ export class FleetManager {
             }
         }
     }
+    /**
+     * #2208: before every write to the raw document — the place is unshared first (an alias on the way becomes its own
+     * copy; an anchor's other aliases get theirs), so the write changes that place only; and it is recorded for the
+     * save's check that nothing else changed.
+     */
+    writingFleetDocument(document, path) {
+        detachForWrite(document, path);
+        this.fleetDocumentWrites?.push([...path]);
+    }
     getSettingsConfigPath() { return this.configPath; }
     async removeInstance(name, authorization, execution) {
         if (execution)
@@ -11169,10 +11884,27 @@ export class FleetManager {
         // Capture instance dir BEFORE lifecycle.remove, which deletes the instance
         // from fleetConfig. (The backend would be unresolvable afterwards.)
         const instanceDirToClean = this.getInstanceDir(name);
-        if (execution)
-            await this.lifecycle.remove(name, authorization, execution, transition);
-        else
-            await this.lifecycle.remove(name, authorization);
+        // #1774: replies sent from here on are a later instance's (a replacement registered while this one goes); the ones
+        // sent before wait for the outcome before they are shown.
+        const removedBelow = this.webChatGeneration(name) + 1, removedDaemon = this.daemons.get(name);
+        this.webChatGenerations.set(name, removedBelow);
+        let settleRemoval;
+        const removalPending = { below: removedBelow, ...(removedDaemon !== undefined ? { daemon: removedDaemon } : {}), done: new Promise(r => { settleRemoval = r; }) };
+        this.webChatRemovalsPending.set(name, removalPending);
+        try {
+            if (execution)
+                await this.lifecycle.remove(name, authorization, execution, transition);
+            else
+                await this.lifecycle.remove(name, authorization);
+            // #1774: removed — its replies still copying their files are no one's to show, replaced or not (a failed removal
+            // throws above: its replies stay its own).
+            this.webChatRemovals.set(name, { below: removedBelow, ...(removedDaemon !== undefined ? { daemon: removedDaemon } : {}) });
+        }
+        finally {
+            if (this.webChatRemovalsPending.get(name) === removalPending)
+                this.webChatRemovalsPending.delete(name);
+            settleRemoval();
+        }
         // A later same-name registration owns its files and caches.
         // Own keys only: an instance named "constructor" is removed as any other (its inherited namesake is not a
         // re-registration) — #1677 review.
@@ -11187,6 +11919,7 @@ export class FleetManager {
         // Its web chat goes with it (only after the removal succeeded): a later instance of the same name
         // must not be shown the old one's conversation, and deleted names must not pile up.
         this.webChatHistory.forget(name);
+        this.searchIndex?.removeInstance(name);
         this.webFiles.forget(name);
         this.compactWatchService?.forget(name);
         // #1664: and it is nobody's favorite any more (every device sees that at its next status frame).
@@ -11398,11 +12131,23 @@ export class FleetManager {
     guildEmojiFetches = new Map();
     // ── #1630: what stands for an instance in the web app, and Discord server emoji in web chat ──
     webImageCaches = null;
+    /** Server emoji whose picture fetch failure was already logged at warn (once each; bounded). */
+    webEmojiFailures = new Set();
     webImageCache(kind) {
         const onError = (key, err) => this.logger.debug({ err: err?.message, key }, "web image fetch failed (kept what was cached)");
+        // A server emoji's picture that cannot be fetched reads `:name:` in web chat (it used to be an empty box, the user's
+        // "tofu"): say why once per emoji, where it can be seen, not on every render (its key is quiet for an hour anyway).
+        const emojiError = (key, err) => {
+            if (this.webEmojiFailures.has(key))
+                return onError(key, err);
+            this.webEmojiFailures.add(key);
+            while (this.webEmojiFailures.size > 512)
+                this.webEmojiFailures.delete(this.webEmojiFailures.values().next().value);
+            this.logger.warn({ err: err?.message, key }, "Discord server emoji picture could not be fetched (web chat shows its :name:)");
+        };
         this.webImageCaches ??= {
             avatars: new WebImageCache({ dir: join(this.dataDir, "cache", "avatars"), onError }),
-            emoji: new WebImageCache({ dir: join(this.dataDir, "cache", "emoji"), onError }),
+            emoji: new WebImageCache({ dir: join(this.dataDir, "cache", "emoji"), onError: emojiError }),
         };
         return this.webImageCaches[kind];
     }
@@ -11855,7 +12600,7 @@ export class FleetManager {
     /** A preview under the inbox, named by a hash of the id (a Telegram file_id is long), pruned after a day. */
     storeStickerPreview(id, picture) {
         const dir = join(this.dataDir, "inbox", "sticker-previews");
-        mkdirSync(dir, { recursive: true });
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
         const now = Date.now();
         for (const name of readdirSync(dir)) {
             try {
@@ -11921,7 +12666,7 @@ export class FleetManager {
         if (!/^\d{15,25}$/.test(id))
             throw new Error("not a Discord emoji id");
         const dir = join(this.dataDir, "inbox", "emoji-previews");
-        mkdirSync(dir, { recursive: true });
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
         const now = Date.now();
         for (const name of readdirSync(dir)) {
             try {
@@ -12320,7 +13065,7 @@ export class FleetManager {
         const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
         const backend = this.fleetConfig?.defaults?.backend || "claude-code";
         try {
-            const { execFile } = await import("node:child_process");
+            const { execFile } = await import("./child-process.js");
             const { promisify } = await import("node:util");
             // execFile with an argv array — no shell, so the backend name cannot be
             // interpreted as a command even if config is malformed.
@@ -12546,6 +13291,51 @@ export class FleetManager {
         }
         return { chatId, opts: {} };
     }
+    /**
+     * #2246 step 3: the task board's daily summary of [since, until) (task-board-summary.ts). Each chat world's General
+     * gets its own instances' cards — a card that no world's instance holds (nobody's, a person's) goes to the primary
+     * one — and each of that world's Generals shows the same text in the web chat. A world with nothing to say gets
+     * nothing. A web-only fleet: everything, in the web chat.
+     */
+    postTaskBoardSummary(since, until) {
+        const board = this.scheduler?.db.board;
+        if (!board)
+            return;
+        const read = board.summaryRead(since.toISOString(), until.toISOString(), this.dispatcherGone);
+        const projects = board.listProjects(true);
+        const stats = board.projectStats();
+        const names = new Map(projects.map((p) => [p.id, p.name]));
+        const configured = this.getPrimaryAdapterId();
+        const primary = configured !== undefined && this.worlds.has(configured) ? configured : this.worlds.keys().next().value;
+        const worldOf = (assignee) => {
+            const owner = assignee ? this.getInstanceAdapterId(assignee) : undefined;
+            return owner !== undefined && this.worlds.has(owner) ? owner : primary;
+        };
+        const zone = this.usageZone();
+        for (const world of this.worlds.size ? [...this.worlds.keys()] : [undefined]) {
+            const summary = buildSummary(read, since, until, { inChat: (assignee) => worldOf(assignee) === world, projects, stats });
+            if (isQuiet(summary))
+                continue;
+            const text = renderSummary(summary, { zone, t: (key, ...args) => t(key, ...args), projectOf: (c) => (c.projectId === null ? null : names.get(c.projectId) ?? null) });
+            const cards = [...new Set([...summary.review, ...summary.blocked, ...summary.done, ...summary.created].map((c) => c.code))];
+            if (world !== undefined) {
+                const adapter = this.worlds.get(world)?.adapter;
+                const target = this.fleetNoticeTarget(world);
+                if (adapter && target) {
+                    adapter.sendText(target.chatId, text, target.opts).catch(e => this.logger.warn({ err: e, world }, "Failed to send the task board's daily summary"));
+                }
+                else {
+                    this.logger.warn({ world }, "The task board's daily summary has no postable target — set a General topic or channel.options.general_channel_id");
+                }
+            }
+            for (const [name, cfg] of Object.entries(this.fleetConfig?.instances ?? {})) {
+                if (cfg.general_topic !== true || (world !== undefined && this.getInstanceAdapterId(name) !== world))
+                    continue;
+                // #2341 review: with the cards it names, so the public link withholds it while one of them is hidden there.
+                this.emitSseEvent("message", { instance: name, sender: name, role: "status", text, ts: new Date().toISOString(), cards });
+            }
+        }
+    }
     /**
      * Post the daily summary where fleet-wide notices go.
      *
@@ -13192,6 +13982,7 @@ export class FleetManager {
                 interactionSummary: p.interaction_summary ?? null,
                 pauseReason, pausedAt,
                 crashedAt: crashed ? (this.needsCrashedAt.get(name) ?? null) : null,
+                signIn: pauseReason === "auth" ? this.signInFor(name) : null,
             });
         }
         return out;
@@ -13253,6 +14044,8 @@ export class FleetManager {
                     return String(topic);
                 return this.classicChannels?.getChannelIdByInstance(instance) ?? undefined;
             },
+            laneTarget: instance => this.instanceChannelTarget(instance),
+            taskRoute: code => this.needsYouRoute(code),
             isFleetAdmin: (userId, world) => this.isFleetAdmin(userId, world),
             fleetAdmins: world => (this.getChannelConfig(world)?.access?.allowed_users ?? []).map(String),
             emitSse: (event, data) => this.emitSseEvent(event, data),
@@ -13261,6 +14054,8 @@ export class FleetManager {
                     throw new Error("the delivery outbox is not open");
                 return this.deliveryOutbox.acknowledge(deliveryId, by);
             },
+            tasks: () => this.needsYouTaskItems(),
+            taskAction: action => this.taskActionFromChat(action),
             settings: () => ({
                 liveMessage: this.fleetConfig?.needs_you?.live_message !== false,
                 dm: this.fleetConfig?.needs_you?.dm === true,
@@ -13271,6 +14066,114 @@ export class FleetManager {
         });
         this.needsYou.start();
     }
+    /**
+     * #2352: where an instance's own notices go — its topic in its world's group, or its ClassicBot room — as a Needs you
+     * lane's place; null when it has neither (or its world has no group).
+     */
+    instanceChannelTarget(instance) {
+        const cfg = this.fleetConfig?.instances && Object.hasOwn(this.fleetConfig.instances, instance) ? this.fleetConfig.instances[instance] : undefined;
+        if (!cfg)
+            return null;
+        const groupId = this.getChannelConfig(this.getInstanceAdapterId(instance))?.group_id;
+        if (cfg.topic_id != null && groupId != null)
+            return { chatId: String(groupId), threadId: String(cfg.topic_id) };
+        const classic = this.classicChannels?.getChannelIdByInstance(instance);
+        return classic ? { chatId: classic } : null;
+    }
+    /**
+     * #2352: the instance whose own channel lists a waiting card — its project's lead — when that channel can be used now
+     * (a fleet instance of a live world, with a topic or room). undefined: its assignee's world's General, as before.
+     * #2434: only a card the person handed out waits for them, so the instance that handed one out is never its lane.
+     */
+    needsYouLane(card, leads) {
+        const usable = (name) => {
+            if (!name || !this.fleetConfig?.instances || !Object.hasOwn(this.fleetConfig.instances, name))
+                return false;
+            const world = this.getInstanceAdapterId(name);
+            return world !== undefined && this.worlds.has(world) && this.instanceChannelTarget(name) !== null;
+        };
+        const lead = card.projectId != null ? leads.get(card.projectId) : null;
+        return usable(lead) ? lead : undefined;
+    }
+    /**
+     * #2355 review: where a card's Needs you buttons belong now — read from the board and the fleet at the moment of a click
+     * or a reply, never from the last render. null: it no longer waits for the person.
+     */
+    /**
+     * #2425 follow-up: an instance that handed out a card and is no longer in the fleet — neither a configured instance nor
+     * a ClassicBot identity (deleted). Its blocked and in-review cards fall back to the person (Needs you, the summary).
+     * Not known before the config and the ClassicBot rooms are loaded: then no one is gone (a live dispatcher's cards never
+     * flash into the person's list at startup).
+     */
+    dispatcherGone = (name) => {
+        const instances = this.fleetConfig?.instances, classic = this.classicChannels;
+        if (!instances || !classic)
+            return false;
+        return !Object.hasOwn(instances, name) && !classic.getAll().some((ch) => ch.instanceName === name);
+    };
+    needsYouRoute(code) {
+        const board = this.scheduler?.db.board;
+        const card = board?.findCard(code);
+        // #2425 (Fable): the same rule as the list — a button rendered before the fix (or before the opt-in went off) for a
+        // card that no longer waits for the person answers "no longer waits".
+        if (!board || !card || this.fleetConfig?.needs_you?.task_board !== true || !waitsForPerson(card, this.dispatcherGone))
+            return null;
+        const leads = new Map(board.listProjects(true).map((p) => [p.id, p.leadInstance]));
+        const lane = this.needsYouLane(card, leads);
+        return lane ? { lane } : {};
+    }
+    /**
+     * #2246 step 3: the task board's cards that wait for the person, for Needs you — under each card's assignee, listed in
+     * its lane's channel (#2352: its project's lead; #2434: never the instance that handed it out), else in General.
+     */
+    needsYouTaskItems() {
+        // #2425: the task board's cards join Needs you only when the fleet asks for them (needs_you.task_board, off by
+        // default since 2.3.0-beta.25); prompts, deliveries and the rest are unchanged.
+        return this.fleetConfig?.needs_you?.task_board === true ? this.needsYouTasks() : [];
+    }
+    needsYouTasks() {
+        const board = this.scheduler?.db.board;
+        if (!board)
+            return [];
+        const leads = new Map(board.listProjects(true).map((p) => [p.id, p.leadInstance]));
+        return board.waitingForPerson(this.dispatcherGone).map(({ card, since }) => {
+            const gap = card.status === "review" ? wrapUpGap(card) : null;
+            const lane = this.needsYouLane(card, leads);
+            return {
+                uuid: card.uuid, code: card.code, title: card.title, status: card.status, version: card.version,
+                assignee: card.assignee, since: Date.parse(since) || 0, ...(gap ? { gap } : {}), ...(lane ? { lane } : {}),
+                note: card.status === "blocked" ? card.blockedReason : gap ? t("needs.task_gap", [
+                    gap.unchecked ? t("needs.task_gap_unchecked", gap.unchecked) : "", gap.noResult ? t("needs.task_gap_no_result") : "",
+                ].filter(Boolean).join(t("needs.task_gap_join"))) : "",
+            };
+        });
+    }
+    /**
+     * #2246 step 3: the person's move on a card from a chat's Needs you list — a fleet admin of that world (checked by the
+     * hub), acting as the person, through the board's rules, at the version the button showed.
+     */
+    taskActionFromChat(action) {
+        const board = this.scheduler?.db.board;
+        if (!board)
+            return { ok: false, message: t("needs.task_board_closed") };
+        const person = { kind: "person", name: action.by.username || `${action.by.platform}:${action.by.userId}` };
+        try {
+            if (action.verb === "confirm")
+                board.moveCard(person, action.code, "done", { version: action.version });
+            else if (action.verb === "back")
+                board.moveCard(person, action.code, "claimed", { version: action.version, reason: action.text });
+            else
+                board.moveCard(person, action.code, "claimed", { version: action.version, comment: action.text });
+            const done = { confirm: "needs.task_confirmed", back: "needs.task_sent_back", answer: "needs.task_answered" }[action.verb];
+            this.logger.info({ code: action.code, verb: action.verb, by: `${action.by.platform}:${action.by.userId}` }, "Task board: the person moved a card from the chat");
+            return { ok: true, message: t(done, action.code) };
+        }
+        catch (err) {
+            if (err instanceof TaskBoardError && err.code === "conflict")
+                return { ok: false, message: t("needs.task_changed", action.code) };
+            return { ok: false, message: t("needs.task_refused", action.code, err.message) };
+        }
+    }
     /** The prompts open on the dashboard right now (a page that loads after one was posted asks for them). */
     listWebPrompts() {
         const open = [];
@@ -13668,7 +14571,7 @@ export class FleetManager {
             ...(input.instance !== undefined ? { target: { adapterId: this.getInstanceAdapterId(input.instance) } } : {}),
             isAdmin: (userId, adapterId) => this.adminGate(userId, adapterId) === "ok",
             authorization: input.session ? this.sessionAuthorizationStore()?.get(input.session.handle) ?? null : null,
-            policy: { ...webAuthorityPolicy(this.fleetConfig?.web), enabled: state.enabled, loopbackOnly: state.loopbackOnly }, epoch: state.epoch, now: Date.now(),
+            policy: { ...webAuthorityPolicy(this.fleetConfig?.web), enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink }, epoch: state.epoch, now: Date.now(),
         });
     }
     sessionAuthorizations = null;
@@ -13693,7 +14596,7 @@ export class FleetManager {
             session, gateway, peer, tokenEpoch: this.webToken ? tokenEpoch(this.webToken) : null,
             isAdmin: (userId, adapterId) => this.adminGate(userId, adapterId) === "ok",
             authorization: { handle: session.handle, owner: session.owner, authorizedAt: now, until: now + policy.maxSessionMs, epoch: state.epoch },
-            policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly }, epoch: state.epoch, now,
+            policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink }, epoch: state.epoch, now,
         });
         if (check.refusal)
             return { ok: false, refusal: check.refusal };
@@ -13708,9 +14611,30 @@ export class FleetManager {
      */
     webAuthorityState() {
         if (!this.dataDir)
-            return { enabled: false, loopbackOnly: true, epoch: 0 };
+            return { enabled: false, loopbackOnly: true, namedLink: false, epoch: 0 };
         this.authorityStateStore ??= new AuthorityStateStore(join(this.dataDir, "web-authority.json"), this.logger, undefined, undefined, () => { this.ensureDeliveryOutbox?.(); return this.deliveryOutbox?.maxWebAuthorityEpoch() ?? 0; });
-        return this.authorityStateStore.current(this.fleetConfig?.web?.verified_authority);
+        const state = this.authorityStateStore.current(this.fleetConfig?.web?.verified_authority);
+        // #2453 (§0.2): the named-link option seen going off — the authority of every session over the link ends now, for
+        // good: their authorizations go (a later "on" can never bring one back without its account's Confirm).
+        if (state.namedLinkClosed)
+            this.sessionAuthorizationStore()?.prune(a => this.webSessions?.findByHandle(a.handle)?.surface === "local");
+        return state;
+    }
+    /**
+     * #2453 review: the web-authority state read on every configuration change (a Settings save, the host's confirm, a
+     * reload) — so a switch turned off and on again between two requests is still seen off: its epoch moves, and the
+     * named-link sessions' authorizations are dropped. Reads that only happen on a request would miss it.
+     */
+    observeWebAuthority() {
+        // Only once the state is in use: any authorization was given through a read that made it (and a first read at
+        // start-up still sees what changed while the fleet was down). Nothing new is opened during a load.
+        try {
+            if (this.dataDir && this.authorityStateStore)
+                this.webAuthorityState();
+        }
+        catch (err) {
+            this.logger.warn({ err: err?.message }, "Web authority state could not be read after a configuration change");
+        }
     }
     /**
      * #1939 S2a: Settings → Web → Web authority — the state in force (the switch counts as off while its state cannot be
@@ -13725,8 +14649,10 @@ export class FleetManager {
         const authorized = state.enabled ? (this.sessionAuthorizationStore()?.list() ?? [])
             .filter(a => a.epoch === state.epoch && sessions.has(a.handle) && now <= Math.min(a.until, a.authorizedAt + maxMs))
             .map(a => ({ handle: a.handle, label: sessions.get(a.handle).label, account: `${a.owner.adapterId}:${a.owner.userId}`, authorizedAt: a.authorizedAt,
-            until: Math.min(a.until, a.authorizedAt + maxMs, sessions.get(a.handle).absoluteExpiry) })) : [];
-        return { state, configured, hours: VERIFIED_SESSION_HOURS, lanHosts, authorized };
+            until: Math.min(a.until, a.authorizedAt + maxMs, sessions.get(a.handle).absoluteExpiry),
+            ...(sessions.get(a.handle).surface === "gateway" ? { named: true } : {}) })) : [];
+        const host = this.fleetConfig?.web?.public_link?.hostname;
+        return { state, configured, hours: VERIFIED_SESSION_HOURS, lanHosts, authorized, namedHost: typeof host === "string" && host ? host : null };
     }
     authorizationRequests = null;
     /**
@@ -13739,7 +14665,9 @@ export class FleetManager {
         const adapterOf = (adapterId) => this.adapters.get(adapterId) ?? this.worlds.get(adapterId)?.adapter;
         // The host's clock, with its zone: the person may read the DM on a phone in another one.
         const when = (ms) => new Date(ms).toLocaleString(undefined, { timeZoneName: "short" });
-        const where = (peer) => t(peer === "loopback" ? "web_auth.peer_loopback" : "web_auth.peer_lan");
+        const where = (peer) => peer === "named_link"
+            ? t("web_auth.peer_named_link", String(this.fleetConfig?.web?.public_link?.hostname ?? "?")) // §0.2: the internet
+            : t(peer === "loopback" ? "web_auth.peer_loopback" : "web_auth.peer_lan");
         return this.authorizationRequests = new SessionAuthorizationRequests({
             now: () => performance.now(), wallNow: () => Date.now(),
             maxSessionMs: () => webAuthorityPolicy(this.fleetConfig?.web).maxSessionMs,
@@ -13773,7 +14701,8 @@ export class FleetManager {
                 const record = this.webSessions?.findByHandle(handle);
                 if (!record)
                     return { ok: false, refusal: "session_gone" };
-                const r = this.authorizeWebSession(record, peer, false);
+                // §0.2: a named-link session is judged as the gateway request it is (its exposure still the current one).
+                const r = this.authorizeWebSession(record, peer, peer === "named_link");
                 // What the card says: the end of the authorization, or the session's own end when that comes first.
                 return r.ok ? { ok: true, until: Math.min(r.authorization.until, record.absoluteExpiry) } : { ok: false, refusal: r.refusal };
             },
@@ -13819,7 +14748,7 @@ export class FleetManager {
             session: s, gateway: input.gateway, peer: input.peer, tokenEpoch: this.webToken ? tokenEpoch(this.webToken) : null,
             isAdmin: (userId, adapterId) => this.adminGate(userId, adapterId) === "ok",
             authorization: s?.owner ? { handle: s.handle, owner: s.owner, authorizedAt: now, until: now + policy.maxSessionMs, epoch: state.epoch } : null,
-            policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly }, epoch: state.epoch, now,
+            policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink }, epoch: state.epoch, now,
         });
         return r.refusal;
     }
@@ -13902,7 +14831,7 @@ export class FleetManager {
                 const current = this.resolveInstanceEffort(instance).effort;
                 return { current, options: levels.map(l => ({ id: l, label: this.effortChoiceLabel(l, current) })) };
             },
-            backendStep: async (instance, args) => {
+            backendStep: async (instance, args, stepOpts) => {
                 const refusal = this.backendCommandRefusal(instance);
                 if (refusal)
                     return { error: refusal };
@@ -13912,7 +14841,13 @@ export class FleetManager {
                     return step.noop ? { text: step.text } : { error: step.text };
                 if (step.kind === "choose") {
                     const id = (token) => joinBackendArgs([...step.args, token]);
-                    return { choices: { prompt: step.text, current: step.current === null ? null : id(step.current), options: step.choices.map(c => ({ id: id(c.token), label: c.label, ...(c.disabled ? { disabled: c.disabled } : {}) })) } };
+                    return { choices: { prompt: step.text, current: step.current === null ? null : id(step.current), options: step.choices.map(c => {
+                                // #2233: the web offers Sign in beside it, so its reason is no longer "use /login".
+                                // Not over the public link: Sign in is refused there, so the choice keeps its "(use /login)" (#2262 review).
+                                const signIn = c.signIn && !stepOpts?.publicLink && dashboardSignInSupported(c.signIn) ? c.signIn : null;
+                                const disabled = signIn ? t("backend.reason_not_signed_in_web") : c.disabled;
+                                return { id: id(c.token), label: signIn ? `${c.token} — ${disabled}` : c.label, ...(disabled ? { disabled } : {}), ...(signIn ? { signIn } : {}) };
+                            }) } };
                 }
                 const now = performance.now();
                 for (const [k, v] of this.webBackendTokens)
@@ -14569,7 +15504,7 @@ export class FleetManager {
                 }
             }
             this.persistCancelButtons();
-            this.logger.info({ instanceName, messageId: sent.messageId }, "Cancel button sent");
+            this.logger.debug({ instanceName, messageId: sent.messageId }, "Cancel button sent"); // #2482: per-turn bookkeeping
             // Retirement is normally edge-triggered, but the edge (or an explicit
             // reply/cancel clear) may have happened while notifyAlert was in flight.
             // Reconcile the level after publication so a late button cannot resurrect
@@ -14835,7 +15770,8 @@ export class FleetManager {
         this.deleteButtonMessage(entry)
             .then(() => {
             this.discardButton(entry);
-            this.logger.info({ instanceName: entry.instanceName, messageId: entry.messageId, historyPreserved: Boolean(entry.toolProgress) }, "Cancel button retired");
+            this.logger.debug(// #2482: per-turn bookkeeping
+            { instanceName: entry.instanceName, messageId: entry.messageId, historyPreserved: Boolean(entry.toolProgress) }, "Cancel button retired");
         })
             .catch((err) => this.scheduleButtonRetry(entry, err));
     }
@@ -15076,6 +16012,86 @@ export class FleetManager {
         }
         return this.loginController;
     }
+    /** #2233: sign-ins started from the web dashboard (local admin sessions), on the same controller as chat's. */
+    webBackendLoginsInstance = null;
+    get webBackendLogins() {
+        this.webBackendLoginsInstance ??= new WebBackendLogins({
+            isLocalAdmin: handle => this.isLocalAdminSession(handle),
+            start: (backend, chat, opts) => this.startWebDashboardLogin(backend, chat, opts),
+            accessToken: sink => this.loginController?.webAccessToken(sink) ?? null,
+            isActiveFor: sink => this.loginController?.isActiveFor(sink) ?? false,
+            cancelFor: sink => this.loginController?.cancelFor(sink) ?? Promise.resolve(false),
+            cancel: () => this.cancelLoginSession(),
+            notice: ({ shown, label, handle }) => this.notifyFleetError(t("login.web_dashboard_notice", shown, label, handle.slice(0, 8))),
+            // No details in the event: each page reads its own view (GET /ui/backend-login), as its session may see it.
+            changed: () => broadcastSseEvent(this.sseClients, "backend_login", {}, err => this.logger.debug({ err }, "backend_login event failed")),
+        });
+        return this.webBackendLoginsInstance;
+    }
+    /** #2233: the login a paused-for-sign-in instance needs, when the dashboard can sign it in. */
+    signInFor(name) {
+        const backend = this.backendNameForInstance(name);
+        const profile = this.credentialProfileOf(name, backend);
+        return dashboardSignInSupported(backend, profile) ? { backend, ...(profile ? { profile } : {}) } : null;
+    }
+    /**
+     * #2233: Settings → Agents' sign-in list — every backend's default login as the availability snapshot has it, then
+     * each credential profile an agent uses (its own login state, read offline).
+     */
+    backendSignInTargets() {
+        const out = [];
+        for (const row of this.backendAvailabilityRows()) {
+            const flow = LOGIN_FLOWS[row.backend];
+            const install = BACKEND_INSTALLATION_INFO[row.backend]?.install;
+            out.push({
+                // Not installed or too old: signing in would not help — the row says how to install (or update) it instead.
+                backend: row.backend, state: row.state, signIn: row.state !== "not_installed" && row.state !== "too_old" && dashboardSignInSupported(row.backend),
+                ...(flow?.remoteLogin === "unsupported" ? { hostCommand: flow.command } : {}),
+                ...(row.state === "not_installed" && install ? { install } : {}),
+                ...(row.state === "too_old" && install ? { update: install } : {}),
+            });
+        }
+        const seen = new Set();
+        for (const name of Object.keys(this.fleetConfig?.instances ?? {}).sort()) {
+            const backend = this.backendNameForInstance(name);
+            const profile = this.credentialProfileOf(name, backend);
+            if (!profile || seen.has(`${backend}\0${profile}`))
+                continue;
+            seen.add(`${backend}\0${profile}`);
+            let login = "unknown";
+            try {
+                login = credentialProfileLogin(this.dataDir, backend, profile).state;
+            }
+            catch { /* unknown */ }
+            const signIn = dashboardSignInSupported(backend, profile);
+            const hostCommand = signIn ? null : credentialProfileLoginCommand(this.dataDir, backend, profile);
+            out.push({ backend, profile, state: login === "logged-in" ? "usable" : login === "signed-out" ? "not_signed_in" : "unknown", signIn,
+                ...(hostCommand ? { hostCommand } : {}) });
+        }
+        return out;
+    }
+    /** #2233: the session with this handle is live, admin, local and of the current dashboard token. */
+    isLocalAdminSession(handle) {
+        const sessions = this.webSessions, token = this.webToken;
+        const record = sessions?.findByHandle(handle);
+        return !!record && !!token && record.tier === "admin" && record.surface === "local" && sessions.isCurrent(record, tokenEpoch(token));
+    }
+    /**
+     * #2233: `/login` for a dashboard requester. The same controller and checks; a CLI that is not installed is refused
+     * with its install command (chat's install-first runs a terminal of its own, which the dashboard does not offer).
+     */
+    startWebDashboardLogin(backendArg, chat, opts) {
+        const wanted = LOGIN_BACKEND_ALIASES[backendArg.toLowerCase()] ?? backendArg.toLowerCase();
+        if (isRemovedBackend(wanted))
+            return Promise.resolve(removedBackendMessage(wanted));
+        const info = BACKEND_INSTALLATION_INFO[wanted];
+        if (info && LOGIN_FLOWS[wanted]?.remoteLogin !== "unsupported" && !this.isCliInstalled(wanted)) {
+            return Promise.resolve(t("login.web_dashboard_not_installed", wanted, info.install));
+        }
+        if (!opts.skipAuthCheck)
+            this.recordLoginFlow(wanted, "login", chat.userId);
+        return this.webLogin.start(backendArg, chat, opts);
+    }
     /**
      * Post the backend chooser for a bare `/login`. Caller enforces admin.
      * Returns why the chooser could not be posted, for the caller to tell the
@@ -15718,6 +16734,36 @@ export class FleetManager {
         const failure = await this.promptLoginBackends(chat);
         await data.respond(failure ?? t("login.chooser_posted"));
     }
+    /** #2293: whose cross-instance messages search leaves out now (web-api /ui/search). */
+    searchVisibility() { return xmsgVisibility(this.fleetConfig); }
+    /** #2293: a cross-instance message for the search index (outbound-handlers, after it was admitted). */
+    indexCrossInstance(record) {
+        this.searchIndex?.record(xmsgDoc(record));
+    }
+    /**
+     * #2293: the global search index, at fleet start — after the web chat is restored (the backfill reads it). Its worker
+     * owns search.db; see search-index.ts. Off with web.search.enabled: false.
+     */
+    startSearchIndex(fleet) {
+        const config = fleet.web?.search;
+        if (config?.enabled === false || this.searchIndex)
+            return;
+        const history = this.webChatHistory;
+        this.searchIndex = new SearchIndex({
+            path: join(this.dataDir, "search.db"),
+            retentionDays: config?.retention_days ?? SEARCH_RETENTION_DAYS,
+            outboxPath: join(this.dataDir, "delivery-outbox.db"),
+            schedulerPath: join(this.dataDir, "scheduler.db"),
+            chatDocs: function* () { for (const name of history.instances())
+                for (const m of history.list(name)) {
+                    const doc = chatDoc(m);
+                    if (doc)
+                        yield doc;
+                } },
+            log: (level, msg) => this.logger[level](msg),
+        });
+        this.searchIndex.start();
+    }
     queueMirrorMessage(text) {
         const mirrorTopicId = this.fleetConfig?.channel?.mirror_topic_id;
         if (mirrorTopicId == null || !this.adapter)
@@ -15812,8 +16858,15 @@ export class FleetManager {
                 links: m.links,
                 channel: m.channel,
                 from: m.from,
+                replyTo: m.replyTo,
+                cards: m.cards,
+                posts: m.posts, // #2281: kept beside the row, never broadcast (not a row field)
+                reserved: m.reserved, // #1774: an agent reply's place, taken when it was sent
             });
-            broadcastSseEvent(this.sseClients, event, recorded, onError, this.webChatHistory.cursorOf(recorded));
+            // A sending page's own id for its pending bubble rides on the live copy only: never recorded, never replayed.
+            const clientId = typeof data.clientId === "string" ? data.clientId : "";
+            broadcastSseEvent(this.sseClients, event, clientId ? { ...recorded, clientId } : recorded, onError, this.webChatHistory.cursorOf(recorded));
+            this.searchIndex?.record(chatDoc(recorded));
             // #1629: live-only receipt after the recorded agent reply. Never persist/replay it or give it an SSE cursor.
             if (recorded.role === "agent")
                 broadcastSseEvent(this.sseClients, "agent_reply_live", { v: 1, boot: recorded.boot, id: recorded.id, instance: recorded.instance }, onError);
@@ -15826,6 +16879,53 @@ export class FleetManager {
         }
         broadcastSseEvent(this.sseClients, event, data, onError);
     }
+    /**
+     * The task board's live side: every committed change goes to the open pages (never to a guest) — the board's new
+     * revision and the card numbers it touched; not who touched them (the page does not need it, and a public-link page
+     * must not learn a hidden instance's name from it). Its news goes to the instances whose cards someone else changed:
+     * one "[Task board]" notice per instance, gathered for 10 s, held by the delivery outbox until it is taken
+     * (task-board-waker.ts).
+     */
+    attachTaskBoard(db) {
+        this.taskBoardWaker?.stop();
+        // #2303: each instance's cards at once, read at every claim (a fleet.yaml edit applies to the next one).
+        db.board.setCardLimit((name) => boardCardLimit(this.fleetConfig, name));
+        const waker = this.taskBoardWaker = new TaskBoardWaker({
+            deliver: (instance, message, key) => this.admitTaskBoardNotice(instance, message, key),
+            isInstance: (name) => this.fleetConfig?.instances?.[name] != null,
+            holds: (wake) => db.board.wakeHolds(wake),
+            card: (uuid) => db.board.findCard(uuid),
+            // #2352: the card's Needs you buttons are in this instance's own channel (it is the card's lane).
+            buttonsHere: (instance, uuid) => {
+                // #2355 review: no live message, no buttons — the old words then.
+                if (this.fleetConfig?.needs_you?.live_message === false)
+                    return false;
+                const card = db.board.findCard(uuid);
+                // #2434: only while it waits for the person — a card that does not is in no Needs you, so no buttons anywhere.
+                if (!card || !waitsForPerson(card, this.dispatcherGone))
+                    return false;
+                const leads = new Map(db.board.listProjects(true).map((p) => [p.id, p.leadInstance]));
+                return this.needsYouLane(card, leads) === instance;
+            },
+            log: (level, message, extra) => this.logger[level](extra ?? {}, message),
+        });
+        db.board.onChange(({ rev, ids, projects, wakes }) => {
+            this.emitSseEvent("tasks", { rev, ids, projects });
+            waker.note(wakes);
+            // step 3: cards waiting for the person are Needs you items; #2355 review: a project's lead routes them too.
+            if (ids.length || projects)
+                this.needsYou?.poke();
+        });
+    }
+    /** A task board notice, as AgEnD's own (not a person's words): through the delivery outbox, held until delivered. */
+    admitTaskBoardNotice(instance, message, key) {
+        this.ensureDeliveryOutbox();
+        const outbox = this.deliveryOutbox;
+        if (!outbox)
+            return false;
+        outbox.admitSystemNotice(instance, key, message, new Date());
+        return true;
+    }
     listClaimedTasks(assignee) {
         try {
             return this.scheduler?.db.listTasks({ assignee, status: "claimed" }) ?? [];
@@ -16028,6 +17128,27 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         this.syncRoleSkills(workDir, backend, "general", knowledgeDir);
         this.logger.debug({ knowledgeDir, workDir, backend }, "Synced general knowledge files");
     }
+    /** Update only AgEnD-managed skill copies; no launch or restart is needed for an experimental switch. */
+    canvasWorkerSettingChanged() {
+        this.refreshExperimentalSkills();
+        this.emitSseEvent("status", this.getUiStatus());
+    }
+    refreshExperimentalSkills() {
+        for (const [name, daemon] of this.daemons) {
+            try {
+                const cfg = daemon.getConfigSnapshot();
+                const backend = cfg.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
+                const workDir = this.resolveKnowledgeWorkDir(cfg.working_directory, backend, name);
+                const classic = this.classicChannels?.getAll().some(ch => ch.instanceName === name) === true;
+                if (classic && !insideManagedWorkspaces(workDir))
+                    continue;
+                this.syncRoleSkills(workDir, backend, classic ? "classic" : cfg.general_topic ? "general" : "worker");
+            }
+            catch (err) {
+                this.logger.warn({ name, err }, "Could not refresh experimental skill visibility");
+            }
+        }
+    }
     /** Publish only the bundled skills eligible for an instance role. */
     syncRoleSkills(workDir, backend, role, knowledgeDir) {
         const skillSegments = FleetManager.SKILLS_DIR_SEGMENTS[backend];
@@ -16041,7 +17162,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // can keep those copies current; other backends never had unmanaged
         // AgEnD-published skills and must retain the normal user-ownership guard.
         const adoptLegacyUnmanaged = backend === "kiro-cli" && role === "general";
-        this.syncManagedSkills(join(workDir, ...skillSegments), join(root, "skills"), role, adoptLegacyUnmanaged);
+        this.syncManagedSkills(join(workDir, ...skillSegments), join(root, "skills"), role, adoptLegacyUnmanaged, 
+        // #2163: a Classic bot's skills folder (or a skill in it) may be a link out of its workspace; every path is
+        // checked where it really lands, just before it is written.
+        role === "classic" ? (path) => insideManagedWorkspaces(path) : undefined);
         this.logger.debug({ workDir, backend, role }, "Synced role-based bundled skills");
     }
     /**
@@ -16127,11 +17251,63 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * migration exception is the pre-manifest Kiro General layout explicitly
      * selected by adoptLegacyUnmanaged.
      */
-    syncManagedSkills(destSkills, srcSkills, role, adoptLegacyUnmanaged = false) {
+    /**
+     * #2482: the user's own skills that shadow bundled ones, said once per directory and change — not once per name on
+     * every start (11 lines a start on the host). The record (`skipped-skills.json` in the AgEnD home) keeps what was said
+     * across restarts; a new name or an edited SKILL.md is said again.
+     */
+    reportSkippedSkills(destSkills, names) {
+        const signature = names.map(name => {
+            let content = "";
+            try {
+                content = readFileSync(join(destSkills, name, "SKILL.md"), "utf-8");
+            }
+            catch { /* gone: its name alone */ }
+            return `${name}:${createHash("sha256").update(content).digest("hex").slice(0, 16)}`;
+        }).join(",");
+        if (this.skippedSkillsSaid.get(destSkills) === signature)
+            return;
+        this.skippedSkillsSaid.set(destSkills, signature);
+        const path = join(this.dataDir, "skipped-skills.json");
+        // Only a log's memory: whatever is in the file (missing, corrupt, any other shape) never stands in the sync's way
+        // (#2493 review) — a record that cannot be read is no record, and the warning is said.
+        const record = Object.create(null);
+        try {
+            const parsed = JSON.parse(readFileSync(path, "utf-8"));
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                for (const [key, value] of Object.entries(parsed))
+                    if (typeof value === "string")
+                        record[key] = value;
+            }
+        }
+        catch { /* none yet, or unreadable */ }
+        if (Object.hasOwn(record, destSkills) && record[destSkills] === signature) {
+            this.logger.debug({ skills: names, destSkills }, "Skipping bundled skills — unchanged since it was last said");
+            return;
+        }
+        record[destSkills] = signature;
+        try {
+            writeFileSync(path, JSON.stringify(record) + "\n");
+        }
+        catch { /* said this time; said again next start */ }
+        this.logger.warn({ skills: names, destSkills }, "Skipping bundled skills — skills of these names exist but were not published by AgEnD");
+    }
+    syncManagedSkills(destSkills, srcSkills, role, adoptLegacyUnmanaged = false, confined) {
         if (!existsSync(srcSkills))
             return;
+        const refuse = (path) => {
+            if (!confined || confined(path))
+                return false;
+            this.logger.warn({ path, destSkills }, "Not publishing skills — the path leads out of the managed workspace");
+            return true;
+        };
+        if (refuse(destSkills))
+            return;
         mkdirSync(destSkills, { recursive: true });
         const manifestPath = join(destSkills, ".agend-managed-skills.json");
+        // Its ownership claims decide what is replaced or removed below: one that lives elsewhere is never believed.
+        if (refuse(manifestPath))
+            return;
         const hadManifest = existsSync(manifestPath);
         let previouslyManaged = [];
         try {
@@ -16144,41 +17320,42 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             .filter(name => existsSync(join(srcSkills, name, "SKILL.md")))
             .sort();
         // Pre-manifest Kiro General copied bundled skills directly into
-        // .kiro/skills. If every existing skill is still a bundled name, this is
-        // the unambiguous legacy layout: adopt it once, update it below, and write
-        // the ownership manifest. Any extra skill name keeps the directory fully
+        // .kiro/skills. If every existing skill is still bundled AND belongs to
+        // the closed pre-manifest cohort, adopt it once, update it below, and
+        // write the ownership manifest. Any extra skill name keeps the directory fully
         // on the user-owned/collision path.
         if (!hadManifest && adoptLegacyUnmanaged) {
             const existing = readdirSync(destSkills, { withFileTypes: true })
                 .filter(entry => entry.isDirectory() && existsSync(join(destSkills, entry.name, "SKILL.md")))
                 .map(entry => entry.name)
                 .sort();
-            if (existing.length > 0 && existing.every(name => bundled.includes(name))) {
+            if (existing.length > 0 && existing.every(name => bundled.includes(name) && PRE_MANIFEST_KIRO_SKILLS.has(name))) {
                 previouslyManaged = existing;
                 this.logger.info({ skills: existing, destSkills }, "Adopted legacy AgEnD skills into managed ownership");
             }
         }
         const eligible = bundled.filter(name => {
             const roles = this.readManagedSkillRoles(join(srcSkills, name, "SKILL.md"));
-            // General is the coordinator and receives both coordinator and worker
-            // playbooks. Workers receive only skills explicitly marked for workers.
-            return role === "general" || roles.includes("worker");
+            // General is the coordinator and receives every playbook. Workers and Classic bots receive only skills
+            // explicitly marked for their role (#2163).
+            return role === "general" || roles.includes(role);
         });
         const managed = [];
+        const skipped = [];
         for (const name of eligible) {
             const destDir = join(destSkills, name);
             const dest = join(destDir, "SKILL.md");
             const isOurs = previouslyManaged.includes(name) || !existsSync(destDir);
             if (!isOurs) {
-                // The user's skill still wins on every sync; only the warning is deduped.
-                if (!this.skippedBundledSkills.has(name)) {
-                    this.skippedBundledSkills.add(name);
-                    this.logger.warn({ skill: name, destSkills }, "Skipping bundled skill — a skill of this name exists but was not published by AgEnD");
-                }
+                // The user's skill still wins on every sync; only the warning is deduped (#2482: one line per directory, and
+                // only when what is skipped there changed since it was last said — across restarts too).
+                skipped.push(name);
                 continue;
             }
             managed.push(name);
-            const newContent = readFileSync(join(srcSkills, name, "SKILL.md"), "utf-8");
+            const newContent = bundledSkillContents(join(srcSkills, name), this.canvasWorkerEnabled());
+            if (refuse(dest))
+                continue;
             try {
                 if (existsSync(dest) && readFileSync(dest, "utf-8") === newContent)
                     continue;
@@ -16187,6 +17364,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             mkdirSync(destDir, { recursive: true });
             writeFileSync(dest, newContent);
         }
+        if (skipped.length)
+            this.reportSkippedSkills(destSkills, skipped);
         // Remove managed skills that are no longer bundled OR no longer eligible
         // for this role. This makes a shared → general-only metadata change take
         // effect on the next worker startup instead of leaving stale capability.
@@ -16225,9 +17404,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             if (!Array.isArray(frontmatter.roles))
                 throw new Error("roles must be an array");
             const roles = [...new Set(frontmatter.roles)]
-                .filter((value) => value === "general" || value === "worker");
+                .filter((value) => value === "general" || value === "worker" || value === "classic");
             if (roles.length !== frontmatter.roles.length || roles.length === 0) {
-                throw new Error("roles must contain only general and/or worker");
+                throw new Error("roles must contain only general, worker and/or classic");
             }
             return roles;
         }
@@ -16518,7 +17697,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             try {
                 const tmpPath = await dlAdapter.downloadAttachment(att.fileId);
                 const inboxDir = join(getAgendHome(), "workspaces", instanceName, "inbox");
-                mkdirSync(inboxDir, { recursive: true });
+                mkdirSync(inboxDir, { recursive: true, mode: 0o700 });
                 const dest = join(inboxDir, basename(tmpPath));
                 // Copy to destination — failure means this attachment is skipped
                 try {
@@ -16930,7 +18109,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             }
         }
         const path = this.cliEnvPath(backend, profile);
-        mkdirSync(dirname(path), { recursive: true });
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
         writeFileSync(path, JSON.stringify(env, null, 2));
         return env;
     }
@@ -18616,23 +19795,56 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * settles, so a later genuine stop (after a restart) still does the work.
      */
     stopAll() {
-        this.stopAllInFlight ??= this.doStopAll().finally(() => { this.stopAllInFlight = null; });
+        this.stopAllInFlight ??= this.doStopAll().finally(() => {
+            // #1956: after the stop's own tmux work; anything later goes direct. A later startAll starts it again.
+            if (this.tmuxExecHelperTimer) {
+                clearInterval(this.tmuxExecHelperTimer);
+                this.tmuxExecHelperTimer = null;
+            }
+            // #2364: and the stop waits (bounded) for the helper to leave on its own, before the caller exits the process.
+            return tmuxExecHelper.stop();
+        }).finally(() => { this.stopAllInFlight = null; });
         return this.stopAllInFlight;
     }
+    tmuxExecHelperTimer = null;
     stopAllInFlight = null;
+    /** Stops release memory. Reassess between batches without waiting for recovery. */
+    async stopInstancesInBatches(entries, stop) {
+        let index = 0;
+        while (index < entries.length) {
+            // Linux procfs can still be read after the periodic sampler is stopped.
+            // Do not revive a stopped Darwin probe/worker just to size a quit batch;
+            // its full shutdown uses the conservative batch size instead.
+            const level = this.memoryPressure.platform === "darwin"
+                ? this.shuttingDown ? "elevated" : this.memoryPressure.snapshot().level
+                : this.memoryPressure.sample().level;
+            const size = fleetStopConcurrency(entries.length, level);
+            const batch = entries.slice(index, index + size);
+            index += batch.length;
+            await Promise.allSettled(batch.map(stop));
+        }
+    }
     async doStopAll() {
+        this.startupMemoryDeadline?.stop();
+        this.startupMemoryDeadline = null;
         this.startupComplete = false;
+        this.startupDashboard = null;
         this.reloadPending = false;
         // Before anything is stopped: everything that dies from here on dies
         // because we asked it to. Set synchronously — doStopAll runs to its first
         // await in the same tick as the signal handler, so no event can slip in.
         this.shuttingDown = true;
+        if (this.updateProgressTimer) {
+            clearInterval(this.updateProgressTimer);
+            this.updateProgressTimer = null;
+        }
         this.settingsGeneration++;
         this.settingsConfirmation?.store.close();
         this.settingsConfirmation = null;
         const settingsControl = this.settingsControl;
         this.settingsControl = null;
         const settingsControlStopped = settingsControl?.close();
+        this.publicLinkAutoOpen?.stop();
         const publicStopped = this.publicWebLink?.close("fleet shutdown");
         // #1386: every live "Needs you" message says the fleet stopped (capabilities revoked first) — while the
         // adapters can still edit. Bounded: a platform that does not answer must not hold the shutdown.
@@ -18690,6 +19902,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         this.clearStatuslineWatchers();
         this.costGuard?.stop();
         this.dailySummary?.stop();
+        this.taskBoardSummary?.stop();
         this.dailyTipScheduler?.stop();
         this.dailyTipScheduler = null;
         if (this.updateCheckTimer) {
@@ -18770,27 +19983,29 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // this is the last moment the prompts can be collapsed.
         await this.retirePendingNoncePrompts();
         this.topicArchiver.stop();
+        this.taskBoardWaker?.stop();
+        this.appIconStore?.close();
         this.scheduler?.shutdown();
+        // What it was sent is written first (bounded: search-index.ts close()).
+        const search = this.searchIndex;
+        this.searchIndex = null;
+        await search?.close();
         // Stop instances in parallel batches to avoid long sequential waits.
         // Concurrency scales with fleet size — larger fleets tolerate more parallel
         // tmux ops, while small fleets stay conservative to avoid overwhelming the
         // tmux server.
         const entries = [...this.daemons.entries()];
-        const STOP_CONCURRENCY = entries.length > 30 ? 15 : entries.length >= 10 ? 10 : 5;
         for (const [name] of entries)
             this.ipcStoppingInstances.add(name);
-        for (let i = 0; i < entries.length; i += STOP_CONCURRENCY) {
-            const batch = entries.slice(i, i + STOP_CONCURRENCY);
-            await Promise.all(batch.map(async ([name, daemon]) => {
-                try {
-                    await daemon.stop();
-                }
-                catch (err) {
-                    this.logger.warn({ name, err }, "Stop failed");
-                }
-                this.daemons.delete(name);
-            }));
-        }
+        await this.stopInstancesInBatches(entries, async ([name, daemon]) => {
+            try {
+                await daemon.stop();
+            }
+            catch (err) {
+                this.logger.warn({ name, err }, "Stop failed");
+            }
+            this.daemons.delete(name);
+        });
         // Close IPC clients in parallel — serial close over a large fleet adds
         // noticeable latency.
         await Promise.all([...this.instanceIpcClients.values()].map(ipc => Promise.resolve(ipc.close()).catch(() => { })));
@@ -19001,6 +20216,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             this.rawFleetConfig = previousRawConfig;
             this.rawFleetDocument = previousRawDocument;
             this.savedFleetConfigSnapshot = previousSavedSnapshot;
+            this.observeWebAuthority(); // #2453 review: the configuration back in force is the one seen
             this.logger.error({
                 oldCount,
                 newCount,
@@ -19020,6 +20236,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             // mark every row done and tell the user "changes applied".
             return { rejected: why };
         }
+        if (canvasWorkerEnabled(oldConfig?.web) !== this.canvasWorkerEnabled()) {
+            this.canvasWorkerSettingChanged();
+        }
         // Classic behavior settings share the fleet defaults but are not entries
         // in fleet.yaml. Snapshot the old effective chain before reloading the
         // Classic file so SIGHUP can hot-apply either source without waiting for
@@ -19096,8 +20315,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // so an old/new diff alone can miss the live daemon's stale value.
         for (const [name, config] of Object.entries(newInstances)) {
             if (!this.daemons.has(name)) {
-                // New instance — startInstance already calls connectIpcToInstance
-                this.logger.info({ name }, "New instance in config — starting");
+                // New instance — startInstance already calls connectIpcToInstance. #2482: a paused one is not started (startInstance
+                // returns at its pause); say so, quietly, instead of "starting" on every reload.
+                if (this.lifecycle.isPaused(name))
+                    this.logger.debug({ name }, "Paused instance in config — not started");
+                else
+                    this.logger.info({ name }, "New instance in config — starting");
                 observe?.(name, "restart", "running");
                 await this.startInstanceUnattended(name, config, topicMode, "new instance");
                 observe?.(name, "restart", "done");
@@ -19106,6 +20329,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 const daemon = this.daemons.get(name);
                 const runtimeConfig = daemon.getConfigSnapshot?.() ?? oldConfig.instances[name];
                 const change = classifyInstanceChange(runtimeConfig, config);
+                // (b) The person switched its task board on: tell it (its tool list shows the `task` tool at once).
+                if (taskBoardSwitchedOn(runtimeConfig.dashboard, config.dashboard)) {
+                    this.admitTaskBoardNotice(name, TASK_BOARD_ON_NOTICE, `task-board-on:${name}:${Date.now()}`);
+                }
                 if (change === "restart") {
                     this.logger.info({ name }, "Instance config changed — restarting");
                     observe?.(name, "restart", "running");
@@ -19269,6 +20496,20 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         return false;
     }
     /** Non-null when startup found the running config and fleet.yaml disagreeing. */
+    /**
+     * #2346 (settings schema): whether a connection added now would start at once — what canHotAddConnections would decide
+     * for the current config with one more connection appended: another one is running, and nothing else this process took
+     * at startup has changed since (a pending locale or access change, say, needs AgEnD restarted anyway).
+     */
+    connectionsStartLive() {
+        if (!this.fleetConfig)
+            return false;
+        const current = this.fleetConfig.channels ?? (this.fleetConfig.channel ? [this.fleetConfig.channel] : []);
+        const probe = { id: "\u0000probe", type: "telegram", mode: "topic", bot_token_env: "\u0000PROBE" };
+        const next = { ...this.fleetConfig, channels: [...current, probe] };
+        delete next.channel;
+        return this.canHotAddConnections(next);
+    }
     fleetSignatureMismatchKeys() {
         return this.fleetSignatureMismatch;
     }
@@ -19487,12 +20728,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         return this.fleetConfig?.web?.provider_secrets === true;
     }
     listProviderSecrets() {
-        return PROVIDER_SECRET_SPECS.map(spec => ({
+        return [...PROVIDER_SECRET_SPECS, PUBLIC_TUNNEL_SECRET_SPEC].map(spec => ({
             id: spec.id,
             display_name: spec.displayName,
             kind: spec.kind,
             token_present: !!process.env[spec.envKey],
-            verifier: spec.verifier ? "available" : "unsupported",
+            verifier: spec.kind === "tunnel_token" ? "local_format" : spec.verifier ? "available" : "unsupported",
             activation: spec.activation,
             stale_consumers: this.providerSecretStaleConsumers(spec.envKey),
         }));
@@ -19502,7 +20743,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // a child process's private environment safely, so report the conservative
         // set of already-running children; the UI can then say "restart these"
         // rather than claiming an existing process reloaded.
-        if (envKey === "GROQ_API_KEY")
+        if (envKey === "GROQ_API_KEY" || envKey === PUBLIC_TUNNEL_TOKEN_ENV)
             return [];
         return [...this.children.keys()].sort();
     }
@@ -19520,10 +20761,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         if (!spec || !this.providerSecretEnvAllowed(spec.envKey)) {
             return { ok: false, status: "invalid", error: "provider secret is not configured" };
         }
-        if (!spec.verifier)
+        const tunnel = spec.kind === "tunnel_token";
+        if (!tunnel && !spec.verifier)
             return { ok: false, status: "unsupported_verifier", error: "this provider has no supported verifier" };
-        if (!input.secret || input.secret.length > 4096 || /[\r\n\0]/.test(input.secret) || /[^\x20-\x7e]/.test(input.secret)) {
-            return { ok: false, status: "invalid", error: "secret is invalid" };
+        const secret = tunnel && !input.clear ? normalizePublicTunnelToken(input.secret) : input.secret;
+        if (input.clear && (!tunnel || input.secret !== "")
+            || !input.clear && (!secret || secret.length > 4096 || /[\r\n\0]/.test(secret) || /[^\x20-\x7e]/.test(secret))) {
+            return { ok: false, status: "invalid", error: tunnel ? PUBLIC_TUNNEL_TOKEN_HINT : "secret is invalid" };
         }
         const challengeKey = `${input.sessionBinding}:api_key:${spec.id}:${spec.envKey}:${input.idempotencyKey}`;
         const existingId = this.providerSecretChallengesByKey.get(challengeKey);
@@ -19533,7 +20777,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
         if (existingId)
             this.providerSecretChallengesByKey.delete(challengeKey);
-        const result = await verifyProviderSecret(spec, input.secret, this.providerSecretHttpClient);
+        const result = tunnel ? { ok: true } : await verifyProviderSecret(spec, input.secret, this.providerSecretHttpClient);
         if (!result.ok) {
             // Do not log provider detail: the HTTP verifier already redacted it and
             // this endpoint has no need to disclose whether a key was close to valid.
@@ -19551,7 +20795,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             operation: "provider-secret.apply",
             idempotencyKey: input.idempotencyKey,
             expiresAt, deadline: performance.now() + SECRET_CHALLENGE_TTL_MS,
-            secret: input.secret,
+            secret: secret,
         };
         this.providerSecretChallenges.set(challenge.id, challenge);
         this.providerSecretChallengesByKey.set(challengeKey, challenge.id);
@@ -19621,6 +20865,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     async runProviderSecretApply(job, secret, execution) {
         const spec = providerSecretSpec(job.specId);
         const allowed = new Set([
+            PUBLIC_TUNNEL_TOKEN_ENV,
             ...PROVIDER_SECRET_SPECS.map(item => item.envKey),
             ...(this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : [])).map(channel => channel.bot_token_env),
         ]);
@@ -19634,7 +20879,14 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             // Construct inside the transaction: symlink/permission refusal must
             // settle the job as a safe failure, not escape the queued microtask.
             store = new SecretStore(join(this.dataDir, ".env"), allowed, { owner: execution?.owner });
-            const write = () => { before = store.write(job.envKey, secret); wrote = true; process.env[job.envKey] = secret; };
+            const write = () => {
+                before = spec.kind === "tunnel_token" && !secret ? store.clear(job.envKey) : store.write(job.envKey, secret);
+                wrote = true;
+                if (secret)
+                    process.env[job.envKey] = secret;
+                else
+                    delete process.env[job.envKey];
+            };
             if (execution)
                 execution.mutate(write);
             else
@@ -19656,12 +20908,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             job.finishedAt = Date.now();
         }
         catch (err) {
-            const safe = safeSecretError(err, secret);
+            const safe = spec?.kind === "tunnel_token" ? "connector token change failed" : safeSecretError(err, secret);
             this.logger.warn({ specId: job.specId, reason: safe }, "Provider API-key apply failed");
             try {
                 // Memory and disk have separate receipts: a host-edited file must
                 // remain, but cannot strand our owned process value or hook snapshot.
-                if (wrote && process.env[job.envKey] === secret) {
+                if (wrote && (process.env[job.envKey] ?? "") === secret) {
                     if (previousProcessValue === undefined)
                         delete process.env[job.envKey];
                     else
@@ -19701,6 +20953,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * hot activation contract explicit and gives tests a failure seam; no generic
      * SIGHUP or caller-provided hook is ever executed. */
     async runProviderSecretReloadHook(hookId, _next, _previous) {
+        if (hookId === "cloudflare.public_link") {
+            await this.publicWebLink?.close("connector token changed");
+            return;
+        }
         if (hookId !== "groq.voice")
             throw new Error("unknown provider secret reload hook");
         const before = this.providerSecretHotSnapshots.get(hookId);
@@ -20373,7 +21629,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 all = false;
                 const message = err?.message ?? String(err);
                 this.adapterState.set(id, { status: "retrying", retryCount: 0, lastError: message });
-                this.scheduleAdapterRetry(id, channel);
+                this.scheduleAdapterRetry(id);
             }
         }
         this.classicChannels?.configureAdapters(this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : []));
@@ -20550,7 +21806,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             await ipc.close();
         }
         this.instanceIpcClients.clear();
-        await Promise.allSettled(instanceNames.map(name => this.stopInstance(name)));
+        await this.stopInstancesInBatches(instanceNames, name => this.stopInstance(name));
         // Kill remaining orphan windows to prevent stale state on restart
         try {
             const agendNames = new Set(instanceNames);
@@ -20683,7 +21939,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             // up to 15s each, and on a beta build BOTH ran — 30s with no WATCHDOG ping,
             // past WatchdogSec's half-interval and enough for systemd to SIGABRT the fleet
             // for a background version check.
-            const { execFile } = await import("node:child_process");
+            const { execFile } = await import("./child-process.js");
             const { promisify } = await import("node:util");
             const execFileP = promisify(execFile);
             const npmVersion = async (spec) => {
@@ -20871,6 +22127,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         if (this.guestScope(owner).size)
             return "ok";
         if (owner && this.fleetConfig?.web?.guests?.enabled === true) {
+            // Before adapters initialize, topic scope is unknown, not revoked. Keep the returning cookie but grant no
+            // request until its configured world exists. Removed connections and initialized denied access stay final.
+            const channels = this.fleetConfig.channels ?? (this.fleetConfig.channel ? [this.fleetConfig.channel] : []);
+            if (this.startupDashboard && !this.worlds.has(owner.adapterId)
+                && channels.some(channel => (channel.id ?? channel.type) === owner.adapterId))
+                return "pending";
             const members = this.guestRooms(), rooms = guestGroupRooms(this.classicChannels?.getAll() ?? [], owner);
             if (rooms.some((room) => members.pending(room, owner.userId))) {
                 void this.refreshGuestRooms(owner, { mode: "triggered" }); // rate-limited per room (30 s), single-flight
@@ -20969,16 +22231,23 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 res.end(JSON.stringify({ error: WEB_HOST_REJECTED_MESSAGE }));
                 return;
             }
-            if (closing) {
+            if (closing || this.shuttingDown) {
                 res.writeHead(503, { Connection: "close", "Retry-After": "10" });
                 res.end(JSON.stringify({ error: "fleet stopping" }));
                 return;
             }
             const requestPath = new URL(req.url ?? "/", `http://localhost:${port}`).pathname;
+            if (!this.canvasWorkerEnabled() && isCanvasWorkerHttpPath(requestPath)) {
+                res.writeHead(403, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+                res.end(JSON.stringify({ error: "canvas_worker_experimental", message: CANVAS_WORKER_EXPERIMENTAL_MESSAGE }));
+                return;
+            }
             if (this.effectBootstrap.handle(req, res))
                 return;
             // Branding is public, after Host admission: automatic favicon requests
             // must not become noisy web-token 401s in the browser console.
+            // #2308: the icon routes and the pages' icon links follow the app icon set in Settings.
+            useAppIconStore(this.appIcon);
             if (handleWebIconRequest(req, res, requestPath))
                 return;
             // Public: the health probe, /agent (instance-token auth of its own), the
@@ -21010,6 +22279,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 // #1920: a guest reaches only GUEST_ROUTES, within the scope derived for it now — default deny, before any
                 // handler, on this listener and the public link's gateway alike (both come through here).
                 if (decision.via === "session" && decision.session.tier === "guest") {
+                    // A browser opening a page gets a page in its language, not the JSON an API caller gets (#2399 smoke).
+                    const navigating = req.method === "GET" && String(req.headers.accept ?? "").includes("text/html") && isWebPageNavigation(requestPath);
                     const owner = decision.session.owner;
                     const admitted = decision.session;
                     const admission = this.guestAdmission(admitted);
@@ -21020,12 +22291,20 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                         return;
                     }
                     if (admission === "gone") {
+                        if (navigating) {
+                            serveGuestRefusedPage(res, 401, "ended");
+                            return;
+                        }
                         res.writeHead(401);
                         res.end(JSON.stringify({ error: "guest_scope_empty" }));
                         return;
                     }
                     const verdict = guestRouteDecision(req.method ?? "GET", parsedUrl, this.guestScope(owner));
                     if (verdict.kind === "deny") {
+                        if (navigating) {
+                            serveGuestRefusedPage(res, verdict.status, "members");
+                            return;
+                        }
                         res.writeHead(verdict.status);
                         res.end(JSON.stringify({ error: verdict.error }));
                         return;
@@ -21041,6 +22320,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                         // #1920 §5.1: guests chat unless the host made them read-only (web.guests.chat: false).
                         chat: () => this.fleetConfig?.web?.guests?.chat !== false });
                 }
+                if (decision.via === "session" && this.webToken) {
+                    const upgrade = sessionCookieUpgrade(req, this.webToken, decision.session);
+                    // No cookie header is set before this gate; auth routes own their headers separately.
+                    if (upgrade)
+                        res.setHeader("Set-Cookie", upgrade);
+                }
             }
             if (req.method === "GET" && req.url === "/health") {
                 const health = this.getFleetHealth();
@@ -21052,6 +22337,14 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 res.end(JSON.stringify(health));
                 return;
             }
+            // Threat: lifecycle/config/chat writes racing boot-owned starts and reconciliation. Reads stay live;
+            // authentication keeps its own checks so a browser can sign in or sign out while agents start.
+            if (this.startupDashboard && !["GET", "HEAD", "OPTIONS"].includes(req.method ?? "GET")
+                && !requestPath.startsWith("/auth/")) {
+                res.writeHead(503, { "Retry-After": "2", "Cache-Control": "no-store", Connection: "close" });
+                res.end(JSON.stringify({ code: "fleet_starting", error: t("fleet.starting_retry") }));
+                return;
+            }
             if (req.method === "GET" && req.url === "/status") {
                 const instances = Object.keys(this.fleetConfig?.instances ?? {}).map(name => {
                     const statusFile = join(this.getInstanceDir(name), "statusline.json");
@@ -21322,6 +22615,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
     }
     startHealthServer(port) {
+        let settled;
+        const listening = new Promise(resolve => { settled = resolve; });
         this.startedAt = Date.now();
         this.healthServerListening = false;
         this.healthPortRetried = false;
@@ -21336,6 +22631,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const drain = trackWebServer(server);
         this.healthServer = server;
         this.healthServerDrain = drain;
+        server.once("close", settled);
         const markListening = (afterTakeover = false) => {
             this.healthServerListening = true;
             this.logger.info({ port }, afterTakeover
@@ -21349,6 +22645,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             // #1306: the preview listener starts once the web listener is bound — its frame-ancestors name the real port.
             const bound = this.healthServer?.address();
             this.startPreviewListener(port, bound && typeof bound === "object" ? bound.port : port);
+            settled();
         };
         this.healthServer.on("error", (err) => {
             this.healthServerListening = false;
@@ -21356,6 +22653,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 if (this.healthPortRetried) {
                     this.logger.error({ err, port }, "Health port still in use after takeover — dashboard disabled");
                     this.notifyFleetError(t("dashboard.port_in_use", port));
+                    settled();
                     return;
                 }
                 this.healthPortRetried = true;
@@ -21391,16 +22689,20 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                     this.logger.debug({ err }, "Old fleet process kill skipped (already gone or no permission)");
                 }
                 setTimeout(() => {
-                    if (!this.healthServer)
+                    if (this.healthServer !== server || this.shuttingDown) {
+                        settled();
                         return;
-                    this.healthServer.listen(port, "127.0.0.1", () => markListening(true));
+                    }
+                    server.listen(port, "127.0.0.1", () => markListening(true));
                 }, 1500);
                 return;
             }
             this.logger.error({ err, port }, "Health server error");
             this.notifyFleetError(t("dashboard.server_failed", err.message));
+            settled();
         });
         this.healthServer.listen(port, "127.0.0.1", () => markListening());
+        return listening;
     }
     /**
      * #1306: the preview listener, beside the web listener and closed with it. When it cannot listen (the port is
@@ -21422,6 +22724,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             return;
         }
         const listener = createPreviewListener({ settings, healthPort: boundPort, config: this.fleetConfig,
+            canvasWorkerEnabled: () => this.canvasWorkerEnabled(),
             // #1723: with a web.preview_origin, the open public link's dashboard frames this listener's preview too.
             extraOrigins: () => { const o = settings.origin ? this.publicWebLink?.openDashboardOrigin() : null; return o ? [o] : []; } });
         this.previewListener = listener;
@@ -21544,15 +22847,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             this.logger.debug({ err }, "bots unreadable (getUiStatus)");
         }
         const instances = names.map(name => {
-            const statusFile = join(this.getInstanceDir(name), "statusline.json");
-            let cost = 0;
-            try {
-                const data = JSON.parse(readFileSync(statusFile, "utf-8"));
-                cost = data.cost?.total_cost_usd ?? 0;
-            }
-            catch (err) {
-                this.logger.debug({ err, name }, "statusline.json read failed (getUiStatus)");
-            }
+            // #1956: read once for this instance; its cost, context and model come from it.
+            const statusline = readStatuslineJson(this.dataDir, name);
+            const cost = statusline?.cost?.total_cost_usd ?? 0;
             // Align with /ctx: statusline for claude-code, pane scrape for kiro/grok/codex.
             const classic = classicOnly.includes(name);
             const backend = classic
@@ -21560,14 +22857,14 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 : (this.fleetConfig?.instances[name]?.backend
                     ?? this.fleetConfig?.defaults?.backend
                     ?? "claude-code");
-            const { context } = resolveInstanceContext(this.dataDir, name, backend, { source: this.getPaneContextSource(name) });
+            const { context } = resolveInstanceContext(this.dataDir, name, backend, { source: this.getPaneContextSource(name), statusline });
             // context_pct: null when unavailable, not 0
             const context_pct = context ?? null;
             // Model: Only Claude Code has live statusline; others use the effective resolver.
-            // readStatuslineModel provides the /ctx-aligned display_name+id combo for Claude.
+            // statuslineModel gives the /ctx-aligned display_name+id combo for Claude (readStatuslineModel's rule).
             // Non-Claude backends must NOT read statusline.json model (may be stale from previous Claude run).
             const resolved = this.resolveInstanceModel(name);
-            const liveModel = backend === "claude-code" ? readStatuslineModel(this.dataDir, name) : null;
+            const liveModel = backend === "claude-code" ? statuslineModel(statusline) : null;
             // Display value: live model for Claude, resolved.display for others (includes "auto (default)" for Kiro)
             const model = liveModel ?? resolved.display;
             // model_source: "live" when Claude statusline succeeded, else the resolver's source
@@ -21605,7 +22902,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                     return {};
                 } })(),
                 // #2118: only this Chat's placement content; guest projection drops global revisions.
-                effect_chat_v: createHash("sha256").update(JSON.stringify(this.themeStore.get(name).placements.effects)).digest("hex").slice(0, 32),
+                effect_chat_v: this.canvasWorkerEnabled() ? createHash("sha256").update(JSON.stringify(this.themeStore.get(name).placements.effects)).digest("hex").slice(0, 32) : null,
                 // #1958: the identity colour's tiers (the page resolves them: the agent's only while it shows agents' themes).
                 color: { ...(colors.get(name)?.color ? { person: colors.get(name).color } : {}), ...(image.agentColor ? { agent: image.agentColor } : {}),
                     ...(image.roleColor ? { role: image.roleColor } : {}), auto: autoIdentityColor(name) },
@@ -21614,6 +22911,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 description: identity.description || undefined,
                 role: identity.role || undefined,
                 tags: identity.tags,
+                teams: instanceTeams(this.fleetConfig?.teams, name), // #2172: the sidebar groups a team's members under it
+                last_reply: this.webChatHistory.lastAgentReply(name) ?? undefined, // #2179: its last reply to a person (ISO)
                 status: this.getInstanceStatus(name),
                 // `state` (presentation: may be awaiting_input) and `execution_state` (working / idle / stuck, or null —
                 // what the dashboard's activity events carry) come from instancePresentation (#1212).
@@ -21630,7 +22929,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             };
         });
         return {
+            canvas_worker: this.canvasWorkerEnabled(),
             instances,
+            startup: this.startupDashboard?.snapshot() ?? null,
             publicLink: this.getPublicWebStatus(),
             uptime: Math.floor((Date.now() - this.startedAt) / 1000),
             // #1519 P7: how many chat connections are configured — 0 is a web-only fleet, which gets the first-run card.