@adhdev/daemon-core 0.5.3 → 0.5.6

package/src/commands/cli-manager.ts

@@ -12,6 +12,8 @@ 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 { getWorkspaceState, resolveLaunchDirectory } from '../config/workspaces.js';
+import { appendWorkspaceActivity } from '../config/workspace-activity.js';
 import { CliProviderInstance } from '../providers/cli-provider-instance.js';
 import { AcpProviderInstance } from '../providers/acp-provider-instance.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
@@ -54,6 +56,25 @@ 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(chalk.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(chalk.green(`  ✓ Recent workspace saved: ${dir}`));
+        } catch (e) {
+            console.error(chalk.red(`  ✗ Failed to save recent workspace: ${e}`));
+        }
+    }
+
     private createAdapter(cliType: string, workingDir: string, cliArgs?: string[]): CliAdapter {
  // cliType normalize (Resolve alias)
         const normalizedType = this.providerLoader.resolveAlias(cliType);
@@ -71,7 +92,8 @@ export class DaemonCliManager {
  // ─── Session start/management ──────────────────────────────
 
     async startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string): Promise<void> {
-        const trimmed = (workingDir || os.homedir()).trim();
+        const trimmed = (workingDir || '').trim();
+        if (!trimmed) throw new Error('working directory required');
         const resolvedDir = trimmed.startsWith('~')
             ? trimmed.replace(/^~/, os.homedir())
             : path.resolve(trimmed);
@@ -161,21 +183,54 @@ export class DaemonCliManager {
         const instanceManager = this.deps.getInstanceManager();
         if (provider && instanceManager) {
             const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key);
-            await instanceManager.addInstance(key, cliInstance, {
-                serverConn: this.deps.getServerConn(),
-                settings: {},
-                onPtyData: (data: string) => {
-                    this.deps.getP2p()?.broadcastPtyOutput(key, data);
-                },
-            });
+            try {
+                await instanceManager.addInstance(key, cliInstance, {
+                    serverConn: this.deps.getServerConn(),
+                    settings: {},
+                    onPtyData: (data: string) => {
+                        this.deps.getP2p()?.broadcastPtyOutput(key, data);
+                    },
+                });
+            } catch (spawnErr: any) {
+                // Spawn failed — cleanup and propagate error
+                LOG.error('CLI', `[${cliType}] Spawn failed: ${spawnErr?.message}`);
+                instanceManager.removeInstance(key);
+                throw new Error(`Failed to start ${cliInfo.displayName}: ${spawnErr?.message}`);
+            }
 
  // Keep adapter ref too (backward compat — write, resize etc)
             this.adapters.set(key, cliInstance.getAdapter() as any);
             console.log(chalk.green(`  ✓ CLI started: ${cliInfo.displayName} v${cliInfo.version || 'unknown'} in ${resolvedDir}`));
+
+            // Monitor for stopped/error → auto-cleanup
+            const checkStopped = setInterval(() => {
+                try {
+                    const adapter = this.adapters.get(key);
+                    if (!adapter) { clearInterval(checkStopped); return; }
+                    const status = adapter.getStatus?.();
+                    if (status?.status === 'stopped' || status?.status === 'error') {
+                        clearInterval(checkStopped);
+                        setTimeout(() => {
+                            if (this.adapters.has(key)) {
+                                this.adapters.delete(key);
+                                this.deps.removeAgentTracking(key);
+                                instanceManager.removeInstance(key);
+                                LOG.info('CLI', `🧹 Auto-cleaned ${status.status} CLI: ${cliType}`);
+                                this.deps.onStatusChange();
+                            }
+                        }, 5000);
+                    }
+                } catch { /* ignore */ }
+            }, 3000);
         } else {
  // Fallback: InstanceManager without directly adapter manage
             const adapter = this.createAdapter(cliType, resolvedDir, cliArgs);
-            await adapter.spawn();
+            try {
+                await adapter.spawn();
+            } catch (spawnErr: any) {
+                LOG.error('CLI', `[${cliType}] Spawn failed: ${spawnErr?.message}`);
+                throw new Error(`Failed to start ${cliInfo.displayName}: ${spawnErr?.message}`);
+            }
 
             const serverConn = this.deps.getServerConn();
             if (serverConn && typeof adapter.setServerConn === 'function') {
@@ -184,12 +239,12 @@ export class DaemonCliManager {
             adapter.setOnStatusChange(() => {
                 this.deps.onStatusChange();
                 const status = adapter.getStatus?.();
-                if (status?.status === 'stopped') {
+                if (status?.status === 'stopped' || status?.status === 'error') {
                     setTimeout(() => {
                         if (this.adapters.get(key) === adapter) {
                             this.adapters.delete(key);
                             this.deps.removeAgentTracking(key);
-                            console.log(chalk.yellow(`  🧹 Auto-cleaned stopped CLI: ${adapter.cliType}`));
+                            LOG.info('CLI', `🧹 Auto-cleaned ${status.status} CLI: ${adapter.cliType}`);
                             this.deps.onStatusChange();
                         }
                     }, 3000);
@@ -214,13 +269,26 @@ export class DaemonCliManager {
     async stopSession(key: string): Promise<void> {
         const adapter = this.adapters.get(key);
         if (adapter) {
-            adapter.shutdown();
+            try {
+                adapter.shutdown();
+            } catch (e: any) {
+                LOG.warn('CLI', `Shutdown error for ${adapter.cliType}: ${e?.message} (force-cleaning)`);
+            }
+            // Always cleanup regardless of shutdown success
             this.adapters.delete(key);
             this.deps.removeAgentTracking(key);
- // Also remove from InstanceManager
             this.deps.getInstanceManager()?.removeInstance(key);
-            console.log(chalk.yellow(`  🛑 CLI Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`));
+            LOG.info('CLI', `🛑 Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
             this.deps.onStatusChange();
+        } else {
+            // Adapter not found — try InstanceManager direct removal
+            const im = this.deps.getInstanceManager();
+            if (im) {
+                im.removeInstance(key);
+                this.deps.removeAgentTracking(key);
+                LOG.warn('CLI', `🧹 Force-removed orphan entry: ${key}`);
+                this.deps.onStatusChange();
+            }
         }
     }
 
@@ -270,8 +338,28 @@ export class DaemonCliManager {
         switch (cmd) {
             case 'launch_cli': {
                 const cliType = args?.cliType;
-                const defaultedToHome = !args?.dir;
-                const dir = args?.dir || os.homedir();
+                const config = loadConfig();
+                const resolved = resolveLaunchDirectory(
+                    {
+                        dir: args?.dir,
+                        workspaceId: args?.workspaceId,
+                        useDefaultWorkspace: args?.useDefaultWorkspace === true,
+                        useHome: args?.useHome === true,
+                    },
+                    config,
+                );
+                if (!resolved.ok) {
+                    const ws = getWorkspaceState(config);
+                    return {
+                        success: false,
+                        error: resolved.message,
+                        code: resolved.code,
+                        workspaces: ws.workspaces,
+                        defaultWorkspacePath: ws.defaultWorkspacePath,
+                    };
+                }
+                const dir = resolved.path;
+                const launchSource = resolved.source;
                 if (!cliType) throw new Error('cliType required');
 
                 await this.startSession(cliType, dir, args?.cliArgs, args?.initialModel);
@@ -284,20 +372,9 @@ export class DaemonCliManager {
                     }
                 }
 
-                try {
-                    const config = loadConfig();
-                    console.log(chalk.cyan(`  📂 Saving recent workspace: ${dir}`));
-                    const recent = config.recentCliWorkspaces || [];
-                    if (!recent.includes(dir)) {
-                        const updated = [dir, ...recent].slice(0, 10);
-                        saveConfig({ ...config, recentCliWorkspaces: updated });
-                        console.log(chalk.green(`  ✓ Recent workspace saved: ${dir}`));
-                    }
-                } catch (e) {
-                    console.error(chalk.red(`  ✗ Failed to save recent workspace: ${e}`));
-                }
+                this.persistRecentDir(cliType, dir);
 
-                return { success: true, cliType, dir, id: newKey, defaultedToHome };
+                return { success: true, cliType, dir, id: newKey, launchSource };
             }
             case 'stop_cli': {
                 const cliType = args?.cliType;
@@ -314,11 +391,32 @@ export class DaemonCliManager {
             }
             case 'restart_session': {
                 const cliType = args?.cliType || args?.agentType || args?.ideType;
-                const dir = args?.dir || process.cwd();
+                const cfg = loadConfig();
+                const rdir = resolveLaunchDirectory(
+                    {
+                        dir: args?.dir,
+                        workspaceId: args?.workspaceId,
+                        useDefaultWorkspace: args?.useDefaultWorkspace === true,
+                        useHome: args?.useHome === true,
+                    },
+                    cfg,
+                );
+                if (!rdir.ok) {
+                    const ws = getWorkspaceState(cfg);
+                    return {
+                        success: false,
+                        error: rdir.message,
+                        code: rdir.code,
+                        workspaces: ws.workspaces,
+                        defaultWorkspacePath: ws.defaultWorkspacePath,
+                    };
+                }
+                const dir = rdir.path;
                 if (!cliType) throw new Error('cliType required');
                 const found = this.findAdapter(cliType, { instanceKey: args?._targetInstance, 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

@@ -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,
+        ),
+    };
+}