@adhdev/daemon-core 0.8.19 → 0.8.20

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.19",
+  "version": "0.8.20",
   "description": "ADHDev local session host core — session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.8.19",
+  "version": "0.8.20",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/cli-manager.ts

@@ -11,7 +11,8 @@ import * as crypto from 'crypto';
 import chalk from 'chalk';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import { detectCLI } from '../detection/cli-detector.js';
-import { loadConfig, saveConfig } from '../config/config.js';
+import { loadConfig } from '../config/config.js';
+import { loadState, saveState } from '../config/state-store.js';
 import { getWorkspaceState, resolveLaunchDirectory } from '../config/workspaces.js';
 import { appendRecentActivity } from '../config/recent-activity.js';
 import { upsertSavedProviderSession } from '../config/saved-sessions.js';
@@ -260,9 +261,9 @@ export class DaemonCliManager {
         title?: string;
     }): void {
         try {
-            let nextConfig = appendRecentActivity(loadConfig(), entry);
+            let nextState = appendRecentActivity(loadState(), entry);
             if (entry.providerSessionId && (entry.kind === 'cli' || entry.kind === 'acp')) {
-                nextConfig = upsertSavedProviderSession(nextConfig, {
+                nextState = upsertSavedProviderSession(nextState, {
                     kind: entry.kind,
                     providerType: entry.providerType,
                     providerName: entry.providerName,
@@ -272,7 +273,7 @@ export class DaemonCliManager {
                     title: entry.title,
                 });
             }
-            saveConfig(nextConfig);
+            saveState(nextState);
         } catch (e) {
             console.error(colorize('red', `  ✗ Failed to save recent activity: ${e}`));
         }

package/src/commands/router.ts

@@ -18,6 +18,7 @@ import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { launchWithCdp, killIdeProcess, isIdeRunning } from '../launch.js';
 import { loadConfig, saveConfig, updateConfig } from '../config/config.js';
+import { loadState, saveState } from '../config/state-store.js';
 import { resolveIdeLaunchWorkspace } from '../config/workspaces.js';
 import { appendRecentActivity, getRecentActivity, markSessionSeen } from '../config/recent-activity.js';
 import { getSavedProviderSessions } from '../config/saved-sessions.js';
@@ -172,9 +173,9 @@ export class DaemonCommandRouter {
                 const offset = Math.max(0, Number(args?.offset) || 0);
                 const limit = Math.max(1, Math.min(100, Number(args?.limit) || 30));
                 const { sessions: historySessions, hasMore } = listSavedHistorySessions(providerType, { offset, limit });
-                const config = loadConfig();
-                const savedSessions = getSavedProviderSessions(config, { providerType, kind });
-                const recentSessions = getRecentActivity(config, 200)
+                const state = loadState();
+                const savedSessions = getSavedProviderSessions(state, { providerType, kind });
+                const recentSessions = getRecentActivity(state, 200)
                     .filter(entry => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
                 const savedSessionById = new Map(savedSessions.map(entry => [entry.providerSessionId, entry]));
                 const recentSessionById = new Map(recentSessions.map(entry => [entry.providerSessionId!, entry]));
@@ -284,18 +285,18 @@ export class DaemonCommandRouter {
                 this.deps.onIdeConnected?.();
                 if (result.success && resolvedWorkspace) {
                     try {
-                        const next = appendRecentActivity(loadConfig(), {
+                        const next = appendRecentActivity(loadState(), {
                             kind: 'ide',
                             providerType: result.ideId || ideKey,
                             providerName: result.ideId || ideKey,
                             workspace: resolvedWorkspace,
                             title: result.ideId || ideKey,
                         });
-                        saveConfig(next);
+                        saveState(next);
                     } catch { /* ignore activity persist errors */ }
                 } else if (result.success && (result.ideId || ideKey)) {
                     try {
-                        saveConfig(appendRecentActivity(loadConfig(), {
+                        saveState(appendRecentActivity(loadState(), {
                             kind: 'ide',
                             providerType: result.ideId || ideKey,
                             providerName: result.ideId || ideKey,
@@ -326,8 +327,8 @@ export class DaemonCommandRouter {
                 if (!sessionId || typeof sessionId !== 'string') {
                     return { success: false, error: 'sessionId is required' };
                 }
-                const currentConfig = loadConfig();
-                const prevSeenAt = currentConfig.sessionReads?.[sessionId] || 0;
+                const currentState = loadState();
+                const prevSeenAt = currentState.sessionReads?.[sessionId] || 0;
                 const sessionEntries = buildSessionEntries(
                     this.deps.instanceManager.collectAllStates(),
                     this.deps.cdpManagers as Map<string, any>,
@@ -335,7 +336,7 @@ export class DaemonCommandRouter {
                 const targetSession = sessionEntries.find((entry) => entry.id === sessionId);
                 const completionMarker = targetSession ? getSessionCompletionMarker(targetSession) : '';
                 const next = markSessionSeen(
-                    currentConfig,
+                    currentState,
                     sessionId,
                     typeof args?.seenAt === 'number' ? args.seenAt : Date.now(),
                     completionMarker,
@@ -343,7 +344,7 @@ export class DaemonCommandRouter {
                 if (READ_DEBUG_ENABLED) {
                     LOG.info('RecentRead', `mark_session_seen sessionId=${sessionId} seenAt=${String(args?.seenAt || '')} prevSeenAt=${String(prevSeenAt)} nextSeenAt=${String(next.sessionReads?.[sessionId] || 0)} marker=${completionMarker || '-'}`);
                 }
-                saveConfig(next);
+                saveState(next);
                 this.deps.onStatusChange?.();
                 return {
                     success: true,

package/src/config/config.d.ts

@@ -4,11 +4,10 @@
  * Manages launcher config, machine auth, and user preferences.
  */
 import type { WorkspaceEntry } from './workspaces.js';
-import type { RecentActivityEntry } from './recent-activity.js';
-import type { SavedProviderSessionEntry } from './saved-sessions.js';
 export type { WorkspaceEntry } from './workspaces.js';
 export type { RecentActivityEntry } from './recent-activity.js';
 export type { SavedProviderSessionEntry } from './saved-sessions.js';
+export type { DaemonState } from './state-store.js';
 export interface ADHDevConfig {
     serverUrl: string;
     selectedIde: string | null;
@@ -23,14 +22,6 @@ export interface ADHDevConfig {
     workspaces?: WorkspaceEntry[];
     /** Default workspace id (from workspaces[]) — never used implicitly for launch */
     defaultWorkspaceId?: string | null;
-    /** Unified recent activity across IDE / CLI / ACP launch flows */
-    recentActivity?: RecentActivityEntry[];
-    /** Persistent resume-capable provider sessions keyed by providerSessionId */
-    savedProviderSessions?: SavedProviderSessionEntry[];
-    /** Last seen timestamps for live sessions, keyed by sessionId */
-    sessionReads?: Record<string, number>;
-    /** Last seen completion marker for live sessions, keyed by sessionId */
-    sessionReadMarkers?: Record<string, string>;
     machineNickname: string | null;
     /**
      * Stable local machine ID (prefix: `mach_`) — generated locally on first run.

package/src/config/config.ts

@@ -9,11 +9,10 @@ import { join } from 'path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'fs';
 import { randomUUID } from 'crypto';
 import type { WorkspaceEntry } from './workspaces.js';
-import type { RecentActivityEntry } from './recent-activity.js';
-import type { SavedProviderSessionEntry } from './saved-sessions.js';
 export type { WorkspaceEntry } from './workspaces.js';
 export type { RecentActivityEntry } from './recent-activity.js';
 export type { SavedProviderSessionEntry } from './saved-sessions.js';
+export type { DaemonState } from './state-store.js';
 
 export interface ADHDevConfig {
  // Server connection
@@ -44,15 +43,6 @@ export interface ADHDevConfig {
  /** Default workspace id (from workspaces[]) — never used implicitly for launch */
     defaultWorkspaceId?: string | null;
 
-    /** Unified recent activity across IDE / CLI / ACP launch flows */
-    recentActivity?: RecentActivityEntry[];
-    /** Persistent resume-capable provider sessions keyed by providerSessionId */
-    savedProviderSessions?: SavedProviderSessionEntry[];
-    /** Last seen timestamps for live sessions, keyed by sessionId */
-    sessionReads?: Record<string, number>;
-    /** Last seen completion marker for live sessions, keyed by sessionId */
-    sessionReadMarkers?: Record<string, string>;
-
  // Machine nickname (user-customizable label for this machine)
     machineNickname: string | null;
 
@@ -102,10 +92,6 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     enabledIdes: [],
     workspaces: [],
     defaultWorkspaceId: null,
-    recentActivity: [],
-    savedProviderSessions: [],
-    sessionReads: {},
-    sessionReadMarkers: {},
     machineNickname: null,
     machineId: undefined,
     machineSecret: null,
@@ -140,16 +126,6 @@ function asBoolean(value: unknown, fallback: boolean): boolean {
 
 function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: string | null } {
     const parsed = isPlainObject(raw) ? raw : {};
-    const legacySessionReads = isPlainObject(parsed.recentSessionReads) ? parsed.recentSessionReads : {};
-    const sessionReads = isPlainObject(parsed.sessionReads) ? parsed.sessionReads : {};
-    const mergedSessionReads = Object.fromEntries(
-        Object.entries({ ...legacySessionReads, ...sessionReads })
-            .filter(([, value]) => typeof value === 'number' && Number.isFinite(value))
-    );
-    const sessionReadMarkers = Object.fromEntries(
-        Object.entries(isPlainObject(parsed.sessionReadMarkers) ? parsed.sessionReadMarkers : {})
-            .filter(([, value]) => typeof value === 'string')
-    );
 
     return {
         serverUrl: typeof parsed.serverUrl === 'string' && parsed.serverUrl.trim()
@@ -165,10 +141,6 @@ function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: str
         enabledIdes: asStringArray(parsed.enabledIdes),
         workspaces: Array.isArray(parsed.workspaces) ? parsed.workspaces as WorkspaceEntry[] : [],
         defaultWorkspaceId: asNullableString(parsed.defaultWorkspaceId) ?? asNullableString(parsed.activeWorkspaceId),
-        recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity as RecentActivityEntry[] : [],
-        savedProviderSessions: Array.isArray(parsed.savedProviderSessions) ? parsed.savedProviderSessions as SavedProviderSessionEntry[] : [],
-        sessionReads: mergedSessionReads,
-        sessionReadMarkers,
         machineNickname: asNullableString(parsed.machineNickname),
         machineId: asOptionalString(parsed.machineId),
         machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
@@ -227,6 +199,48 @@ function getConfigPath(): string {
     return join(getConfigDir(), 'config.json');
 }
 
+/**
+ * One-time migration: move runtime state fields from config.json to state.json.
+ * Called eagerly during loadConfig so state is extracted before the config
+ * normalizer strips the unknown fields.
+ */
+function migrateStateToStateFile(raw: Record<string, any>): void {
+    const statePath = join(getConfigDir(), 'state.json');
+    if (existsSync(statePath)) return;
+
+    const recentActivity = Array.isArray(raw.recentActivity) ? raw.recentActivity : [];
+    const savedProviderSessions = Array.isArray(raw.savedProviderSessions) ? raw.savedProviderSessions : [];
+    const legacySessionReads = isPlainObject(raw.recentSessionReads) ? raw.recentSessionReads : {};
+    const sessionReads = isPlainObject(raw.sessionReads) ? raw.sessionReads : {};
+    const sessionReadMarkers = isPlainObject(raw.sessionReadMarkers) ? raw.sessionReadMarkers : {};
+
+    const hasData = recentActivity.length > 0
+        || savedProviderSessions.length > 0
+        || Object.keys(sessionReads).length > 0
+        || Object.keys(legacySessionReads as object).length > 0
+        || Object.keys(sessionReadMarkers as object).length > 0;
+
+    if (!hasData) return;
+
+    const mergedReads = Object.fromEntries(
+        Object.entries({ ...legacySessionReads, ...sessionReads })
+            .filter(([, v]) => typeof v === 'number' && Number.isFinite(v as number))
+    );
+    const cleanedMarkers = Object.fromEntries(
+        Object.entries(sessionReadMarkers as Record<string, unknown>)
+            .filter(([, v]) => typeof v === 'string')
+    );
+
+    const state = {
+        recentActivity,
+        savedProviderSessions,
+        sessionReads: mergedReads,
+        sessionReadMarkers: cleanedMarkers,
+    };
+
+    writeFileSync(statePath, JSON.stringify(state, null, 2), { encoding: 'utf-8', mode: 0o600 });
+}
+
 /**
  * Load configuration from disk
  */
@@ -244,6 +258,10 @@ export function loadConfig(): ADHDevConfig {
     try {
         const raw = readFileSync(configPath, 'utf-8');
         const parsed = JSON.parse(raw);
+
+        // One-time migration: move runtime state to ~/.adhdev/state.json
+        migrateStateToStateFile(parsed);
+
         const normalizedInput = normalizeConfig(parsed);
         const ensured = ensureMachineId(normalizedInput);
         const normalized = ensured.config as ADHDevConfig & { activeWorkspaceId?: string | null };

package/src/config/recent-activity.ts

@@ -8,7 +8,7 @@
  */
 
 import * as path from 'path';
-import type { ADHDevConfig } from './config.js';
+import type { DaemonState } from './state-store.js';
 import { expandPath } from './workspaces.js';
 
 export interface RecentActivityEntry {
@@ -49,9 +49,9 @@ export function buildRecentActivityKeyForEntry(
 }
 
 export function appendRecentActivity(
-    config: ADHDevConfig,
+    state: DaemonState,
     entry: Omit<RecentActivityEntry, 'id' | 'lastUsedAt'> & { lastUsedAt?: number },
-): ADHDevConfig {
+): DaemonState {
     const nextEntry: RecentActivityEntry = {
         ...entry,
         workspace: entry.workspace ? normalizeWorkspace(entry.workspace) : undefined,
@@ -59,39 +59,39 @@ export function appendRecentActivity(
         lastUsedAt: entry.lastUsedAt || Date.now(),
     };
 
-    const filtered = (config.recentActivity || []).filter((item) => item.id !== nextEntry.id);
+    const filtered = (state.recentActivity || []).filter((item) => item.id !== nextEntry.id);
     return {
-        ...config,
+        ...state,
         recentActivity: [nextEntry, ...filtered].slice(0, MAX_ACTIVITY),
     };
 }
 
-export function getRecentActivity(config: ADHDevConfig, limit = 20): RecentActivityEntry[] {
-    return [...(config.recentActivity || [])]
+export function getRecentActivity(state: DaemonState, limit = 20): RecentActivityEntry[] {
+    return [...(state.recentActivity || [])]
         .sort((a, b) => b.lastUsedAt - a.lastUsedAt)
         .slice(0, limit);
 }
 
-export function getSessionSeenAt(config: ADHDevConfig, sessionId: string): number {
-    return config.sessionReads?.[sessionId] || 0;
+export function getSessionSeenAt(state: DaemonState, sessionId: string): number {
+    return state.sessionReads?.[sessionId] || 0;
 }
 
-export function getSessionSeenMarker(config: ADHDevConfig, sessionId: string): string {
-    return config.sessionReadMarkers?.[sessionId] || '';
+export function getSessionSeenMarker(state: DaemonState, sessionId: string): string {
+    return state.sessionReadMarkers?.[sessionId] || '';
 }
 
 export function markSessionSeen(
-    config: ADHDevConfig,
+    state: DaemonState,
     sessionId: string,
     seenAt = Date.now(),
     completionMarker?: string | null,
-): ADHDevConfig {
-    const prev = config.sessionReads || {};
+): DaemonState {
+    const prev = state.sessionReads || {};
     const nextSeenAt = Math.max(prev[sessionId] || 0, seenAt);
-    const prevMarkers = config.sessionReadMarkers || {};
+    const prevMarkers = state.sessionReadMarkers || {};
     const nextMarker = typeof completionMarker === 'string' ? completionMarker : '';
     return {
-        ...config,
+        ...state,
         sessionReads: {
             ...prev,
             [sessionId]: nextSeenAt,

package/src/config/saved-sessions.ts

@@ -1,5 +1,5 @@
 import * as path from 'path';
-import type { ADHDevConfig } from './config.js';
+import type { DaemonState } from './state-store.js';
 import { expandPath } from './workspaces.js';
 
 export interface SavedProviderSessionEntry {
@@ -31,14 +31,14 @@ export function buildSavedProviderSessionKey(providerSessionId: string) {
 }
 
 export function upsertSavedProviderSession(
-    config: ADHDevConfig,
+    state: DaemonState,
     entry: Omit<SavedProviderSessionEntry, 'id' | 'createdAt' | 'lastUsedAt'> & { createdAt?: number; lastUsedAt?: number },
-): ADHDevConfig {
+): DaemonState {
     const providerSessionId = typeof entry.providerSessionId === 'string' ? entry.providerSessionId.trim() : '';
-    if (!providerSessionId) return config;
+    if (!providerSessionId) return state;
 
     const id = buildSavedProviderSessionKey(providerSessionId);
-    const existing = (config.savedProviderSessions || []).find(item => item.id === id);
+    const existing = (state.savedProviderSessions || []).find(item => item.id === id);
     const nextEntry: SavedProviderSessionEntry = {
         id,
         kind: entry.kind,
@@ -52,18 +52,18 @@ export function upsertSavedProviderSession(
         lastUsedAt: entry.lastUsedAt || Date.now(),
     };
 
-    const filtered = (config.savedProviderSessions || []).filter(item => item.id !== id);
+    const filtered = (state.savedProviderSessions || []).filter(item => item.id !== id);
     return {
-        ...config,
+        ...state,
         savedProviderSessions: [nextEntry, ...filtered].slice(0, MAX_SAVED_SESSIONS),
     };
 }
 
 export function getSavedProviderSessions(
-    config: ADHDevConfig,
+    state: DaemonState,
     filters?: { providerType?: string; kind?: SavedProviderSessionEntry['kind'] },
 ): SavedProviderSessionEntry[] {
-    return [...(config.savedProviderSessions || [])]
+    return [...(state.savedProviderSessions || [])]
         .filter(entry => {
             if (filters?.providerType && entry.providerType !== filters.providerType) return false;
             if (filters?.kind && entry.kind !== filters.kind) return false;

package/src/config/state-store.ts

@@ -0,0 +1,94 @@
+/**
+ * ADHDev State Store — Runtime state persistence
+ *
+ * Separates volatile runtime state (sessions, activity, read markers)
+ * from static configuration (config.json).
+ *
+ * State is stored in ~/.adhdev/state.json
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getConfigDir } from './config.js';
+import type { RecentActivityEntry } from './recent-activity.js';
+import type { SavedProviderSessionEntry } from './saved-sessions.js';
+
+export interface DaemonState {
+    /** Unified recent activity across IDE / CLI / ACP launch flows */
+    recentActivity: RecentActivityEntry[];
+    /** Persistent resume-capable provider sessions keyed by providerSessionId */
+    savedProviderSessions: SavedProviderSessionEntry[];
+    /** Last seen timestamps for live sessions, keyed by sessionId */
+    sessionReads: Record<string, number>;
+    /** Last seen completion marker for live sessions, keyed by sessionId */
+    sessionReadMarkers: Record<string, string>;
+}
+
+const DEFAULT_STATE: DaemonState = {
+    recentActivity: [],
+    savedProviderSessions: [],
+    sessionReads: {},
+    sessionReadMarkers: {},
+};
+
+function isPlainObject(value: unknown): value is Record<string, any> {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function getStatePath(): string {
+    return join(getConfigDir(), 'state.json');
+}
+
+function normalizeState(raw: unknown): DaemonState {
+    const parsed = isPlainObject(raw) ? raw : {};
+
+    const sessionReads = Object.fromEntries(
+        Object.entries(isPlainObject(parsed.sessionReads) ? parsed.sessionReads : {})
+            .filter(([, value]) => typeof value === 'number' && Number.isFinite(value as number))
+    );
+    const sessionReadMarkers = Object.fromEntries(
+        Object.entries(isPlainObject(parsed.sessionReadMarkers) ? parsed.sessionReadMarkers : {})
+            .filter(([, value]) => typeof value === 'string')
+    );
+
+    return {
+        recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity as RecentActivityEntry[] : [],
+        savedProviderSessions: Array.isArray(parsed.savedProviderSessions) ? parsed.savedProviderSessions as SavedProviderSessionEntry[] : [],
+        sessionReads,
+        sessionReadMarkers,
+    };
+}
+
+/**
+ * Load runtime state from disk
+ */
+export function loadState(): DaemonState {
+    const statePath = getStatePath();
+
+    if (!existsSync(statePath)) {
+        return { ...DEFAULT_STATE };
+    }
+
+    try {
+        const raw = readFileSync(statePath, 'utf-8');
+        return normalizeState(JSON.parse(raw));
+    } catch {
+        return { ...DEFAULT_STATE };
+    }
+}
+
+/**
+ * Save runtime state to disk
+ */
+export function saveState(state: DaemonState): void {
+    const statePath = getStatePath();
+    const normalized = normalizeState(state);
+    writeFileSync(statePath, JSON.stringify(normalized, null, 2), { encoding: 'utf-8', mode: 0o600 });
+}
+
+/**
+ * Reset runtime state
+ */
+export function resetState(): void {
+    saveState({ ...DEFAULT_STATE });
+}

package/src/index.ts

@@ -69,6 +69,10 @@ export type { RecentActivityEntry } from './config/recent-activity.js';
 export { getSavedProviderSessions, upsertSavedProviderSession } from './config/saved-sessions.js';
 export type { SavedProviderSessionEntry } from './config/saved-sessions.js';
 
+// ── State Store ──
+export { loadState, saveState, resetState } from './config/state-store.js';
+export type { DaemonState } from './config/state-store.js';
+
 // ── Detection ──
 export { detectIDEs } from './detection/ide-detector.js';
 export type { IDEInfo } from './detection/ide-detector.js';

package/src/status/snapshot.ts

@@ -8,6 +8,7 @@
 
 import * as os from 'os';
 import { loadConfig } from '../config/config.js';
+import { loadState } from '../config/state-store.js';
 import { getRecentActivity, getSessionSeenAt, getSessionSeenMarker } from '../config/recent-activity.js';
 import { getWorkspaceState } from '../config/workspaces.js';
 import { getHostMemorySnapshot } from '../system/host-memory.js';
@@ -195,16 +196,17 @@ function buildRecentLaunches(
 
 export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnapshot {
     const cfg = loadConfig();
+    const state = loadState();
     const wsState = getWorkspaceState(cfg);
     const memSnap = getHostMemorySnapshot();
-    const recentActivity = getRecentActivity(cfg, 20);
+    const recentActivity = getRecentActivity(state, 20);
     const sessions = buildSessionEntries(
         options.allStates,
         options.cdpManagers as Map<string, any>,
     );
     for (const session of sessions) {
-        const lastSeenAt = getSessionSeenAt(cfg, session.id);
-        const seenCompletionMarker = getSessionSeenMarker(cfg, session.id);
+        const lastSeenAt = getSessionSeenAt(state, session.id);
+        const seenCompletionMarker = getSessionSeenMarker(state, session.id);
         const lastUsedAt = getSessionLastUsedAt(session);
         const completionMarker = getSessionCompletionMarker(session);
         const { unread, inboxBucket } = session.surfaceHidden