@adhdev/daemon-core 0.7.38 → 0.7.40

package/dist/shared-types.d.ts

@@ -0,0 +1,205 @@
+/**
+ * ADHDev Shared Types — Cross-package type definitions
+ *
+ * Types used across daemon-core, web-core, and downstream consumers.
+ * Import via: import type { ... } from '@adhdev/daemon-core/types'
+ *
+ * IMPORTANT: This file must remain runtime-free (types only).
+ */
+import type { StatusResponse, ChatMessage, ExtensionInfo, SystemInfo, DetectedIde, AgentEntry } from './types.js';
+export type { StatusResponse, ChatMessage, ExtensionInfo, SystemInfo, DetectedIde, AgentEntry, };
+export type { ProviderState, ProviderStatus, ActiveChatData, IdeProviderState, CliProviderState, AcpProviderState, ExtensionProviderState, ProviderEvent, } from './providers/provider-instance.js';
+export type { ProviderErrorReason } from './providers/provider-instance.js';
+import type { ActiveChatData as _ActiveChatData, ProviderErrorReason as _ProviderErrorReason } from './providers/provider-instance.js';
+import type { WorkspaceEntry } from './config/workspaces.js';
+import type { ProviderResumeCapability } from './providers/contracts.js';
+export type { WorkspaceEntry } from './config/workspaces.js';
+/** Agent stream snapshot carried by flattened UI entries. */
+export interface AgentSessionStream {
+    sessionId?: string;
+    instanceId?: string;
+    parentSessionId?: string | null;
+    agentType: string;
+    agentName: string;
+    extensionId: string;
+    transport?: SessionTransport;
+    status: string;
+    title?: string;
+    messages: ChatMessage[];
+    inputContent: string;
+    model?: string;
+    activeModal: {
+        message: string;
+        buttons: string[];
+    } | null;
+}
+export type SessionTransport = 'cdp-page' | 'cdp-webview' | 'pty' | 'acp';
+export type SessionKind = 'workspace' | 'agent';
+export type SessionCapability = 'read_chat' | 'send_message' | 'new_session' | 'list_sessions' | 'switch_session' | 'resolve_action' | 'terminal_io' | 'resize_terminal' | 'change_model' | '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;
+    providerType: string;
+    providerName: string;
+    kind: SessionKind;
+    transport: SessionTransport;
+    status: SessionStatus;
+    title: string;
+    workspace: string | null;
+    runtimeKey?: string;
+    runtimeDisplayName?: string;
+    runtimeWorkspaceLabel?: string;
+    runtimeWriteOwner?: RuntimeWriteOwner | null;
+    runtimeAttachedClients?: RuntimeAttachedClient[];
+    resume?: ProviderResumeCapability;
+    activeChat: _ActiveChatData | null;
+    capabilities: SessionCapability[];
+    cdpConnected?: boolean;
+    currentModel?: string;
+    currentPlan?: string;
+    currentAutoApprove?: string;
+    acpConfigOptions?: AcpConfigOption[];
+    acpModes?: AcpMode[];
+    /** Dynamic control current values (generic key-value) */
+    controlValues?: Record<string, string | number | boolean>;
+    /** Provider-declared controls schema (transmitted once, cached by frontend) */
+    providerControls?: ProviderControlSchema[];
+    errorMessage?: string;
+    errorReason?: _ProviderErrorReason;
+    lastUpdated?: number;
+    unread?: boolean;
+    lastSeenAt?: number;
+    inboxBucket?: RecentSessionBucket;
+    surfaceHidden?: boolean;
+}
+/** Available provider information */
+export interface AvailableProviderInfo {
+    type: string;
+    name: string;
+    category: 'ide' | 'extension' | 'cli' | 'acp';
+    displayName: string;
+    icon: string;
+}
+/** ACP config option (model/mode/thought_level selection) */
+export interface AcpConfigOption {
+    category: 'model' | 'mode' | 'thought_level' | 'other';
+    configId: string;
+    currentValue?: string;
+    options: {
+        value: string;
+        name: string;
+        description?: string;
+        group?: string;
+    }[];
+}
+/** ACP mode */
+export interface AcpMode {
+    id: string;
+    name: string;
+    description?: string;
+}
+/** Provider control schema transmitted to frontend */
+export interface ProviderControlSchema {
+    id: string;
+    type: 'select' | 'toggle' | 'cycle' | 'slider' | 'action';
+    label: string;
+    icon?: string;
+    placement: 'bar' | 'header' | 'menu';
+    /** Static options (for select/cycle) */
+    options?: {
+        value: string;
+        label: string;
+        description?: string;
+        group?: string;
+    }[];
+    /** Dynamic options — frontend should call listScript to load */
+    dynamic?: boolean;
+    /** Script name to list options */
+    listScript?: string;
+    /** Script name to change value (value-based controls) */
+    setScript?: string;
+    /** Field name in readChat result for current value */
+    readFrom?: string;
+    /** Default value */
+    defaultValue?: string | number | boolean;
+    /** Script name to invoke (action type) */
+    invokeScript?: string;
+    /** How to display action result */
+    resultDisplay?: 'toast' | 'inline' | 'none';
+    /** Slider range */
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Sort order */
+    order?: number;
+}
+/** Machine hardware/OS info (reported by daemon, displayed by web) */
+export interface MachineInfo {
+    hostname: string;
+    platform: string;
+    arch: string;
+    cpus: number;
+    totalMem: number;
+    freeMem: number;
+    /** macOS: reclaimable-inclusive; prefer for UI used% */
+    availableMem?: number;
+    loadavg: number[];
+    uptime: number;
+    release: string;
+}
+/** Detected IDE on a machine */
+export interface DetectedIdeInfo {
+    type: string;
+    id?: string;
+    name: string;
+    running: boolean;
+    path?: 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 RecentLaunchEntry {
+    id: string;
+    providerType: string;
+    providerName: string;
+    kind: 'ide' | 'cli' | 'acp';
+    title?: string;
+    workspace?: string | null;
+    currentModel?: string;
+    lastLaunchedAt: number;
+}
+export interface StatusReportPayload {
+    /** Unique daemon instance identifier */
+    instanceId: string;
+    /** Daemon version */
+    version: string;
+    /** Daemon mode flag */
+    daemonMode: boolean;
+    /** Machine info */
+    machine: MachineInfo;
+    /** Machine nickname (user-set) */
+    machineNickname?: string | null;
+    /** Timestamp */
+    timestamp: number;
+    /** Detected IDEs on this machine */
+    detectedIdes: DetectedIdeInfo[];
+    /** P2P state */
+    p2p?: {
+        available: boolean;
+        state: string;
+        peers: number;
+        screenshotActive?: boolean;
+    };
+    /** Canonical daemon runtime sessions */
+    sessions: SessionEntry[];
+    /** Saved workspaces */
+    workspaces?: WorkspaceEntry[];
+    defaultWorkspaceId?: string | null;
+    defaultWorkspacePath?: string | null;
+    recentLaunches?: RecentLaunchEntry[];
+    terminalBackend?: TerminalBackendStatus;
+    /** Available providers (present in StatusSnapshot, optional in raw payload) */
+    availableProviders?: AvailableProviderInfo[];
+}

package/dist/status/builders.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Status Builders — shared conversion functions for ProviderState → ManagedEntry
+ *
+ * Used by:
+ *   - daemon-standalone (StandaloneServer.getStatus)
+ *   - DaemonStatusReporter
+ *
+ * Consolidates ProviderState→ManagedEntry mapping logic.
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { SessionEntry } from '../shared-types.js';
+import type { ProviderState } from '../providers/provider-instance.js';
+/**
+ * Find a CDP manager by key, with prefix matching for multi-window support.
+ *
+ * Lookup order:
+ *   1. Exact match: cdpManagers.get(key)
+ *   2. Prefix match: key starts with `${ideType}_` (multi-window: "cursor_remote_vs")
+ *   3. null
+ *
+ * This replaces raw `cdpManagers.get(ideType)` calls that broke when
+ * multi-window keys like "cursor_remote_vs" were used.
+ */
+export declare function findCdpManager(cdpManagers: Map<string, DaemonCdpManager>, key: string): DaemonCdpManager | null;
+/**
+ * Check if any CDP manager matches the given key (exact or prefix).
+ */
+export declare function hasCdpManager(cdpManagers: Map<string, DaemonCdpManager>, key: string): boolean;
+/**
+ * Check if any CDP manager matching the key is connected.
+ */
+export declare function isCdpConnected(cdpManagers: Map<string, DaemonCdpManager>, key: string): boolean;
+export declare function buildSessionEntries(allStates: ProviderState[], cdpManagers: Map<string, DaemonCdpManager>): SessionEntry[];

package/dist/status/normalize.d.ts

@@ -1 +1,14 @@
-export { x as ManagedStatus, X as isManagedStatusWaiting, Y as isManagedStatusWorking, a0 as normalizeActiveChatData, a1 as normalizeManagedStatus } from '../normalize-DVI4Lo5I.js';
+import type { ActiveChatData } from '../providers/provider-instance.js';
+export type ManagedStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+export declare function normalizeManagedStatus(status?: string | null, opts?: {
+    activeModal?: {
+        buttons?: unknown[] | null;
+    } | null;
+}): ManagedStatus;
+export declare function isManagedStatusWorking(status?: string | null): boolean;
+export declare function isManagedStatusWaiting(status?: string | null, opts?: {
+    activeModal?: {
+        buttons?: unknown[] | null;
+    } | null;
+}): boolean;
+export declare function normalizeActiveChatData<T extends ActiveChatData | null | undefined>(activeChat: T): T;

package/dist/status/reporter.d.ts

@@ -0,0 +1,69 @@
+/**
+ * DaemonStatusReporter — status collect & transmit (StatusReport / P2P / StatusEvent)
+ *
+ * Collect status from ProviderInstanceManager → assemble payload → transmit
+ * Each Instance manages its own status/transition. This module only assembles + transmits.
+ */
+import type { ProviderState } from '../providers/provider-instance.js';
+export interface StatusReporterDeps {
+    serverConn: {
+        isConnected(): boolean;
+        sendMessage(type: string, data: any): void;
+        getUserPlan(): string;
+    } | null;
+    cdpManagers: Map<string, {
+        isConnected: boolean;
+    }>;
+    p2p: {
+        isConnected: boolean;
+        isAvailable: boolean;
+        connectionState: string;
+        connectedPeerCount: number;
+        screenshotActive: boolean;
+        sendStatus(data: any): void;
+    } | null;
+    providerLoader: {
+        resolve(type: string): any;
+        getAll(): any[];
+    };
+    detectedIdes: any[];
+    instanceId: string;
+    daemonVersion?: string;
+    instanceManager: {
+        collectAllStates(): ProviderState[];
+        collectStatesByCategory(cat: string): ProviderState[];
+    };
+    getScreenshotUsage?: () => {
+        dailyUsedMinutes: number;
+        dailyBudgetMinutes: number;
+        budgetExhausted: boolean;
+    } | null;
+}
+export declare class DaemonStatusReporter {
+    private deps;
+    private log;
+    private lastStatusSentAt;
+    private statusPendingThrottle;
+    private lastP2PStatusHash;
+    private lastStatusSummary;
+    private statusTimer;
+    private p2pTimer;
+    constructor(deps: StatusReporterDeps, opts?: {
+        logFn?: (msg: string) => void;
+    });
+    startReporting(): void;
+    stopReporting(): void;
+    onStatusChange(): void;
+    throttledReport(): void;
+    emitStatusEvent(event: Record<string, unknown>): void;
+    removeAgentTracking(_key: string): void;
+    updateAgentStreams(_ideType: string, _streams: any[]): void;
+    /** Reset P2P dedup hash — forces next send to transmit even if content unchanged */
+    resetP2PHash(): void;
+    private ts;
+    sendUnifiedStatusReport(opts?: {
+        p2pOnly?: boolean;
+    }): Promise<void>;
+    private sendP2PPayload;
+    private simpleHash;
+}

package/dist/status/snapshot.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Shared status snapshot builders.
+ *
+ * Used by:
+ * - DaemonStatusReporter (cloud)
+ * - daemon-standalone HTTP/WS status responses
+ */
+import type { ProviderState } from '../providers/provider-instance.js';
+import type { AvailableProviderInfo, StatusReportPayload } from '../shared-types.js';
+export interface StatusSnapshotOptions {
+    allStates: ProviderState[];
+    cdpManagers: Map<string, unknown>;
+    providerLoader: {
+        getAll(): Array<{
+            type: string;
+            icon?: string;
+            displayName?: string;
+            category: 'ide' | 'extension' | 'cli' | 'acp';
+        }>;
+    };
+    detectedIdes: Array<{
+        id: string;
+        name?: string;
+        displayName?: string;
+        installed?: boolean;
+        path?: string;
+    }>;
+    instanceId: string;
+    version: string;
+    daemonMode: boolean;
+    timestamp?: number;
+    p2p?: StatusReportPayload['p2p'];
+    machineNickname?: string | null;
+}
+export interface StatusSnapshot extends StatusReportPayload {
+    availableProviders: AvailableProviderInfo[];
+}
+export declare function getSessionCompletionMarker(session: {
+    activeChat?: {
+        messages?: Array<{
+            role?: string;
+            id?: string;
+            index?: number;
+            timestamp?: number | string;
+            receivedAt?: number | string;
+            createdAt?: number | string;
+            _turnKey?: string;
+        }> | null;
+    } | null;
+}): string;
+export declare function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnapshot;

package/dist/system/host-memory.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Host memory metrics — macOS-aware "available" memory.
+ *
+ * Node's os.freemem() on darwin reports only the tiny truly-free pool; most RAM
+ * sits in inactive/file-backed cache that the OS can reclaim. Dashboard "used %"
+ * based on (total - freemem) looks ~99% almost always — misleading.
+ *
+ * On macOS we parse `vm_stat` and approximate available bytes as:
+ *   (free + inactive + speculative + purgeable [+ file_backed]) × page size
+ * (aligned with common Activity Monitor–style interpretations.)
+ */
+export interface HostMemorySnapshot {
+    totalMem: number;
+    /** Raw kernel "free" — small on macOS; kept for debugging / API compat */
+    freeMem: number;
+    /** Use this for UI "used %" — on darwin from vm_stat; else equals freeMem */
+    availableMem: number;
+}
+export declare function getHostMemorySnapshot(): HostMemorySnapshot;

package/dist/types.d.ts

@@ -0,0 +1,123 @@
+/**
+ * ADHDev Daemon Core — Shared Types
+ *
+ * Shared types referenced by daemon-core, daemon-standalone, and web-core.
+ * When modifying this file, also update interface contracts in AGENT_PROTOCOL.md.
+ */
+import type { StatusReportPayload, AvailableProviderInfo } from './shared-types.js';
+/** Full status response from /api/v1/status and WS events */
+export interface StatusResponse extends StatusReportPayload {
+    /** For standalone API compat */
+    id: string;
+    type: string;
+    platform: string;
+    hostname: string;
+    /** User display name from config */
+    userName?: string;
+    /** Available providers */
+    availableProviders: AvailableProviderInfo[];
+    /** System info (legacy compat) */
+    system?: SystemInfo;
+}
+export interface ChatMessage {
+    role: string;
+    /** Plain text (legacy) or rich content blocks (ACP standard) */
+    content: string | ContentBlock[];
+    kind?: string;
+    id?: string;
+    index?: number;
+    timestamp?: number;
+    receivedAt?: number;
+    /** Tool calls associated with this message */
+    toolCalls?: ToolCallInfo[];
+    /** Optional: fiber metadata */
+    _type?: string;
+    _sub?: string;
+    /** Meta information for thought/terminal logs etc */
+    meta?: {
+        label?: string;
+        isRunning?: boolean;
+    } | Record<string, any>;
+    /** Sender name for shared sessions */
+    senderName?: string;
+}
+import type { ContentBlock, ToolCallInfo } from './providers/contracts.js';
+export interface ExtensionInfo {
+    id: string;
+    type: string;
+    name: string;
+    isMonitored?: boolean;
+    agentStatus?: string;
+}
+export interface CommandResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+}
+export interface ProviderConfig {
+    id: string;
+    type: 'ide' | 'extension' | 'cli' | 'acp';
+    name: string;
+    /** CDP port detection */
+    cdpDetect?: {
+        processName?: string;
+        portFlag?: string;
+    };
+    /** Capabilities */
+    capabilities?: string[];
+}
+export type DaemonEvent = {
+    type: 'status';
+    data: StatusResponse;
+} | {
+    type: 'chat_update';
+    data: {
+        ideId: string;
+        messages: ChatMessage[];
+    };
+} | {
+    type: 'screenshot';
+    data: {
+        ideId: string;
+        base64: string;
+    };
+} | {
+    type: 'action_log';
+    data: {
+        ideId: string;
+        text: string;
+        timestamp: number;
+    };
+} | {
+    type: 'error';
+    data: {
+        message: string;
+    };
+};
+export interface SystemInfo {
+    cpus: number;
+    totalMem: number;
+    freeMem: number;
+    /** macOS: reclaimable-inclusive; prefer for UI used% (see host-memory.ts) */
+    availableMem?: number;
+    loadavg: number[];
+    uptime: number;
+    arch: string;
+}
+export interface DetectedIde {
+    id: string;
+    type: string;
+    name: string;
+    installed: boolean;
+    running: boolean;
+}
+export interface ProviderInfo extends AvailableProviderInfo {
+}
+/** Flattened agent entry from /api/v1/agents */
+export interface AgentEntry {
+    ideId: string;
+    type: string;
+    name: string;
+    status: string;
+    source: 'native' | 'extension';
+}

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.7.38",
+  "version": "0.7.40",
   "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.7.38",
+  "version": "0.7.40",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,8 @@
     }
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && npm run build:types",
+    "build:types": "tsc -p tsconfig.json --emitDeclarationOnly --declaration --declarationMap false",
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },

package/src/commands/cli-manager.ts

@@ -11,9 +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, addCliHistory } from '../config/config.js';
+import { loadConfig, saveConfig } from '../config/config.js';
 import { getWorkspaceState, resolveLaunchDirectory } from '../config/workspaces.js';
-import { appendWorkspaceActivity } from '../config/workspace-activity.js';
 import { appendRecentActivity } from '../config/recent-activity.js';
 import { CliProviderInstance } from '../providers/cli-provider-instance.js';
 import { AcpProviderInstance } from '../providers/acp-provider-instance.js';
@@ -91,25 +90,6 @@ export class DaemonCliManager {
         return `${cliType}_${hash}`;
     }
 
-    private persistRecentDir(cliType: string, dir: string): void {
-        try {
-            const normalizedType = this.providerLoader.resolveAlias(cliType);
-            const provider = this.providerLoader.getByAlias(cliType);
-            const actKind = provider?.category === 'acp' ? 'acp' : 'cli';
-            let next = loadConfig();
-            console.log(colorize('cyan', `  📂 Saving recent workspace: ${dir}`));
-            const recent = next.recentCliWorkspaces || [];
-            if (!recent.includes(dir)) {
-                next = { ...next, recentCliWorkspaces: [dir, ...recent].slice(0, 10) };
-            }
-            next = appendWorkspaceActivity(next, dir, { kind: actKind, agentType: normalizedType });
-            saveConfig(next);
-            console.log(colorize('green', `  ✓ Recent workspace saved: ${dir}`));
-        } catch (e) {
-            console.error(colorize('red', `  ✗ Failed to save recent workspace: ${e}`));
-        }
-    }
-
     private persistRecentActivity(entry: {
         kind: 'ide' | 'cli' | 'acp';
         providerType: string;
@@ -316,7 +296,6 @@ export class DaemonCliManager {
                 }
             }
 
-            try { addCliHistory({ category: 'acp', cliType: normalizedType, dir: resolvedDir, workspace: resolvedDir, cliArgs, model: initialModel }); } catch (e) { LOG.warn('CLI', `ACP history save failed: ${(e as Error)?.message}`); }
             this.persistRecentActivity({
                 kind: 'acp',
                 providerType: normalizedType,
@@ -393,7 +372,6 @@ export class DaemonCliManager {
             console.log(colorize('green', `  ✓ CLI started: ${cliInfo.displayName} v${cliInfo.version || 'unknown'} in ${resolvedDir}`));
         }
 
-        try { addCliHistory({ category: 'cli', cliType, dir: resolvedDir, workspace: resolvedDir, cliArgs, model: initialModel }); } catch (e) { LOG.warn('CLI', `CLI history save failed: ${(e as Error)?.message}`); }
         this.persistRecentActivity({
             kind: 'cli',
             providerType: normalizedType,
@@ -569,8 +547,6 @@ export class DaemonCliManager {
                     }
                 }
 
-                this.persistRecentDir(cliType, dir);
-
                 return { success: true, cliType, dir, id: newKey, launchSource };
             }
             case 'stop_cli': {
@@ -614,7 +590,6 @@ export class DaemonCliManager {
                 const found = this.findAdapter(cliType, { instanceKey: args?.targetSessionId, dir });
                 if (found) await this.stopSession(found.key);
                 await this.startSession(cliType, dir);
-                this.persistRecentDir(cliType, dir);
                 return { success: true, restarted: true };
             }
             case 'agent_command': {

package/src/commands/handler.ts

@@ -29,7 +29,6 @@ import * as Cdp from './cdp-commands.js';
 import * as Stream from './stream-commands.js';
 import * as WorkspaceCmd from './workspace-commands.js';
 import { getWorkspaceState } from '../config/workspaces.js';
-import { getWorkspaceActivity } from '../config/workspace-activity.js';
 
 export interface CommandResult {
     success: boolean;
@@ -416,27 +415,11 @@ export class DaemonCommandHandler implements CommandHelpers {
             case 'file_list': return Cdp.handleFileList(this, args);
             case 'file_list_browse': return Cdp.handleFileListBrowse(this, args);
 
-            // ─── VSCode API commands (not available) ────
-            case 'vscode_command_exec':
-            case 'execute_vscode_command': {
-                const resolvedCmd = args?.commandId || args?.command;
-                if (resolvedCmd === 'adhdev.captureCdpScreenshot') {
-                    return Cdp.handleScreenshot(this, args);
-                }
-                return { success: false, error: `VSCode command not available: ${resolvedCmd || cmd}` };
-            }
             // ─── Workspace cmds ──────────────
-            case 'get_recent_workspaces': return this.handleGetRecentWorkspaces(args);
-            case 'get_cli_history': {
-                const config = loadConfig();
-                return { success: true, history: config.cliHistory || [] };
-            }
-
             case 'workspace_list': return WorkspaceCmd.handleWorkspaceList();
             case 'workspace_add': return WorkspaceCmd.handleWorkspaceAdd(args);
             case 'workspace_remove': return WorkspaceCmd.handleWorkspaceRemove(args);
             case 'workspace_set_default':
-            case 'workspace_set_active':
                 return WorkspaceCmd.handleWorkspaceSetDefault(args);
 
             // ─── Script manage ───────────────────
@@ -476,20 +459,6 @@ export class DaemonCommandHandler implements CommandHelpers {
 
     // ─── Misc (kept in handler — too small to extract) ───────
 
-    private async handleGetRecentWorkspaces(_args: any): Promise<CommandResult> {
-        const config = loadConfig();
-        const cliRecent = config.recentCliWorkspaces || [];
-        const ws = getWorkspaceState(config);
-        return {
-            success: true,
-            result: cliRecent,
-            workspaces: ws.workspaces,
-            defaultWorkspaceId: ws.defaultWorkspaceId,
-            defaultWorkspacePath: ws.defaultWorkspacePath,
-            activity: getWorkspaceActivity(config, 25),
-        };
-    }
-
     private async handleRefreshScripts(_args: any): Promise<CommandResult> {
         if (this._ctx.providerLoader) {
             await this._ctx.providerLoader.fetchLatest().catch(() => {});