@adhdev/daemon-core 0.6.75 → 0.6.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.75",
+  "version": "0.6.77",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -146,6 +146,25 @@ function stripAnsi(str: string): string {
         .replace(/  +/g, ' ');
 }
 
+function stripTerminalNoise(str: string): string {
+    return String(str || '')
+        // Remove remaining C0/C1 control chars except newlines/tabs.
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, '')
+        // Drop common terminal negotiation/report fragments that can remain after ANSI stripping.
+        .replace(/(^|[\s([])(?:\??\d{1,4}(?:;\d{1,4})*[A-Za-z])(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:\[\??\d{1,4}(?:;\d{1,4})*[A-Za-z])(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:\d{1,4};\?)(?=$|[\s)\]])/g, '$1')
+        .replace(/\r+/g, '\n')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/ {2,}/g, ' ');
+}
+
+function sanitizeTerminalText(str: string): string {
+    return stripTerminalNoise(stripAnsi(str));
+}
+
 function findBinary(name: string): string {
     const isWin = os.platform() === 'win32';
     try {
@@ -370,6 +389,9 @@ export class ProviderCliAdapter implements CliAdapter {
  // Approval state machine
     private approvalTransitionBuffer: string = '';
     private approvalExitTimeout: NodeJS.Timeout | null = null;
+    private pendingScriptStatus: 'generating' | 'waiting_approval' | null = null;
+    private pendingScriptStatusSince = 0;
+    private pendingScriptStatusTimer: NodeJS.Timeout | null = null;
 
  // Output settle debounce — fires after PTY output goes quiet
     private settleTimer: NodeJS.Timeout | null = null;
@@ -454,6 +476,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private readonly sendDelayMs: number;
     private readonly sendKey: string;
     private readonly submitStrategy: 'wait_for_echo' | 'immediate';
+    private static readonly SCRIPT_STATUS_DEBOUNCE_MS = 1000;
 
     constructor(provider: CliProviderModule, workingDir: string, private extraArgs: string[] = []) {
         this.provider = provider;
@@ -645,7 +668,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private handleOutput(rawData: string): void {
         this.terminalScreen.write(rawData);
         this.terminalHistory = mergeTerminalHistory(this.terminalHistory, this.terminalScreen.getText());
-        const cleanData = stripAnsi(rawData);
+        const cleanData = sanitizeTerminalText(rawData);
 
         if (this.isWaitingForResponse && cleanData) {
             this.responseBuffer = (this.responseBuffer + cleanData).slice(-8000);
@@ -764,26 +787,45 @@ export class ProviderCliAdapter implements CliAdapter {
 
         const prevStatus = this.currentStatus;
 
-        if (scriptStatus === 'waiting_approval') {
-            // Auto-accept startup safety dialogs (e.g., "Claude Code'll be able to read, edit, and execute")
-            const modalMessage = modal?.message || '';
-            const screenText = this.terminalScreen.getText() || this.accumulatedBuffer;
-            const autoAcceptPatterns = [
-                /be able to read, edit, and execute/i,
-                /Security guide/i,
-                /Enter to confirm/i,
-                /Quick safety check/i,
-                /Do you trust the files/i,
-                /Is this a project/i,
-            ];
-            if (autoAcceptPatterns.some(p => p.test(modalMessage) || p.test(screenText))) {
-                LOG.info('CLI', `[${this.cliType}] Auto-accepting startup dialog: ${modalMessage.slice(0, 80)}`);
-                setTimeout(() => this.ptyProcess?.write('\r'), 200);
-                this.lastApprovalResolvedAt = Date.now();
-                this.activeModal = null;
+        const clearPendingScriptStatus = () => {
+            this.pendingScriptStatus = null;
+            this.pendingScriptStatusSince = 0;
+            if (this.pendingScriptStatusTimer) {
+                clearTimeout(this.pendingScriptStatusTimer);
+                this.pendingScriptStatusTimer = null;
+            }
+        };
+        const armPendingScriptStatus = (delayMs: number) => {
+            if (this.pendingScriptStatusTimer) clearTimeout(this.pendingScriptStatusTimer);
+            this.pendingScriptStatusTimer = setTimeout(() => {
+                this.pendingScriptStatusTimer = null;
+                this.settledBuffer = this.recentOutputBuffer;
+                this.evaluateSettled();
+            }, delayMs);
+        };
+        const shouldDebouncePromotion = (status: string) =>
+            prevStatus === 'idle'
+            && !this.isWaitingForResponse
+            && !this.currentTurnScope
+            && (status === 'generating' || status === 'waiting_approval');
+
+        if (shouldDebouncePromotion(scriptStatus)) {
+            if (this.pendingScriptStatus !== scriptStatus) {
+                this.pendingScriptStatus = scriptStatus as 'generating' | 'waiting_approval';
+                this.pendingScriptStatusSince = now;
+                armPendingScriptStatus(ProviderCliAdapter.SCRIPT_STATUS_DEBOUNCE_MS);
+                return;
+            }
+            const elapsed = now - this.pendingScriptStatusSince;
+            if (elapsed < ProviderCliAdapter.SCRIPT_STATUS_DEBOUNCE_MS) {
+                armPendingScriptStatus(ProviderCliAdapter.SCRIPT_STATUS_DEBOUNCE_MS - elapsed);
                 return;
             }
+        } else {
+            clearPendingScriptStatus();
+        }
 
+        if (scriptStatus === 'waiting_approval') {
             const inCooldown = this.lastApprovalResolvedAt && (Date.now() - this.lastApprovalResolvedAt) < this.timeouts.approvalCooldown;
             if (!inCooldown) {
                 this.isWaitingForResponse = true;
@@ -800,6 +842,16 @@ export class ProviderCliAdapter implements CliAdapter {
         }
 
         if (scriptStatus === 'generating') {
+            const screenText = this.terminalScreen.getText() || this.accumulatedBuffer;
+            const noActiveTurn = !this.currentTurnScope;
+            const looksIdleChrome = /(^|\n)\s*[❯›>]\s*(?:\n|$)/m.test(screenText)
+                || (/accept edits on/i.test(screenText)
+                    && (/Update available!/i.test(screenText)
+                        || /\/effort/i.test(screenText)
+                        || /^.*➜\s+\S+/m.test(screenText)));
+            if (prevStatus === 'idle' && !this.isWaitingForResponse && noActiveTurn && !modal && looksIdleChrome) {
+                return;
+            }
             if (prevStatus === 'waiting_approval') {
                 // Transitioned out of approval → generating
                 if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
@@ -1242,7 +1294,7 @@ export class ProviderCliAdapter implements CliAdapter {
             committedMessages: this.committedMessages.slice(-20),
             structuredMessages: this.structuredMessages.slice(-20),
             messageCount: this.committedMessages.length,
-            screenText: this.terminalScreen.getText().slice(-4000),
+            screenText: sanitizeTerminalText(this.terminalScreen.getText()).slice(-4000),
             terminalHistory: this.terminalHistory.slice(-8000),
             currentTurnScope: this.currentTurnScope,
             startupBuffer: this.startupBuffer.slice(-4000),
@@ -1251,6 +1303,7 @@ export class ProviderCliAdapter implements CliAdapter {
             accumulatedBufferLength: this.accumulatedBuffer.length,
             accumulatedRawBufferLength: this.accumulatedRawBuffer.length,
             rawBufferPreview: this.accumulatedRawBuffer.slice(-1000),
+            sanitizedRawPreview: sanitizeTerminalText(this.accumulatedRawBuffer).slice(-1000),
             responseBuffer: this.responseBuffer.slice(-1000),
             isWaitingForResponse: this.isWaitingForResponse,
             activeModal: this.activeModal,

package/src/commands/handler.ts

@@ -168,8 +168,24 @@ export class DaemonCommandHandler implements CommandHelpers {
     getCliAdapter(type?: string): any | null {
         const target = type || this._currentIdeType;
         if (!target || !this._ctx.adapters) return null;
+        // Normalize composite transport IDs:
+        //   standalone_xxx:cli:<uuid> -> <uuid>
+        //   daemon:acp:<uuid>         -> <uuid>
+        let normalizedTarget = target;
+        const colonIdx = normalizedTarget.lastIndexOf(':');
+        if (colonIdx >= 0) normalizedTarget = normalizedTarget.substring(colonIdx + 1);
+
+        const direct = this._ctx.adapters.get(normalizedTarget);
+        if (direct) return direct;
+
         for (const [key, adapter] of this._ctx.adapters.entries()) {
-            if ((adapter as any).cliType === target || key.startsWith(target)) {
+            if (
+                (adapter as any).cliType === target
+                || (adapter as any).cliType === normalizedTarget
+                || key === normalizedTarget
+                || key.startsWith(target)
+                || key.startsWith(normalizedTarget)
+            ) {
                 return adapter;
             }
         }

package/src/daemon/dev-server.ts

@@ -1895,22 +1895,25 @@ export class DevServer {
     return path.join(scriptsDir, versions[0]);
   }
 
-  private resolveAutoImplWritableProviderDir(category: ProviderCategory, type: string, requestedDir?: string): string | null {
+  private resolveAutoImplWritableProviderDir(
+    category: ProviderCategory,
+    type: string,
+    requestedDir?: string,
+  ): { dir: string | null; reason?: string } {
     const canonicalUserDir = path.resolve(this.providerLoader.getUserProviderDir(category, type));
     const desiredDir = requestedDir ? path.resolve(requestedDir) : canonicalUserDir;
-
-    if (desiredDir !== canonicalUserDir) {
-      return null;
+    const upstreamRoot = path.resolve(this.providerLoader.getUpstreamDir());
+    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path.sep}`)) {
+      return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
     }
 
-    const userRoot = path.resolve(this.providerLoader.getUserDir());
-    if (desiredDir !== userRoot && !desiredDir.startsWith(`${userRoot}${path.sep}`)) {
-      return null;
+    if (path.basename(desiredDir) !== type) {
+      return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
     }
 
     const sourceDir = this.findProviderDir(type);
     if (!sourceDir) {
-      return null;
+      return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
 
     if (!fs.existsSync(desiredDir)) {
@@ -1921,7 +1924,7 @@ export class DevServer {
 
     const providerJson = path.join(desiredDir, 'provider.json');
     if (!fs.existsSync(providerJson)) {
-      return null;
+      return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
 
     try {
@@ -1930,11 +1933,14 @@ export class DevServer {
         providerData.disableUpstream = true;
         fs.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
       }
-    } catch {
-      return null;
+    } catch (error) {
+      return {
+        dir: null,
+        reason: `Failed to update provider.json in writable provider directory: ${(error as Error).message}`,
+      };
     }
 
-    return desiredDir;
+    return { dir: desiredDir };
   }
 
   private loadAutoImplReferenceScripts(referenceType: string | null): Record<string, string> {
@@ -1975,13 +1981,14 @@ export class DevServer {
     const provider = this.providerLoader.resolve(type);
     if (!provider) { this.json(res, 404, { error: `Provider not found: ${type}` }); return; }
 
-    const providerDir = this.resolveAutoImplWritableProviderDir(provider.category, type, requestedProviderDir);
-    if (!providerDir) {
+    const writableProvider = this.resolveAutoImplWritableProviderDir(provider.category, type, requestedProviderDir);
+    if (!writableProvider.dir) {
       this.json(res, 409, {
-        error: `Auto-implement only writes to the canonical user provider directory for '${type}'.`,
+        error: writableProvider.reason || `Auto-implement only writes to the canonical user provider directory for '${type}'.`,
       });
       return;
     }
+    const providerDir = writableProvider.dir;
 
     try {
       // 1. Collect DOM context
@@ -2529,14 +2536,16 @@ export class DevServer {
     lines.push('| Status | When to use | How to detect |');
     lines.push('|---|---|---|');
     lines.push('| `idle` | AI is NOT generating, no approval needed | Default state. No stop button, no spinners, no approval pills/buttons |');
-    lines.push('| `generating` | AI is actively streaming/thinking | ANY of: (1) Stop/Cancel button visible, (2) CSS animation (animate-spin/pulse/bounce), (3) floating state text like Thinking/Generating/Sailing, (4) streaming indicator class |');
+    lines.push('| `generating` | AI is actively streaming/thinking | ANY of: (1) Submit button icon SVG changes (e.g. arrow→stop square, fill="none"→fill="currentColor"), (2) Stop/Cancel button visible, (3) CSS animation, (4) Structural markers (aria-labels that only appear during generation) |');
     lines.push('| `waiting_approval` | AI stopped and needs user action | Actionable buttons like Run/Skip/Accept/Reject are visible AND clickable |');
     lines.push('');
     lines.push('### ⚠️ Status Detection Gotchas (MUST READ!)');
-    lines.push('1. **FALSE POSITIVES from old messages**: Chat history may contain text like "Command Awaiting Approval" from PAST turns. If you search the entire chat panel for this text, you will get false matches from parent divs whose innerText includes ALL child text. ONLY match small leaf elements (under 80 chars) or use explicit button/pill selectors.');
-    lines.push('2. **Awaiting Approval pill without actions**: Some IDEs show a floating pill/banner saying "Awaiting Approval" that is just a scroll-to indicator (not an actual approval dialog). If this pill exists but NO actionable buttons (Run/Skip/Accept/Reject) exist anywhere in the panel, the status should be `idle`, NOT `waiting_approval`.');
-    lines.push('3. **generating detection must be multi-signal**: Do NOT rely on just one indicator. Check ALL of: stop buttons, CSS animations, floating state labels, streaming classes. IDEs differ widely.');
-    lines.push('4. **activeModal must include actions**: When `status` is `waiting_approval`, the `activeModal` object MUST include a non-empty `actions` array listing the button labels. If you cannot find any action buttons, the status is NOT `waiting_approval`.');
+    lines.push('1. **DO NOT rely on button text/labels in the user\'s language.** OS locale may be Korean, Japanese, etc. Button text like "Cancel" or "Stop" will be localized. Instead, detect STRUCTURAL indicators: SVG icon changes, CSS classes, aria-labels from the extension\'s own React/Radix UI (which stay in English regardless of OS locale).');
+    lines.push('2. **Use sendMessage to CREATE a generating state, then CAPTURE the DOM.** Send a LONG prompt (e.g. "Write an extremely detailed 5000-word essay...") so the AI takes 10+ seconds. Then periodically capture the DOM during generation to find which elements appear/change. Compare idle vs generating DOM snapshots to find reliable structural markers.');
+    lines.push('3. **Look for SVG icon changes in the submit button.** Many IDEs change the submit button icon from an arrow (send) to a square (stop) during generation. Check the SVG `fill` attribute or path data.');
+    lines.push('4. **FALSE POSITIVES from old messages**: Chat history may contain text like "Command Awaiting Approval" from PAST turns. ONLY match small leaf elements (under 80 chars) or use explicit button/pill selectors.');
+    lines.push('5. **Awaiting Approval pill without actions**: Some IDEs show a floating pill/banner that is just a scroll-to indicator. If NO actionable buttons exist, the status should be `idle`, NOT `waiting_approval`.');
+    lines.push('6. **activeModal must include actions**: When `status` is `waiting_approval`, the `activeModal` object MUST include a non-empty `actions` array.');
     lines.push('');
 
     lines.push('## Action');
@@ -2599,10 +2608,10 @@ export class DevServer {
     lines.push(`echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); r=d.get('result',d); r=json.loads(r) if isinstance(r,str) else r; assert r.get('status')=='idle', f'Expected idle, got {r.get(chr(34)+chr(115)+chr(116)+chr(97)+chr(116)+chr(117)+chr(115)+chr(34))}'; print('Step 1 PASS: status=idle')"`);
     lines.push('```');
     lines.push('');
-    lines.push('### Step 2: Send a message that triggers generation');
+    lines.push('### Step 2: Send a LONG message that triggers extended generation (10+ seconds)');
     lines.push('```bash');
-    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${type}", "args": {"message": "Say hello in one word"}}'`);
-    lines.push('sleep 2');
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${type}", "args": {"message": "Write an extremely detailed 5000-word essay about the history of artificial intelligence from Alan Turing to 2025. Be very thorough and verbose."}}'`);
+    lines.push('sleep 3');
     lines.push('```');
     lines.push('');
     lines.push('### Step 3: Check generating OR completed');
@@ -2749,6 +2758,9 @@ export class DevServer {
     lines.push('8. Keep exports compatible with the existing `scripts.js` router (`module.exports = function ...`).');
     lines.push('9. Do not rewrite unrelated provider config. Only touch the scripts needed for this task unless a tiny supporting change is required.');
     lines.push('10. When the verification API returns `instanceId`, keep using that exact instance for follow-up `send`, `resolve`, `raw`, and `stop` calls. Do not assume type-only routing is safe if multiple sessions exist.');
+    lines.push('11. Do NOT repeatedly dump the same target files. Read the target scripts once, reproduce the bug, then move directly to patching.');
+    lines.push('12. If the user instructions include concrete screen text, raw PTY snippets, or a specific repro, treat that as the primary acceptance criteria.');
+    lines.push('13. After the first successful live repro, stop broad diagnosis. Edit the scripts, reload, and verify. Do not burn tokens on repeated re-inspection without code changes.');
     lines.push('');
 
     lines.push('## Task');
@@ -2792,6 +2804,9 @@ export class DevServer {
     lines.push('');
     lines.push('Use `resolve` when the parsed modal buttons are correct. Use `raw` when the CLI expects a literal keystroke like `1`, `y`, or Enter. Repeat until idle.');
     lines.push('');
+    lines.push('### Patch Discipline');
+    lines.push('Once the repro is confirmed, immediately edit the target files. Avoid loops where you keep re-reading long files or re-running the same debug commands without changing code.');
+    lines.push('');
     lines.push('### 5. Verify the side effects outside the CLI');
     lines.push('```bash');
     lines.push('test -f tmp/adhdev_provider_fix_test.py');

package/src/detection/cli-detector.ts

@@ -16,12 +16,18 @@ export interface CLIInfo {
     displayName: string;
     icon: string;
     command: string;
+    versionCommand?: string;
     installed: boolean;
     version?: string;
     path?: string;
     category?: string;
 }
 
+function parseVersion(raw: string): string {
+    const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
+    return match ? match[1] : raw.split('\n')[0].slice(0, 100);
+}
+
 /** Run a shell command with timeout, returning stdout or null on failure */
 function execAsync(cmd: string, timeoutMs = 5000): Promise<string | null> {
     return new Promise((resolve) => {
@@ -62,11 +68,18 @@ export async function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIIn
                 // Get version (parallel with other checks)
                 let version: string | undefined;
                 try {
-                    const versionResult = await execAsync(`${cli.command} --version 2>/dev/null`, 3000);
-                    if (versionResult) {
-                        // Extract version number (e.g. "gemini v1.2.3" → "1.2.3")
-                        const match = versionResult.match(/(\d+\.\d+[\.\d]*)/);
-                        version = match ? match[1] : versionResult.split('\n')[0].slice(0, 30);
+                    const versionCommands = [
+                        cli.versionCommand,
+                        `${cli.command} --version 2>/dev/null`,
+                        `${cli.command} -V 2>/dev/null`,
+                        `${cli.command} -v 2>/dev/null`,
+                    ].filter((v): v is string => !!v);
+                    for (const versionCommand of versionCommands) {
+                        const versionResult = await execAsync(versionCommand, 3000);
+                        if (versionResult) {
+                            version = parseVersion(versionResult);
+                            break;
+                        }
                     }
                 } catch { }
 

package/src/providers/cli-provider-instance.ts

@@ -85,25 +85,6 @@ export class CliProviderInstance implements ProviderInstance {
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
- // Preserve rich message objects, just truncate extremely long text strings
-        const recentMessages = adapterStatus.messages.slice(-50).map((m: any) => {
-            const content = typeof m.content === 'string' && m.content.length > 8000
-                ? m.content.slice(0, 8000) + '\n... (truncated)'
-                : m.content;
-            return { ...m, content };
-        });
-
- // generating during partial response add
- // Save history
-        if (recentMessages.length > 0) {
-            const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
-            this.historyWriter.appendNewMessages(
-                this.type,
-                recentMessages,
-                `${this.provider.name} · ${dirName}`,
-                this.instanceId,
-            );
-        }
         if (adapterStatus.terminalHistory?.trim()) {
             this.historyWriter.appendTerminalHistory(
                 this.type,
@@ -118,12 +99,12 @@ export class CliProviderInstance implements ProviderInstance {
             name: this.provider.name,
             category: 'cli',
             status: adapterStatus.status,
-            mode: (this.settings.mode as 'terminal' | 'chat') || 'terminal',
+            mode: 'terminal',
             activeChat: {
                 id: `${this.type}_${this.workingDir}`,
                 title: `${this.provider.name} · ${dirName}`,
                 status: adapterStatus.status,
-                messages: recentMessages,
+                messages: [],
                 activeModal: adapterStatus.activeModal,
                 terminalHistory: adapterStatus.terminalHistory,
                 inputContent: '',
@@ -138,11 +119,15 @@ export class CliProviderInstance implements ProviderInstance {
 
     onEvent(event: string, data?: any): void {
         if (event === 'send_message' && data?.text) {
-            this.adapter.sendMessage(data.text);
+            void this.adapter.sendMessage(data.text).catch((e: any) => {
+                LOG.warn('CLI', `[${this.type}] send_message failed: ${e?.message || e}`);
+            });
         } else if (event === 'server_connected' && data?.serverConn) {
             this.adapter.setServerConn(data.serverConn);
         } else if (event === 'resolve_action' && data) {
-            this.adapter.resolveAction(data);
+            void this.adapter.resolveAction(data).catch((e: any) => {
+                LOG.warn('CLI', `[${this.type}] resolve_action failed: ${e?.message || e}`);
+            });
         }
     }
 

package/src/providers/provider-loader.ts

@@ -237,16 +237,23 @@ export class ProviderLoader {
  * Build CLI/ACP detection list (replaces cli-detector)
  * Dynamically generated from provider.js spawn.command.
  */
-  getCliDetectionList(): { id: string; displayName: string; icon: string; command: string; category: string }[] {
-    const result: { id: string; displayName: string; icon: string; command: string; category: string }[] = [];
+  getCliDetectionList(): { id: string; displayName: string; icon: string; command: string; category: string; versionCommand?: string }[] {
+    const result: { id: string; displayName: string; icon: string; command: string; category: string; versionCommand?: string }[] = [];
     for (const p of this.providers.values()) {
       if ((p.category === 'cli' || p.category === 'acp') && p.spawn?.command) {
+        const verCmdConfig = (p as any).versionCommand;
+        const versionCommand = typeof verCmdConfig === 'object' && verCmdConfig !== null
+          ? verCmdConfig[process.platform]
+          : verCmdConfig;
         result.push({
           id: p.type,
           displayName: p.displayName || p.name,
           icon: p.icon || '🔧',
           command: p.spawn.command,
           category: p.category,
+          ...(typeof versionCommand === 'string' && versionCommand.trim()
+            ? { versionCommand: versionCommand.trim() }
+            : {}),
         });
       }
     }

package/src/shared-types.ts

@@ -75,7 +75,7 @@ export interface ManagedCliEntry {
     cliType: string;
     cliName: string;
     status: string;
-    mode: 'terminal' | 'chat';
+    mode: 'terminal';
     workspace: string;
     activeChat: _ActiveChatData | null;
 }

package/src/status/builders.ts

@@ -156,7 +156,7 @@ export function buildManagedClis(
         cliType: s.type,
         cliName: s.name,
         status: s.status,
-        mode: s.mode as 'terminal' | 'chat',
+        mode: 'terminal' as const,
         workspace: s.workspace || '',
         activeChat: s.activeChat,
     }));