@oar-sh/oar 0.9.15 → 0.9.17

package/server/server-runtime.mjs

@@ -45,6 +45,9 @@ import { registerClaudeCloudRoutes } from './routes/claude-cloud-routes.mjs';
 import { createPreviewScopeResolver, registerPreviewRoutes } from './routes/preview-routes.mjs';
 import { registerRemoteRelayRoutes } from './routes/remote-relay-routes.mjs';
 import { registerRelayEventRoutes } from './routes/relay-event-routes.mjs';
+import { registerRelayScheduleRoutes } from './routes/relay-schedule-routes.mjs';
+import { registerDeepSeekUsageImportRoutes } from './routes/deepseek-usage-import-routes.mjs';
+import { registerRelayAskRoutes } from './routes/relay-ask-routes.mjs';
 import { createRemoteRelayRepository } from './repositories/remote-relay-repository.mjs';
 import { createConversationGroupRepository } from './repositories/conversation-group-repository.mjs';
 import { createShareRepository } from './repositories/share-repository.mjs';
@@ -62,6 +65,12 @@ import { createClaudeCloudCredentials } from '../shared/claude-cloud/credentials
 import { createClaudeCloudClient } from '../shared/claude-cloud/api-client.mjs';
 import { resolveClaudeCloudBaseUrl } from '../shared/claude-cloud/base-url.mjs';
 import { createClaudeCloudSettingsService } from './services/claude-cloud-settings-service.mjs';
+import { createDeepSeekSettingsService } from './services/deepseek-settings-service.mjs';
+import { createWorkerPostRedaction } from './services/worker-secret-redaction.mjs';
+import { createDeepSeekBalanceService } from './services/deepseek-balance-service.mjs';
+import { deepseekCardCurrency } from './services/plan-usage-deepseek.mjs';
+import { createDeepSeekUsageImportService } from './services/deepseek-usage-import.mjs';
+import { DEEPSEEK_DEFAULT_AUTO_COMPACT_WINDOW, DEFAULT_DEEPSEEK_MODEL, deepseekModelLabel } from '../shared/deepseek-models.mjs';
 import { createClaudeCloudSessionService } from './services/claude-cloud-session-service.mjs';
 import { createClaudeCloudRepoService, listRecentCloudSourcesFromStatements } from './services/claude-cloud-repo-service.mjs';
 import { createClaudeAccountUsageService } from './services/claude-account-usage-service.mjs';
@@ -84,6 +93,9 @@ import {
 } from './services/restart-resume-service.mjs';
 import { createBackgroundWorkView } from './services/background-work-view.mjs';
 import { createRelayEventService } from './services/relay-event-service.mjs';
+import { createRelayScheduleService } from './services/relay-schedule-service.mjs';
+import { createRelayAskService } from './services/relay-ask-service.mjs';
+import { createRelayAskLinkService } from './services/relay-ask-link-service.mjs';
 import { createRelayEventLinkService } from './services/relay-event-link-service.mjs';
 import { buildClaudeAttributionSettings, normalizeClaudeAttributionMode, resolveClaudeAttributionMode, DEFAULT_CLAUDE_ATTRIBUTION_MODE } from '../shared/claude-attribution.mjs';
 import {
@@ -133,7 +145,7 @@ import { createRelayCliLauncherService } from './services/relay-cli-launcher-ser
 import { createSessionWorkerRegistry } from './services/session-worker-registry-service.mjs';
 import { createSessionWorkerSupervisor } from './services/session-worker-supervisor-service.mjs';
 import { createSessionWorkerProcessInspector } from './services/session-worker-process-service.mjs';
-import { applyClaudeCloudProviderEnvironment, applyClaudeProviderEnvironment, applyCopilotSdkProviderEnvironment, applyCursorProviderEnvironment, applyGrokProviderEnvironment, applyOpenAIProviderEnvironment, copilotSdkEngineUnavailableReason, killTmuxSession, launchSessionCli } from './services/session-worker-launch-service.mjs';
+import { applyClaudeCloudProviderEnvironment, applyClaudeProviderEnvironment, applyCopilotSdkProviderEnvironment, applyCursorProviderEnvironment, applyDeepSeekProviderEnvironment, applyGrokProviderEnvironment, applyOpenAIProviderEnvironment, copilotSdkEngineUnavailableReason, killTmuxSession, launchSessionCli } from './services/session-worker-launch-service.mjs';
 import { createSshTunnelManager } from './services/ssh-tunnel-manager-service.mjs';
 import { createCloudflaredTunnelManager } from './services/cloudflared-tunnel-service.mjs';
 import {
@@ -2825,6 +2837,58 @@ const claudeCloudRepoService = createClaudeCloudRepoService({
   isEnabled: () => claudeCloudSettingsService.getSettings().enabled === true,
   listRecentCloudSources: () => listRecentCloudSourcesFromStatements(stmts),
 });
+// What a session worker posts loses every key a provider saved in Settings
+// (worker-secret-redaction.mjs). Built here, at the start, so it reads the
+// saved keys now, and the DeepSeek save below notes each key it writes: one
+// changed before any worker has posted is still redacted.
+const workerPostRedaction = createWorkerPostRedaction({ readSetting: readAppSettingValue });
+// DeepSeek: one API key per relay, its models and its endpoint. The key stays
+// in the settings table; GET routes answer `configured`, never the key.
+const deepseekSettingsService = createDeepSeekSettingsService({
+  readSetting: readAppSettingValue,
+  writeSetting: (key, value) => {
+    stmts.upsertAppSetting.run(key, String(value), new Date().toISOString());
+    workerPostRedaction.noteSavedSetting(key, value);
+  },
+  deleteSetting: (key) => stmts.deleteAppSetting.run(key),
+  listProviderCandidates: () => stmts.listRuntimeSessionProviderCandidates?.all?.() || [],
+});
+function getDeepSeekProviderSettings() {
+  return deepseekSettingsService.getSettings();
+}
+// The DeepSeek balance for Check Usage: read with the saved key only while
+// DeepSeek is on, kept for a minute.
+const deepseekBalanceService = createDeepSeekBalanceService({ getSettings: getDeepSeekProviderSettings });
+// DeepSeek's own usage export, imported in Settings (or with
+// `npm run deepseek:import`): the usage card shows its figures for the days
+// it covers, for the saved key only, and the estimate after.
+const deepseekUsageImportService = createDeepSeekUsageImportService({
+  db,
+  getApiKey: () => getDeepSeekProviderSettings()?.apiKey || '',
+});
+// Where DeepSeek workers keep their Claude Code state (sessions, transcripts,
+// settings): a directory of the relay's own, so no Claude login is in reach
+// of a CLI that talks to DeepSeek and their sessions stay out of Claude's.
+const DEEPSEEK_CLAUDE_CONFIG_DIR = path.join(DATA_DIR, 'deepseek-claude');
+
+/**
+ * What a DeepSeek session's commits and PRs say: the DeepSeek tab's mode
+ * (OAR or off), the folder override on top, the DeepSeek model's name in the
+ * trailer. A folder set to vanilla gets OAR's: Claude Code's own lines would
+ * credit Claude for DeepSeek's work.
+ */
+function deepseekAttributionForConversation(conv, modelId) {
+  const root = String(conv?.runtime_workspace_root_path || conv?.configured_workspace_root_path || '').trim()
+    || currentWorkspaceRootPath();
+  const resolved = resolveClaudeAttributionMode({
+    providerMode: getDeepSeekProviderSettings().attribution,
+    folderMode: workspaceRootAttributionMode(root),
+  });
+  return buildClaudeAttributionSettings({
+    mode: resolved === 'vanilla' ? 'oar' : resolved,
+    modelLabel: deepseekModelLabel(modelId),
+  });
+}
 // The account's live usage for the Check Usage modal. The Claude Cloud switch
 // is the consent to use the Claude CLI's login, so nothing is read while it
 // is off.
@@ -3053,7 +3117,7 @@ function buildSessionWorkerLaunchEnvForSession(targetSessionId) {
   const providerType = String(runtimeSession?.provider_type || 'github').trim().toLowerCase();
   // Clear every provider's variables first (the appliers' kind-guarded deletes
   // keep the chained clears order-independent), then apply only the bound one.
-  const cleared = applyClaudeCloudProviderEnvironment(applyCopilotSdkProviderEnvironment(applyGrokProviderEnvironment(applyCursorProviderEnvironment(applyClaudeProviderEnvironment(applyOpenAIProviderEnvironment(sessionWorkerLaunchEnv))))));
+  const cleared = applyDeepSeekProviderEnvironment(applyClaudeCloudProviderEnvironment(applyCopilotSdkProviderEnvironment(applyGrokProviderEnvironment(applyCursorProviderEnvironment(applyClaudeProviderEnvironment(applyOpenAIProviderEnvironment(sessionWorkerLaunchEnv)))))));
   // A Claude Cloud conversation gets its own worker and nothing else: it must
   // never reach the Copilot CLI fall-through at the end of this function. The
   // environment names the worker and the model, no credential.
@@ -3083,6 +3147,19 @@ function buildSessionWorkerLaunchEnvForSession(targetSessionId) {
       dataDir: DATA_DIR,
     });
   }
+  // A DeepSeek conversation gets its own worker and must never reach the
+  // Copilot fall-through below. Without a key the applier throws, and the
+  // conversation gets the launch note.
+  if (providerType === 'deepseek') {
+    const deepseekSettings = getDeepSeekProviderSettings();
+    return applyDeepSeekProviderEnvironment(cleared, {
+      enabled: true,
+      model: String(runtimeSession?.provider_model || runtimeSession?.model || deepseekSettings.model).trim(),
+      apiKey: deepseekSettings.apiKey,
+      baseUrl: deepseekSettings.baseUrl,
+      configDir: DEEPSEEK_CLAUDE_CONFIG_DIR,
+    });
+  }
   if (providerType === 'grok') {
     const grokSettings = getGrokProviderSettings();
     const grokModel = String(runtimeSession?.provider_model || runtimeSession?.model || grokSettings.model).trim();
@@ -3311,12 +3388,13 @@ async function stopSessionWorkerForProviderRebind(sdkSessionId) {
 
 async function reconcileUnstartedConversationProviders({ enabled, model, provider = 'openai' } = {}) {
   const normalizedProvider = String(provider || 'openai').trim().toLowerCase();
-  const managedProvider = ['claude', 'cursor', 'grok'].includes(normalizedProvider) ? normalizedProvider : 'openai';
+  const managedProvider = ['claude', 'cursor', 'grok', 'deepseek'].includes(normalizedProvider) ? normalizedProvider : 'openai';
   const managedDefaultModel = {
     openai: DEFAULT_OPENAI_MODEL,
     claude: DEFAULT_CLAUDE_MODEL,
     cursor: DEFAULT_CURSOR_MODEL,
     grok: DEFAULT_GROK_MODEL,
+    deepseek: DEFAULT_DEEPSEEK_MODEL,
   }[managedProvider];
   const providerType = enabled === true ? managedProvider : 'github';
   const providerModel = enabled === true
@@ -3390,7 +3468,9 @@ async function reconcileUnstartedConversationProviders({ enabled, model, provide
           ? getCursorProviderSettings().configured === true
           : (currentProvider === 'grok'
             ? getGrokProviderSettings().enabled === true
-            : (currentProvider !== 'openai' || getOpenAIProviderSettings().configured === true)));
+            : (currentProvider === 'deepseek'
+              ? getDeepSeekProviderSettings().configured === true
+              : (currentProvider !== 'openai' || getOpenAIProviderSettings().configured === true))));
       if (providerWasUpdated && canRestorePreviousProvider) {
         stmts.updateRuntimeSessionProvider.run(
           currentProvider,
@@ -5128,6 +5208,11 @@ function createCompactedConversation(sourceConversationId) {
     targetRuntimeSession = ensureRuntimeSessionBinding(targetConversationId, null, now);
   });
   tx();
+  // Its schedules go on in the new conversation, both the ones that fire
+  // into it and the ones it set: the archived source would end them.
+  try { relayScheduleService.carryToCompacted(sourceConversationId, targetConversationId); } catch {}
+  // And so do its questions that don't block, asked in it or by it.
+  try { relayAskService.carryToCompacted(sourceConversationId, targetConversationId); } catch {}
 
   return {
     sourceConversationId,
@@ -5458,6 +5543,37 @@ relayEventService = createRelayEventService({
   logger: console,
 });
 
+// ─── Relay schedules ──────────────────────────────────────────────────────────
+// Prompts agents scheduled with remote_relay's `schedule`: kept in the
+// database, their timers rebuilt at boot (services/relay-schedule-service.mjs).
+const relayScheduleService = createRelayScheduleService({
+  db,
+  stmts,
+  emit: (event, payload) => io.emit(event, payload),
+  // The scheduled message is an ordinary pending one, like a relay event's.
+  wake: () => {
+    void primePendingSessionWorkers('relay-schedule');
+    sessionWorkerWebSocketService?.emitQueueChanged?.('relay-schedule');
+  },
+  // A firing into another session is a prompt of the conversation that set
+  // it: the agents' loop guard counts it (and holds it once it wants the user).
+  admitFiring: ({ createdBy }) => remoteRelayDispatcher.admitScheduledFiring({ createdBy }),
+  logger: console,
+});
+
+// ─── Questions that don't block ───────────────────────────────────────────────
+// remote_relay's `ask`: a card in the session and the Inbox; the answer
+// reaches the askers as a relay event (services/relay-ask-service.mjs).
+const relayAskService = createRelayAskService({
+  db,
+  emit: (event, payload) => io.emit(event, payload),
+  relayEvents: relayEventService,
+  // urgency "now" only.
+  pushQuestion: (question) => pushDispatchService.notifyQuestion?.(question),
+  logger: console,
+});
+if (!relayAskService.isAvailable()) console.warn(`[relay-asks] not available this boot: ${relayAskService.problem()}`);
+
 /** A worker died: its tasks are gone, and whoever watches its sessions hears of it. */
 function noteWorkerDeathForEvents(sessionId, conversationIds, reason) {
   const ids = new Set((conversationIds || []).map((id) => String(id || '').trim()).filter(Boolean));
@@ -5943,6 +6059,14 @@ const readContextFromSessionEvents = contextSnapshotService.readContextFromSessi
 // Claude-provider sessions live under the Agent SDK's project layout rather than
 // ~/.copilot/session-state, so their browsable session folder resolves separately.
 const claudeSessionRootResolver = createClaudeSessionRootResolver({ fs, path });
+// DeepSeek chats run Claude Code with a config dir of their own: only that
+// root, never the host's ~/.claude.
+const deepseekSessionRootResolver = createClaudeSessionRootResolver({
+  fs,
+  path,
+  env: { CLAUDE_CONFIG_DIR: DEEPSEEK_CLAUDE_CONFIG_DIR },
+  homedir: () => '',
+});
 const cursorSessionRootResolver = createCursorSessionRootResolver({ fs, path, serverDir: __dirname, dataDir: DATA_DIR });
 
 // ─── Express + Socket.io Setup ────────────────────────────────────────────────
@@ -6330,8 +6454,12 @@ async function requestSessionWorkerSocketDelivery({ sessionId, pid, reason = 'wo
       // without a new queue column or push channel. null = Auto.
       ...((() => {
         const conv = out.conversationId ? stmts.getConvAnyStatus.get(out.conversationId) : null;
+        const deliveredProvider = String(out.providerType || '').trim().toLowerCase();
         return {
-          autoCompactWindow: parseAutoCompactWindow(conv?.auto_compact_window),
+          // DeepSeek's window is 1M; its sessions compact at 400K unless the
+          // conversation pins another window.
+          autoCompactWindow: parseAutoCompactWindow(conv?.auto_compact_window)
+            ?? (deliveredProvider === 'deepseek' ? DEEPSEEK_DEFAULT_AUTO_COMPACT_WINDOW : null),
           // Per-conversation thinking control, same delivery scoping. An
           // explicit null on thinkingEnabled means Host default — the worker
           // distinguishes it from an absent key (an older relay), so both
@@ -6343,7 +6471,14 @@ async function requestSessionWorkerSocketDelivery({ sessionId, pid, reason = 'wo
           // attribution. Always present on such a delivery, so the worker can
           // tell "left as it was" (absent) from "vanilla" (null).
           ...((() => {
-            const deliveredProvider = String(out.providerType || '').trim().toLowerCase();
+            // A DeepSeek session runs Claude Code on the host like a Claude
+            // one: the same two settings, with DeepSeek's attribution.
+            if (deliveredProvider === 'deepseek') {
+              return {
+                attribution: deepseekAttributionForConversation(conv, out.providerModel || out.model),
+                claudeBackgroundCommandLimitMs: claudeBackgroundCommandLimitMinutesToMs(getClaudeBackgroundCommandLimitMinutes()),
+              };
+            }
             if (deliveredProvider !== 'claude' && deliveredProvider !== 'claude-cloud') return {};
             return {
               attribution: claudeAttributionForConversation(conv, out.providerModel || out.model, {
@@ -6699,6 +6834,9 @@ app.use((req, _res, next) => {
   stripRequestPathPrefix(req, remotePath);
   next();
 });
+// What a session worker posts loses every key a provider saved in Settings
+// before any route stores, broadcasts or logs it (worker-secret-redaction.mjs).
+app.use(workerPostRedaction);
 function isApiRequestPath(requestPath) {
   return /^\/api(?:\/|$)/.test(String(requestPath || ''));
 }
@@ -6883,7 +7021,10 @@ const remoteRelayRegistry = createRemoteRelayRegistry({
   platform: process.platform,
   version: RUNNING_VERSION,
   emit: (event, payload) => io.emit(event, payload),
-  onRemove: (entry) => { void relayEventLinkService?.noteRelayRemoved(entry); },
+  onRemove: (entry) => {
+    void relayEventLinkService?.noteRelayRemoved(entry);
+    try { relayAskService.noteRelayRemoved(entry?.id); } catch {}
+  },
   logger: console,
 });
 relayEventLinkService = createRelayEventLinkService({
@@ -6892,6 +7033,13 @@ relayEventLinkService = createRelayEventLinkService({
   client: remoteRelayClient,
   logger: console,
 });
+// The answers to asks this relay's agents put on paired relays.
+const relayAskLinkService = createRelayAskLinkService({
+  asks: relayAskService,
+  registry: remoteRelayRegistry,
+  client: remoteRelayClient,
+  logger: console,
+});
 const remoteRelayPairing = createRemoteRelayPairing({
   registry: remoteRelayRegistry,
   client: remoteRelayClient,
@@ -6946,6 +7094,9 @@ const remoteRelayDispatcher = createRemoteRelayDispatcher({
   resolveConversationId: (id) => resolveConversationRecord({ conversationId: id, sdkSessionId: id })?.id || id,
   relayEvents: relayEventService,
   relayEventLink: relayEventLinkService,
+  relaySchedules: relayScheduleService,
+  relayAsks: relayAskService,
+  relayAskLink: relayAskLinkService,
   logger: console,
 });
 
@@ -7020,6 +7171,10 @@ const sharedRouteDeps = {
   getClaudeCloudProviderSettings,
   claudeCloudSettingsService,
   claudeCloudSessionService,
+  getDeepSeekProviderSettings,
+  deepseekSettingsService,
+  deepseekBalanceService,
+  deepseekUsageImportService,
   claudeCloudRepoService,
   // The login's state for the workers' nudge route (never the token).
   claudeCloudLoginStatus: { describe: () => claudeCloudCredentials.describe() },
@@ -7144,6 +7299,8 @@ const sharedRouteDeps = {
   relayRestartOrchestrator,
   resolveSessionStateRoot,
   resolveClaudeSessionRoot: claudeSessionRootResolver.resolveClaudeSessionRoot,
+  resolveDeepSeekSessionRoot: deepseekSessionRootResolver.resolveClaudeSessionRoot,
+  deepseekClaudeConfigDir: DEEPSEEK_CLAUDE_CONFIG_DIR,
   resolveCursorSessionRoot: cursorSessionRootResolver.resolveCursorSessionRoot,
   getTurnCeilingMinutes,
   setTurnCeilingMinutes,
@@ -7165,6 +7322,8 @@ const sharedRouteDeps = {
   collectHostActivity,
   usageLimitPauseService,
   relayEventService,
+  relayScheduleService,
+  relayAskService,
   sessionActivityTracker,
   resolveConversationRecord,
   markSharedViewerPresence,
@@ -7210,6 +7369,30 @@ registerRelayEventRoutes(app, {
   relayEventService,
   remoteRelayInbound,
 });
+registerRelayScheduleRoutes(app, {
+  auth,
+  relayScheduleService,
+  remoteRelayInbound,
+});
+registerDeepSeekUsageImportRoutes(app, {
+  auth,
+  deepseekUsageImportService,
+  remoteRelayInbound,
+  // The usage card's currency (the balance's), so the import's answer can
+  // say whether the card uses the export's rows.
+  getCardCurrency: async () => deepseekCardCurrency(await deepseekBalanceService.getBalance()),
+});
+registerRelayAskRoutes(app, {
+  auth,
+  db,
+  stmts,
+  formatQuestionRow,
+  relayAskService,
+  relayAskLinkService,
+  remoteRelayInbound,
+  remoteRelayRegistry,
+  remoteRelayClient,
+});
 registerRelayRestartRoutes(app, {
   auth,
   // Read only: a GET neither fires the restart nor asks the question.
@@ -7480,10 +7663,12 @@ function ensureRuntimeSessionBinding(
           // default below and bind a GitHub (Copilot CLI) session.
           : (normalizedRequestedProviderType === 'claude-cloud'
             ? 'claude-cloud'
-            : (normalizedRequestedProviderType === 'github'
-              ? 'github'
-              : (openAISettings?.enabled ? 'openai' : 'github'))))));
-  const resolvedProviderModel = (resolvedProviderType === 'openai' || resolvedProviderType === 'claude' || resolvedProviderType === 'cursor' || resolvedProviderType === 'grok' || resolvedProviderType === 'claude-cloud')
+            : (normalizedRequestedProviderType === 'deepseek'
+              ? 'deepseek'
+              : (normalizedRequestedProviderType === 'github'
+                ? 'github'
+                : (openAISettings?.enabled ? 'openai' : 'github')))))));
+  const resolvedProviderModel = (resolvedProviderType === 'openai' || resolvedProviderType === 'claude' || resolvedProviderType === 'cursor' || resolvedProviderType === 'grok' || resolvedProviderType === 'claude-cloud' || resolvedProviderType === 'deepseek')
     ? (String(providerModel || normalizedModel || '').trim() || null)
     : null;
   try {
@@ -7572,6 +7757,11 @@ void primePendingSessionWorkers('startup');
 // heartbeat are swept from here on.
 relayEventService.start();
 relayEventLinkService.start();
+// Schedules get their timers back; one that came due while the relay was
+// down fires now, once.
+relayScheduleService.start();
+// Asks on paired relays still open there: look for their answers again.
+relayAskLinkService.start();
 runtimeTimers.pendingWorkerPrime = setInterval(() => {
   void primePendingSessionWorkers('maintenance');
   detachedWorkerWatch.sweep().catch((error) => {
@@ -7892,6 +8082,8 @@ function shutdownRuntime(reason = 'unknown', { exitCode = 0 } = {}) {
   try { relayEventService.noteRelayExit({ action: runtimeShutdownExitCode === RELAY_RESTART_EXIT_CODE ? 'restart' : 'shutdown', reason }); } catch {}
   try { relayEventService.stop(); } catch {}
   try { relayEventLinkService.stop(); } catch {}
+  try { relayScheduleService.stop(); } catch {}
+  try { relayAskLinkService.stop(); } catch {}
   tmuxInspectorSocketService.stop();
   stopWorkspaceFileWatcher();
   sshTunnelManager.stop();

package/server/services/about-service.mjs

@@ -30,6 +30,7 @@ export const ABOUT_PROVIDER_LABELS = Object.freeze({
   'claude-cloud': 'Claude Cloud',
   cursor: 'Cursor',
   grok: 'Grok',
+  deepseek: 'DeepSeek',
 });
 
 // The CLI each provider runs, keyed as the CLI install service keys them.

package/server/services/cache-rebuild-service.mjs

@@ -68,6 +68,9 @@ export function createCacheRebuildService({
   // Session groups: a purged head leaves its group, and a wipe is followed
   // by a repair of what the wiped rows headed. Absent in older wiring.
   conversationGroups = null,
+  // (conversationId, { deleted }) => void: a conversation this service
+  // archived or removed (its relay schedules end). Absent in older wiring.
+  onConversationGone = null,
 }) {
   const legacyConversationList = buildLegacyConversationList(db);
   const boundConversationList = buildBoundConversationList(db);
@@ -99,10 +102,19 @@ export function createCacheRebuildService({
       db.prepare(`DELETE FROM conversations WHERE id = ?`).run(sid);
     })();
     closePreviews(sid);
+    noteGone(sid, { deleted: true });
     deleteOrphanedUploads(orphanedUploads);
     return orphanedUploads;
   }
 
+  function noteGone(conversationId, options) {
+    try {
+      onConversationGone?.(conversationId, options);
+    } catch (error) {
+      console.warn(`[cache] the end of a conversation was not passed on: ${error?.message || error}`);
+    }
+  }
+
   function closePreviews(conversationId) {
     try {
       closeConversationPreviews?.(conversationId);
@@ -115,7 +127,9 @@ export function createCacheRebuildService({
     const sid = normalizeId(conversationId);
     if (!sid) return false;
     const result = db.prepare(`UPDATE conversations SET archived = 1, updated_at = ? WHERE id = ? AND status != 'deleted'`).run(new Date().toISOString(), sid);
-    return Number(result?.changes || 0) > 0;
+    const archived = Number(result?.changes || 0) > 0;
+    if (archived) noteGone(sid, { deleted: false });
+    return archived;
   }
 
   function fullWipeCache() {
@@ -176,7 +190,10 @@ export function createCacheRebuildService({
     })();
 
     for (const conversationId of conversationIds) {
-      if (!manualTitleConversationSet.has(conversationId)) closePreviews(conversationId);
+      if (!manualTitleConversationSet.has(conversationId)) {
+        closePreviews(conversationId);
+        noteGone(conversationId, { deleted: true });
+      }
     }
 
     deleteOrphanedUploads(uploadHashes);