@adhdev/daemon-core 0.7.37 → 0.7.39

package/src/commands/router.ts

@@ -18,8 +18,6 @@ import type { ProviderInstanceManager } from '../providers/provider-instance-man
 import { launchWithCdp, killIdeProcess, isIdeRunning } from '../launch.js';
 import { loadConfig, saveConfig, updateConfig } from '../config/config.js';
 import { resolveIdeLaunchWorkspace } from '../config/workspaces.js';
-import { appendWorkspaceActivity } from '../config/workspace-activity.js';
-import { addCliHistory } from '../config/config.js';
 import { appendRecentActivity, buildRecentActivityKey, markRecentSessionSeen } from '../config/recent-activity.js';
 import { detectIDEs } from '../detection/ide-detector.js';
 import { SessionRegistry } from '../sessions/registry.js';
@@ -208,17 +206,6 @@ export class DaemonCommandRouter {
                 };
                 LOG.info('LaunchIDE', `target=${ideKey || 'auto'}`);
                 const result = await launchWithCdp(launchArgs);
-                if (result.success && (result.ideId || ideKey)) {
-                    try {
-                        addCliHistory({
-                            category: 'ide',
-                            cliType: result.ideId || ideKey,
-                            dir: resolvedWorkspace || '',
-                            workspace: resolvedWorkspace || '',
-                            newWindow: args?.newWindow === true,
-                        });
-                    } catch { /* ignore history failure */ }
-                }
 
                 if (result.success && result.port && result.ideId && !this.deps.cdpManagers.has(result.ideId)) {
                     const logFn = this.deps.getCdpLogFn
@@ -241,11 +228,7 @@ export class DaemonCommandRouter {
                 this.deps.onIdeConnected?.();
                 if (result.success && resolvedWorkspace) {
                     try {
-                        let next = appendWorkspaceActivity(loadConfig(), resolvedWorkspace, {
-                            kind: 'ide',
-                            agentType: result.ideId,
-                        });
-                        next = appendRecentActivity(next, {
+                        const next = appendRecentActivity(loadConfig(), {
                             kind: 'ide',
                             providerType: result.ideId || ideKey,
                             providerName: result.ideId || ideKey,

package/src/commands/stream-commands.ts

@@ -5,7 +5,6 @@
 
 import type { CommandResult, CommandHelpers } from './handler.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
-import { loadConfig } from '../config/config.js';
 import { LOG } from '../logging/logger.js';
 
 export async function handleFocusSession(h: CommandHelpers, args: any): Promise<CommandResult> {
@@ -193,14 +192,13 @@ export function handleGetIdeExtensions(h: CommandHelpers, args: any): CommandRes
     if (!loader) return { success: false, error: 'ProviderLoader not initialized' };
 
     const allExtProviders = loader.getByCategory?.('extension') || [];
-    const config = loadConfig();
 
     if (ideType) {
         const extensions = allExtProviders.map(p => ({
             type: p.type,
             name: p.name,
             extensionId: p.extensionId,
-            enabled: config.ideSettings?.[ideType]?.extensions?.[p.type]?.enabled === true,
+            enabled: loader.getIdeExtensionEnabledState?.(ideType, p.type) === true,
         }));
         return { success: true, ideType, extensions };
     }
@@ -212,7 +210,7 @@ export function handleGetIdeExtensions(h: CommandHelpers, args: any): CommandRes
             type: p.type,
             name: p.name,
             extensionId: p.extensionId,
-            enabled: config.ideSettings?.[ide]?.extensions?.[p.type]?.enabled === true,
+            enabled: loader.getIdeExtensionEnabledState?.(ide, p.type) === true,
         }));
     }
     return { success: true, ideExtensions: result };

package/src/commands/workspace-commands.ts

@@ -4,7 +4,6 @@
 
 import { loadConfig, saveConfig } from '../config/config.js';
 import * as W from '../config/workspaces.js';
-import { appendWorkspaceActivity, getWorkspaceActivity, removeActivityForPath } from '../config/workspace-activity.js';
 
 export type WorkspaceCommandResult = { success: boolean;[key: string]: unknown };
 
@@ -16,8 +15,6 @@ export function handleWorkspaceList(): WorkspaceCommandResult {
         workspaces: state.workspaces,
         defaultWorkspaceId: state.defaultWorkspaceId,
         defaultWorkspacePath: state.defaultWorkspacePath,
-        legacyRecentPaths: config.recentCliWorkspaces || [],
-        activity: getWorkspaceActivity(config, 25),
     };
 }
 
@@ -31,10 +28,9 @@ export function handleWorkspaceAdd(args: any): WorkspaceCommandResult {
     const result = W.addWorkspaceEntry(config, rawPath, label, { createIfMissing });
     if ('error' in result) return { success: false, error: result.error };
 
-    let cfg = appendWorkspaceActivity(result.config, result.entry.path, {});
-    saveConfig(cfg);
-    const state = W.getWorkspaceState(cfg);
-    return { success: true, entry: result.entry, ...state, activity: getWorkspaceActivity(cfg, 25) };
+    saveConfig(result.config);
+    const state = W.getWorkspaceState(result.config);
+    return { success: true, entry: result.entry, ...state };
 }
 
 export function handleWorkspaceRemove(args: any): WorkspaceCommandResult {
@@ -46,13 +42,9 @@ export function handleWorkspaceRemove(args: any): WorkspaceCommandResult {
     const result = W.removeWorkspaceEntry(config, id);
     if ('error' in result) return { success: false, error: result.error };
 
-    let cfg = result.config;
-    if (removed) {
-        cfg = removeActivityForPath(cfg, removed.path);
-    }
-    saveConfig(cfg);
-    const state = W.getWorkspaceState(cfg);
-    return { success: true, removedId: id, ...state, activity: getWorkspaceActivity(cfg, 25) };
+    saveConfig(result.config);
+    const state = W.getWorkspaceState(result.config);
+    return { success: true, removedId: id, ...state };
 }
 
 export function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult {
@@ -66,7 +58,6 @@ export function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult {
         return {
             success: true,
             ...state,
-            activity: getWorkspaceActivity(result.config, 25),
         };
     }
 
@@ -98,12 +89,7 @@ export function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult {
     const result = W.setDefaultWorkspaceId(config, nextId);
     if ('error' in result) return { success: false, error: result.error };
 
-    let out = result.config;
-    const ap = W.getDefaultWorkspacePath(out);
-    if (ap) {
-        out = appendWorkspaceActivity(out, ap, { kind: 'default' });
-    }
-    saveConfig(out);
-    const state = W.getWorkspaceState(out);
-    return { success: true, ...state, activity: getWorkspaceActivity(out, 25) };
+    saveConfig(result.config);
+    const state = W.getWorkspaceState(result.config);
+    return { success: true, ...state };
 }

package/src/config/config.ts

@@ -8,12 +8,9 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'fs';
 import { randomUUID } from 'crypto';
-import { migrateWorkspacesFromRecent } from './workspaces.js';
 import type { WorkspaceEntry } from './workspaces.js';
-import type { WorkspaceActivityEntry } from './workspace-activity.js';
 import type { RecentActivityEntry } from './recent-activity.js';
 export type { WorkspaceEntry } from './workspaces.js';
-export type { WorkspaceActivityEntry } from './workspace-activity.js';
 export type { RecentActivityEntry } from './recent-activity.js';
 
 export interface ADHDevConfig {
@@ -54,15 +51,12 @@ export interface ADHDevConfig {
 
  // Daemon: which IDEs to connect (empty = all)
     enabledIdes: string[];
-    recentCliWorkspaces: string[];
 
  /** Saved workspaces for IDE/CLI/ACP launch (daemon-local) */
     workspaces?: WorkspaceEntry[];
  /** Default workspace id (from workspaces[]) — never used implicitly for launch */
     defaultWorkspaceId?: string | null;
 
-    /** Recently used workspaces (IDE / CLI / ACP / default) for quick resume */
-    recentWorkspaceActivity?: WorkspaceActivityEntry[];
     /** Unified recent activity across IDE / CLI / ACP launch flows */
     recentActivity?: RecentActivityEntry[];
     /** Last seen timestamps for machine-facing recent/session entries */
@@ -94,9 +88,6 @@ export interface ADHDevConfig {
      */
     registeredMachineId?: string;
 
- // CLI launch history
-    cliHistory: CliHistoryEntry[];
-
  // Per-provider user config (public setting values)
     providerSettings: Record<string, Record<string, any>>;
 
@@ -113,18 +104,6 @@ export interface ADHDevConfig {
     providerDir?: string;
 }
 
-export interface CliHistoryEntry {
-    category?: 'ide' | 'cli' | 'acp';
-    cliType: string;
-    dir: string;
-    cliArgs?: string[];
-    workspace?: string;
-    newWindow?: boolean;
-    model?: string;
-    timestamp: number;
-    label?: string;
-}
-
 const DEFAULT_CONFIG: ADHDevConfig = {
     serverUrl: 'https://api.adhf.dev',
     apiToken: null,
@@ -140,17 +119,14 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     setupDate: null,
     configuredCLIs: [],
     enabledIdes: [],
-    recentCliWorkspaces: [],
     workspaces: [],
     defaultWorkspaceId: null,
-    recentWorkspaceActivity: [],
     recentActivity: [],
     recentSessionReads: {},
     machineNickname: null,
     machineId: undefined,
     machineSecret: null,
     registeredMachineId: undefined,
-    cliHistory: [],
     providerSettings: {},
     ideSettings: {},
     disableUpstream: false,
@@ -227,18 +203,9 @@ export function loadConfig(): ADHDevConfig {
             (merged as ADHDevConfig).defaultWorkspaceId = merged.activeWorkspaceId;
         }
         delete (merged as any).activeWorkspaceId;
-        const hadStoredWorkspaces = Array.isArray(parsed.workspaces) && parsed.workspaces.length > 0;
         const ensured = ensureMachineId(merged);
         const normalized = ensured.config as ADHDevConfig & { activeWorkspaceId?: string | null };
-        migrateWorkspacesFromRecent(normalized);
-        
-        let configChanged = ensured.changed;
-
-        if (!hadStoredWorkspaces && (normalized.workspaces?.length || 0) > 0) {
-            configChanged = true;
-        }
-
-        if (configChanged) {
+        if (ensured.changed) {
             try {
                 saveConfig(normalized);
             } catch { /* ignore */ }
@@ -318,47 +285,3 @@ export function generateConnectionToken(): string {
     }
     return token;
 }
-/**
- * Add launch to history (max 20, dedup by category+type+dir+args+workspace+model)
- */
-export function addCliHistory(entry: Omit<CliHistoryEntry, 'timestamp'>): void {
-    const config = loadConfig();
-    const history = config.cliHistory || [];
-    const argsKey = (entry.cliArgs || []).join(' ');
-    const category = entry.category || 'cli';
-    const workspaceKey = entry.workspace || '';
-    const modelKey = entry.model || '';
-    
- // Remove duplicate (same category + type + dir + args + workspace + model)
-    const filtered = history.filter(h => {
-        const hArgsKey = (h.cliArgs || []).join(' ');
-        return !(
-            (h.category || 'cli') === category &&
-            h.cliType === entry.cliType &&
-            h.dir === entry.dir &&
-            hArgsKey === argsKey &&
-            (h.workspace || '') === workspaceKey &&
-            (h.model || '') === modelKey
-        );
-    });
-    
- // Add to front
-    filtered.unshift({
-        ...entry,
-        category,
-        timestamp: Date.now(),
-        label: entry.label || (() => {
-            const base = `${entry.cliType} · ${entry.dir.split('/').filter(Boolean).pop() || 'root'}`;
-            const suffix: string[] = [];
-            if (entry.workspace && entry.workspace !== entry.dir) suffix.push(entry.workspace.split('/').filter(Boolean).pop() || entry.workspace);
-            if (entry.model) suffix.push(`model=${entry.model}`);
-            if (argsKey) suffix.push(argsKey);
-            if (entry.newWindow) suffix.push('new window');
-            return suffix.length > 0 ? `${base} (${suffix.join(' · ')})` : base;
-        })(),
-    });
-    
- // Keep max 20
-    config.cliHistory = filtered.slice(0, 20);
-    saveConfig(config);
-}

package/src/config/workspaces.ts

@@ -42,30 +42,6 @@ export function defaultWorkspaceLabel(absPath: string): string {
     return base;
 }
 
-/**
- * Ensure config.workspaces exists; seed from recentCliWorkspaces once (same paths).
- */
-export function migrateWorkspacesFromRecent(config: ADHDevConfig): ADHDevConfig {
-    if (!config.workspaces) config.workspaces = [];
-    if (config.workspaces.length > 0) return config;
-
-    const recent = config.recentCliWorkspaces || [];
-    const now = Date.now();
-    for (const raw of recent) {
-        const abs = expandPath(raw);
-        if (!abs || validateWorkspacePath(abs).ok !== true) continue;
-        if (config.workspaces.some(w => path.resolve(w.path) === abs)) continue;
-        config.workspaces.push({
-            id: randomUUID(),
-            path: abs,
-            label: defaultWorkspaceLabel(abs),
-            addedAt: now,
-        });
-        if (config.workspaces.length >= MAX_WORKSPACES) break;
-    }
-    return config;
-}
-
 export function getDefaultWorkspacePath(config: ADHDevConfig): string | null {
     const id = config.defaultWorkspaceId;
     if (!id) return null;

package/src/index.ts

@@ -33,7 +33,6 @@ export type {
   MachineInfo,
   DetectedIdeInfo,
   WorkspaceEntry,
-  WorkspaceActivity,
   ProviderStatus,
   ProviderErrorReason,
   ActiveChatData,
@@ -43,26 +42,28 @@ export type {
   ExtensionProviderState,
 } from './shared-types.js';
 
-export interface RecentSessionEntry {
-  id: string;
-  sessionId?: string | null;
-  providerType: string;
-  providerName: string;
-  kind: 'ide' | 'cli' | 'acp';
-  title: string;
-  workspace?: string | null;
-  currentModel?: string;
-  status?: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
-  lastUsedAt: number;
-}
+// These types live in shared-types-extra.ts — imported directly because
+// rollup-dts cannot resolve re-exports from shared-types.ts for them.
+import type { RuntimeWriteOwner as _RuntimeWriteOwner } from './shared-types-extra.js';
+import type { RuntimeAttachedClient as _RuntimeAttachedClient } from './shared-types-extra.js';
+import type { RecentSessionEntry as _RecentSessionEntry } from './shared-types.js';
+import type { TerminalBackendStatus as _TerminalBackendStatus } from './shared-types-extra.js';
+export type RuntimeWriteOwner = _RuntimeWriteOwner;
+export type RuntimeAttachedClient = _RuntimeAttachedClient;
+export type RecentSessionEntry = _RecentSessionEntry;
+export type TerminalBackendStatus = _TerminalBackendStatus;
+
+// Type aliases — rollup-dts cannot bundle re-exported type aliases at all.
+// Canonical definition lives in shared-types-extra.ts — keep these in sync.
+export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
 
 // ── Core Interface ──
 export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
 
 // ── Config ──
-export { loadConfig, saveConfig, resetConfig, isSetupComplete, addCliHistory, markSetupComplete, updateConfig } from './config/config.js';
+export { loadConfig, saveConfig, resetConfig, isSetupComplete, markSetupComplete, updateConfig } from './config/config.js';
 export { getWorkspaceState } from './config/workspaces.js';
-export { getWorkspaceActivity } from './config/workspace-activity.js';
 export { appendRecentActivity, getRecentActivity } from './config/recent-activity.js';
 export type { RecentActivityEntry } from './config/recent-activity.js';
 

package/src/providers/provider-loader.ts

@@ -284,16 +284,24 @@ export class ProviderLoader {
   isEnabled(type: string, ideType?: string): boolean {
     if (!ideType) return true;
     try {
-      const { loadConfig } = require('../config/config.js');
-      const config = loadConfig();
-      const baseIdeType = ideType.split('_')[0];
-      const val = config.ideSettings?.[baseIdeType]?.extensions?.[type]?.enabled;
-      return val === true; // undefined → false (default inactive)
+      return this.getIdeExtensionEnabledState(ideType, type);
     } catch {
       return false;
     }
   }
 
+ /**
+ * Resolve per-IDE extension enabled state using the same normalization
+ * that runtime attach/remove uses.
+ */
+  getIdeExtensionEnabledState(ideType: string, extensionType: string): boolean {
+    const { loadConfig } = require('../config/config.js');
+    const config = loadConfig();
+    const baseIdeType = ideType.split('_')[0];
+    const val = config.ideSettings?.[baseIdeType]?.extensions?.[extensionType]?.enabled;
+    return val === true;
+  }
+
  /**
  * Save IDE extension enabled setting
  */

package/src/shared-types-extra.ts

@@ -0,0 +1,34 @@
+/**
+ * ADHDev Shared Types — Additional cross-package type definitions
+ *
+ * Extracted common sub-types previously inlined across multiple packages.
+ * Separated from shared-types.ts due to rollup-dts bundling constraints.
+ *
+ * IMPORTANT: This file must remain runtime-free (types only).
+ */
+
+/** Runtime terminal write-owner descriptor */
+export interface RuntimeWriteOwner {
+    clientId: string;
+    ownerType: 'agent' | 'user';
+}
+
+/** Runtime attached client descriptor */
+export interface RuntimeAttachedClient {
+    clientId: string;
+    type: 'daemon' | 'web' | 'local-terminal';
+    readOnly: boolean;
+}
+
+/** Session status union (used by SessionEntry.status, RecentSessionEntry.status, etc.) */
+export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+
+/** Inbox bucket categories for recent sessions */
+export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
+
+/** Terminal backend status */
+export interface TerminalBackendStatus {
+    backend: 'xterm' | 'ghostty-vt';
+    preference: 'auto' | 'xterm' | 'ghostty-vt';
+    ghosttyAvailable: boolean;
+}

package/src/shared-types.ts

@@ -86,6 +86,9 @@ export type SessionCapability =
     | 'set_mode'
     | 'set_thought_level';
 
+import type { RuntimeWriteOwner, RuntimeAttachedClient, SessionStatus } from './shared-types-extra.js';
+export type { RuntimeWriteOwner, RuntimeAttachedClient, SessionStatus } from './shared-types-extra.js';
+
 export interface SessionEntry {
     id: string;
     parentId: string | null;
@@ -93,21 +96,14 @@ export interface SessionEntry {
     providerName: string;
     kind: SessionKind;
     transport: SessionTransport;
-    status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+    status: SessionStatus;
     title: string;
     workspace: string | null;
     runtimeKey?: string;
     runtimeDisplayName?: string;
     runtimeWorkspaceLabel?: string;
-    runtimeWriteOwner?: {
-        clientId: string;
-        ownerType: 'agent' | 'user';
-    } | null;
-    runtimeAttachedClients?: {
-        clientId: string;
-        type: 'daemon' | 'web' | 'local-terminal';
-        readOnly: boolean;
-    }[];
+    runtimeWriteOwner?: RuntimeWriteOwner | null;
+    runtimeAttachedClients?: RuntimeAttachedClient[];
     resume?: ProviderResumeCapability;
     activeChat: _ActiveChatData | null;
     capabilities: SessionCapability[];
@@ -128,6 +124,7 @@ export interface SessionEntry {
     unread?: boolean;
     lastSeenAt?: number;
     inboxBucket?: RecentSessionBucket;
+    surfaceHidden?: boolean;
 }
 
 /** Available provider information */
@@ -214,13 +211,9 @@ export interface DetectedIdeInfo {
     path?: string;
 }
 
-/** Workspace recent activity */
-export interface WorkspaceActivity {
-    path: string;
-    lastUsedAt: number;
-    kind?: string;
-    agentType?: string;
-}
+export type { RecentSessionBucket, TerminalBackendStatus } from './shared-types-extra.js';
+import type { RecentSessionBucket } from './shared-types-extra.js';
+import type { TerminalBackendStatus } from './shared-types-extra.js';
 
 export interface RecentSessionEntry {
     id: string;
@@ -237,21 +230,14 @@ export interface RecentSessionEntry {
     unread?: boolean;
     lastSeenAt?: number;
     inboxBucket?: RecentSessionBucket;
-}
-
-export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
-
-export interface TerminalBackendStatus {
-    backend: 'xterm' | 'ghostty-vt';
-    preference: 'auto' | 'xterm' | 'ghostty-vt';
-    ghosttyAvailable: boolean;
+    surfaceHidden?: boolean;
 }
 
 // ─── Status Report Payload (daemon → server) ────────────────────────
 // Full payload shape sent via WebSocket status_report
 
 export interface StatusReportPayload {
-    /** Daemon instance ID */
+    /** Unique daemon instance identifier */
     instanceId: string;
     /** Daemon version */
     version: string;
@@ -273,7 +259,8 @@ export interface StatusReportPayload {
     workspaces?: WorkspaceEntry[];
     defaultWorkspaceId?: string | null;
     defaultWorkspacePath?: string | null;
-    workspaceActivity?: WorkspaceActivity[];
     recentSessions?: RecentSessionEntry[];
     terminalBackend?: TerminalBackendStatus;
+    /** Available providers (present in StatusSnapshot, optional in raw payload) */
+    availableProviders?: AvailableProviderInfo[];
 }

package/src/status/builders.ts

@@ -337,5 +337,17 @@ export function buildSessionEntries(
         sessions.push(buildAcpSession(state));
     }
 
+    // Hide native IDE parent rows from inbox/recent surfaces when extension tabs exist.
+    const extensionParentIds = new Set(
+        sessions
+            .filter((session) => session.transport === 'cdp-webview' && !!session.parentId)
+            .map((session) => session.parentId as string)
+    );
+    for (const session of sessions) {
+        if (session.transport === 'cdp-page' && extensionParentIds.has(session.id)) {
+            session.surfaceHidden = true;
+        }
+    }
+
     return sessions;
 }

package/src/status/reporter.ts

@@ -207,6 +207,7 @@ export class DaemonStatusReporter {
                 unread: (session as any).unread,
                 lastSeenAt: (session as any).lastSeenAt,
                 inboxBucket: (session as any).inboxBucket,
+                surfaceHidden: (session as any).surfaceHidden,
                 controlValues: session.controlValues,
                 providerControls: session.providerControls,
                 acpConfigOptions: session.acpConfigOptions,

package/src/status/snapshot.ts

@@ -10,7 +10,6 @@ import * as os from 'os';
 import { loadConfig } from '../config/config.js';
 import { buildRecentActivityKey, getRecentActivity, getRecentSessionSeenAt } from '../config/recent-activity.js';
 import { getWorkspaceState } from '../config/workspaces.js';
-import { getWorkspaceActivity } from '../config/workspace-activity.js';
 import { getHostMemorySnapshot } from '../system/host-memory.js';
 import { getTerminalBackendRuntimeStatus } from '../cli-adapters/terminal-screen.js';
 import { buildSessionEntries, isCdpConnected } from './builders.js';
@@ -149,8 +148,10 @@ function buildRecentSessions(
     recentActivity: ReturnType<typeof getRecentActivity>,
     readState: Record<string, number>,
 ): RecentSessionEntry[] {
+    const visibleKeys = new Set<string>();
+    const hiddenKeys = new Set<string>();
     const live = sessions
-        .filter((session) => !session.parentId && session.status !== 'stopped')
+        .filter((session) => !session.surfaceHidden && session.status !== 'stopped')
         .map((session) => {
             const kind = getSessionKind(session);
             const recentKey = buildRecentActivityKey({
@@ -182,11 +183,21 @@ function buildRecentSessions(
                 unread,
                 lastSeenAt,
                 inboxBucket,
+                surfaceHidden: false,
             };
-        })
-    const seen = new Set(live.map((item) => `${item.kind}:${item.providerType}:${item.workspace || ''}`));
+        });
+    for (const item of live) {
+        visibleKeys.add(`${item.kind}:${item.providerType}:${item.workspace || ''}`);
+    }
+    for (const session of sessions) {
+        if (!session.surfaceHidden) continue;
+        hiddenKeys.add(`${getSessionKind(session)}:${session.providerType}:${session.workspace || ''}`);
+    }
     const persisted = recentActivity
-        .filter((item) => !seen.has(`${item.kind}:${item.providerType}:${item.workspace || ''}`))
+        .filter((item) => {
+            const key = `${item.kind}:${item.providerType}:${item.workspace || ''}`;
+            return !visibleKeys.has(key) && !hiddenKeys.has(key);
+        })
         .map((item) => {
             const lastSeenAt = readState[item.id] || 0;
             const unread = item.lastUsedAt > lastSeenAt;
@@ -204,6 +215,7 @@ function buildRecentSessions(
                 unread,
                 lastSeenAt,
                 inboxBucket: unread ? 'task_complete' : 'idle' as RecentSessionBucket,
+                surfaceHidden: false,
             };
         });
 
@@ -231,13 +243,15 @@ export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnaps
         });
         const lastSeenAt = getRecentSessionSeenAt(cfg, recentKey);
         const lastUsedAt = getSessionLastUsedAt(session);
-        const { unread, inboxBucket } = getUnreadState(
-            getSessionMessageUpdatedAt(session) > 0,
-            session.status,
-            lastUsedAt,
-            lastSeenAt,
-            getLastMessageRole(session),
-        );
+        const { unread, inboxBucket } = session.surfaceHidden
+            ? { unread: false, inboxBucket: 'idle' as RecentSessionBucket }
+            : getUnreadState(
+                getSessionMessageUpdatedAt(session) > 0,
+                session.status,
+                lastUsedAt,
+                lastSeenAt,
+                getLastMessageRole(session),
+            );
         session.recentKey = recentKey;
         session.lastSeenAt = lastSeenAt;
         session.unread = unread;
@@ -269,7 +283,6 @@ export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnaps
         workspaces: wsState.workspaces,
         defaultWorkspaceId: wsState.defaultWorkspaceId,
         defaultWorkspacePath: wsState.defaultWorkspacePath,
-        workspaceActivity: getWorkspaceActivity(cfg, 15),
         recentSessions: buildRecentSessions(sessions, recentActivity, readState),
         terminalBackend,
         availableProviders: buildAvailableProviders(options.providerLoader),