@adhdev/daemon-core 0.5.3 → 0.5.5

package/providers/_builtin/ide/cursor/scripts/0.49.bak/send_message.js

@@ -0,0 +1,23 @@
+/**
+ * Cursor — send_message
+ *
+ * Cursor는 cdp-type-and-send 방식:
+ *   1. 입력 필드 존재 확인
+ *   2. needsTypeAndSend: true 반환 → daemon이 CDP로 타이핑 + Enter 처리
+ *
+ * 입력 셀렉터: .aislash-editor-input[contenteditable="true"]
+ * 파라미터: ${ MESSAGE } (사용되지 않음 — daemon이 직접 타이핑)
+ */
+(() => {
+  try {
+    const input = document.querySelector('.aislash-editor-input[contenteditable="true"]');
+    if (!input) return JSON.stringify({ sent: false, error: 'Input box not found' });
+    return JSON.stringify({
+      sent: false,
+      needsTypeAndSend: true,
+      selector: '.aislash-editor-input[contenteditable="true"]',
+    });
+  } catch(e) {
+    return JSON.stringify({ sent: false, error: e.message });
+  }
+})()

package/providers/_builtin/ide/cursor/scripts/0.49.bak/set_mode.js

@@ -0,0 +1,38 @@
+/**
+ * Cursor — set_mode
+ *
+ * 모드 드롭다운에서 대상 모드 선택:
+ *   1. 드롭다운 열기
+ *   2. 매칭 아이템 클릭
+ *
+ * params.mode: string — 모드 이름
+ * → { success: true/false, mode? }
+ */
+async (params) => {
+  try {
+    const target = params.mode;
+
+    const modeBtn = document.querySelector('.composer-unified-dropdown:not(.composer-unified-dropdown-model)');
+    if (!modeBtn) return JSON.stringify({ success: false, error: 'Mode button not found' });
+
+    modeBtn.click();
+    await new Promise(r => setTimeout(r, 500));
+
+    const menu = document.querySelector('[data-testid="model-picker-menu"]') || document.querySelector('.typeahead-popover');
+    if (!menu) return JSON.stringify({ success: false, error: 'Mode menu not found' });
+
+    const items = menu.querySelectorAll('.composer-unified-context-menu-item');
+    for (const item of items) {
+      const nameEl = item.querySelector('.monaco-highlighted-label');
+      const name = nameEl?.textContent?.trim() || '';
+      if (name && (name === target || name.toLowerCase() === target.toLowerCase())) {
+        item.click();
+        await new Promise(r => setTimeout(r, 200));
+        return JSON.stringify({ success: true, mode: name });
+      }
+    }
+
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    return JSON.stringify({ success: false, error: 'mode not found: ' + target });
+  } catch(e) { return JSON.stringify({ success: false, error: e.message }); }
+}

package/providers/_builtin/ide/cursor/scripts/0.49.bak/set_model.js

@@ -0,0 +1,81 @@
+/**
+ * Cursor — set_model
+ *
+ * 모델 드롭다운에서 대상 모델 선택:
+ *   1. 드롭다운 열기
+ *   2. Auto 토글 끄기 (필요 시)
+ *   3. 검색 입력으로 필터
+ *   4. 매칭 아이템 클릭
+ *   5. 원래 Auto 상태 복원
+ *
+ * params.model: string — 모델 이름 (🧠 접미사 가능)
+ * → { success: true/false, model? }
+ */
+async (params) => {
+  try {
+    const target = params.model;
+
+    const modelBtn = document.querySelector('.composer-unified-dropdown-model');
+    if (!modelBtn) return JSON.stringify({ success: false, error: 'Model button not found' });
+
+    modelBtn.click();
+    await new Promise(r => setTimeout(r, 500));
+
+    const menu = document.querySelector('[data-testid="model-picker-menu"]');
+    if (!menu) return JSON.stringify({ success: false, error: 'Model picker menu not found' });
+
+    // 🧠 접미사 처리
+    const wantBrain = target.includes('🧠');
+    const searchName = target.replace(/\s*🧠\s*$/, '').trim();
+
+    // Auto 토글 끄기
+    const autoItem = menu.querySelector('.composer-unified-context-menu-item[data-is-selected="true"]');
+    const autoToggle = autoItem ? [...autoItem.querySelectorAll('[class*="rounded-full"]')].find(el => el.offsetWidth === 24 && el.offsetHeight === 14) : null;
+    let wasAutoOn = false;
+    if (autoToggle) {
+      const bgStyle = autoToggle.getAttribute('style') || '';
+      wasAutoOn = bgStyle.includes('green');
+      if (wasAutoOn) {
+        autoToggle.click();
+        await new Promise(r => setTimeout(r, 500));
+      }
+    }
+
+    // 검색 입력으로 필터링
+    const refreshedMenu = document.querySelector('[data-testid="model-picker-menu"]');
+    const searchInput = refreshedMenu?.querySelector('input[placeholder="Search models"]');
+    if (searchInput) {
+      searchInput.focus();
+      searchInput.value = searchName;
+      searchInput.dispatchEvent(new Event('input', { bubbles: true }));
+      await new Promise(r => setTimeout(r, 300));
+    }
+
+    // 아이템에서 찾기
+    const items = (refreshedMenu || menu).querySelectorAll('.composer-unified-context-menu-item');
+    for (const item of items) {
+      const nameEl = item.querySelector('.monaco-highlighted-label');
+      const name = nameEl?.textContent?.trim() || '';
+      if (!name || name === 'Add Models') continue;
+      const hasBrain = !!item.querySelector('[class*="codicon-br"]');
+
+      if (name.toLowerCase().includes(searchName.toLowerCase()) && hasBrain === wantBrain) {
+        item.click();
+        await new Promise(r => setTimeout(r, 200));
+        const displayName = hasBrain ? name + ' 🧠' : name;
+        return JSON.stringify({ success: true, model: displayName });
+      }
+    }
+
+    // Auto 복원 + 닫기
+    if (wasAutoOn) {
+      const nm = document.querySelector('[data-testid="model-picker-menu"]');
+      const nai = nm?.querySelector('.composer-unified-context-menu-item');
+      const nt = nai ? [...nai.querySelectorAll('[class*="rounded-full"]')].find(el => el.offsetWidth === 24) : null;
+      if (nt) nt.click();
+      await new Promise(r => setTimeout(r, 200));
+    }
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    return JSON.stringify({ success: false, error: 'model not found: ' + target });
+  } catch(e) { return JSON.stringify({ success: false, error: e.message }); }
+}

package/providers/_builtin/ide/cursor/scripts/0.49.bak/switch_session.js

@@ -0,0 +1,28 @@
+/**
+ * Cursor — switch_session
+ *
+ * 사이드바 셀 클릭으로 세션 전환:
+ *   제목 매칭 (params.title) 또는 인덱스 (params.index)
+ *
+ * params.index: number, params.title: string|null
+ * → { switched: true/false, title?, error? }
+ */
+(params) => {
+  try {
+    const cells = [...document.querySelectorAll('.agent-sidebar-cell')];
+    let target;
+    if (params.title) {
+      target = cells.find(c => {
+        const t = c.querySelector('.agent-sidebar-cell-text')?.textContent?.trim() || '';
+        return t.toLowerCase().includes(params.title.toLowerCase());
+      });
+    } else {
+      target = cells[params.index || 0];
+    }
+    if (!target) return JSON.stringify({ switched: false, error: 'Session not found', available: cells.length });
+    target.click();
+    return JSON.stringify({ switched: true, title: target.querySelector('.agent-sidebar-cell-text')?.textContent?.trim() });
+  } catch(e) {
+    return JSON.stringify({ switched: false, error: e.message });
+  }
+}

package/providers/_builtin/ide/windsurf/scripts/read_chat.js

@@ -86,6 +86,23 @@
         const title = document.title.split(' \u2014 ')[0].trim() || 'Cascade';
 
         // ─── 4. HTML → Markdown 변환기 ───
+        const BLOCK_TAGS = new Set(['DIV', 'P', 'BR', 'LI', 'TR', 'SECTION', 'ARTICLE', 'HEADER', 'FOOTER']);
+        function extractCodeText(node) {
+            if (node.nodeType === 3) return node.textContent || '';
+            if (node.nodeType !== 1) return '';
+            if (node.tagName === 'BR') return '\n';
+            const parts = [];
+            for (const child of node.childNodes) {
+                const isBlock = child.nodeType === 1 && BLOCK_TAGS.has(child.tagName);
+                const text = extractCodeText(child);
+                if (text) {
+                    if (isBlock && parts.length > 0) parts.push('\n');
+                    parts.push(text);
+                    if (isBlock) parts.push('\n');
+                }
+            }
+            return parts.join('').replace(/\n{2,}/g, '\n');
+        }
         function htmlToMd(node) {
             if (node.nodeType === 3) return node.textContent || '';
             if (node.nodeType !== 1) return '';
@@ -121,7 +138,7 @@
             if (tag === 'PRE') {
                 const codeEl = node.querySelector('code');
                 const lang = codeEl ? (codeEl.className.match(/language-(\w+)/)?.[1] || '') : '';
-                const code = (codeEl || node).textContent || '';
+                const code = extractCodeText(codeEl || node);
                 return '\n```' + lang + '\n' + code.trim() + '\n```\n';
             }
             if (tag === 'CODE') {

package/src/cli-adapters/provider-cli-adapter.ts

@@ -16,6 +16,7 @@
  */
 
 import * as os from 'os';
+import * as path from 'path';
 import { execSync } from 'child_process';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import { LOG } from '../logging/logger.js';
@@ -23,6 +24,22 @@ import { LOG } from '../logging/logger.js';
 let pty: any;
 try {
     pty = require('node-pty');
+    // node-pty@1.1.0 ships spawn-helper without +x on macOS — fix it
+    if (os.platform() !== 'win32') {
+        try {
+            const fs = require('fs');
+            const ptyDir = path.dirname(require.resolve('node-pty'));
+            const arch = os.arch() === 'arm64' ? 'darwin-arm64' : 'darwin-x64';
+            const helper = path.join(ptyDir, 'prebuilds', arch, 'spawn-helper');
+            if (fs.existsSync(helper)) {
+                const stat = fs.statSync(helper);
+                if (!(stat.mode & 0o111)) {
+                    fs.chmodSync(helper, stat.mode | 0o755);
+                    LOG.info('CLI', '[node-pty] Fixed spawn-helper permissions');
+                }
+            }
+        } catch { /* best-effort */ }
+    }
 } catch {
     LOG.error('CLI', '[ProviderCliAdapter] node-pty not found. Install: npm install node-pty@1.0.0');
 }
@@ -93,6 +110,124 @@ function findBinary(name: string): string {
     }
 }
 
+/** True if file starts with a UTF-8 BOM then #!, or plain #!. */
+function isScriptBinary(binaryPath: string): boolean {
+    if (!path.isAbsolute(binaryPath)) return false;
+    try {
+        const fs = require('fs');
+        const resolved = fs.realpathSync(binaryPath);
+        const head = Buffer.alloc(8);
+        const fd = fs.openSync(resolved, 'r');
+        fs.readSync(fd, head, 0, 8, 0);
+        fs.closeSync(fd);
+        let i = 0;
+        if (head[0] === 0xef && head[1] === 0xbb && head[2] === 0xbf) i = 3;
+        return head[i] === 0x23 && head[i + 1] === 0x21; // '#!'
+    } catch {
+        return false;
+    }
+}
+
+/** True only for Mach-O / ELF — npm shims and shell scripts return false. */
+function looksLikeMachOOrElf(filePath: string): boolean {
+    if (!path.isAbsolute(filePath)) return false;
+    try {
+        const fs = require('fs');
+        const resolved = fs.realpathSync(filePath);
+        const buf = Buffer.alloc(8);
+        const fd = fs.openSync(resolved, 'r');
+        fs.readSync(fd, buf, 0, 8, 0);
+        fs.closeSync(fd);
+        let i = 0;
+        if (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) i = 3;
+        const b = buf.subarray(i);
+        if (b.length < 4) return false;
+        // ELF
+        if (b[0] === 0x7f && b[1] === 0x45 && b[2] === 0x4c && b[3] === 0x46) return true;
+        const le = b.readUInt32LE(0);
+        const be = b.readUInt32BE(0);
+        const magics = [0xfeedface, 0xfeedfacf, 0xcafebabe, 0xbebafeca];
+        return magics.some(m => m === le || m === be);
+    } catch {
+        return false;
+    }
+}
+
+function shSingleQuote(arg: string): string {
+    if (/^[a-zA-Z0-9@%_+=:,./-]+$/.test(arg)) return arg;
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * provider.json stores regex placeholders as `{}` — JSON.parse leaves plain objects,
+ * so `.test` is missing and the PTY handler throws on first output. Coerce to RegExp
+ * (including `{ "source": "...", "flags": "i" }`) or fall back to generic TUIs (Claude Code, etc.).
+ */
+function parsePatternEntry(x: unknown): RegExp | null {
+    if (x instanceof RegExp) return x;
+    if (x && typeof x === 'object' && typeof (x as { source?: string }).source === 'string') {
+        try {
+            const s = x as { source: string; flags?: string };
+            return new RegExp(s.source, s.flags || '');
+        } catch {
+            return null;
+        }
+    }
+    return null;
+}
+
+function coercePatternArray(raw: unknown, fallbacks: RegExp[]): RegExp[] {
+    if (!Array.isArray(raw)) return [...fallbacks];
+    const parsed = raw.map(parsePatternEntry).filter((r): r is RegExp => r != null);
+    return parsed.length > 0 ? parsed : [...fallbacks];
+}
+
+/** Defaults tuned for Claude Code / similar agent CLIs when provider.json patterns are empty. */
+const FALLBACK_PROMPT: RegExp[] = [
+    /Type your message/i,
+    />\s*$/,
+    /[›➤]\s*$/,
+    /for shortcuts/i,
+    /\?\s*for help/i,
+    /Press enter/i,
+    /^[\s\u2500-\u257f]*>\s*$/m,
+];
+
+const FALLBACK_GENERATING: RegExp[] = [
+    /thinking/i,
+    /writing/i,
+    /Claude is/i,
+    /Opus|Sonnet|Haiku/i,
+    /[\u2800-\u28ff]/, // Braille spinner blocks
+];
+
+const FALLBACK_APPROVAL: RegExp[] = [
+    /approve/i,
+    /Allow( once)?/i,
+    /\(y\/n\)/i,
+    /\[Y\/n\]/i,
+    /continue\?/i,
+    /Run this command/i,
+];
+
+function defaultCleanOutput(raw: string, _lastUserInput?: string): string {
+    return stripAnsi(raw).trim();
+}
+
+export function normalizeCliProviderForRuntime(raw: any): CliProviderModule {
+    const patterns = raw?.patterns || {};
+    return {
+        ...raw,
+        patterns: {
+            prompt: coercePatternArray(patterns.prompt, FALLBACK_PROMPT),
+            generating: coercePatternArray(patterns.generating, FALLBACK_GENERATING),
+            approval: coercePatternArray(patterns.approval, FALLBACK_APPROVAL),
+            ready: coercePatternArray(patterns.ready, []),
+        },
+        cleanOutput: typeof raw?.cleanOutput === 'function' ? raw.cleanOutput : defaultCleanOutput,
+    };
+}
+
 export class ProviderCliAdapter implements CliAdapter {
     readonly cliType: string;
     readonly cliName: string;
@@ -129,7 +264,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private readonly timeouts: Required<NonNullable<CliProviderModule['timeouts']>>;
 
     constructor(provider: CliProviderModule, workingDir: string, private extraArgs: string[] = []) {
-        this.provider = provider;
+        this.provider = normalizeCliProviderForRuntime(provider);
         this.cliType = provider.type;
         this.cliName = provider.name;
         this.workingDir = workingDir.startsWith('~')
@@ -180,18 +315,28 @@ export class ProviderCliAdapter implements CliAdapter {
 
         let shellCmd: string;
         let shellArgs: string[];
-
-        if (spawnConfig.shell) {
- // Execute via shell (for gemini etc npm shim compat)
+        const useShellUnix = !isWin && (
+            !!spawnConfig.shell
+            || !path.isAbsolute(binaryPath)
+            || isScriptBinary(binaryPath)
+            || !looksLikeMachOOrElf(binaryPath)
+        );
+        const useShell = isWin ? !!spawnConfig.shell : useShellUnix;
+
+        if (useShell) {
+ // Execute via shell (npm shims, shebang scripts, anything that is not a bare Mach-O/ELF)
+            if (!spawnConfig.shell && !isWin) {
+                LOG.info('CLI', `[${this.cliType}] Using login shell (script shim or non-native binary)`);
+            }
             shellCmd = isWin ? 'cmd.exe' : (process.env.SHELL || '/bin/zsh');
-            const fullCmd = [binaryPath, ...allArgs].join(' ');
+            const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(' ');
             shellArgs = isWin ? ['/c', fullCmd] : ['-l', '-c', fullCmd];
         } else {
             shellCmd = binaryPath;
             shellArgs = allArgs;
         }
 
-        this.ptyProcess = pty.spawn(shellCmd, shellArgs, {
+        const ptyOpts = {
             name: 'xterm-256color',
             cols: 120,
             rows: 40,
@@ -200,7 +345,22 @@ export class ProviderCliAdapter implements CliAdapter {
                 ...process.env,
                 ...spawnConfig.env,
             } as Record<string, string>,
-        });
+        };
+
+        try {
+            this.ptyProcess = pty.spawn(shellCmd, shellArgs, ptyOpts);
+        } catch (err: any) {
+            const msg = err?.message || String(err);
+            if (!isWin && !useShell && /posix_spawn|spawn/i.test(msg)) {
+                LOG.warn('CLI', `[${this.cliType}] Direct spawn failed (${msg}), retrying via login shell`);
+                shellCmd = process.env.SHELL || '/bin/zsh';
+                const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(' ');
+                shellArgs = ['-l', '-c', fullCmd];
+                this.ptyProcess = pty.spawn(shellCmd, shellArgs, ptyOpts);
+            } else {
+                throw err;
+            }
+        }
 
         this.ptyProcess.onData((data: string) => {
             this.handleOutput(data);

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': {