@adhdev/daemon-core 0.5.3 → 0.5.5

package/src/commands/handler.ts

@@ -23,6 +23,9 @@ import { LOG } from '../logging/logger.js';
 import * as Chat from './chat-commands.js';
 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;
@@ -176,6 +179,11 @@ export class DaemonCommandHandler implements CommandHelpers {
 
     /** Extract ideType from _targetInstance */
     private extractIdeType(args: any): string | undefined {
+        // Also accept explicit ideType from args (agentType for extensions)
+        if (args?.ideType && this._ctx.cdpManagers.has(args.ideType)) {
+            return args.ideType;
+        }
+
         if (args?._targetInstance) {
             let raw = args._targetInstance as string;
             const ideMatch = raw.match(/:ide:(.+)$/);
@@ -189,8 +197,25 @@ export class DaemonCommandHandler implements CommandHelpers {
                 return this._ctx.instanceIdMap.get(raw)!;
             }
 
+            // Direct CDP manager key match (e.g. "cursor", "antigravity")
+            if (this._ctx.cdpManagers.has(raw)) {
+                return raw;
+            }
+
+            // Fallback: if no structured format matched and raw looks like a machine ID
+            // (e.g. "standalone_hostname"), find first available connected CDP
+            if (!ideMatch && !cliMatch && !acpMatch) {
+                for (const [key, mgr] of this._ctx.cdpManagers.entries()) {
+                    if (mgr.isConnected) return key;
+                }
+            }
+
+            // Legacy: strip trailing _N suffix (e.g. "cursor_1" → "cursor")
             const lastUnderscore = raw.lastIndexOf('_');
-            if (lastUnderscore > 0) return raw.substring(0, lastUnderscore);
+            if (lastUnderscore > 0) {
+                const stripped = raw.substring(0, lastUnderscore);
+                if (this._ctx.cdpManagers.has(stripped)) return stripped;
+            }
             return raw;
         }
         return undefined;
@@ -273,6 +298,17 @@ export class DaemonCommandHandler implements CommandHelpers {
             case 'get_commands':
                 return { success: false, error: `${cmd} requires bridge-extension (removed)` };
             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 ───────────────────
             case 'refresh_scripts': return this.handleRefreshScripts(args);
@@ -312,10 +348,18 @@ export class DaemonCommandHandler implements CommandHelpers {
 
     // ─── Misc (kept in handler — too small to extract) ───────
 
-    private async handleGetRecentWorkspaces(args: any): Promise<CommandResult> {
+    private async handleGetRecentWorkspaces(_args: any): Promise<CommandResult> {
         const config = loadConfig();
         const cliRecent = config.recentCliWorkspaces || [];
-        return { success: true, result: cliRecent };
+        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> {

package/src/commands/router.ts

@@ -17,6 +17,9 @@ import { DaemonCliManager } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { launchWithCdp } 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 { detectIDEs } from '../detection/ide-detector.js';
 import { LOG } from '../logging/logger.js';
 import { logCommand } from '../logging/command-log.js';
@@ -185,8 +188,20 @@ export class DaemonCommandRouter {
 
             // ─── IDE launch + CDP connect ───
             case 'launch_ide': {
-                const launchArgs = { ...args, ideId: args?.ideId || args?.ideType };
-                const ideKey = launchArgs.ideId;
+                const ideKey = args?.ideId || args?.ideType;
+                const resolvedWorkspace = resolveIdeLaunchWorkspace(
+                    {
+                        workspace: args?.workspace,
+                        workspaceId: args?.workspaceId,
+                        useDefaultWorkspace: args?.useDefaultWorkspace,
+                    },
+                    loadConfig(),
+                );
+                const launchArgs = {
+                    ideId: ideKey,
+                    workspace: resolvedWorkspace,
+                    newWindow: args?.newWindow,
+                };
                 LOG.info('LaunchIDE', `target=${ideKey || 'auto'}`);
                 const result = await launchWithCdp(launchArgs);
 
@@ -209,6 +224,14 @@ export class DaemonCommandRouter {
                     }
                 }
                 this.deps.onIdeConnected?.();
+                if (result.success && resolvedWorkspace) {
+                    try {
+                        saveConfig(appendWorkspaceActivity(loadConfig(), resolvedWorkspace, {
+                            kind: 'ide',
+                            agentType: result.ideId,
+                        }));
+                    } catch { /* ignore activity persist errors */ }
+                }
                 return { success: result.success, ...result as any };
             }
 
@@ -217,6 +240,13 @@ export class DaemonCommandRouter {
                 this.deps.detectedIdes.value = await detectIDEs();
                 return { success: true, ides: this.deps.detectedIdes.value };
             }
+
+            // ─── Machine Settings ───
+            case 'set_machine_nickname': {
+                const nickname = args?.nickname;
+                updateConfig({ machineNickname: nickname || null });
+                return { success: true };
+            }
         }
 
         return null; // Not handled at this level → delegate to CommandHandler

package/src/commands/workspace-commands.ts

@@ -0,0 +1,108 @@
+/**
+ * workspace_* commands — list/add/remove/default (config.json)
+ */
+
+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 };
+
+export function handleWorkspaceList(): WorkspaceCommandResult {
+    const config = loadConfig();
+    const state = W.getWorkspaceState(config);
+    return {
+        success: true,
+        workspaces: state.workspaces,
+        defaultWorkspaceId: state.defaultWorkspaceId,
+        defaultWorkspacePath: state.defaultWorkspacePath,
+        legacyRecentPaths: config.recentCliWorkspaces || [],
+        activity: getWorkspaceActivity(config, 25),
+    };
+}
+
+export function handleWorkspaceAdd(args: any): WorkspaceCommandResult {
+    const rawPath = (args?.path || args?.dir || '').trim();
+    const label = (args?.label || '').trim() || undefined;
+    if (!rawPath) return { success: false, error: 'path required' };
+
+    const config = loadConfig();
+    const result = W.addWorkspaceEntry(config, rawPath, label);
+    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) };
+}
+
+export function handleWorkspaceRemove(args: any): WorkspaceCommandResult {
+    const id = (args?.id || '').trim();
+    if (!id) return { success: false, error: 'id required' };
+
+    const config = loadConfig();
+    const removed = (config.workspaces || []).find(w => w.id === id);
+    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) };
+}
+
+export function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult {
+    const clear = args?.clear === true || args?.id === null || args?.id === '';
+    if (clear) {
+        const config = loadConfig();
+        const result = W.setDefaultWorkspaceId(config, null);
+        if ('error' in result) return { success: false, error: result.error };
+        saveConfig(result.config);
+        const state = W.getWorkspaceState(result.config);
+        return {
+            success: true,
+            ...state,
+            activity: getWorkspaceActivity(result.config, 25),
+        };
+    }
+
+    const pathArg = (args?.path != null && String(args.path).trim()) ? String(args.path).trim() : '';
+    const idArg = args?.id !== undefined && args?.id !== null && String(args.id).trim()
+        ? String(args.id).trim()
+        : '';
+
+    if (!pathArg && !idArg) {
+        return { success: false, error: 'id or path required (or clear: true)' };
+    }
+
+    let config = loadConfig();
+    let nextId: string;
+
+    if (pathArg) {
+        let w = W.findWorkspaceByPath(config, pathArg);
+        if (!w) {
+            const add = W.addWorkspaceEntry(config, pathArg);
+            if ('error' in add) return { success: false, error: add.error };
+            config = add.config;
+            w = add.entry;
+        }
+        nextId = w.id;
+    } else {
+        nextId = idArg;
+    }
+
+    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) };
+}

package/src/config/config.ts

@@ -7,6 +7,11 @@
 import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'fs';
+import { migrateWorkspacesFromRecent } from './workspaces.js';
+import type { WorkspaceEntry } from './workspaces.js';
+import type { WorkspaceActivityEntry } from './workspace-activity.js';
+export type { WorkspaceEntry } from './workspaces.js';
+export type { WorkspaceActivityEntry } from './workspace-activity.js';
 
 export interface ADHDevConfig {
  // Server connection
@@ -42,6 +47,14 @@ export interface ADHDevConfig {
     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[];
+
  // Machine nickname (user-customizable label for this machine)
     machineNickname: string | null;
 
@@ -81,6 +94,9 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     configuredCLIs: [],
     enabledIdes: [],
     recentCliWorkspaces: [],
+    workspaces: [],
+    defaultWorkspaceId: null,
+    recentWorkspaceActivity: [],
     machineNickname: null,
     cliHistory: [],
     providerSettings: {},
@@ -118,7 +134,19 @@ export function loadConfig(): ADHDevConfig {
     try {
         const raw = readFileSync(configPath, 'utf-8');
         const parsed = JSON.parse(raw);
-        return { ...DEFAULT_CONFIG, ...parsed };
+        const merged = { ...DEFAULT_CONFIG, ...parsed } as ADHDevConfig & { activeWorkspaceId?: string | null };
+        if (merged.defaultWorkspaceId == null && merged.activeWorkspaceId != null) {
+            (merged as ADHDevConfig).defaultWorkspaceId = merged.activeWorkspaceId;
+        }
+        delete (merged as any).activeWorkspaceId;
+        const hadStoredWorkspaces = Array.isArray(parsed.workspaces) && parsed.workspaces.length > 0;
+        migrateWorkspacesFromRecent(merged);
+        if (!hadStoredWorkspaces && (merged.workspaces?.length || 0) > 0) {
+            try {
+                saveConfig(merged);
+            } catch { /* ignore */ }
+        }
+        return merged;
     } catch {
         return { ...DEFAULT_CONFIG };
     }

package/src/config/workspace-activity.ts

@@ -0,0 +1,65 @@
+/**
+ * Recent workspace activity — quick "pick up where you left off" (daemon-local).
+ */
+
+import * as path from 'path';
+import type { ADHDevConfig } from './config.js';
+import { expandPath } from './workspaces.js';
+
+export interface WorkspaceActivityEntry {
+    path: string;
+    lastUsedAt: number;
+    /** `active` legacy — same meaning as default */
+    kind?: 'ide' | 'cli' | 'acp' | 'default' | 'active';
+    /** IDE id or CLI/ACP provider type */
+    agentType?: string;
+}
+
+const MAX_ACTIVITY = 30;
+
+export function normWorkspacePath(p: string): string {
+    try {
+        return path.resolve(expandPath(p));
+    } catch {
+        return path.resolve(p);
+    }
+}
+
+/**
+ * Append or bump a path to the front of recent activity (returns new config object).
+ */
+export function appendWorkspaceActivity(
+    config: ADHDevConfig,
+    rawPath: string,
+    meta?: { kind?: WorkspaceActivityEntry['kind']; agentType?: string },
+): ADHDevConfig {
+    const abs = normWorkspacePath(rawPath);
+    if (!abs) return config;
+
+    const prev = config.recentWorkspaceActivity || [];
+    const filtered = prev.filter(e => normWorkspacePath(e.path) !== abs);
+    const entry: WorkspaceActivityEntry = {
+        path: abs,
+        lastUsedAt: Date.now(),
+        kind: meta?.kind,
+        agentType: meta?.agentType,
+    };
+    const recentWorkspaceActivity = [entry, ...filtered].slice(0, MAX_ACTIVITY);
+    return { ...config, recentWorkspaceActivity };
+}
+
+export function getWorkspaceActivity(config: ADHDevConfig, limit = 20): WorkspaceActivityEntry[] {
+    const list = [...(config.recentWorkspaceActivity || [])];
+    list.sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+    return list.slice(0, limit);
+}
+
+export function removeActivityForPath(config: ADHDevConfig, rawPath: string): ADHDevConfig {
+    const n = normWorkspacePath(rawPath);
+    return {
+        ...config,
+        recentWorkspaceActivity: (config.recentWorkspaceActivity || []).filter(
+            e => normWorkspacePath(e.path) !== n,
+        ),
+    };
+}

package/src/config/workspaces.ts

@@ -0,0 +1,250 @@
+/**
+ * Saved workspaces — shared by IDE launch, CLI, ACP (daemon-local).
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+import type { ADHDevConfig } from './config.js';
+
+export interface WorkspaceEntry {
+    id: string;
+    path: string;
+    label?: string;
+    addedAt: number;
+}
+
+const MAX_WORKSPACES = 50;
+
+export function expandPath(p: string): string {
+    const t = (p || '').trim();
+    if (!t) return '';
+    if (t.startsWith('~')) return path.join(os.homedir(), t.slice(1).replace(/^\//, ''));
+    return path.resolve(t);
+}
+
+export function validateWorkspacePath(absPath: string): { ok: true } | { ok: false; error: string } {
+    try {
+        if (!absPath) return { ok: false, error: 'Path required' };
+        if (!fs.existsSync(absPath)) return { ok: false, error: 'Path does not exist' };
+        const st = fs.statSync(absPath);
+        if (!st.isDirectory()) return { ok: false, error: 'Not a directory' };
+        return { ok: true };
+    } catch (e: any) {
+        return { ok: false, error: e?.message || 'Invalid path' };
+    }
+}
+
+/** Default workspace label from path */
+export function defaultWorkspaceLabel(absPath: string): string {
+    const base = path.basename(absPath) || absPath;
+    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;
+    const w = (config.workspaces || []).find(x => x.id === id);
+    if (!w) return null;
+    const abs = expandPath(w.path);
+    if (validateWorkspacePath(abs).ok !== true) return null;
+    return abs;
+}
+
+export function getWorkspaceState(config: ADHDevConfig): {
+    workspaces: WorkspaceEntry[];
+    defaultWorkspaceId: string | null;
+    defaultWorkspacePath: string | null;
+} {
+    const workspaces = [...(config.workspaces || [])].sort((a, b) => b.addedAt - a.addedAt);
+    const defaultWorkspacePath = getDefaultWorkspacePath(config);
+    return {
+        workspaces,
+        defaultWorkspaceId: config.defaultWorkspaceId ?? null,
+        defaultWorkspacePath,
+    };
+}
+
+export type LaunchDirectorySource = 'dir' | 'workspaceId' | 'defaultWorkspace' | 'home';
+
+export type ResolveLaunchDirectoryResult =
+    | { ok: true; path: string; source: LaunchDirectorySource }
+    | { ok: false; code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED'; message: string };
+
+/**
+ * Resolve cwd for CLI/ACP. No implicit default workspace or home — caller must pass
+ * useDefaultWorkspace or useHome (or an explicit dir / workspaceId).
+ */
+export function resolveLaunchDirectory(
+    args: {
+        dir?: string;
+        workspaceId?: string;
+        useDefaultWorkspace?: boolean;
+        useHome?: boolean;
+    } | undefined,
+    config: ADHDevConfig,
+): ResolveLaunchDirectoryResult {
+    const a = args || {};
+    if (a.dir != null && String(a.dir).trim()) {
+        const abs = expandPath(String(a.dir).trim());
+        if (abs && validateWorkspacePath(abs).ok === true) {
+            return { ok: true, path: abs, source: 'dir' };
+        }
+        return {
+            ok: false,
+            code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED',
+            message: abs ? 'Directory path is not valid or does not exist' : 'Invalid directory path',
+        };
+    }
+    if (a.workspaceId) {
+        const w = (config.workspaces || []).find(x => x.id === a.workspaceId);
+        if (w) {
+            const abs = expandPath(w.path);
+            if (validateWorkspacePath(abs).ok === true) {
+                return { ok: true, path: abs, source: 'workspaceId' };
+            }
+        }
+        return {
+            ok: false,
+            code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED',
+            message: 'Saved workspace not found or path is no longer valid',
+        };
+    }
+    if (a.useDefaultWorkspace === true) {
+        const d = getDefaultWorkspacePath(config);
+        if (d) return { ok: true, path: d, source: 'defaultWorkspace' };
+        return {
+            ok: false,
+            code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED',
+            message: 'No default workspace is set',
+        };
+    }
+    if (a.useHome === true) {
+        return { ok: true, path: os.homedir(), source: 'home' };
+    }
+    return {
+        ok: false,
+        code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED',
+        message: 'Choose a directory, saved workspace, default workspace, or home before launching.',
+    };
+}
+
+/**
+ * IDE folder from explicit args only (`workspace`, `workspaceId`, or `useDefaultWorkspace: true`).
+ */
+export function resolveIdeWorkspaceFromArgs(
+    args: {
+        workspace?: string;
+        workspaceId?: string;
+        useDefaultWorkspace?: boolean;
+    } | undefined,
+    config: ADHDevConfig,
+): string | undefined {
+    const ar = args || {};
+    if (ar.workspace) {
+        const abs = expandPath(ar.workspace);
+        if (abs && validateWorkspacePath(abs).ok === true) return abs;
+    }
+    if (ar.workspaceId) {
+        const w = (config.workspaces || []).find(x => x.id === ar.workspaceId);
+        if (w) {
+            const abs = expandPath(w.path);
+            if (validateWorkspacePath(abs).ok === true) return abs;
+        }
+    }
+    if (ar.useDefaultWorkspace === true) {
+        return getDefaultWorkspacePath(config) || undefined;
+    }
+    return undefined;
+}
+
+/**
+ * IDE launch folder — same saved workspaces + default as CLI/ACP.
+ * After explicit `workspace` / `workspaceId` / `useDefaultWorkspace: true`, falls back to
+ * config default workspace when set. Pass `useDefaultWorkspace: false` to open IDE without that folder.
+ */
+export function resolveIdeLaunchWorkspace(
+    args: {
+        workspace?: string;
+        workspaceId?: string;
+        useDefaultWorkspace?: boolean;
+    } | undefined,
+    config: ADHDevConfig,
+): string | undefined {
+    const direct = resolveIdeWorkspaceFromArgs(args, config);
+    if (direct) return direct;
+    if (args?.useDefaultWorkspace === false) return undefined;
+    return getDefaultWorkspacePath(config) || undefined;
+}
+
+export function findWorkspaceByPath(config: ADHDevConfig, rawPath: string): WorkspaceEntry | undefined {
+    const abs = path.resolve(expandPath(rawPath));
+    if (!abs) return undefined;
+    return (config.workspaces || []).find(w => path.resolve(expandPath(w.path)) === abs);
+}
+
+export function addWorkspaceEntry(config: ADHDevConfig, rawPath: string, label?: string): { config: ADHDevConfig; entry: WorkspaceEntry } | { error: string } {
+    const abs = expandPath(rawPath);
+    const v = validateWorkspacePath(abs);
+    if (!v.ok) return { error: v.error };
+
+    const list = [...(config.workspaces || [])];
+    if (list.some(w => path.resolve(w.path) === abs)) {
+        return { error: 'Workspace already in list' };
+    }
+    if (list.length >= MAX_WORKSPACES) {
+        return { error: `Maximum ${MAX_WORKSPACES} workspaces` };
+    }
+    const entry: WorkspaceEntry = {
+        id: randomUUID(),
+        path: abs,
+        label: (label || '').trim() || defaultWorkspaceLabel(abs),
+        addedAt: Date.now(),
+    };
+    list.push(entry);
+    return { config: { ...config, workspaces: list }, entry };
+}
+
+export function removeWorkspaceEntry(config: ADHDevConfig, id: string): { config: ADHDevConfig } | { error: string } {
+    const list = (config.workspaces || []).filter(w => w.id !== id);
+    if (list.length === (config.workspaces || []).length) return { error: 'Workspace not found' };
+    let defaultWorkspaceId = config.defaultWorkspaceId;
+    if (defaultWorkspaceId === id) defaultWorkspaceId = null;
+    return { config: { ...config, workspaces: list, defaultWorkspaceId } };
+}
+
+export function setDefaultWorkspaceId(config: ADHDevConfig, id: string | null): { config: ADHDevConfig } | { error: string } {
+    if (id === null) {
+        return { config: { ...config, defaultWorkspaceId: null } };
+    }
+    const w = (config.workspaces || []).find(x => x.id === id);
+    if (!w) return { error: 'Workspace not found' };
+    const abs = expandPath(w.path);
+    if (validateWorkspacePath(abs).ok !== true) return { error: 'Workspace path is no longer valid' };
+    return { config: { ...config, defaultWorkspaceId: id } };
+}

package/src/daemon/dev-server.ts

@@ -2238,7 +2238,7 @@ export class DevServer {
     lines.push('## Required Return Format');
     lines.push('| Function | Return JSON |');
     lines.push('|---|---|');
-    lines.push('| readChat | `{ id, status, title, messages: [{role, content, index}], inputContent, activeModal }` |');
+    lines.push('| readChat | `{ id, status, title, messages: [{role, content, index, kind?, meta?}], inputContent, activeModal }` — optional `kind`: standard, thought, tool, terminal; optional `meta`: e.g. `{ label, isRunning }` for dashboard |');
     lines.push('| sendMessage | `{ sent: false, needsTypeAndSend: true, selector }` |');
     lines.push('| resolveAction | `{ resolved: true/false, clicked? }` |');
     lines.push('| listSessions | `{ sessions: [{ id, title, active, index }] }` |');

package/src/index.ts

@@ -29,11 +29,16 @@ export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
 
 // ── Config ──
 export { loadConfig, saveConfig, resetConfig, isSetupComplete, addCliHistory, markSetupComplete, updateConfig } from './config/config.js';
+export { getWorkspaceState } from './config/workspaces.js';
+export { getWorkspaceActivity } from './config/workspace-activity.js';
+export type { WorkspaceEntry } from './config/workspaces.js';
 
 // ── Detection ──
 export { detectIDEs } from './detection/ide-detector.js';
 export type { IDEInfo } from './detection/ide-detector.js';
 export { detectCLIs } from './detection/cli-detector.js';
+export { getHostMemorySnapshot } from './system/host-memory.js';
+export type { HostMemorySnapshot } from './system/host-memory.js';
 
 // ── CDP ──
 export { DaemonCdpManager } from './cdp/manager.js';

package/src/launch.ts

@@ -224,7 +224,7 @@ function detectCurrentWorkspace(ideId: string): string | undefined {
                 );
                 if (fs.existsSync(storagePath)) {
                     const data = JSON.parse(fs.readFileSync(storagePath, 'utf-8'));
- // openedPathsList.workspaces3 has recent folders
+ // openedPathsList.workspaces3 has recent workspace paths
                     const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
                     if (workspaces.length > 0) {
                         const recent = workspaces[0];