@songsid/agend 2.3.2-beta.9 → 2.3.3-beta.1

package/dist/fleet-manager.js

@@ -1,4 +1,8 @@
-import { hasLegacyOffice, normalizeOfficeStorage } from "./dashboard-permissions.js";
+import { supportsVerifiedKiroMigration, getCachedKiroCliCompatibility, kiroV1DbPath, kiroV2SessionsDir } from "./backend/kiro.js";
+import { listKiroV1Sessions, readKiroClassicLinks } from "./backend/kiro-identity.js";
+import { readKiroV1SavedModel } from "./backend/kiro-retired-model.js";
+import { sharedKiroV2StoreLane } from "./backend/kiro-v2-store.js";
+import { SEPARATE_FEATURE_KEYS, hasLegacyOffice, normalizeOfficeStorage } from "./dashboard-permissions.js";
 import { loginNoticeMode, normalizeNoticeDelivery, setNoticeMode } from "./notice-delivery.js";
 import { DEFAULT_REPLY_TRIGGERS } from "./reply-triggers.js";
 import { WorkingRecoveryCoordinator, WORKING_RECOVERY_KIND, buildWorkingRecoveryPrompt } from "./working-recovery.js";
@@ -24,7 +28,7 @@ import { PUBLIC_PREVIEW_FRAME_SRC, PUBLIC_PREVIEW_TUNNEL_DIR, PublicPreview, pub
 import { CloudflaredProvider } from "./tunnel/cloudflared.js";
 import { ensureCloudflared } from "./tunnel/cloudflared-install.js";
 import { OFFICE_SHARE_TUNNEL_DIR, OfficeShareService } from "./office-share-service.js";
-import { ALL_OFFICES } from "./office-share.js";
+import { ALL_OFFICES, WHOLE_FLEET } from "./office-share.js";
 import { TunnelPurposeLane } from "./tunnel/purpose-lane.js";
 import { ManagedTunnel } from "./tunnel/manager.js";
 import { withinBudget } from "./monotonic-budget.js";
@@ -43,11 +47,12 @@ import { join, dirname, basename, delimiter, isAbsolute, relative, resolve as re
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
+import { planKiroReconciliation, applyKiroReconciliation, kiroReconciliationPrompt } from "./kiro-reconcile.js";
 import { applyKiroMigration, kiroMigrationPrompt, planKiroMigration } from "./kiro-migrate.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 { sdNotify, sdNotifyBlocking, setSdNotifyWarn, startSdWatchdog } from "./sd-notify.js";
 import { StartupMemoryDeadline, fleetStopConcurrency } from "./startup-memory-deadline.js";
 import { readFleetMemory } from "./process-memory.js";
 import { MemoryPressure } from "./memory-pressure.js";
@@ -83,13 +88,13 @@ import { createBackend } from "./backend/factory.js";
 import { readEffortMetadata } from "./backend/effort-metadata.js";
 import { codexEffort, flagEffort } from "./backend/launch-effort.js";
 import { codexMetadataHomes, readCodexModelEffortLevels, resolveCodexLaunchModel } from "./backend/codex-metadata.js";
-import { CLI_ENV_TTL_MS, isModelCompatible, noteResolvedBinary, resolveBinary, SYSINFO_BACKEND_IDS, UnsupportedCliError } from "./backend/types.js";
+import { CLI_ENV_TTL_MS, isModelCompatible, noteResolvedBinary, resolveBinary, SYSINFO_BACKEND_IDS, UnsupportedCliError, ResumeBlockedError } from "./backend/types.js";
 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 { TaskBoardWaker, namesCard } 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";
@@ -170,6 +175,7 @@ import { ThemeStore } from "./web-theme-store.js";
 import { OfficeStore, OfficeWriteLimiter } from "./web-office-store.js";
 import { OfficeSkinStore } from "./web-office-skins.js";
 import { OfficeActs } from "./web-office-acts.js";
+import { OFFICE_PACK_TOOLS, OfficePackTools } from "./web-office-pack-tools.js";
 import { WebAppearance } from "./web-appearance.js";
 import { WebEffectLibrary } from "./web-effect-library.js";
 import { WebEffectTrials } from "./web-effect-trials.js";
@@ -225,10 +231,11 @@ import { ONBOARDING_BACKENDS, readPendingBackendSignIns } from "./backend-signin
 import { structuredSignInSupported } from "./structured-signin.js";
 import { handleSettingsRequest } from "./settings-api.js";
 import { setLocale, detectLocale, getLocale, t } from "./locale.js";
+import { remoteCardAction, remoteCardChoiceLabel, remoteCardOutcomeText, remoteCardPrompt, REMOTE_CARD_TEXT_MAX } from "./remote-card-prompt.js";
 import { recentChatContext } from "./log-tail.js";
 import { describeSignalSource, recordInternalRequest, withOrigin } from "./fleet-control-audit.js";
 import { handleAgentRequest, ToolNotPermittedError } from "./agent-endpoint.js";
-import { ClassicChannelManager, classicWebEchoOn, getClassicBackendChoices, inferClassicChannelType, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
+import { ClassicChannelManager, classicWebEchoOn, getClassicBackendChoices, inferClassicChannelType, isSelectableClassicBackend, readClassicLastActivityAt, readClassicRoomNames } from "./classic-channel-manager.js";
 import { assertExplicitInstanceRemoval } from "./instance-removal.js";
 import { KNOWN_BACKENDS, validateFleetConfig } from "./config-validator.js";
 import { isRemovedBackend, removedBackendMessage } from "./backend/removed.js";
@@ -247,8 +254,7 @@ import { isSetupComplete, markSetupComplete } from "./setup-marker.js";
 import { manualCleanupMessage, reapStaleTunnel } from "./tunnel/lease.js";
 import { buildToolPermissionsNotice } from "./tool-permissions-notice.js";
 import { NeedsYouHub } from "./needs-you-hub.js";
-import { WEB_CHAT_NOTICE, claimNotice, hasWebChat, releaseNotice, upgradeNoticesPath } from "./upgrade-notices.js";
-import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
+import { GENERAL_NAME, GENERAL_PAUSE_ERROR, adoptGeneralByName, freeGeneralName, isGeneralInstance } from "./general-instance.js";
 import { buildOrgChart } from "./web-org.js";
 import { topMemoryHogs } from "./memory-hogs.js";
 import { GENERAL_POINTING_REFUSALS, SNOWFLAKE, hasPlaceRefs, placeRef, webRoute, webTextLinks, placeSuffix, renderPlaceRefs, stripPlaceRefs, topicUrl, worldPlaceOf } from "./topic-link.js";
@@ -478,6 +484,13 @@ const MODEL_SELECT_CALLBACK_PREFIX = "model-select:";
 const EFFORT_SELECT_CALLBACK_PREFIX = "effort-select:";
 const BACKEND_SELECT_CALLBACK_PREFIX = "backend-select:";
 const INTERACTIVE_ASSIST_CALLBACK_PREFIX = "interactive-assist:";
+/** #2675: a card a CLI shows in place of its composer (kiro V3's Question / MCP input), posted with its answers. */
+const REMOTE_CARD_CALLBACK_PREFIX = "card-answer:";
+const REMOTE_CARD_CALLBACK_RE = /^card-answer:([0-9a-f]{32}):(opt-\d{1,2}|sub-all|sub-\d{1,2}|back|skip|decline|cancel|text)$/;
+/** A posted card's buttons stay this long; the card itself waits in the pane for as long as it takes. */
+const REMOTE_CARD_TIMEOUT_MS = 12 * 60 * 60_000;
+/** A reply already taken as a card's answer is remembered this long, so another bot's copy of it is dropped (#2675). */
+const REMOTE_CARD_TAKEN_TTL_MS = 10 * 60_000;
 const EXIT_RESTART_CALLBACK_PREFIX = "exit-restart:";
 const OOM_RETRY_CALLBACK_PREFIX = "oom-retry:";
 /** #1386: how long a paused instance's marker reason is reused before it is read again (transitions drop it at once). */
@@ -486,6 +499,11 @@ const HANG_CALLBACK_PREFIX = "hang:";
 const CLEAR_CONFIRM_CALLBACK_PREFIX = "clear-confirm:";
 /** #2598 B2: a kiro classic → TUI move's Confirm in General. "kiro-migrate:" (13) + 32 hex + ":confirm" (8) = 53 bytes. */
 const KIRO_MIGRATE_CALLBACK_PREFIX = "kiro-migrate:";
+const KIRO_RECONCILE_CALLBACK_PREFIX = "kiro-reconcile:";
+/** #2692: a fleet admin's Approve / Reject on an agent's pending skin-pack change, in General. */
+const OFFICE_PACK_CALLBACK_PREFIX = "office-pack:";
+/** #2692: the skin-pack tools' IPC types (answered as web theme tools). */
+const OFFICE_PACK_IPC = new Set(OFFICE_PACK_TOOLS.map(tool => `fleet_${tool}`));
 /** Long enough for an admin to read the prompt; the move is judged again on the click. */
 const KIRO_MIGRATE_TIMEOUT_MS = 10 * 60_000;
 /**
@@ -496,6 +514,7 @@ const KIRO_MIGRATE_TIMEOUT_MS = 10 * 60_000;
  */
 const WEB_MIRRORED_PROMPT_PREFIXES = new Set([
     HANG_CALLBACK_PREFIX, EXIT_RESTART_CALLBACK_PREFIX, OOM_RETRY_CALLBACK_PREFIX, INTERACTIVE_ASSIST_CALLBACK_PREFIX,
+    REMOTE_CARD_CALLBACK_PREFIX,
 ]);
 /**
  * Where a reply goes on a fleet with no chat platform (web track C4): it is "sent" by being shown in the
@@ -592,7 +611,6 @@ export function deriveSpawnConcurrency(freeMemMB, cores) {
 /** #926: how often reply obligations are checked, the owner-reminder grace, and the default overdue window. */
 const REPLY_OBLIGATION_SWEEP_MS = 30_000;
 const REPLY_REMINDER_GRACE_MS = 60_000;
-const DEFAULT_REPLY_OVERDUE_MINUTES = 15;
 /**
  * The filter `list_emojis` and `list_stickers` take (#1226). Values may come from the agent CLI as strings, so a
  * limit is read as a number and the flags accept "true". No limit means all of them — never zero.
@@ -656,32 +674,6 @@ export class FleetManager {
             laneFree: name => !this.isInstanceRestarting(name) && !this.activeDurableTargets.has(name)
                 && outbox.countForTarget(name, ["queued", "retry_wait", "delivering", "submission_started", "reconciliation_pending"]) === 0,
             admit: (episode, tasks, advisory) => outbox.admitWorkingRecovery(episode, buildWorkingRecoveryPrompt(tasks, this.workingRecoveryCause, advisory), advisory),
-            summary: (group, rows) => {
-                const general = this.findGeneralInstance();
-                if (!general || !this.daemons.has(general))
-                    return;
-                // Our own informational notice must not supersede General's recovery
-                // as unrelated pending work before it crosses the input boundary.
-                const generalEpisode = store.get(general);
-                if (generalEpisode?.outcome === "admitted" && generalEpisode.deliveryId) {
-                    const state = outbox.get(generalEpisode.deliveryId)?.state;
-                    if (!state || !["delivered", "uncertain", "failed", "cancelled"].includes(state))
-                        return;
-                }
-                const deferredAdvisories = rows.filter(row => row.outcome === "deferred"
-                    && (this.daemons.get(row.instance)?.getWorkingRecoveryState?.().background ?? null) === null)
-                    .map(row => `${row.instance} (${row.reason})`);
-                const posted = store.summary(group, () => outbox.admitSystemNotice(general, `working-recovery-summary:${group}`, `[system:working-recovery-summary] Observed cause: unknown interruption${this.workingRecoveryCause === "unknown_interruption" ? "" : `; prior requested action: ${this.workingRecoveryCause}`}. ${rows.length} interrupted instances; continuation queued ${rows.filter(r => r.outcome === "admitted").length}, excluded ${rows.filter(r => r.outcome === "excluded").length}, still deferred ${rows.filter(r => r.outcome === "deferred").length}. ${rows.filter(r => r.reason === "advisory_background_unknown").length ? `Advisory, background unknown: ${rows.filter(r => r.reason === "advisory_background_unknown").map(r => r.instance).join(", ")}. ` : ""}${deferredAdvisories.length ? `Deferred advisory candidates (background unknown; all other gates still apply): ${deferredAdvisories.join(", ")}. ` : ""}Details are in the Log. Deferred work remains eligible; no action or confirmation is requested.`));
-                if (posted) {
-                    const counts = { interrupted: rows.length, queued: rows.filter(row => row.outcome === "admitted").length,
-                        excluded: rows.filter(row => row.outcome === "excluded").length, deferred: rows.filter(row => row.outcome === "deferred").length };
-                    const requestedAction = this.workingRecoveryCause === "unknown_interruption" ? null : this.workingRecoveryCause;
-                    this.logger.info({ group, ...counts, observedCause: "unknown_interruption", requestedAction }, "Interrupted work recovery summary queued for General");
-                    this.eventLog?.insert(general, "working_state", { reason: "recovery_summary", group, ...counts,
-                        observedCause: "unknown_interruption", requestedAction,
-                        message: `Interrupted work summary queued for General: ${counts.interrupted} interrupted; ${counts.queued} queued, ${counts.excluded} excluded, ${counts.deferred} deferred.` });
-                }
-            },
             log: (episode, outcome, reason) => {
                 const requestedAction = this.workingRecoveryCause === "unknown_interruption" ? null : this.workingRecoveryCause;
                 this.logger.info({ name: episode.instance, episode: episode.key, outcome, reason,
@@ -913,6 +905,8 @@ export class FleetManager {
     pendingNonceButtons = new Map();
     /** #2598 B2: the kiro moves waiting on a fleet admin's Confirm in General, by prompt nonce. */
     pendingKiroMigrations = new Map();
+    pendingKiroReconciliations = new Map();
+    kiroMigrationRuns = new Map();
     /** #1386 "Needs you": the list, its live chat messages and Acknowledge. Started with the fleet (finishStartup). */
     needsYou = null;
     /** When the fleet first saw an instance crashed, for its "Needs you" age; cleared when it is not. */
@@ -925,6 +919,12 @@ export class FleetManager {
      * adapter emits — whatever fields its payload carries — can claim a dashboard click's authority.
      */
     webPromptClicks = new WeakSet();
+    /** #2675: a dashboard click's typed answer, for the click it came with. */
+    webPromptTexts = new WeakMap();
+    /** #2675: the nonce of each instance's posted card. */
+    remoteCardPosts = new Map();
+    /** #2675: replies taken as a card's answer (`<chatId>|<messageId>` → monotonic expiry), so another bot's copy is dropped. */
+    takenCardReplies = new Map();
     /** The web clicks consumeNonceCallback actually claimed (the others were refused or lost a race). */
     webPromptClaims = new WeakSet();
     // Model failover state
@@ -1195,6 +1195,7 @@ export class FleetManager {
                 needs: () => this.needsYouItems().map(i => i.instance),
                 hidden: name => crossInstanceVisibility(this.fleetConfig, name) === "hidden",
                 skins: this.officeSkins,
+                levels: () => this.officeLevelsSnapshot(),
             },
             manager: new ManagedTunnel({ dataDir: join(this.dataDir, OFFICE_SHARE_TUNNEL_DIR), log: () => this.logger.warn("Office share tunnel cleanup requires attention") }),
             ensure: signal => ensureCloudflared({ dataDir: this.dataDir, pinnedOnly: true, signal }),
@@ -1211,7 +1212,7 @@ export class FleetManager {
      * `share` null with `count`: "Revoke all".
      */
     officeShareNotice(event, who, share, count) {
-        const office = !share ? "" : share.office === ALL_OFFICES ? t("office_share.all") : this.officeStore.list().offices.find(o => o.id === share.office)?.name ?? share.office;
+        const office = !share ? "" : share.office === ALL_OFFICES ? t("office_share.all") : share.office === WHOLE_FLEET ? t("office_share.whole") : this.officeStore.list().offices.find(o => o.id === share.office)?.name ?? share.office;
         const minutes = share ? Math.round((share.expiresAt - share.createdAt) / 60_000) : 0;
         const text = event === "created" ? t("office_share.created_notice", who, office, minutes < 60 ? `${minutes} min` : `${Math.round(minutes / 60)} h`)
             : share ? t("office_share.revoked_notice", who, office) : t("office_share.revoked_all_notice", who, count);
@@ -1235,6 +1236,98 @@ export class FleetManager {
             changed: acts => this.emitSseEvent("office_acts", { acts, now: Date.now() }),
         }));
     }
+    officePackToolsInstance;
+    /** #2692: the agents' skin-pack tools — their log, the admins' approval mode and the pending changes (memory only). */
+    get officePackTools() {
+        return (this.officePackToolsInstance ??= new OfficePackTools({
+            skins: this.officeSkins, offices: this.officeStore,
+            allowedAgents: () => this.officePackAgents(),
+            notice: (text, pending) => { void this.officePackNotice(text, pending); },
+            settled: (id, text) => this.settleOfficePackPrompt(id, text),
+            changed: what => {
+                if (what.skins !== undefined)
+                    this.emitSseEvent("office_skins", { rev: what.skins });
+                if (what.offices !== undefined)
+                    this.emitSseEvent("offices", { rev: what.offices });
+                if (what.changes)
+                    this.emitSseEvent("office_pack_changes", {});
+            },
+            logger: this.logger,
+        }));
+    }
+    /** #2692: the instances whose `office_packs` feature is on (their own switch, else the defaults'): the Office page lists them. */
+    officePackAgents() {
+        const names = new Set([...Object.keys(this.fleetConfig?.instances ?? {}), ...(this.classicChannels?.getAll() ?? []).map(ch => ch.instanceName)]);
+        return [...names].filter(name => dashboardRefusalIn(this.fleetConfig, name, "office_pack_upload") === null);
+    }
+    /** #2692: the nonce of each pending pack change's prompt in General (its buttons are retired when it is decided). */
+    officePackPrompts = new Map();
+    /**
+     * #2692: tell the fleet's admins of an agent's pack change — one short message in General (notifyFleetError, never a
+     * sign-in notice). A pending one comes with Approve / Reject (a fleet admin's, as a kiro move); where no General can
+     * carry buttons it is the plain message, and the Office page decides it.
+     */
+    async officePackNotice(text, pending) {
+        if (!pending) {
+            this.notifyFleetError(text, { throttle: false });
+            return;
+        }
+        const general = this.findGeneralInstance();
+        const adapterId = general ? this.getInstanceAdapterId(general) : undefined;
+        const adapter = general ? this.getAdapterForInstance(general) : undefined;
+        const chatId = general ? this.getGroupIdForInstance(general) : undefined;
+        const topic = general ? String(this.fleetConfig?.instances[general]?.topic_id ?? "") : "";
+        if (general && adapterId && adapter && chatId) {
+            try {
+                const nonce = await this.postNonceButtonPromptOrThrow({
+                    prefix: OFFICE_PACK_CALLBACK_PREFIX, alertType: "clear_confirm", instanceName: pending.instance, adapter, adapterId, chatId,
+                    ...(topic ? { threadId: topic } : {}), message: text,
+                    choices: [{ action: "approve", label: t("office_packs.approve_button") }, { action: "reject", label: t("office_packs.reject_button") }],
+                    expiredText: t("office_packs.expired", ""), timeoutMs: Math.max(1_000, pending.expires_at - Date.now()),
+                });
+                if (this.officePackTools.pendingViews().some(v => v.id === pending.id))
+                    this.officePackPrompts.set(pending.id, nonce);
+                else
+                    this.retireOfficePackNonce(nonce, t("office_packs.gone"));
+                return;
+            }
+            catch (err) {
+                this.logger.info({ err: err.message }, "Office pack approval prompt unavailable; the plain notice and the Office page remain");
+            }
+        }
+        this.notifyFleetError(text, { throttle: false });
+    }
+    retireOfficePackNonce(nonce, text) {
+        const entry = this.pendingNonceButtons.get(nonce);
+        if (!entry || entry.prefix !== OFFICE_PACK_CALLBACK_PREFIX)
+            return;
+        this.pendingNonceButtons.delete(nonce);
+        clearTimeout(entry.timer);
+        void this.retireNonceButtons(entry, entry.messageId ?? "", text);
+    }
+    /** #2692: a pending change was decided (here or on the page) or expired: its prompt says so and loses its buttons. */
+    settleOfficePackPrompt(id, text) {
+        const nonce = this.officePackPrompts.get(id);
+        this.officePackPrompts.delete(id);
+        if (nonce)
+            this.retireOfficePackNonce(nonce, text);
+    }
+    /** #2692: Approve / Reject on a pending pack change. Any fleet admin (the default nonce authorization), in General. */
+    async handleOfficePackCallback(data, adapterId, adapter) {
+        const claimed = this.consumeNonceCallback(OFFICE_PACK_CALLBACK_PREFIX, /^office-pack:([0-9a-f]{32}):(approve|reject)$/, data, adapterId, adapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const { entry, action } = claimed;
+        const nonce = data.callbackData.slice(OFFICE_PACK_CALLBACK_PREFIX.length, OFFICE_PACK_CALLBACK_PREFIX.length + 32);
+        const id = [...this.officePackPrompts].find(([, n]) => n === nonce)?.[0];
+        if (id)
+            this.officePackPrompts.delete(id);
+        const decided = id ? this.officePackTools.decide(id, action, t("settings_confirm.admin_label", data.userId ?? "")) : null;
+        await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, decided?.text ?? t("office_packs.gone"));
+        return true;
+    }
     /**
      * #2578: each instance's state as the org chart shows it (fleet-org.js orgState, from the same fields the status
      * frame and the Needs-you list carry) and its display name (resolveInstanceIdentity, as getUiStatus) — read once.
@@ -1245,7 +1338,10 @@ export class FleetManager {
             needs.set(item.instance, (needs.get(item.instance) ?? 0) + 1);
         const classicRooms = new Map((this.classicChannels?.getAll() ?? []).map(ch => [ch.instanceName, ch]));
         let profiles = null;
+        // #2661: the levels as last worked out (never waits; none while off or not worked out yet).
+        const levels = this.officeLevelsSnapshot();
         return {
+            level: name => (levels && Object.prototype.hasOwnProperty.call(levels, name) ? levels[name].level : undefined),
             stateOf: name => {
                 if (!this.isKnownInstance(name))
                     return "missing";
@@ -1797,12 +1893,96 @@ export class FleetManager {
         this.logger.info({ id: view.id }, "Settings change requires local `agend settings confirm <id>`");
     }
     kiroMigrateDeps() {
+        let token;
+        const current = (name) => {
+            const run = this.kiroMigrationRuns.get(name);
+            return !!token && run?.token === token && !this.shuttingDown
+                && (this.explicitStopGeneration.get(name) ?? 0) === run.stopGeneration;
+        };
         return {
-            agendHome: getAgendHome(),
-            fleetConfig: () => this.fleetConfig,
-            saveFleetConfig: () => this.saveFleetConfig(),
+            agendHome: getAgendHome(), fleetConfig: () => this.fleetConfig, saveFleetConfig: () => this.saveFleetConfig(),
             status: name => this.getInstanceStatus(name),
-            restart: name => this.restartSingleInstance(name, { explicit: true }),
+            reserve: name => {
+                if (this.kiroMigrationRuns.has(name) || this.restartsInFlight.has(name) || this.stopsInFlight.has(name))
+                    throw new Error(t("kiro_migrate.in_progress"));
+                token = Symbol(name);
+                this.kiroMigrationRuns.set(name, { token, stopGeneration: this.explicitStopGeneration.get(name) ?? 0 });
+                return { current: () => current(name), release: () => {
+                        if (this.kiroMigrationRuns.get(name)?.token === token)
+                            this.kiroMigrationRuns.delete(name);
+                        this.scheduleDeliveryOutboxPump();
+                    } };
+            },
+            preflight: async (name, plan) => {
+                const compat = getCachedKiroCliCompatibility(resolveBinary("kiro-cli"));
+                if (!supportsVerifiedKiroMigration(compat))
+                    throw new Error(t("kiro_migrate.version_required"));
+                const daemon = this.daemons.get(name);
+                if (this.getInstanceStatus(name) === "running" && (!daemon || !await daemon.kiroMigrationIdle()))
+                    throw new Error(t("kiro_migrate.idle_required"));
+                if (!current(name) || daemon && this.daemons.get(name) !== daemon)
+                    throw new Error(t("kiro_migrate.superseded"));
+                const inst = this.fleetConfig?.instances[name];
+                const model = daemon?.getModelOverride() ?? inst?.model ?? (plan.classicId ? readKiroV1SavedModel({ id: plan.classicId,
+                    workingDirectory: plan.workingDirectory, dbPath: kiroV1DbPath(plan.credentialProfile) }) : undefined);
+                if (!model && plan.classicId)
+                    throw new Error(t("kiro_migrate.model_unknown"));
+                return model ?? "";
+            },
+            restart: async (name) => {
+                if (!current(name))
+                    throw new Error(t("kiro_migrate.superseded"));
+                const run = this.kiroMigrationRuns.get(name);
+                const expected = run.stopGeneration + 1;
+                // This restart owns exactly one stop. A person's concurrent stop must not be hidden by the workflow.
+                try {
+                    await this.restartSingleInstance(name, { explicit: true, kiroMigration: token });
+                }
+                finally {
+                    // Even a failed replacement owns its completed stop; retain authority to clean up/pause it.
+                    if (this.kiroMigrationRuns.get(name) === run && this.explicitStopGeneration.get(name) === expected)
+                        run.stopGeneration = expected;
+                }
+                if (this.explicitStopGeneration.get(name) !== expected)
+                    throw new Error(t("kiro_migrate.superseded"));
+            },
+            verify: async (name, id, model, archived) => {
+                const daemon = this.daemons.get(name), deadline = performance.now() + 60_000;
+                if (!daemon)
+                    throw new Error(t("kiro_migrate.verification_failed"));
+                while (performance.now() < deadline) {
+                    if (!current(name) || this.daemons.get(name) !== daemon)
+                        throw new Error(t("kiro_migrate.superseded"));
+                    const observed = await daemon.kiroMigrationObservation();
+                    if (observed) {
+                        if (observed.sessionId !== id || observed.model !== model || resolvePath(observed.transcript) !== resolvePath(kiroV2SessionsDir(), id + ".jsonl"))
+                            throw new Error(t("kiro_migrate.verification_failed"));
+                        const inst = this.fleetConfig.instances[name];
+                        const reply = await sharedKiroV2StoreLane.read({ keys: [], sessionsDir: kiroV2SessionsDir(), migration: {
+                                agendHome: getAgendHome(), instance: name, workingDirectory: inst.working_directory, credentialProfile: instanceCredentialProfile(inst, this.fleetConfig?.defaults, "kiro-cli"),
+                                sessionId: id, sessionsDir: kiroV2SessionsDir(), dbPath: kiroV1DbPath(instanceCredentialProfile(inst, this.fleetConfig?.defaults, "kiro-cli")),
+                                model, archived, outboxDbPath: join(this.dataDir, "delivery-outbox.db"), knownInstances: Object.keys(this.fleetConfig.instances),
+                            } });
+                        if (!current(name) || this.daemons.get(name) !== daemon)
+                            throw new Error(t("kiro_migrate.superseded"));
+                        if (reply.kind !== "ok" || !reply.verification)
+                            throw new Error(reply.kind === "unreadable" ? reply.detail : t("kiro_migrate.verification_failed"));
+                        return reply.verification;
+                    }
+                    await new Promise(r => setTimeout(r, 500));
+                }
+                throw new Error(t("kiro_migrate.verification_failed"));
+            },
+            stop: async (name) => { try {
+                await this.stopInstance(name);
+            }
+            finally {
+                writePausedMarker(this.getInstanceDir(name), Date.now(), "error");
+            } },
+            readClassicStore: async (workingDirectory, credentialProfile) => {
+                const dbPath = kiroV1DbPath(credentialProfile);
+                return listKiroV1Sessions(workingDirectory, dbPath, await readKiroClassicLinks(workingDirectory, dbPath));
+            },
         };
     }
     /**
@@ -1810,7 +1990,7 @@ export class FleetManager {
      * here; the move runs on the Confirm (handleKiroMigrateCallback), judged again then.
      */
     async requestKiroMigration(name, startFresh) {
-        const judged = planKiroMigration(this.kiroMigrateDeps(), name, startFresh);
+        const judged = await planKiroMigration(this.kiroMigrateDeps(), name, startFresh);
         if (!judged.ok)
             return judged;
         const general = this.findGeneralInstance();
@@ -1860,8 +2040,77 @@ export class FleetManager {
         const outcome = await applyKiroMigration(this.kiroMigrateDeps(), plan);
         this.logger.info({ name: plan.name, ok: outcome.ok, classicId: plan.classicId }, "kiro classic → TUI move");
         this.notifyFleetError(outcome.text);
-        if (outcome.ok)
-            this.notifyInstanceTopic(plan.name, outcome.text);
+        this.notifyInstanceTopic(plan.name, outcome.text);
+        return true;
+    }
+    kiroReconcileDeps() {
+        return { ...this.kiroMigrateDeps(), store: async (input, plan, actor, rollbackReceipt) => {
+                const reply = await sharedKiroV2StoreLane.read({ keys: [], sessionsDir: input.sessionsDir, reconciliation: { input, plan, actor, rollbackReceipt } });
+                if (reply.kind !== "ok" || !reply.reconciliation)
+                    throw new Error(reply.kind === "unreadable" ? reply.detail : t("kiro_reconcile.changed"));
+                return reply.reconciliation;
+            } };
+    }
+    async requestKiroReconciliation(name, keep, archive, rollbackReceipt) {
+        try {
+            if (!this.eventLog)
+                return { ok: false, error: t("kiro_reconcile.audit_failed") };
+            const plan = await planKiroReconciliation(this.kiroReconcileDeps(), name, keep, archive, rollbackReceipt);
+            const general = this.findGeneralInstance(), adapterId = general ? this.getInstanceAdapterId(general) : undefined;
+            const adapter = general ? this.getAdapterForInstance(general) : undefined, chatId = general ? this.getGroupIdForInstance(general) : undefined;
+            const topic = general ? String(this.fleetConfig?.instances[general]?.topic_id ?? "") : "";
+            if (!general || !adapterId || !adapter || !chatId)
+                return { ok: false, error: t("kiro_migrate.no_general") };
+            const nonce = await this.postNonceButtonPromptOrThrow({ prefix: KIRO_RECONCILE_CALLBACK_PREFIX, alertType: "clear_confirm", instanceName: name,
+                adapter, adapterId, chatId, ...(topic ? { threadId: topic } : {}), message: kiroReconciliationPrompt(plan),
+                choices: [{ action: "confirm", label: t("kiro_migrate.confirm_button") }, { action: "cancel", label: t("kiro_migrate.cancel_button") }],
+                expiredText: t("kiro_migrate.expired", name), timeoutMs: KIRO_MIGRATE_TIMEOUT_MS });
+            this.pendingKiroReconciliations.set(nonce, plan);
+            setTimeout(() => this.pendingKiroReconciliations.delete(nonce), KIRO_MIGRATE_TIMEOUT_MS + 60_000).unref?.();
+            this.eventLog?.insert(name, "kiro_reconcile", { phase: "requested", keep, archive, rollbackReceipt, message: kiroReconciliationPrompt(plan) });
+            return { ok: true, text: t("kiro_migrate.requested") };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof SyntaxError ? "Malformed reconciliation data" : error.message };
+        }
+    }
+    async handleKiroReconcileCallback(data, adapterId, adapter) {
+        const claimed = this.consumeNonceCallback(KIRO_RECONCILE_CALLBACK_PREFIX, /^kiro-reconcile:([0-9a-f]{32}):(confirm|cancel)$/, data, adapterId, adapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const { entry, action } = claimed;
+        const nonce = data.callbackData.slice(KIRO_RECONCILE_CALLBACK_PREFIX.length, KIRO_RECONCILE_CALLBACK_PREFIX.length + 32);
+        const plan = this.pendingKiroReconciliations.get(nonce);
+        this.pendingKiroReconciliations.delete(nonce);
+        if (action === "cancel" || !plan) {
+            await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t(plan ? "kiro_migrate.cancelled" : "kiro_migrate.expired", entry.instanceName));
+            this.eventLog?.insert(entry.instanceName, "kiro_reconcile", { phase: "cancelled_or_expired", userId: data.userId });
+            return true;
+        }
+        let outcome;
+        try {
+            if (!this.eventLog)
+                throw new Error(t("kiro_reconcile.audit_failed"));
+            this.eventLog.insert(plan.name, "kiro_reconcile", { phase: "confirmed", userId: data.userId, keep: plan.input.sessionId, archive: plan.input.archiveId });
+        }
+        catch {
+            await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("kiro_reconcile.audit_failed"));
+            this.notifyFleetError(t("kiro_reconcile.audit_failed"));
+            return true;
+        }
+        await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("kiro_reconcile.applying", plan.name));
+        outcome = await applyKiroReconciliation(this.kiroReconcileDeps(), plan, `${adapterId}:${data.userId}`);
+        try {
+            this.eventLog.insert(plan.name, "kiro_reconcile", { phase: outcome.ok ? "completed" : "failed", userId: data.userId, receipt: outcome.receipt, message: outcome.text });
+        }
+        catch {
+            this.logger.error({ name: plan.name, receipt: outcome.receipt }, "Kiro reconciliation final Log entry failed; confirmed intent remains in the audit and archive");
+        }
+        this.logger.info({ name: plan.name, ok: outcome.ok, receipt: outcome.receipt }, "Kiro explicit reconciliation");
+        this.notifyFleetError(outcome.text);
+        this.notifyInstanceTopic(plan.name, outcome.text);
         return true;
     }
     async handleSettingsChangeCallback(data, adapterId, adapter) {
@@ -2327,27 +2576,8 @@ export class FleetManager {
         const daemon = this.daemons.get(name);
         if (daemon?.bootId === daemonBootId)
             this.listenForWorkingState(name, daemon);
-        const outbox = this.deliveryOutbox;
-        if (!outbox)
-            return;
-        for (const prior of outbox.getUnansweredAccepted(name, daemonBootId)) {
-            try {
-                outbox.admitPostRestartOutcomeNotice(prior, daemonBootId);
-            }
-            catch (err) {
-                this.logger.error({ err, source: name, operationId: prior.operationId }, "Could not persist post-restart delivery outcome notice");
-            }
-        }
-        // #926: a restart kills the turn that was working on a request, and a
-        // resumed CLI does not pick it back up. Remind the owner once per restart.
-        try {
-            const now = new Date();
-            this.expireReplyObligations(now);
-            outbox.remindReplyObligations(name, { reason: "restart", graceMs: 0, now, since: now, restartId: daemonBootId });
-        }
-        catch (err) {
-            this.logger.error({ err, owner: name }, "Could not persist the post-restart reply reminder");
-        }
+        // #2802: no post-restart notices. The outbox still delivers or fails a row accepted before the restart, and an open
+        // request is reminded by the ordinary turn-ended nudge (sweepReplyObligations) once the owner is idle.
         this.scheduleDeliveryOutboxPump();
     }
     workingStateListeners;
@@ -2431,9 +2661,8 @@ export class FleetManager {
         }
     }
     /**
-     * #926: the two reply-obligation safety nets. Idle owners with an unanswered
-     * request get one reminder (after the grace); requesters get one overdue
-     * notice when the owner is not working and nothing came back in time.
+     * #926: idle owners with an unanswered request get one reminder (after the grace). #2802: the only reply notice —
+     * requesters are no longer told about overdue or expired asks (they can check delivery_status / describe_instance).
      */
     sweepReplyObligations(now = new Date()) {
         const outbox = this.deliveryOutbox;
@@ -2444,10 +2673,8 @@ export class FleetManager {
             this.expireReplyObligations(now);
             for (const name of this.daemons.keys()) {
                 if (stateOf(name) === "idle")
-                    outbox.remindReplyObligations(name, { now, graceMs: REPLY_REMINDER_GRACE_MS, reason: "turn-ended" });
+                    outbox.remindReplyObligations(name, { now, graceMs: REPLY_REMINDER_GRACE_MS });
             }
-            const minutes = this.fleetConfig?.defaults?.reply_overdue_minutes ?? DEFAULT_REPLY_OVERDUE_MINUTES;
-            outbox.notifyOverdueReplyObligations({ now, overdueMs: minutes * 60_000, ownerIdle: name => stateOf(name) !== "working" });
         }
         catch (err) {
             this.logger.error({ err }, "Reply-obligation sweep failed");
@@ -5441,7 +5668,10 @@ export class FleetManager {
      */
     resumePaused = false, 
     /** Phase 2a: the caller's transition, for a start made from inside a restart or wake. */
-    transition, execution) {
+    transition, execution, kiroMigration) {
+        const migration = this.kiroMigrationRuns?.get(name);
+        if (migration && migration.token !== kiroMigration)
+            throw new Error(t("kiro_migrate.in_progress"));
         execution?.assert();
         if (this.sessionOomStopped(name)) {
             if (resumePaused)
@@ -5937,6 +6167,11 @@ export class FleetManager {
     stopOnUnsupportedCli(name, err, what) {
         if (!(err instanceof UnsupportedCliError))
             return false;
+        if (err instanceof ResumeBlockedError) {
+            this.logger.error({ name, reason: err.message }, `Not starting ${what}: retained session needs store repair`);
+            void this.notifyFleetError(t("fleet.resume_blocked", name, err.message, err.remedy));
+            return true;
+        }
         this.logger.error({ name, reason: err.message }, `Not starting ${what}: the installed CLI cannot run it as configured`);
         this.queueUnsupportedCliNotice(name, err.message);
         this.queueKiroIncompatNotice(name, err.message);
@@ -6136,6 +6371,9 @@ export class FleetManager {
     }
     /** Restart a single instance, reloading fleet.yaml first to pick up config changes. */
     async restartSingleInstance(name, opts) {
+        const migration = this.kiroMigrationRuns?.get(name);
+        if (migration && migration.token !== opts?.kiroMigration)
+            throw new Error(t("kiro_migrate.in_progress"));
         if (opts?.recoveryCurrent && !opts.recoveryCurrent())
             throw new Error(t("exit.expired", name));
         const retry = opts?.explicit ? opts.sessionOomRetry ?? captureSessionOomRetry(this.getInstanceDir(name)) : undefined;
@@ -6196,7 +6434,7 @@ export class FleetManager {
         return run;
     }
     isInstanceRestarting(name) {
-        return this.restartsInFlight.has(name);
+        return this.restartsInFlight.has(name) || this.kiroMigrationRuns?.has(name) === true;
     }
     /** InstanceLifecycleContext: an explicit wake joins the restart in flight. */
     restartInFlight(name) {
@@ -6301,7 +6539,8 @@ export class FleetManager {
                 return { backend, profile: credentialHomeSpec(backend) ? instanceCredentialProfile(config, this.fleetConfig?.defaults, backend) : null };
             });
             const topicMode = this.fleetConfig?.channel?.mode === "topic";
-            await this.startAfterRestart(name, wasPaused, pausedAt, pauseReason, () => this.startInstance(name, config, topicMode ?? false, "fleet-topic", false, transition));
+            await this.startAfterRestart(name, wasPaused, pausedAt, pauseReason, () => opts?.kiroMigration ? this.startInstance(name, config, topicMode ?? false, "fleet-topic", false, transition, undefined, opts.kiroMigration)
+                : this.startInstance(name, config, topicMode ?? false, "fleet-topic", false, transition));
             this.stormWindow.markRecovered(name);
             return;
         }
@@ -7057,9 +7296,22 @@ export class FleetManager {
                         ...(sent.outcome.kind === "dm_failed" ? { reason: sent.outcome.reason, platform: sent.outcome.platform, ...(sent.outcome.startUrl ? { startUrl: sent.outcome.startUrl } : {}) } : {}) } } : {}) };
         }).sort((x, y) => (y.lastSeen ?? -1) - (x.lastSeen ?? -1));
         // #2348: `explicit` — grants are the scope (default deny); false: the derived scope of #1920, until grants are saved.
-        return { enabled: cfg?.enabled === true, chat: cfg?.chat !== false, explicit: cfg?.grants !== undefined, instances: Object.keys(this.fleetConfig?.instances ?? {}).sort(), connections, guests,
+        // #2667: the ClassicBot rooms there are now, apart from fleet.yaml's instances (a grant may name either: guestReach),
+        // with its display name as the sidebar resolves it (a profile alias, else the room's own), when it has one.
+        const profiles = profileIdentities(this.dataDir);
+        const rooms = (this.classicChannels?.getAll() ?? []).filter((r) => !Object.hasOwn(this.fleetConfig?.instances ?? {}, r.instanceName))
+            .map((r) => {
+            const shown = resolveInstanceIdentity({ classic: r, profile: profiles.get(r.instanceName) }).display_name;
+            return { name: r.instanceName, ...(shown && shown !== r.instanceName ? { display_name: shown } : {}) };
+        })
+            .sort((x, y) => (x.name < y.name ? -1 : x.name > y.name ? 1 : 0));
+        return { enabled: cfg?.enabled === true, chat: cfg?.chat !== false, explicit: cfg?.grants !== undefined, instances: Object.keys(this.fleetConfig?.instances ?? {}).sort(), rooms, connections, guests,
             audit: this.guestAudit() };
     }
+    /** #2667: the ClassicBot rooms' instance names now — what a settings save's validation knows besides fleet.yaml's instances. */
+    classicRoomNames() {
+        return (this.classicChannels?.getAll() ?? []).map((r) => r.instanceName);
+    }
     /**
      * #2499 review: the guest audit an admin reads — the newest grant changes and admin-sent codes from the event log
      * (`fleet` rows: no agent's Log shows them). Through guestOverview only: Settings' admin gate, never over the public
@@ -7868,7 +8120,7 @@ export class FleetManager {
         setSdNotifyWarn((fields, message) => this.logger.warn(fields, message));
         if (this.watchdogTimer)
             clearInterval(this.watchdogTimer);
-        this.watchdogTimer = setInterval(() => sdNotify("WATCHDOG=1"), 30_000);
+        this.watchdogTimer = startSdWatchdog();
         this.eventLoopWatch?.stop();
         this.eventLoopWatch = startEventLoopWatch({ logger: this.logger });
         try {
@@ -8082,8 +8334,8 @@ export class FleetManager {
         const channelConfigs = fleet.channels ?? (fleet.channel ? [fleet.channel] : []);
         this.warnUnboundGeneralChannelIds(fleet);
         const primaryAdapterId = channelConfigs[0] ? (channelConfigs[0].id ?? channelConfigs[0].type) : undefined;
+        let generalsCreated = adoptGeneralByName(fleet, this.logger, dir => insideManagedWorkspaces(dir) || resolvePath(dir) === join(getAgendHome(), GENERAL_NAME));
         const generalInstances = Object.entries(fleet.instances).filter(([, inst]) => inst.general_topic === true);
-        let generalsCreated = false;
         // Collect unbound generals (no channel_id set) for auto-assignment
         const unboundGenerals = generalInstances.filter(([, inst]) => !inst.channel_id);
         // Track which adapters still need a general
@@ -8143,9 +8395,16 @@ export class FleetManager {
         }
         // Phase 3: Create new generals for any remaining adapters
         for (const need of needsGeneral) {
-            const name = channelConfigs.length > 1 ? `general-${need.adapterId}` : "general";
-            if (fleet.instances[name])
+            let name = channelConfigs.length > 1 ? `general-${need.adapterId}` : GENERAL_NAME;
+            if (fleet.instances[name]?.general_topic)
                 continue;
+            if (fleet.instances[name]) {
+                // M-2069: the name is an agent's that is not the General (adoptGeneralByName left it: it works in a project
+                // of the user's) — the fleet still gets its General, under a free name, never none.
+                const taken = name;
+                name = freeGeneralName(fleet.instances, taken);
+                this.logger.warn({ taken, name }, "An agent is named like the General but is not one — creating the General under a free name; rename that agent to clear this");
+            }
             this.logger.warn({ adapter: need.adapterId, name }, "No general instance for adapter — auto-creating");
             const generalDir = join(getAgendHome(), name);
             mkdirSync(generalDir, { recursive: true, mode: 0o700 });
@@ -8425,8 +8684,6 @@ export class FleetManager {
                 }
                 await this.sendFleetStartCompletionFallback(String(fleet.channel.group_id), text, generalThreadId != null ? String(generalThreadId) : undefined);
             }
-            // 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();
         }
@@ -9935,6 +10192,10 @@ export class FleetManager {
             }))
                 return;
         }
+        // #2675: a reply to a posted question card is its typed answer (judged by who may talk to that instance), not a
+        // message for the instance — which could not take one while its card is up anyway.
+        if (await this.takeRemoteCardReply(msg))
+            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:
@@ -10557,34 +10818,6 @@ export class FleetManager {
      * their fleet is organised. Both stay theirs — this only makes sure they are
      * not discovered by an agent failing at three in the morning.
      */
-    /**
-     * #1366: the first time a fleet runs 2.2 or later, tell each chat platform's General — once — that its agents can
-     * now be talked to from a browser. Claimed in upgrade-notices.json before the send, released if the send fails.
-     * Platforms with nowhere to post fleet notices (no group, or a Discord fleet with no General channel) are skipped
-     * and not recorded, so they are told once they have one.
-     */
-    async announceWebChatOnce(version) {
-        if (!hasWebChat(version))
-            return;
-        const path = upgradeNoticesPath(this.dataDir);
-        for (const [adapterId, world] of this.worlds) {
-            if (this.shuttingDown)
-                return;
-            const target = this.fleetNoticeTarget(adapterId);
-            if (!target)
-                continue;
-            if (!claimNotice(path, WEB_CHAT_NOTICE, adapterId))
-                continue;
-            try {
-                await world.adapter.sendText(target.chatId, t("upgrade.web_chat"), target.opts);
-                this.logger.info({ adapterId, notice: WEB_CHAT_NOTICE }, "Announced web chat in General");
-            }
-            catch (err) {
-                const released = releaseNotice(path, WEB_CHAT_NOTICE, adapterId);
-                this.logger.warn({ err, adapterId, released }, "Could not announce web chat in General — will try at the next start");
-            }
-        }
-    }
     announceToolPermissionsChange() {
         try {
             const thirtyDaysAgo = new Date(Date.now() - 30 * 864e5).toISOString().slice(0, 19).replace("T", " ");
@@ -11326,7 +11559,7 @@ export class FleetManager {
         if (!ipc || !fleetRequestId)
             return;
         const type = String(msg.type);
-        const responseType = isCanvasWorkerTool(type.replace(/^fleet_/, "")) || type === "fleet_office_view" || type === "fleet_office_set" ? "fleet_web_theme_response"
+        const responseType = isCanvasWorkerTool(type.replace(/^fleet_/, "")) || type === "fleet_office_view" || type === "fleet_office_set" || OFFICE_PACK_IPC.has(type) ? "fleet_web_theme_response"
             : type.startsWith("fleet_schedule_") ? "fleet_schedule_response"
                 : type.startsWith("fleet_decision_") ? "fleet_decision_response"
                     : type === "fleet_task" ? "fleet_task_response"
@@ -11381,7 +11614,10 @@ export class FleetManager {
             || type === "fleet_set_web_widget" || type === "fleet_remove_web_widget"
             || type === "fleet_set_web_ambient" || type === "fleet_clear_web_ambient"
             || type === "fleet_export_web_mod" || type === "fleet_propose_web_mod"
-            || type === "fleet_office_view" || type === "fleet_office_set") {
+            || type === "fleet_office_view" || type === "fleet_office_set"
+            // #2692: the skin packs (OFFICE_PACK_IPC), answered as web theme tools.
+            || type === "fleet_office_pack_check" || type === "fleet_office_pack_upload" || type === "fleet_office_pack_delete"
+            || type === "fleet_office_pack_restore" || type === "fleet_office_pack_list" || type === "fleet_office_set_style") {
             this.handleWebTheme(name, msg);
             return;
         }
@@ -11403,7 +11639,8 @@ export class FleetManager {
                 ? this.appearanceTools.handle(instanceName, tool, args)
                 : tool === "export_web_mod" || tool === "propose_web_mod" ? this.agentMods.handle(instanceName, tool, args)
                     : tool === "office_view" || tool === "office_set" ? this.officeActs.handle(instanceName, tool, args)
-                        : this.webAppearance.handleTool(instanceName, tool, args);
+                        : OFFICE_PACK_IPC.has(`fleet_${tool}`) ? this.officePackTools.handle(instanceName, tool, args)
+                            : this.webAppearance.handleTool(instanceName, tool, args);
             ipc.send({ type: "fleet_web_theme_response", fleetRequestId, result });
         }
         catch (err) {
@@ -11841,6 +12078,8 @@ export class FleetManager {
             return this.agentMods.handle(instance, tool, args);
         if (tool === "office_view" || tool === "office_set")
             return this.officeActs.handle(instance, tool, args); // #2578
+        if (OFFICE_PACK_IPC.has(`fleet_${tool}`))
+            return this.officePackTools.handle(instance, tool, args); // #2692
         return this.webAppearance.handleTool(instance, tool, args);
     }
     async handlePreviewEmojisHttp(instance, args) {
@@ -12279,12 +12518,21 @@ export class FleetManager {
         normalizeOfficeStorage(this.fleetConfig);
         explicitPatches = explicitPatches.flatMap(patch => {
             const path = patch.path;
-            if (path.at(-2) === "dashboard" && path.at(-1) === "office" && !patch.remove) {
-                return [{ ...patch, path: [...path.slice(0, -2), "office_access"] }, { path, remove: true }];
-            }
-            if (path.at(-1) === "dashboard" && patch.value && typeof patch.value === "object" && Object.hasOwn(patch.value, "office")) {
-                const { office, ...dashboard } = patch.value;
-                return [{ ...patch, value: dashboard }, { path: [...path.slice(0, -1), "office_access"], value: office, remove: office === null }];
+            // #2601 (and #2692's office_packs): a separately kept feature is written under its own key, never in `dashboard`.
+            const separate = path.at(-2) === "dashboard" ? SEPARATE_FEATURE_KEYS[path.at(-1)] : undefined;
+            if (separate && !patch.remove) {
+                return [{ ...patch, path: [...path.slice(0, -2), separate] }, { path, remove: true }];
+            }
+            if (path.at(-1) === "dashboard" && patch.value && typeof patch.value === "object" && Object.keys(SEPARATE_FEATURE_KEYS).some(f => Object.hasOwn(patch.value, f))) {
+                const dashboard = { ...patch.value }, moved = [];
+                for (const [feature, key] of Object.entries(SEPARATE_FEATURE_KEYS)) {
+                    if (!Object.hasOwn(dashboard, feature))
+                        continue;
+                    const value = dashboard[feature];
+                    delete dashboard[feature];
+                    moved.push({ path: [...path.slice(0, -1), key], value, remove: value === null });
+                }
+                return [{ ...patch, value: dashboard }, ...moved];
             }
             // #2581's DM choice was withdrawn: an old string is just "on", posted in the topic, and its route is dropped.
             if (patch.path.join(".") === "web.notify_login" && patch.value === "dm")
@@ -12398,11 +12646,11 @@ export class FleetManager {
             const previous = daemon.getConfigSnapshot?.();
             if (!next || !previous)
                 continue;
-            if (isDeepStrictEqual(previous.dashboard, next.dashboard) && previous.office_access === next.office_access)
+            if (isDeepStrictEqual(previous.dashboard, next.dashboard) && previous.office_access === next.office_access && previous.office_pack_access === next.office_pack_access)
                 continue;
             // Only permissions are adopted here. Cold fields retain the live daemon's old snapshot, so reconcile still
             // detects that they require a restart. MCP menus also watch the raw file; this updates the next spawn's env.
-            daemon.applyConfigUpdate({ dashboard: next.dashboard ?? null, office_access: next.office_access ?? null });
+            daemon.applyConfigUpdate({ dashboard: next.dashboard ?? null, office_access: next.office_access ?? null, office_pack_access: next.office_pack_access ?? null });
             if (taskBoardSwitchedOn(previous.dashboard, next.dashboard)) {
                 this.admitTaskBoardNotice(name, TASK_BOARD_ON_NOTICE, `task-board-on:${name}:${Date.now()}`);
             }
@@ -12436,7 +12684,7 @@ export class FleetManager {
     logConfigWarningsAtStartup() {
         let warnings = [];
         try {
-            warnings = validateFleetConfig(this.rawFleetConfig).warnings;
+            warnings = validateFleetConfig(this.rawFleetConfig, { rooms: readClassicRoomNames(this.dataDir) }).warnings;
         }
         catch (err) {
             this.logger.debug({ err }, "fleet.yaml validation failed (startup warnings)");
@@ -12467,11 +12715,13 @@ export class FleetManager {
             const patches = [];
             const raw = this.rawFleetConfig;
             for (const [path, item] of [[["defaults"], raw.defaults], ...Object.entries(raw.instances ?? {}).map(([name, value]) => [["instances", name], value])]) {
-                if (!item?.dashboard || !Object.hasOwn(item.dashboard, "office"))
-                    continue;
-                patches.push({ path: [...path, "dashboard", "office"], remove: true });
-                if (!Object.hasOwn(item, "office_access") && typeof item.dashboard.office === "boolean")
-                    patches.push({ path: [...path, "office_access"], value: item.dashboard.office });
+                for (const [feature, key] of Object.entries(SEPARATE_FEATURE_KEYS)) {
+                    if (!item?.dashboard || !Object.hasOwn(item.dashboard, feature))
+                        continue;
+                    patches.push({ path: [...path, "dashboard", feature], remove: true });
+                    if (!Object.hasOwn(item, key) && typeof item.dashboard[feature] === "boolean")
+                        patches.push({ path: [...path, key], value: item.dashboard[feature] });
+                }
             }
             this.saveFleetConfig(patches);
             this.logger.info("Stored Office access outside dashboard for downgrade compatibility");
@@ -12706,6 +12956,7 @@ export class FleetManager {
             this.mods.forgetInstance(name);
             this.agentMods.forget(name);
             this.officeActsInstance?.forget(name);
+            this.officePackToolsInstance?.forget(name);
         }
         catch (err) {
             this.logger.warn({ err: err.message, name }, "Dropping a removed instance's web theme failed");
@@ -14073,7 +14324,7 @@ export class FleetManager {
             return;
         const read = board.summaryRead(since.toISOString(), until.toISOString(), this.dispatcherGone);
         const projects = board.listProjects(true);
-        const stats = board.projectStats();
+        const stats = board.projectStats(this.dispatcherGone);
         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;
@@ -14337,7 +14588,7 @@ export class FleetManager {
                 entry.web = {
                     text: web.text,
                     ...(links ? { links } : {}),
-                    actions: opts.choices.map(c => ({ id: c.action, label: c.label })),
+                    actions: [...opts.choices.map(c => ({ id: c.action, label: c.label })), ...(opts.webInput ? [{ id: opts.webInput.action, label: opts.webInput.label, input: true }] : [])],
                     expiresAt: Date.now() + (opts.timeoutMs ?? NONCE_BUTTON_TIMEOUT_MS),
                 };
                 this.emitSseEvent("prompt", { instance: entry.instanceName, nonce, ...entry.web });
@@ -14514,6 +14765,10 @@ export class FleetManager {
             return true;
         if (await this.handleKiroMigrateCallback(data, adapterId, adapter))
             return true;
+        if (await this.handleKiroReconcileCallback(data, adapterId, adapter))
+            return true;
+        if (await this.handleOfficePackCallback(data, adapterId, adapter))
+            return true;
         if (await this.handleDashboardCallback(data, adapterId, adapter))
             return true;
         if (await this.handleClassicApproval(data, adapterId, adapter))
@@ -14530,6 +14785,8 @@ export class FleetManager {
             return true;
         if (await this.handleInteractivePromptAssist(data, adapterId, adapter))
             return true;
+        if (await this.handleRemoteCardClick(data, adapterId, adapter))
+            return true;
         if (await this.handleClassicBackendSelection(data))
             return true;
         if (await this.handleModelSelection(data, adapterId))
@@ -14706,6 +14963,34 @@ export class FleetManager {
             messages: messages.filter(m => keep(m.instance)),
         });
     }
+    /** #2661: the Office levels as last worked out, and the work in flight (officeLevels). */
+    officeLevelsMemo = null;
+    officeLevelsRun = null;
+    /**
+     * #2661: every instance's Office level (office-levels.ts) — worked out by the cache service from the usage store, at
+     * most once per OFFICE_LEVELS_TTL_MS however many pages and share links ask (one run at a time). Null when
+     * web.office_levels is false.
+     */
+    async officeLevels() {
+        if (this.fleetConfig?.web?.office_levels === false)
+            return null;
+        const { OFFICE_LEVELS_TTL_MS } = await import("./office-levels.js");
+        const memo = this.officeLevelsMemo;
+        if (memo && performance.now() - memo.at < OFFICE_LEVELS_TTL_MS)
+            return memo.levels;
+        this.officeLevelsRun ??= this.cacheServiceFor().officeLevels(Date.now()).then((levels) => { this.officeLevelsMemo = { at: performance.now(), levels }; return levels; }).finally(() => { this.officeLevelsRun = null; });
+        return this.officeLevelsRun;
+    }
+    /**
+     * #2661: the levels as last worked out, for a synchronous reader (a share link's gateway): never waits; a stale or
+     * missing set starts the next run. Null when web.office_levels is false or none has been worked out yet.
+     */
+    officeLevelsSnapshot() {
+        if (this.fleetConfig?.web?.office_levels === false)
+            return null;
+        void this.officeLevels().catch(() => { });
+        return this.officeLevelsMemo?.levels ?? null;
+    }
     /** #2001: get_cache_report's — the same report, as last worked out (reused for a minute, until the next pass). */
     cacheReportPublished(window) {
         return this.cacheServiceFor().published(cacheWindow(window));
@@ -15003,8 +15288,12 @@ export class FleetManager {
         const buttons = this.replyButtons();
         return buttons ? buttons.clickWeb(instance, id, index, voter) : Promise.resolve({ status: 409, error: t("reply_buttons.closed") });
     }
-    async clickWebPrompt(instance, nonce, action) {
-        if (!/^[0-9a-f]{32}$/.test(nonce) || !/^[a-z][a-z-]{0,23}$/.test(action))
+    async clickWebPrompt(instance, nonce, action, text) {
+        if (!/^[0-9a-f]{32}$/.test(nonce) || !/^[a-z][a-z0-9-]{0,23}$/.test(action))
+            return { status: 400, error: "Malformed prompt answer" };
+        // #2675: only an action the page shows a text box for takes text, and it must say something.
+        const input = this.pendingNonceButtons.get(nonce)?.web?.actions.find(a => a.id === action)?.input === true;
+        if (input !== (text !== undefined) || (input && (!text.trim() || text.length > REMOTE_CARD_TEXT_MAX)))
             return { status: 400, error: "Malformed prompt answer" };
         const entry = this.pendingNonceButtons.get(nonce);
         // Unknown is the same answer as answered or expired: the page drops the buttons either way.
@@ -15026,6 +15315,8 @@ export class FleetManager {
                 notice = n; },
         };
         this.webPromptClicks.add(data);
+        if (text !== undefined)
+            this.webPromptTexts.set(data, text);
         await this.dispatchAdapterCallback(data, entry.adapterId, entry.adapter);
         if (this.webPromptClaims.has(data))
             return { status: 200 };
@@ -16083,6 +16374,163 @@ export class FleetManager {
         }
         return true;
     }
+    // ── #2675: a card a CLI shows in place of its composer, answered from the chat ─────────────────────────────────
+    /**
+     * Where an instance's card is put to people: its own place — its topic, or its ClassicBot room — or, on a fleet with
+     * no chat platform, the dashboard. Never General: the answer is the instance's conversation.
+     */
+    remoteCardPlace(instanceName) {
+        const web = this.webOnlyPromptPlace();
+        if (web)
+            return web;
+        const room = this.classicChannels?.getChannelIdByInstance(instanceName);
+        if (room) {
+            const adapterId = this.classicChannels?.getAdapterIdByInstance(instanceName) ?? this.getPrimaryAdapterId();
+            const adapter = adapterId ? this.worlds.get(adapterId)?.adapter : undefined;
+            return adapter && adapterId ? { adapter, adapterId, chatId: room } : null;
+        }
+        const adapterId = this.getInstanceAdapterId(instanceName);
+        const adapter = adapterId ? this.worlds.get(adapterId)?.adapter : undefined;
+        const chatId = this.getGroupIdForInstance(instanceName);
+        const topicId = this.fleetConfig?.instances[instanceName]?.topic_id;
+        if (!adapter || !adapterId || !chatId || topicId == null)
+            return null;
+        return { adapter, adapterId, chatId, threadId: String(topicId) };
+    }
+    /**
+     * The daemon saw a card held still on `instanceName`'s screen (remote_card): put it to the people who talk to that
+     * instance, with a button per answer. A card already posted for the instance is retired first (the daemon said it
+     * was gone; this is the fallback).
+     */
+    async postRemoteCard(instanceName, card) {
+        this.retireRemoteCard(instanceName, null, t("card.answered_in_pane"));
+        const place = this.remoteCardPlace(instanceName);
+        if (!place) {
+            this.logger.warn({ instanceName }, "A card is waiting on screen but the instance has no place to post it — the parked notice stands");
+            return;
+        }
+        const prompt = remoteCardPrompt(instanceName, card);
+        const nonce = await this.postNonceButtonPrompt({
+            prefix: REMOTE_CARD_CALLBACK_PREFIX, alertType: "interactive_prompt", instanceName, ...place,
+            message: prompt.message, choices: prompt.choices, webInput: prompt.webInput,
+            expiredText: t("card.expired", instanceName), timeoutMs: REMOTE_CARD_TIMEOUT_MS,
+            extra: { remoteCard: { identity: card.identity, kind: card.kind, options: card.kind === "question" ? card.options.map(o => ({ n: o.n, title: o.title })) : [] } },
+        });
+        if (nonce)
+            this.remoteCardPosts.set(instanceName, nonce);
+    }
+    /**
+     * The card is gone from the screen (remote_card_gone, `identity`; null: whichever is posted): its buttons collapse to
+     * `text` if nobody answered them here.
+     */
+    retireRemoteCard(instanceName, identity, text = t("card.answered_in_pane")) {
+        const nonce = this.remoteCardPosts.get(instanceName);
+        if (!nonce)
+            return;
+        const entry = this.pendingNonceButtons.get(nonce);
+        if (entry && identity !== null && entry.remoteCard?.identity !== identity)
+            return;
+        this.remoteCardPosts.delete(instanceName);
+        if (!entry)
+            return;
+        this.pendingNonceButtons.delete(nonce);
+        if (entry.timer)
+            clearTimeout(entry.timer);
+        void this.retireNonceButtons(entry, entry.messageId ?? "", text);
+    }
+    /** Who may answer an instance's card: whoever may already talk to it there (a ClassicBot room is open to all). */
+    mayAnswerRemoteCard(userId, entry) {
+        if (this.classicChannels?.getChannelIdByInstance(entry.instanceName) === entry.chatId)
+            return true;
+        const am = this.worlds.get(entry.adapterId)?.accessManager ?? this.accessManager;
+        return !am || am.isAllowed(userId);
+    }
+    /** A click on a card's button (platform or dashboard). */
+    async handleRemoteCardClick(data, callbackAdapterId, receivingAdapter) {
+        if (!data.callbackData.startsWith(REMOTE_CARD_CALLBACK_PREFIX))
+            return false;
+        // A typed answer from the dashboard must come with its text; refused before the claim, so the buttons stay.
+        const match = REMOTE_CARD_CALLBACK_RE.exec(data.callbackData);
+        if (match?.[2] === "text" && remoteCardAction("text", this.webPromptTexts.get(data)) === null) {
+            data.ack?.(t("buttons.stale_notice"));
+            return true;
+        }
+        const claimed = this.consumeNonceCallback(REMOTE_CARD_CALLBACK_PREFIX, REMOTE_CARD_CALLBACK_RE, data, callbackAdapterId, receivingAdapter, undefined, (userId, entry) => this.mayAnswerRemoteCard(userId, entry));
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const action = remoteCardAction(claimed.action, this.webPromptTexts.get(data));
+        const who = this.webPromptClicks.has(data) ? t("card.someone_on_dashboard") : (data.username ?? data.userId ?? "?");
+        await this.answerRemoteCardFor(claimed.entry, action, who, data.messageId, data.editClicked);
+        return true;
+    }
+    /**
+     * An inbound message that replies to a posted question card, by someone who may answer it: its text is the typed
+     * answer, and the message goes no further (true). Another bot's copy of a reply already taken is dropped (true).
+     */
+    async takeRemoteCardReply(msg) {
+        if (msg.isBotMessage || !msg.replyTo)
+            return false;
+        const now = performance.now();
+        for (const [key, until] of this.takenCardReplies)
+            if (until <= now)
+                this.takenCardReplies.delete(key);
+        const key = `${msg.chatId}|${msg.messageId}`;
+        if (this.takenCardReplies.has(key))
+            return true;
+        for (const [nonce, entry] of this.pendingNonceButtons) {
+            if (entry.prefix !== REMOTE_CARD_CALLBACK_PREFIX || entry.remoteCard?.kind !== "question")
+                continue;
+            // By place, whichever of the fleet's bots received the reply (a sibling's copy can arrive first, #2680 review), on
+            // the post's own platform; who may answer is judged by the post's world (mayAnswerRemoteCard), as Needs you does.
+            if (entry.chatId !== msg.chatId || entry.messageId !== msg.replyTo || entry.adapter.type !== msg.source)
+                continue;
+            if (!msg.userId || !this.mayAnswerRemoteCard(msg.userId, entry))
+                return false; // not theirs to answer: it is just a message
+            const action = remoteCardAction("text", msg.text ?? "");
+            if (!action)
+                return false;
+            this.pendingNonceButtons.delete(nonce);
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            this.webPromptGone(entry);
+            this.takenCardReplies.set(key, now + REMOTE_CARD_TAKEN_TTL_MS);
+            await this.answerRemoteCardFor(entry, action, msg.username ?? msg.userId, entry.messageId ?? msg.replyTo);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Key a claimed answer into the instance's card (the daemon checks it is still that card and walks a verified
+     * cursor), then collapse the post to what happened. When the card is still waiting and was not answered — refused
+     * or stopped part-way — it is posted again, so it can still be answered from here.
+     */
+    async answerRemoteCardFor(entry, action, who, messageId, editClicked) {
+        if (this.remoteCardPosts.get(entry.instanceName) === entry.nonce)
+            this.remoteCardPosts.delete(entry.instanceName);
+        const daemon = this.daemons.get(entry.instanceName);
+        const card = entry.remoteCard;
+        let outcome;
+        if (!card || !action)
+            outcome = { outcome: "refused", reason: "malformed" };
+        else if (!daemon?.answerRemoteCard)
+            outcome = { outcome: "stale" };
+        else {
+            try {
+                outcome = await daemon.answerRemoteCard(card.identity, action);
+            }
+            catch (err) {
+                this.logger.warn({ err: err?.message, instanceName: entry.instanceName }, "Answering a card from the chat failed");
+                outcome = { outcome: "stopped", step: "error" };
+            }
+        }
+        this.eventLog?.insert(entry.instanceName, "remote_card_answer", { action: action?.kind ?? null, outcome: outcome.outcome });
+        const choice = card && action ? remoteCardChoiceLabel(card, action) : "?";
+        await this.retireNonceButtons(entry, messageId, remoteCardOutcomeText(entry.instanceName, who, choice, outcome), editClicked);
+        if (outcome.outcome === "refused" || outcome.outcome === "stopped")
+            daemon?.repostRemoteCard?.();
+    }
     // ── Cancel button ────────────────────────────────────────────────────
     // Sent after delivering a user message to an instance; clicking it (or
     // /cancel) sends Escape to the instance's pane to interrupt generation.
@@ -17793,8 +18241,8 @@ export class FleetManager {
      * 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).
+     * one "[Task board]" notice per instance, gathered for 10 s, held by the delivery outbox until it is taken, or
+     * withdrawn once its cards changed again (#2801; task-board-waker.ts).
      */
     attachTaskBoard(db) {
         this.taskBoardWaker?.stop();
@@ -17803,6 +18251,19 @@ export class FleetManager {
         const waker = this.taskBoardWaker = new TaskBoardWaker({
             deliver: (instance, message, key) => this.admitTaskBoardNotice(instance, message, key),
             isInstance: (name) => this.fleetConfig?.instances?.[name] != null,
+            // #2785 (c), #2801: the maker's own message already told it; the board's line would repeat it.
+            messagedAbout: (from, to, codes, sinceMs) => {
+                const outbox = this.deliveryOutbox;
+                if (!outbox?.isOpen)
+                    return false;
+                return outbox.recentTextsFrom(to, from, new Date(sinceMs).toISOString()).some((text) => codes.some((code) => namesCard(text, code)));
+            },
+            // #2801: a notice still waiting whose cards have all changed again is not delivered.
+            withdraw: (prefix, stale, reason) => {
+                const outbox = this.deliveryOutbox;
+                return outbox?.isOpen ? outbox.withdrawWaitingNotices(prefix, stale, reason).length : 0;
+            },
+            changedAt: (uuid) => db.board.lastChangeAt(uuid),
             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).
@@ -17819,12 +18280,13 @@ export class FleetManager {
             },
             log: (level, message, extra) => this.logger[level](extra ?? {}, message),
         });
-        db.board.onChange(({ rev, ids, projects, wakes }) => {
+        db.board.onChange(({ rev, ids, projects, wakes, changed }) => {
             // Refresh both old and new owners on reassignment; wakes are not an ownership index.
             if (ids.length)
                 for (const name of this.daemons.keys())
                     this.observeWorkingState(name, "tasks");
             this.emitSseEvent("tasks", { rev, ids, projects });
+            waker.changed(changed);
             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)
@@ -22978,7 +23440,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                     // From the install's own channel tag, this is what /update installs — even a stable the release pointed the
                     // tag at (2.2.0 on @alpha / @beta): the plain /update text, never "/update stays on … use --stable" (#1928).
                     const key = fromChannel ? "update.available_current" : updateNoticeKey(currentVersion, target);
-                    this.notifyInstanceTopic(generalId, t(key, `v${target}`, `v${currentVersion}`));
+                    // #2775: null = a beta install and a stable target; beta users are never told to switch.
+                    if (key)
+                        this.notifyInstanceTopic(generalId, t(key, `v${target}`, `v${currentVersion}`));
                 }
             }
         }