aicodeman 1.46.0 → 1.48.0

package/dist/web/server.js

@@ -44,6 +44,8 @@ import { looksLikeHostReboot, newestPersistedActivity, planRebootRestore } from
 import { rebootRestoreRegistry } from './reboot-restore-registry.js';
 import { dataPath, getDataDir, CODEMAN_INSTANCE } from '../config/instance.js';
 import { WebhookNotifier, readWebhookConfig } from '../webhook-notify.js';
+import { DiscordBridge, screenTail } from '../discord-bridge.js';
+import { isExternalCliTranscriptMode } from './response-viewer-transcript.js';
 import { stopHostSensors } from '../host-sensors.js';
 import { webviewFetch } from './webview-egress.js';
 import { readRemoteHosts, rehydrateRemoteHostFields } from '../remote-hosts.js';
@@ -66,8 +68,8 @@ import { attachmentRegistry, buildFileThumbnailRoute, registerExternalAttachment
 import { folderGrants } from '../folder-listing.js';
 import { getCli, enabledClis, listClis } from '../config/cli-registry/registry.js';
 import { isCliEntryInstalled, probeStockCliAvailability } from '../utils/cli-installed-probes.js';
-import { readCustomModelHosts } from '../custom-model-hosts.js';
-import { applyCustomModelInjection, customModelConfigDir, removeConfigDir } from '../custom-model-injection-apply.js';
+import { readCustomModelHosts, resolveCustomModelContextLength } from '../custom-model-hosts.js';
+import { applyCustomModelInjection, customModelConfigDir, removeConfigDir, } from '../custom-model-injection-apply.js';
 import { registerGeneratedArtifactAttachment } from '../generated-artifact-attachments.js';
 import { buildDetectedAttachmentHistoryItem, buildExternalAttachmentHistoryItem, } from '../session-attachment-history.js';
 import { TranscriptWatcher } from '../transcript-watcher.js';
@@ -99,6 +101,9 @@ import { probePathKind } from '../utils/bounded-path-probe.js';
 import { defaultDockerWorkspaces } from './routes/git-status-routes.js';
 import { composerIsEmpty, plainFrame } from '../session-submit-verifier.js';
 import { detectUsageLimitPause } from '../usage-limit-patterns.js';
+import { EditHistorySync } from './edit-history-sync.js';
+import { EditHistoryStore } from '../edit-history-store.js';
+import { probeLocalPaths, readClaudeEditSources, resolveClaudeTranscript } from '../edit-history-local-source.js';
 import { stopDeepSeekWeb } from '../deepseek-web-server.js';
 import { wireRespawnListeners, setupTimedRespawn, restoreRespawnController, saveRespawnConfig, } from './respawn-event-wiring.js';
 import { reconcileUpdateOnBoot } from './self-update.js';
@@ -134,8 +139,9 @@ import { registerAuthMiddleware, registerSecurityHeaders, registerHostGuard, isL
 import { isMultiUserMode } from '../config/multiuser.js';
 import { bootstrapInitialAdmin, hasUsers, resolveClaudeModeForUsername } from '../user-store.js';
 import { installRouteErrorHandler } from './route-error-handler.js';
+import { installEmptyApiPostParser } from './request-body-parser.js';
 import { isExplicitlyEnabled, isLoopbackBindHost, buildHostPolicy } from './network-auth-policy.js';
-import { registerPushRoutes, registerTeamRoutes, registerMuxRoutes, registerFileRoutes, registerHtmlViewRoutes, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, registerInboxRoutes, registerRebootRestoreRoutes, registerReadMyMindRoutes, registerGitStatusRoutes, registerStatusTelemetryRoutes, registerSystemRoutes, registerCaseRoutes, registerWorktreeRoutes, registerSessionRoutes, registerAgentSessionRoutes, registerRespawnRoutes, registerRalphRoutes, registerPlanRoutes, registerClipboardRoutes, registerSearchRoutes, registerOrchestratorRoutes, registerCronRoutes, registerMeRoutes, registerAdminRoutes, registerWsRoutes, registerVoiceRoutes, registerWebviewRoutes, registerTabLayoutRoutes, registerMcpSyncRoutes, registerConfigBackupRoutes, runConfigBackup, registerWebhookRoutes, registerDoctorRoutes, registerCustomModelRoutes, refreshAllCustomModelHosts, readCustomModelEndpointsEnabled, closeAllLlamaSwapLogTails, detectCustomModelSwapDisplacements, pruneIdleLlamaSwapLogTails, tryWebviewRefererFallback, registerCliRegistryRoutes, } from './routes/index.js';
+import { registerPushRoutes, registerTeamRoutes, registerMuxRoutes, registerFileRoutes, registerHtmlViewRoutes, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, registerInboxRoutes, registerRebootRestoreRoutes, registerReadMyMindRoutes, registerGitStatusRoutes, registerEditHistoryRoutes, registerStatusTelemetryRoutes, registerSystemRoutes, registerCaseRoutes, registerWorktreeRoutes, registerSessionRoutes, registerAgentSessionRoutes, registerRespawnRoutes, registerRalphRoutes, registerPlanRoutes, registerClipboardRoutes, registerSearchRoutes, registerOrchestratorRoutes, registerCronRoutes, registerMeRoutes, registerAdminRoutes, registerWsRoutes, registerVoiceRoutes, registerWebviewRoutes, registerTabLayoutRoutes, registerMcpSyncRoutes, registerConfigBackupRoutes, runConfigBackup, registerWebhookRoutes, registerDiscordRoutes, registerDoctorRoutes, registerCustomModelRoutes, refreshAllCustomModelHosts, readCustomModelEndpointsEnabled, closeAllLlamaSwapLogTails, detectCustomModelSwapDisplacements, pruneIdleLlamaSwapLogTails, tryWebviewRefererFallback, registerCliRegistryRoutes, } from './routes/index.js';
 import { isLostWebviewFrameNavigation } from './webview-proxy.js';
 import { CronService } from '../cron/cron-service.js';
 import { caseSessionSettled } from '../case-rename.js';
@@ -204,6 +210,19 @@ function getOrCreateSelfSignedCert() {
 export class WebServer extends EventEmitter {
     app;
     sessions = new Map();
+    /**
+     * The edit history panel's reader (edit-history-sync.ts). Reads only when the panel asks;
+     * the main transcript is the one the transcript watcher follows (hook-reported path), or,
+     * before the first hook after a restart, a lookup under the session's claude config dir.
+     */
+    editHistorySync = new EditHistorySync({
+        transcriptPath: (session) => resolveClaudeTranscript(this.transcriptWatchers.get(session.id)?.getPath(), [session.claudeSessionId || session.id, session.id], session.claudeConfigDir),
+        readSources: readClaudeEditSources,
+        probe: probeLocalPaths,
+        loadStore: (sessionId) => EditHistoryStore.load(sessionId),
+        deleteStore: (sessionId) => EditHistoryStore.delete(sessionId),
+        sweepStores: (keep) => EditHistoryStore.sweep(keep),
+    });
     respawnControllers = new Map();
     respawnTimers = new Map();
     runSummaryTrackers = new Map();
@@ -350,6 +369,29 @@ export class WebServer extends EventEmitter {
     pushStore = new PushSubscriptionStore();
     /** ntfy / Slack / Discord / generic webhook for the push events; config in webhook.json (0600). */
     webhookNotifier = new WebhookNotifier(() => readWebhookConfig(getDataDir()), webviewFetch);
+    /** Two-way Discord bridge (thread per tab); config in discord.json (0600). Idle until enabled in Settings. */
+    /** Set by the session routes when they register (see SessionPort). */
+    lastResponseFor;
+    discordBridge = new DiscordBridge({
+        configDir: getDataDir(),
+        fetchImpl: webviewFetch,
+        sendInput: async (sessionId, text) => {
+            const session = this.sessions.get(sessionId);
+            if (!session)
+                return false;
+            // A Discord reply is a person's own input, so it names the tab like any other prompt.
+            if (await session.writeViaMux(text, { fromUser: true }).catch(() => false))
+                return true;
+            return session.write(text, { fromUser: true });
+        },
+        agentExited: (id) => !!this.sessions.get(id)?.paneExit,
+        awaitingChoice: (id) => approvalInbox.listPending().some((item) => item.sessionId === id && item.kind !== 'idle'),
+        // Remote (ssh) sessions keep their folder on another host, so received files have nowhere local to go.
+        sessionDir: (sessionId) => {
+            const session = this.sessions.get(sessionId);
+            return session && !session.remote ? session.workingDir : undefined;
+        },
+    });
     teamWatcher = new TeamWatcher();
     _orchestratorLoop = null;
     titleHostname;
@@ -681,6 +723,7 @@ export class WebServer extends EventEmitter {
             addSession: this.registerSessionWithLayout.bind(this),
             tabLayouts: this.tabLayouts,
             cleanupSession: this.cleanupSession.bind(this),
+            forgetEditHistory: this.forgetEditHistory.bind(this),
             setupSessionListeners: this.setupSessionListeners.bind(this),
             persistSessionState: this.persistSessionState.bind(this),
             persistSessionStateNow: this._persistSessionStateNow.bind(this),
@@ -817,6 +860,8 @@ export class WebServer extends EventEmitter {
             this.userFailures = authState.userFailures;
             this.userIpFailures = authState.userIpFailures;
         }
+        // Bodyless API POSTs may arrive as empty chunked streams through a proxy.
+        installEmptyApiPostParser(this.app);
         // WebSocket support (terminal I/O — low-latency bidirectional channel)
         await this.app.register(fastifyWebsocket);
         // Multipart parsing (used by paste-image). Replaces a hand-rolled
@@ -1083,6 +1128,7 @@ export class WebServer extends EventEmitter {
         registerRebootRestoreRoutes(this.app, ctx);
         registerReadMyMindRoutes(this.app, ctx);
         registerGitStatusRoutes(this.app, ctx);
+        registerEditHistoryRoutes(this.app, ctx, this.editHistorySync);
         // Git fetch on an interval: this is only the wake-up, the scheduler itself decides what is due. Off in
         // tests for the same reason as the polls below: a test drives `tick()` directly instead of waiting on
         // a timer the harness would have to keep alive. The setting is read FRESH inside `tick()`, so turning
@@ -1101,6 +1147,8 @@ export class WebServer extends EventEmitter {
         // The registry's lifetime is the server's: it drops per-session wake state on every
         // cleanup path and resolves in-flight wakes on shutdown.
         this.remoteWake = registerSessionRoutes(this.app, ctx);
+        // The routes' ctx is a separate object: take the last-response reader they registered on it (Discord alerts).
+        this.lastResponseFor = ctx.lastResponseFor;
         registerAgentSessionRoutes(this.app, ctx);
         registerRespawnRoutes(this.app, ctx);
         registerRalphRoutes(this.app, ctx);
@@ -1113,12 +1161,23 @@ export class WebServer extends EventEmitter {
         registerWebviewRoutes(this.app, ctx, this.basePath);
         registerTabLayoutRoutes(this.app, ctx);
         registerMcpSyncRoutes(this.app);
-        registerConfigBackupRoutes(this.app);
+        registerConfigBackupRoutes(this.app, { reloadDiscord: () => this.discordBridge.reload() });
         registerWebhookRoutes(this.app, {
             notifier: this.webhookNotifier,
             configDir: getDataDir(),
             hostTitle: () => this.windowTitle,
         });
+        registerDiscordRoutes(this.app, {
+            bridge: this.discordBridge,
+            configDir: getDataDir(),
+            ctx,
+            hostTitle: () => this.windowTitle,
+        });
+        if (!this.testMode) {
+            // The gateway waits for restoreMuxSessions(): a reply during restore would be told the tab is gone.
+            this.discordBridge.hold();
+            void this.discordBridge.ensureLoaded().catch(() => undefined);
+        }
         registerDoctorRoutes(this.app);
         registerCustomModelRoutes(this.app);
         registerCliRegistryRoutes(this.app);
@@ -1237,13 +1296,46 @@ export class WebServer extends EventEmitter {
             return undefined;
         }
         try {
-            return applyCustomModelInjection(entry, endpoint, saved.modelId, session.id, endpoint.modelContextLengths?.[saved.modelId])?.envOverrides;
+            // Boot recovery omits both `workingDir` (no reason to re-answer a trust dialog that
+            // already fired once) and the session-env real-home lookup: the injected VALUES are
+            // never persisted, so after a real restart the session can no longer carry its
+            // allowlisted `DSH_HOME` either (`getEnvOverridesForPersist()` keeps only
+            // `CLAUDE_CODE_*`/`CLAUDE_CONFIG_DIR`): the lookup could only ever hit on the first
+            // apply in-process. Real-home resolution therefore falls back to the SERVER's
+            // `DSH_HOME` or the recipe's `realHomeFallback` (~/.dsh).
+            return applyCustomModelInjection(entry, endpoint, saved.modelId, session.id, resolveCustomModelContextLength(endpoint, saved.modelId));
         }
         catch (err) {
             console.warn('[WebServer] Failed to rebuild custom-model env on recovery:', err);
             return undefined;
         }
     }
+    /**
+     * Restore one persisted custom-model selection (both boot-recovery paths). The rebuilt
+     * bookkeeping must come from the CURRENT recipe, not from the saved record: this is the
+     * first feature where a shipped recipe changed KIND (deepseek: env redirect -> per-session
+     * patch home), so a selection saved by an old build restores with e.g. no `configDir`
+     * while the new recipe writes one, and clearing it later could then never delete the
+     * generated dir. `envKeys` is the UNION of saved and applied keys: the tmux session may
+     * still carry `setenv`s from both, and a clear has to unset every one.
+     */
+    async _restoreCustomModel(session, saved) {
+        const applied = await this._rebuildCustomModelEnv(session, saved);
+        if (!applied) {
+            // Endpoint gone or CLI unregistered: restore the bookkeeping exactly as saved, which
+            // is what a later clear needs.
+            session.setCustomModel(saved);
+            return;
+        }
+        session.setCustomModel({
+            ...saved,
+            // Prefer the current recipe's dir; keep the saved one when the recipe writes none,
+            // so a clear can still delete a directory an older recipe created.
+            configDir: applied.configDir ?? saved.configDir,
+            launchModel: applied.launchModel,
+            envKeys: [...new Set([...saved.envKeys, ...applied.envKeys])],
+        }, applied.envOverrides);
+    }
     /** Persists full session state including respawn config to state.json */
     _persistSessionStateNow(session) {
         // See session-manager.updateSessionState: __envOverrides is an internal disk-only
@@ -1493,7 +1585,9 @@ export class WebServer extends EventEmitter {
             // Only remove from state.json if we're also killing the mux session.
             // When killMux=false (server shutdown), preserve state for recovery.
             if (killMux) {
-                this.store.demoteOrRemoveSession(sessionId);
+                // The edit history goes with the record; a pinned session's demoted record keeps it.
+                if (this.store.demoteOrRemoveSession(sessionId) !== 'preserved')
+                    this.forgetEditHistory(sessionId);
             }
         }
         // Release anything blocked on this session, in the documented order: 'exit'
@@ -1507,8 +1601,11 @@ export class WebServer extends EventEmitter {
         // detach: mail posted before that is still there when the session is re-attached
         // (while detached, the routes answer 404, so nothing new arrives). Before
         // cancelAll, so a reader released by it reads an empty inbox.
-        if (killMux)
+        if (killMux) {
             agentInbox.drop(sessionId);
+            // A real delete only: a detach (killMux=false) leaves the session running and re-attachable.
+            void this.discordBridge.sessionDeleted(sessionId).catch(() => undefined);
+        }
         sessionWaits.notifySignal(sessionId, 'exit');
         sessionWaits.cancelAll(sessionId);
         approvalInbox.resolveForSession(sessionId, 'session_ended');
@@ -1777,12 +1874,23 @@ export class WebServer extends EventEmitter {
         const summaryTracker = new RunSummaryTracker(session.id, session.name);
         this.runSummaryTrackers.set(session.id, summaryTracker);
         summaryTracker.recordSessionStarted(session.mode, session.workingDir);
-        // Set working directory for Ralph tracker to auto-load @fix_plan.md (not supported for external CLIs)
+        // Set working directory for Ralph tracker to auto-load @fix_plan.md (not supported for external CLIs).
+        // A remote session's workingDir is a path on the remote host, and the watcher reads and
+        // fs.watch()es it on the LOCAL disk, so a remote session only records the path: the fix plan stays
+        // authoritative as for a local session (keeping the output-based completion guessers off), and its
+        // file is read over ssh only on an explicit import (fix-plan/read).
         if (!isExternalCliMode(session.mode)) {
-            session.ralphTracker.setWorkingDir(session.workingDir);
+            if (session.remote) {
+                session.ralphTracker.setRemoteWorkingDir(session.workingDir);
+            }
+            else {
+                session.ralphTracker.setWorkingDir(session.workingDir);
+            }
         }
-        // Start watching for new images in this session's working directory (if enabled globally and per-session)
-        if ((await this.isImageWatcherEnabled()) && session.imageWatcherEnabled) {
+        // Start watching for new images in this session's working directory (if enabled globally and per-session).
+        // A remote session's workingDir is a path on the remote host, and the watcher watches it on the LOCAL
+        // disk, so it is skipped there (the per-session and app-wide toggles skip it too).
+        if ((await this.isImageWatcherEnabled()) && session.imageWatcherEnabled && !session.remote) {
             imageWatcher.watchSession(session.id, session.workingDir);
         }
         // Create and attach all listener handlers via dependency injection
@@ -2223,9 +2331,25 @@ export class WebServer extends EventEmitter {
         const lifecycleLog = getLifecycleLog();
         for (const s of result.cleaned) {
             lifecycleLog.log({ event: 'stale_cleaned', sessionId: s.id, name: s.name });
+            this.forgetEditHistory(s.id);
         }
+        // History files no session owns (a crash between removing a record and deleting its file).
+        const exists = (id) => this.sessions.has(id) || !!this.store.getSession(id);
+        await this.editHistorySync.sweep(exists).catch((err) => {
+            console.warn('[EditHistory] Sweeping orphaned histories failed:', getErrorMessage(err));
+        });
         return result.count;
     }
+    /**
+     * Delete a session's edit history (diffs can hold secrets) once its record is gone: deleted
+     * live (`cleanupSession`), deleted as a record only (DELETE route), or cleaned as stale
+     * (startup, `POST /api/cleanup-state`).
+     */
+    forgetEditHistory(sessionId) {
+        void this.editHistorySync.remove(sessionId).catch((err) => {
+            console.warn(`[EditHistory] Removing history of ${sessionId} failed:`, getErrorMessage(err));
+        });
+    }
     /**
      * Get lightweight state for SSE init - excludes full terminal buffers
      * to prevent browser freezes. Terminal buffers are fetched on-demand.
@@ -2326,6 +2450,23 @@ export class WebServer extends EventEmitter {
         // Multi-user: derive an ownership routing hint so an event only reaches the
         // clients entitled to it (no-op in single-user — hint stays undefined).
         this.sse.broadcast(event, data, isMultiUserMode() ? this.deriveSseHint(event, data) : undefined);
+        this.bridgeSessionEvent(event, data);
+    }
+    /** Keep the Discord thread in step with the tab: created, renamed, deleted. Never throws. */
+    bridgeSessionEvent(event, data) {
+        // Deletion is NOT handled here: `session:deleted` also fires for a detach (killMux=false), where the
+        // session keeps running and can be re-attached. The real delete calls the bridge from the cleanup path.
+        if (event !== SseEvent.SessionCreated && event !== SseEvent.SessionUpdated)
+            return;
+        const d = (data ?? {});
+        const s = d.session ?? d;
+        if (!s.id)
+            return;
+        const id = s.id;
+        const run = event === SseEvent.SessionCreated
+            ? this.discordBridge.sessionCreated(id, s.name).then(() => this.discordBridge.sessionRenamed(id, s.name))
+            : this.discordBridge.sessionRenamed(id, s.name);
+        void run.catch(() => undefined);
     }
     /**
      * Map an SSE event + payload to a routing hint (multi-user). Session-scoped
@@ -2433,15 +2574,26 @@ export class WebServer extends EventEmitter {
         const getPaneExit = this.mux.getPaneExit?.bind(this.mux);
         if (!getPaneExit)
             return;
+        const getPaneCurrentPath = this.mux.getPaneCurrentPath?.bind(this.mux);
         for (const session of this.sessions.values()) {
             const muxName = session.muxName;
             // No pane, so nothing to report — and `setPaneExit()` would force UNKNOWN
             // for such a session anyway.
             if (!muxName)
                 continue;
-            if (!session.setPaneExit(getPaneExit(muxName)))
+            // The pane's live directory rides the same read: it is the base a relative
+            // path printed in the terminal resolves against. The manager's answer is
+            // applied as given, `undefined` included: it keeps its map across a failed
+            // or empty read and carries a blank `#{pane_current_path}` forward, so an
+            // `undefined` here means an authoritative read listed no single directory
+            // for the session (split into several panes, or gone from the socket).
+            const paneCwdChanged = getPaneCurrentPath ? session.setPaneCwd(getPaneCurrentPath(muxName)) : false;
+            if (session.setPaneExit(getPaneExit(muxName))) {
+                this.persistSessionState(session);
+            }
+            else if (!paneCwdChanged) {
                 continue;
-            this.persistSessionState(session);
+            }
             this.broadcastSessionStateDebounced(session.id);
         }
         this.closeCleanlyExitedSessions();
@@ -2552,6 +2704,26 @@ export class WebServer extends EventEmitter {
             host: this.windowTitle,
         })
             .catch(() => undefined);
+        // Discord: same event, same independence from Web Push. It adds the tail of what the CLI printed,
+        // so the person reading the thread can see what is being asked without opening the tab.
+        const dcSession = sessionId ? this.sessions.get(sessionId) : undefined;
+        // A question or permission dialog lives on the screen, so it keeps the screen tail (its options are
+        // there); a finished turn posts the CLI's whole last message instead, from its transcript.
+        const dialogEvent = event === SseEvent.HookPermissionPrompt || event === SseEvent.HookElicitationDialog;
+        void this.discordBridge
+            .notify({
+            event,
+            title: template.title,
+            body,
+            urgency: template.urgency,
+            sessionId: sessionId || undefined,
+            sessionName: sessionName || undefined,
+            // A function, so the screen is only read (a synchronous tmux exec) once the bridge has decided to post.
+            tail: dcSession ? () => this.discordTail(dcSession, !dialogEvent) : undefined,
+            fullText: dcSession && !dialogEvent ? () => this.discordFullText(dcSession) : undefined,
+            host: this.windowTitle,
+        })
+            .catch(() => undefined);
         const subscriptions = this.pushStore.getAll();
         if (subscriptions.length === 0)
             return;
@@ -2626,6 +2798,33 @@ export class WebServer extends EventEmitter {
             });
         }
     }
+    /**
+     * What the person would see on the tab right now, for a Discord alert: the rendered tmux screen
+     * (`capture-pane -p`), never the raw output stream, which a full-screen UI repaints in place and
+     * reads as garbage. A session with no pane falls back to its plain text output, else nothing.
+     */
+    discordTail(session, cutComposer) {
+        const pane = session.muxName ? (this.mux.capturePaneText?.(session.muxName) ?? null) : null;
+        // The composer row and the status lines under it are screen chrome, not what the CLI said.
+        const glyph = cutComposer ? getCli(session.mode)?.capabilities.workDetect?.promptGlyph : undefined;
+        return screenTail(pane ?? session.textOutput ?? '', 14, 900, glyph);
+    }
+    /**
+     * The CLI's whole last message from the response viewer's reader (the CLI's own transcript, or the pane
+     * segmented into turns for the CLIs that keep none); undefined for a shell, which has no turns, and the
+     * screen tail stands in whenever the reader finds nothing.
+     */
+    async discordFullText(session) {
+        if (!this.lastResponseFor)
+            return undefined;
+        // A CLI with a transcript reader, or whose pane the viewer segments into turns; a shell has neither.
+        if (getCli(session.mode)?.capabilities.transcript === 'none' && !isExternalCliTranscriptMode(session.mode)) {
+            return undefined;
+        }
+        const r = await this.lastResponseFor(session);
+        // The turn it came from: the transcript's stamp, else when the person last submitted (a pane has no stamp).
+        return { text: r.text, version: r.timestamp || String(session.lastSubmitAt ?? '') };
+    }
     /** The notification body for an event (shared by Web Push and the webhook channel). */
     static pushBodyText(event, data, sessionName) {
         let body = sessionName ? `[${sessionName}]` : '';
@@ -2765,6 +2964,21 @@ export class WebServer extends EventEmitter {
                 console.log(`[AgentInbox] restored ${restoredMail} pending message(s)`);
             const restored = await this.restoreMuxSessions();
             await this.finalizeRestoredState(restored);
+            void this.discordBridge
+                .release()
+                .then(async () => {
+                // Only after a successful restore, like the agent inbox prune and the tab layout reconciliation, and
+                // with the same keep set: a reboot-restore rebuild reuses the old id.
+                if (!restored)
+                    return;
+                await this.discordBridge.prune([
+                    ...this.sessions.keys(),
+                    ...Object.keys(this.store.getSessions()),
+                    ...rebootRestoreRegistry.list(() => true).map((entry) => entry.sessionId),
+                ]);
+            })
+                .then(() => this.discordBridge.startStaleSweep())
+                .catch(() => undefined);
             // Instance-scoped reaper: after restore, `docker rm -f` managed containers of
             // THIS instance whose case is gone from docker-cases.json (best-effort, never
             // touches another instance's containers). Runs after restore so containers
@@ -3141,7 +3355,7 @@ export class WebServer extends EventEmitter {
             // bookkeeping survives a restart and the values are re-derived here.
             const savedCustomModel = saved.__customModel;
             if (savedCustomModel) {
-                session.setCustomModel(savedCustomModel, await this._rebuildCustomModelEnv(session, savedCustomModel));
+                await this._restoreCustomModel(session, savedCustomModel);
             }
             if (saved.niceEnabled !== undefined || saved.niceValue !== undefined) {
                 session.setNice({ enabled: saved.niceEnabled, niceValue: saved.niceValue });
@@ -3279,6 +3493,9 @@ export class WebServer extends EventEmitter {
         catch (err) {
             console.warn(`[Server] releasing the tab layout slot failed: ${getErrorMessage(err)}`);
         }
+        // Per-tab bridge state only: a reboot-restore rebuild reuses the old id and stays on offer for a
+        // retry, so its thread must survive the discard.
+        this.discordBridge.forgetTab(sessionId);
         // Any `session:updated` the half-built session emitted before it failed left a
         // tab on every other open board, and the client's handler is an upsert.
         this.broadcast(SseEvent.SessionDeleted, { id: sessionId });
@@ -3437,7 +3654,7 @@ export class WebServer extends EventEmitter {
                         // the isolated config dir; an endpoint that has since been deleted still gets
                         // the bookkeeping restored, which is what a later clear needs to unset.
                         if (savedCustomModel) {
-                            session.setCustomModel(savedCustomModel, await this._rebuildCustomModelEnv(session, savedCustomModel));
+                            await this._restoreCustomModel(session, savedCustomModel);
                         }
                         // Update session name if it was a "Restored:" placeholder or doesn't match saved name
                         if (savedState?.name && muxSession.name !== savedState.name) {
@@ -3806,6 +4023,8 @@ export class WebServer extends EventEmitter {
         // Same teardown rule: the per-endpoint llama-swap log tails are otherwise closed
         // only by the periodic idle sweep, whose interval is disposed just below.
         closeAllLlamaSwapLogTails();
+        // Close the Discord gateway socket and its heartbeat, and clear the bridge's per-tab maps.
+        this.discordBridge.stop();
         // Dispose all managed timers (intervals + resettable timeouts)
         this.cleanup.dispose();
         // Gracefully close all SSE connections and clear batching state
@@ -3915,6 +4134,9 @@ export class WebServer extends EventEmitter {
         this.respawnTimers.clear();
         this.runSummaryTrackers.clear();
         this.transcriptWatchers.clear();
+        await this.editHistorySync.flushAll().catch((err) => {
+            console.warn('[EditHistory] Saving on shutdown failed:', getErrorMessage(err));
+        });
         this.sessionListenerRefs.clear();
         this.scheduledRuns.clear();
         // Dispose StaleExpirationMaps (stops internal cleanup timers)