@adhdev/daemon-core 0.6.53 → 0.6.56

package/src/daemon/dev-server.ts

@@ -1866,6 +1866,51 @@ export class DevServer {
 
   // ─── Phase 2: Auto-Implement Backend ───
 
+  private getDefaultAutoImplReference(category: string, type: string): string {
+    if (category === 'cli') {
+      return type === 'codex-cli' ? 'claude-cli' : 'codex-cli';
+    }
+    return 'antigravity';
+  }
+
+  private resolveAutoImplReference(category: string, requestedReference: string | undefined, targetType: string): string | null {
+    const desired = requestedReference || this.getDefaultAutoImplReference(category, targetType);
+    const ref = this.providerLoader.resolve(desired) || this.providerLoader.getMeta(desired);
+    if (ref?.category === category) return desired;
+
+    const all = this.providerLoader.getAll();
+    const fallback = all.find((p: any) => p.category === category && p.type !== targetType);
+    return fallback?.type || null;
+  }
+
+  private loadAutoImplReferenceScripts(category: string, referenceType: string | null): Record<string, string> {
+    if (!referenceType) return {};
+
+    const builtinDir = this.providerLoader.getPrimaryBuiltinDir();
+    const refDir = path.join(builtinDir, category, referenceType);
+    if (!fs.existsSync(refDir)) return {};
+
+    const referenceScripts: Record<string, string> = {};
+    const scriptsDir = path.join(refDir, 'scripts');
+    if (!fs.existsSync(scriptsDir)) return referenceScripts;
+
+    const versions = fs.readdirSync(scriptsDir).filter((d: string) => {
+      try { return fs.statSync(path.join(scriptsDir, d)).isDirectory(); } catch { return false; }
+    }).sort().reverse();
+    if (versions.length === 0) return referenceScripts;
+
+    const latestDir = path.join(scriptsDir, versions[0]);
+    for (const file of fs.readdirSync(latestDir)) {
+      if (!file.endsWith('.js')) continue;
+      try {
+        referenceScripts[file] = fs.readFileSync(path.join(latestDir, file), 'utf-8');
+      } catch {
+        // ignore broken reference files
+      }
+    }
+    return referenceScripts;
+  }
+
   private async handleAutoImplement(type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     const body = await this.readBody(req);
     const { agent = 'claude-cli', functions, reference = 'antigravity', model, comment } = body;
@@ -1888,37 +1933,33 @@ export class DevServer {
     try {
       // 1. Collect DOM context
       // 1. Skip heavy DOM pre-parsing (Agent will use cURL to explore via CDP!)
-      this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'analyzing', message: '에이전트 초기화 (DOM 탐색 권한 부여)...' } });
+      const resolvedReference = this.resolveAutoImplReference(provider.category, reference, type);
+      this.sendAutoImplSSE({
+        event: 'progress',
+        data: {
+          function: '_init',
+          status: 'analyzing',
+          message: provider.category === 'cli'
+            ? 'Initializing agent (granting CLI PTY debug access)...'
+            : 'Initializing agent (granting DOM access)...'
+        }
+      });
       const domContext = null;
 
       // 2. Load reference scripts
-      this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'loading_reference', message: `레퍼런스 스크립트 로드 중 (${reference})...` } });
-
-      let referenceScripts: Record<string, string> = {};
-      const builtinDir = this.providerLoader.getPrimaryBuiltinDir();
-      const refDir = path.join(builtinDir, 'ide', reference);
-      if (fs.existsSync(refDir)) {
-        // Find latest versioned scripts dir
-        const scriptsDir = path.join(refDir, 'scripts');
-        if (fs.existsSync(scriptsDir)) {
-          const versions = fs.readdirSync(scriptsDir).filter((d: string) => {
-            try { return fs.statSync(path.join(scriptsDir, d)).isDirectory(); } catch { return false; }
-          }).sort().reverse();
-          if (versions.length > 0) {
-            const latestDir = path.join(scriptsDir, versions[0]);
-            for (const file of fs.readdirSync(latestDir)) {
-              if (file.endsWith('.js')) {
-                try {
-                  referenceScripts[file] = fs.readFileSync(path.join(latestDir, file), 'utf-8');
-                } catch { /* skip */ }
-              }
-            }
-          }
+      this.sendAutoImplSSE({
+        event: 'progress',
+        data: {
+          function: '_init',
+          status: 'loading_reference',
+          message: `Loading reference script (${resolvedReference || 'none'})...`
         }
-      }
+      });
+
+      const referenceScripts = this.loadAutoImplReferenceScripts(provider.category, resolvedReference);
 
       // 3. Build the prompt
-      const prompt = this.buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts, comment);
+      const prompt = this.buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference);
 
       // 4. Write prompt to temp file (avoids shell escaping issues with special chars)
       const tmpDir = path.join(os.tmpdir(), 'adhdev-autoimpl');
@@ -1940,7 +1981,7 @@ export class DevServer {
 
       // ─── ACP Agent: use ACP SDK (JSON-RPC protocol) ───
       if (agentCategory === 'acp') {
-        this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'spawning', message: `ACP 에이전트 실행 중: ${spawn.command} ${(spawn.args || []).join(' ')}` } });
+        this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'spawning', message: `Spawning ACP agent: ${spawn.command} ${(spawn.args || []).join(' ')}` } });
         this.autoImplStatus = { running: true, type, progress: [] };
 
         // Dynamic import ACP SDK
@@ -2022,7 +2063,7 @@ export class DevServer {
           this.autoImplProcess = null;
           this.autoImplStatus.running = false;
           const success = code === 0;
-          this.sendAutoImplSSE({ event: 'complete', data: { success, exitCode: code, functions, message: success ? '✅ ACP Auto-implement 완료' : `❌ ACP 에이전트 종료 (code: ${code})` } });
+          this.sendAutoImplSSE({ event: 'complete', data: { success, exitCode: code, functions, message: success ? '✅ ACP Auto-implement complete' : `❌ ACP agent exited (code: ${code})` } });
           try { this.providerLoader.reload(); } catch { /* ignore */ }
           try { fs.unlinkSync(promptFile); } catch { /* ignore */ }
           this.log(`Auto-implement (ACP) ${success ? 'completed' : 'failed'}: ${type} (exit: ${code})`);
@@ -2034,18 +2075,18 @@ export class DevServer {
             this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'initializing', message: 'ACP initialize...' } });
             await connection.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
 
-            this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'session', message: 'ACP session 생성 중...' } });
+            this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'session', message: 'Creating ACP session...' } });
             const session = await connection.newSession({ cwd: providerDir, mcpServers: [] });
             const sessionId = session?.sessionId;
             if (!sessionId) throw new Error('No sessionId returned from session/new');
 
-            this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'prompting', message: `프롬프트 전송 중 (${prompt.length} chars)...` } });
+            this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'prompting', message: `Sending prompt (${prompt.length} chars)...` } });
             await connection.prompt({
               sessionId,
               prompt: [{ type: 'text', text: prompt }],
             });
 
-            this.sendAutoImplSSE({ event: 'progress', data: { function: '_done', status: 'complete', message: '✅ ACP 프롬프트 처리 완료' } });
+            this.sendAutoImplSSE({ event: 'progress', data: { function: '_done', status: 'complete', message: '✅ ACP prompt processing complete' } });
           } catch (e: any) {
             this.sendAutoImplSSE({ event: 'output', data: { chunk: `[ACP Error] ${e.message}\n`, stream: 'stderr' } });
             this.log(`Auto-implement ACP error: ${e.message}`);
@@ -2105,7 +2146,7 @@ export class DevServer {
         shellCmd = `cat '${promptFile}' | ${command} ${escapedArgs}`;
       }
 
-      this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'spawning', message: `에이전트 실행 중: ${shellCmd.substring(0, 200)}... (prompt: ${prompt.length} chars)` } });
+      this.sendAutoImplSSE({ event: 'progress', data: { function: '_init', status: 'spawning', message: `Spawning agent: ${shellCmd.substring(0, 200)}... (prompt: ${prompt.length} chars)` } });
 
       this.autoImplStatus = { running: true, type, progress: [] };
       const spawnedAt = Date.now();
@@ -2218,7 +2259,7 @@ export class DevServer {
           const success = code === 0;
           this.sendAutoImplSSE({
             event: 'complete',
-            data: { success, exitCode: code, functions, message: success ? '✅ Auto-implement 완료' : `❌ 에이전트 종료 (code: ${code})` },
+            data: { success, exitCode: code, functions, message: success ? '✅ Auto-implement complete' : `❌ Agent exited (code: ${code})` },
           });
           try { this.providerLoader.reload(); } catch { /* ignore */ }
           try { fs.unlinkSync(promptFile); } catch { /* ignore */ }
@@ -2247,7 +2288,7 @@ export class DevServer {
               success,
               exitCode: code,
               functions,
-              message: success ? '✅ Auto-implement 완료' : `❌ 에이전트 종료 (code: ${code})`,
+              message: success ? '✅ Auto-implement complete' : `❌ Agent exited (code: ${code})`,
             },
           });
           try { this.providerLoader.reload(); } catch { /* ignore */ }
@@ -2278,7 +2319,12 @@ export class DevServer {
     domContext: any,
     referenceScripts: Record<string, string>,
     userComment?: string,
+    referenceType?: string | null,
   ): string {
+    if (provider.category === 'cli') {
+      return this.buildCliAutoImplPrompt(type, provider, providerDir, functions, referenceScripts, userComment, referenceType);
+    }
+
     const lines: string[] = [];
 
     // ── System instructions ──
@@ -2341,7 +2387,7 @@ export class DevServer {
     };
 
     if (Object.keys(referenceScripts).length > 0) {
-      lines.push('## Reference Implementation (from Antigravity provider)');
+      lines.push(`## Reference Implementation (from ${referenceType || 'antigravity'} provider)`);
       lines.push('These are WORKING scripts from another IDE. Adapt the PATTERNS (not selectors) for the target IDE.');
       lines.push('');
       for (const fn of functions) {
@@ -2507,6 +2553,186 @@ export class DevServer {
     return lines.join('\n');
   }
 
+  private buildCliAutoImplPrompt(
+    type: string,
+    provider: any,
+    providerDir: string,
+    functions: string[],
+    referenceScripts: Record<string, string>,
+    userComment?: string,
+    referenceType?: string | null,
+  ): string {
+    const lines: string[] = [];
+
+    lines.push('You are implementing PTY parsing scripts for a CLI provider.');
+    lines.push('Be concise. Do NOT explain your reasoning. Edit files directly and verify with the local DevServer.');
+    lines.push('');
+
+    lines.push(`# Target: ${provider.name || type} (${type})`);
+    lines.push(`Provider directory: \`${providerDir}\``);
+    lines.push('Provider category: `cli`');
+    lines.push('');
+
+    lines.push('## Current Target Files');
+    lines.push('These are the files you need to edit. Replace TODO or heuristic-only logic with working PTY-aware implementations.');
+    lines.push('');
+
+    const scriptsDir = path.join(providerDir, 'scripts');
+    if (fs.existsSync(scriptsDir)) {
+      const versions = fs.readdirSync(scriptsDir).filter((d: string) => {
+        try { return fs.statSync(path.join(scriptsDir, d)).isDirectory(); } catch { return false; }
+      }).sort().reverse();
+      if (versions.length > 0) {
+        const vDir = path.join(scriptsDir, versions[0]);
+        lines.push(`Scripts version directory: \`${vDir}\``);
+        lines.push('');
+        for (const file of fs.readdirSync(vDir)) {
+          if (!file.endsWith('.js')) continue;
+          try {
+            const content = fs.readFileSync(path.join(vDir, file), 'utf-8');
+            lines.push(`### \`${file}\``);
+            lines.push('```javascript');
+            lines.push(content);
+            lines.push('```');
+            lines.push('');
+          } catch {
+            // ignore
+          }
+        }
+      }
+    }
+
+    const funcToFile: Record<string, string> = {
+      parseOutput: 'parse_output.js',
+      detectStatus: 'detect_status.js',
+      parseApproval: 'parse_approval.js',
+    };
+
+    if (Object.keys(referenceScripts).length > 0) {
+      lines.push(`## Reference Implementation (from ${referenceType || 'another CLI'} provider)`);
+      lines.push('These are working CLI PTY parser scripts. Reuse the parsing shape and runtime contract, but adapt to the target CLI screen.');
+      lines.push('');
+      for (const fn of functions) {
+        const fileName = funcToFile[fn];
+        if (fileName && referenceScripts[fileName]) {
+          lines.push(`### ${fn} → \`${fileName}\``);
+          lines.push('```javascript');
+          lines.push(referenceScripts[fileName]);
+          lines.push('```');
+          lines.push('');
+        }
+      }
+      if (referenceScripts['scripts.js']) {
+        lines.push('### Router → `scripts.js`');
+        lines.push('```javascript');
+        lines.push(referenceScripts['scripts.js']);
+        lines.push('```');
+        lines.push('');
+      }
+    }
+
+    lines.push('## Runtime Contract');
+    lines.push('The daemon runtime is already implemented in `packages/daemon-core/src/cli-adapters/provider-cli-adapter.ts`.');
+    lines.push('Your scripts receive PTY-derived input and must return plain JS objects.');
+    lines.push('');
+    lines.push('| Function | Input | Return |');
+    lines.push('|---|---|---|');
+    lines.push('| `parseOutput` | `{ buffer, rawBuffer, recentBuffer, screenText, messages, partialResponse }` | `{ id, status, title, messages, activeModal }` |');
+    lines.push('| `detectStatus` | `{ tail, screenText, rawBuffer }` | `idle`, `generating`, `waiting_approval`, or `error` |');
+    lines.push('| `parseApproval` | `{ buffer, rawBuffer, tail }` | `{ message, buttons }` or `null` |');
+    lines.push('');
+
+    lines.push('## Rules');
+    lines.push('1. These scripts run in Node.js CommonJS, not in the browser. Do NOT use DOM APIs.');
+    lines.push('2. Prefer `screenText` for current visible UI state. That is the PTY equivalent of parsing the current IDE DOM.');
+    lines.push('3. Use `messages` as prior transcript state so redraws do not duplicate old turns on every parse.');
+    lines.push('4. Use `partialResponse` for the actively streaming assistant text when status is `generating`.');
+    lines.push('5. `detectStatus` must stay lightweight and tail-based. Do not scan the entire history there.');
+    lines.push('6. `parseApproval` should understand the live approval area and return clean button labels.');
+    lines.push('7. Use `rawBuffer` only when ANSI/control-sequence artifacts matter. Do not depend on raw escape noise unless necessary.');
+    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('');
+
+    lines.push('## Task');
+    lines.push(`Edit files in \`${providerDir}\` to implement: **${functions.join(', ')}**`);
+    lines.push('');
+
+    lines.push('## Verification API');
+    lines.push('Use the DevServer CLI debug endpoints, not DOM/CDP routes.');
+    lines.push('');
+    lines.push('### 1. Launch the target CLI');
+    lines.push('```bash');
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/launch \\`);
+    lines.push('  -H "Content-Type: application/json" \\');
+    lines.push(`  -d '{"type":"${type}","workingDir":"${providerDir.replace(/\\/g, '\\\\')}"}'`);
+    lines.push('```');
+    lines.push('');
+    lines.push('### 2. Inspect parsed + raw adapter state');
+    lines.push('```bash');
+    lines.push(`curl -sS http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/debug/${type}`);
+    lines.push(`curl -sS http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/status`);
+    lines.push('```');
+    lines.push('');
+    lines.push('Extract the current `instanceId` from the launch or status response and keep using it below.');
+    lines.push('');
+    lines.push('### 3. Send a realistic approval-triggering prompt');
+    lines.push('```bash');
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/send \\`);
+    lines.push('  -H "Content-Type: application/json" \\');
+    lines.push(`  -d '{"type":"${type}","instanceId":"<INSTANCE_ID>","text":"Create a file at tmp/adhdev_provider_fix_test.py that prints the current working directory and the squares of 1 through 5, then run python3 tmp/adhdev_provider_fix_test.py and tell me the exact output."}'`);
+    lines.push('```');
+    lines.push('');
+    lines.push('### 4. If approval appears, resolve it until the CLI reaches idle');
+    lines.push('```bash');
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/resolve \\`);
+    lines.push('  -H "Content-Type: application/json" \\');
+    lines.push(`  -d '{"type":"${type}","instanceId":"<INSTANCE_ID>","buttonIndex":0}'`);
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/raw \\`);
+    lines.push('  -H "Content-Type: application/json" \\');
+    lines.push(`  -d '{"type":"${type}","instanceId":"<INSTANCE_ID>","keys":"1"}'`);
+    lines.push('```');
+    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('### 5. Verify the side effects outside the CLI');
+    lines.push('```bash');
+    lines.push('test -f tmp/adhdev_provider_fix_test.py');
+    lines.push('python3 tmp/adhdev_provider_fix_test.py');
+    lines.push('```');
+    lines.push('');
+    lines.push('### 6. Stop the CLI when finished');
+    lines.push('```bash');
+    lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/stop \\`);
+    lines.push('  -H "Content-Type: application/json" \\');
+    lines.push(`  -d '{"type":"${type}","instanceId":"<INSTANCE_ID>"}'`);
+    lines.push('```');
+    lines.push('');
+
+    lines.push('## Required Validation');
+    lines.push('1. Confirm `detectStatus` changes sensibly between startup, generating, approval, and idle.');
+    lines.push('2. Confirm `parseOutput` produces a stable transcript without duplicating past turns when the PTY redraws.');
+    lines.push('3. Confirm the latest assistant message streams through `partialResponse` while generation is in progress.');
+    lines.push('4. Confirm approval parsing returns meaningful button labels when the CLI requests permission.');
+    lines.push('5. Confirm the Python file was actually created and executed, not just described in chat text.');
+    lines.push('6. Confirm the final assistant transcript includes the exact Python output, including the working directory line and the five square numbers.');
+    lines.push('7. Re-run the debug endpoints after edits. Do NOT finish until the parsed result looks correct.');
+    lines.push('');
+
+    if (userComment) {
+      lines.push('## ⚠️ User Instructions (HIGH PRIORITY)');
+      lines.push('The user has provided the following additional instructions. Follow them strictly:');
+      lines.push('');
+      lines.push(userComment);
+      lines.push('');
+    }
+
+    lines.push('Start NOW. Launch the CLI, inspect PTY state, edit the scripts, and verify via the CLI debug endpoints.');
+
+    return lines.join('\n');
+  }
+
   private handleAutoImplSSE(type: string, req: http.IncomingMessage, res: http.ServerResponse): void {
     res.writeHead(200, {
       'Content-Type': 'text/event-stream',
@@ -2531,7 +2757,7 @@ export class DevServer {
     if (this.autoImplProcess) {
       this.autoImplProcess.kill('SIGTERM');
       setTimeout(() => { if (this.autoImplProcess) this.autoImplProcess.kill('SIGKILL'); }, 3000);
-      this.sendAutoImplSSE({ event: 'complete', data: { success: false, exitCode: -1, message: '⛔ 사용자에 의해 중단됨' } });
+      this.sendAutoImplSSE({ event: 'complete', data: { success: false, exitCode: -1, message: '⛔ Aborted by user' } });
       this.autoImplProcess = null;
       this.autoImplStatus.running = false;
       this.json(res, 200, { cancelled: true });
@@ -2617,6 +2843,17 @@ export class DevServer {
     this.json(res, 200, { instances: result, count: result.length });
   }
 
+  private findCliTarget(type?: string, instanceId?: string): any | null {
+    if (!this.instanceManager) return null;
+    const cliStates = this.instanceManager
+      .collectAllStates()
+      .filter(s => s.category === 'cli' || s.category === 'acp');
+    if (instanceId) return cliStates.find(s => s.instanceId === instanceId) || null;
+    if (!type) return cliStates[cliStates.length - 1] || null;
+    const matches = cliStates.filter(s => s.type === type);
+    return matches[matches.length - 1] || null;
+  }
+
   /** POST /api/cli/launch — launch a CLI agent { type, workingDir?, args? } */
   private async handleCliLaunch(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     if (!this.cliManager) {
@@ -2650,12 +2887,7 @@ export class DevServer {
       return;
     }
 
-    // Find the CLI instance by type or instanceId
-    const allStates = this.instanceManager.collectAllStates();
-    const target = allStates.find(s =>
-      (s.category === 'cli' || s.category === 'acp') &&
-      (instanceId ? s.instanceId === instanceId : s.type === type)
-    );
+    const target = this.findCliTarget(type, instanceId);
     if (!target) {
       this.json(res, 404, { error: `No running instance found for: ${type || instanceId}` });
       return;
@@ -2678,11 +2910,7 @@ export class DevServer {
     const body = await this.readBody(req);
     const { type, instanceId } = body;
 
-    const allStates = this.instanceManager.collectAllStates();
-    const target = allStates.find(s =>
-      (s.category === 'cli' || s.category === 'acp') &&
-      (instanceId ? s.instanceId === instanceId : s.type === type)
-    );
+    const target = this.findCliTarget(type, instanceId);
     if (!target) {
       this.json(res, 404, { error: `No running instance found for: ${type || instanceId}` });
       return;
@@ -2742,12 +2970,9 @@ export class DevServer {
       return;
     }
 
-    // Find the matching CLI instance
-    const allStates = this.instanceManager.collectAllStates();
-    const target = allStates.find(s =>
-      (s.category === 'cli' || s.category === 'acp') && s.type === type
-    );
+    const target = this.findCliTarget(type);
     if (!target) {
+      const allStates = this.instanceManager.collectAllStates();
       this.json(res, 404, { error: `No running instance for: ${type}`, available: allStates.filter(s => s.category === 'cli' || s.category === 'acp').map(s => s.type) });
       return;
     }
@@ -2800,19 +3025,28 @@ export class DevServer {
       this.json(res, 503, { error: 'CliManager not available' });
       return;
     }
-    // Find adapter from cliManager.adapters map
-    let adapter: any = null;
-    for (const [, a] of this.cliManager.adapters) {
-      if (type && (a as any).cliType === type) { adapter = a; break; }
+    if (!this.instanceManager) {
+      this.json(res, 503, { error: 'InstanceManager not available' });
+      return;
     }
-    if (!adapter) {
+
+    const target = this.findCliTarget(type, instanceId);
+    if (!target) {
       this.json(res, 404, { error: `No running adapter for: ${type || instanceId}` });
       return;
     }
+
+    const instance = this.instanceManager.getInstance(target.instanceId) as any;
+    const adapter = instance?.getAdapter?.() || instance?.adapter;
+    if (!adapter) {
+      this.json(res, 404, { error: `Adapter not found for instance: ${target.instanceId}` });
+      return;
+    }
+
     try {
       if (typeof adapter.resolveModal === 'function') {
         adapter.resolveModal(buttonIndex);
-        this.json(res, 200, { resolved: true, type, buttonIndex });
+        this.json(res, 200, { resolved: true, type: target.type, instanceId: target.instanceId, buttonIndex });
       } else {
         this.json(res, 400, { error: 'resolveModal not available on this adapter' });
       }
@@ -2834,18 +3068,28 @@ export class DevServer {
       this.json(res, 503, { error: 'CliManager not available' });
       return;
     }
-    let adapter: any = null;
-    for (const [, a] of this.cliManager.adapters) {
-      if (type && (a as any).cliType === type) { adapter = a; break; }
+    if (!this.instanceManager) {
+      this.json(res, 503, { error: 'InstanceManager not available' });
+      return;
+    }
+
+    const target = this.findCliTarget(type, instanceId);
+    if (!target) {
+      this.json(res, 404, { error: `No running adapter for: ${type || instanceId}` });
+      return;
     }
+
+    const instance = this.instanceManager.getInstance(target.instanceId) as any;
+    const adapter = instance?.getAdapter?.() || instance?.adapter;
     if (!adapter) {
-      this.json(res, 404, { error: `No running adapter for: ${type || instanceId}` });
+      this.json(res, 404, { error: `Adapter not found for instance: ${target.instanceId}` });
       return;
     }
+
     try {
       if (typeof adapter.writeRaw === 'function') {
         adapter.writeRaw(keys);
-        this.json(res, 200, { sent: true, type, keysLength: keys.length });
+        this.json(res, 200, { sent: true, type: target.type, instanceId: target.instanceId, keysLength: keys.length });
       } else {
         this.json(res, 400, { error: 'writeRaw not available on this adapter' });
       }

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

@@ -51,7 +51,7 @@ import type { ProviderInstance, ProviderState, AcpProviderState, ProviderErrorRe
 import { StatusMonitor } from './status-monitor.js';
 import { LOG } from '../logging/logger.js';
 
-// ─── Internal Display Types (dashboard용) ────────────────────────────
+// ─── Internal Display Types (for dashboard) ────────────────────────────
 
 interface AcpMessage {
     role: 'user' | 'assistant' | 'system';

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

@@ -81,25 +81,37 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     getState(): ProviderState {
-        const adapterStatus = this.adapter.getStatus();
+        const rawStatus = this.adapter.getStatus();
+        const parsedStatus = this.adapter.getScriptParsedStatus();
+        
+        // Prefer rich script parsed status if available
+        const adapterStatus = parsedStatus ? {
+            ...rawStatus,
+            messages: parsedStatus.messages || rawStatus.messages,
+            activeModal: parsedStatus.activeModal || rawStatus.activeModal,
+        } : rawStatus;
+
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
- // Message truncate (recent 50, 2000 char limit)
-        const recentMessages = adapterStatus.messages.slice(-50).map(m => ({
-            role: m.role,
-            content: m.content.length > 2000 ? m.content.slice(0, 2000) + '\n... (truncated)' : m.content,
-            timestamp: m.timestamp,
-        }));
+ // 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
         const partial = this.adapter.getPartialResponse();
-        if (adapterStatus.status === 'generating' && partial) {
+        const shouldAppendRawPartial = !parsedStatus;
+        if (shouldAppendRawPartial && adapterStatus.status === 'generating' && partial) {
             const cleaned = partial.trim();
             if (cleaned && cleaned !== '(generating...)') {
                 recentMessages.push({
                     role: 'assistant',
-                    content: (cleaned.length > 2000 ? cleaned.slice(0, 2000) + '...' : cleaned) + '...',
+                    content: (cleaned.length > 8000 ? cleaned.slice(0, 8000) + '...' : cleaned) + '...',
                     timestamp: Date.now(),
+                    meta: { streaming: true },
                 });
             }
         }
@@ -142,6 +154,8 @@ export class CliProviderInstance implements ProviderInstance {
             this.adapter.sendMessage(data.text);
         } else if (event === 'server_connected' && data?.serverConn) {
             this.adapter.setServerConn(data.serverConn);
+        } else if (event === 'resolve_action' && data) {
+            this.adapter.resolveAction(data);
         }
     }
 

package/src/providers/provider-loader.ts

@@ -1141,8 +1141,9 @@ export class ProviderLoader {
   }
 
   private compareVersions(a: string, b: string): number {
-    const pa = a.split('.').map(Number);
-    const pb = b.split('.').map(Number);
+    const normalize = (v: string) => v.split(/[-_+]/)[0].split('.').map(x => parseInt(x, 10) || 0);
+    const pa = normalize(a);
+    const pb = normalize(b);
     for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
       const va = pa[i] || 0;
       const vb = pb[i] || 0;

package/providers/_builtin/ide/pearai/scripts/1.0/webview_list_models.js

@@ -1,43 +0,0 @@
-/**
- * Cline — list_models
- * 드롭다운에서 사용 가능한 모델 목록 + 현재 선택된 모델 반환
- * → { models: string[], current: string }
- */
-(async () => {
-    try {
-        const inner = document.querySelector('iframe');
-        const doc = inner?.contentDocument || inner?.contentWindow?.document;
-        if (!doc) return JSON.stringify({ models: [], current: '', error: 'no doc' });
-
-        // 현재 모델: mode-switch 또는 model selector에서 읽기
-        let current = '';
-        const modeSwitch = doc.querySelector('[data-testid="mode-switch"]');
-        if (modeSwitch) current = (modeSwitch.textContent || '').trim();
-        if (!current) {
-            const modelSel = doc.querySelector('[data-testid*="model"], [aria-label*="model" i]');
-            if (modelSel) current = (modelSel.textContent || '').trim();
-        }
-
-        // 드롭다운 트리거 찾기
-        const trigger = doc.querySelector('[data-testid="model-selector"], [data-testid*="model-dropdown"], [data-testid="dropdown-trigger"]');
-        if (!trigger) return JSON.stringify({ models: [], current, error: 'no model trigger' });
-
-        // 드롭다운 열기
-        trigger.click();
-        await new Promise(r => setTimeout(r, 300));
-
-        // 옵션 수집
-        const options = doc.querySelectorAll('[data-testid*="dropdown-option"], [role="option"], [class*="dropdown"] [class*="item"], [class*="listbox"] [class*="option"]');
-        const models = [];
-        for (const opt of options) {
-            const text = (opt.textContent || '').trim();
-            if (text && text.length > 1 && text.length < 100) models.push(text);
-        }
-
-        // 닫기
-        doc.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
-        if (trigger.click) trigger.click(); // fallback close
-
-        return JSON.stringify({ models: [...new Set(models)], current });
-    } catch (e) { return JSON.stringify({ models: [], current: '', error: e.message }); }
-})()