@adhdev/daemon-core 0.6.53 → 0.6.55

package/dist/index.js

@@ -591,6 +591,246 @@ var init_logger = __esm({
   }
 });
 
+// src/cli-adapters/terminal-screen.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+var TerminalScreen;
+var init_terminal_screen = __esm({
+  "src/cli-adapters/terminal-screen.ts"() {
+    "use strict";
+    TerminalScreen = class {
+      rows;
+      cols;
+      cursorRow = 0;
+      cursorCol = 0;
+      savedRow = 0;
+      savedCol = 0;
+      lines;
+      constructor(rows = 40, cols = 120) {
+        this.rows = rows;
+        this.cols = cols;
+        this.lines = this.makeLines(rows, cols);
+      }
+      reset(rows = this.rows, cols = this.cols) {
+        this.rows = rows;
+        this.cols = cols;
+        this.cursorRow = 0;
+        this.cursorCol = 0;
+        this.savedRow = 0;
+        this.savedCol = 0;
+        this.lines = this.makeLines(rows, cols);
+      }
+      resize(rows, cols) {
+        const nextRows = Math.max(1, rows | 0);
+        const nextCols = Math.max(1, cols | 0);
+        const next = this.makeLines(nextRows, nextCols);
+        const copyRows = Math.min(this.rows, nextRows);
+        const copyCols = Math.min(this.cols, nextCols);
+        for (let r = 0; r < copyRows; r++) {
+          for (let c = 0; c < copyCols; c++) {
+            next[r][c] = this.lines[r][c];
+          }
+        }
+        this.rows = nextRows;
+        this.cols = nextCols;
+        this.lines = next;
+        this.cursorRow = clamp(this.cursorRow, 0, this.rows - 1);
+        this.cursorCol = clamp(this.cursorCol, 0, this.cols - 1);
+        this.savedRow = clamp(this.savedRow, 0, this.rows - 1);
+        this.savedCol = clamp(this.savedCol, 0, this.cols - 1);
+      }
+      write(data) {
+        let i = 0;
+        while (i < data.length) {
+          const ch = data[i];
+          if (ch === "\x1B") {
+            const consumed = this.consumeEscape(data, i);
+            i = consumed > i ? consumed : i + 1;
+            continue;
+          }
+          if (ch === "\r") {
+            this.cursorCol = 0;
+            i++;
+            continue;
+          }
+          if (ch === "\n") {
+            this.newLine();
+            i++;
+            continue;
+          }
+          if (ch === "\b") {
+            this.cursorCol = Math.max(0, this.cursorCol - 1);
+            i++;
+            continue;
+          }
+          if (ch === "	") {
+            const nextStop = Math.min(this.cols - 1, this.cursorCol + (8 - (this.cursorCol % 8 || 8)));
+            while (this.cursorCol < nextStop) this.putChar(" ");
+            i++;
+            continue;
+          }
+          if (ch >= " " && ch !== "\x7F") {
+            this.putChar(ch);
+          }
+          i++;
+        }
+      }
+      getText() {
+        const raw = this.lines.map((line) => line.join("").replace(/\s+$/, ""));
+        let start = 0;
+        let end = raw.length;
+        while (start < end && raw[start] === "") start++;
+        while (end > start && raw[end - 1] === "") end--;
+        return raw.slice(start, end).join("\n");
+      }
+      consumeEscape(data, start) {
+        const next = data[start + 1];
+        if (!next) return start + 1;
+        if (next === "[") {
+          let end = start + 2;
+          while (end < data.length && !/[@-~]/.test(data[end])) end++;
+          if (end >= data.length) return data.length;
+          this.applyCsi(data.slice(start + 2, end), data[end]);
+          return end + 1;
+        }
+        if (next === "]") {
+          let end = start + 2;
+          while (end < data.length) {
+            if (data[end] === "\x07") return end + 1;
+            if (data[end] === "\x1B" && data[end + 1] === "\\") return end + 2;
+            end++;
+          }
+          return data.length;
+        }
+        if (next === "7") {
+          this.savedRow = this.cursorRow;
+          this.savedCol = this.cursorCol;
+          return start + 2;
+        }
+        if (next === "8") {
+          this.cursorRow = this.savedRow;
+          this.cursorCol = this.savedCol;
+          return start + 2;
+        }
+        return start + 2;
+      }
+      applyCsi(paramText, finalChar) {
+        const privateMode = paramText.startsWith("?");
+        const normalized = privateMode ? paramText.slice(1) : paramText;
+        const params = normalized.length > 0 ? normalized.split(";").map((p) => parseInt(p || "0", 10) || 0) : [0];
+        switch (finalChar) {
+          case "A":
+            this.cursorRow = clamp(this.cursorRow - (params[0] || 1), 0, this.rows - 1);
+            return;
+          case "B":
+            this.cursorRow = clamp(this.cursorRow + (params[0] || 1), 0, this.rows - 1);
+            return;
+          case "C":
+            this.cursorCol = clamp(this.cursorCol + (params[0] || 1), 0, this.cols - 1);
+            return;
+          case "D":
+            this.cursorCol = clamp(this.cursorCol - (params[0] || 1), 0, this.cols - 1);
+            return;
+          case "E":
+            this.cursorRow = clamp(this.cursorRow + (params[0] || 1), 0, this.rows - 1);
+            this.cursorCol = 0;
+            return;
+          case "F":
+            this.cursorRow = clamp(this.cursorRow - (params[0] || 1), 0, this.rows - 1);
+            this.cursorCol = 0;
+            return;
+          case "G":
+            this.cursorCol = clamp((params[0] || 1) - 1, 0, this.cols - 1);
+            return;
+          case "H":
+          case "f": {
+            const row = (params[0] || 1) - 1;
+            const col = (params[1] || 1) - 1;
+            this.cursorRow = clamp(row, 0, this.rows - 1);
+            this.cursorCol = clamp(col, 0, this.cols - 1);
+            return;
+          }
+          case "J": {
+            const mode = params[0] || 0;
+            if (mode === 2 || mode === 3) {
+              this.reset(this.rows, this.cols);
+            } else if (mode === 0) {
+              this.clearToEndOfScreen();
+            } else if (mode === 1) {
+              this.clearToStartOfScreen();
+            }
+            return;
+          }
+          case "K": {
+            const mode = params[0] || 0;
+            if (mode === 2) this.clearLine(this.cursorRow, 0, this.cols - 1);
+            else if (mode === 1) this.clearLine(this.cursorRow, 0, this.cursorCol);
+            else this.clearLine(this.cursorRow, this.cursorCol, this.cols - 1);
+            return;
+          }
+          case "m":
+            return;
+          case "s":
+            this.savedRow = this.cursorRow;
+            this.savedCol = this.cursorCol;
+            return;
+          case "u":
+            this.cursorRow = this.savedRow;
+            this.cursorCol = this.savedCol;
+            return;
+          case "h":
+          case "l":
+            if (privateMode && (normalized === "1049" || normalized === "47")) {
+              this.reset(this.rows, this.cols);
+            }
+            return;
+          default:
+            return;
+        }
+      }
+      putChar(ch) {
+        if (this.cursorRow < 0 || this.cursorRow >= this.rows) return;
+        if (this.cursorCol < 0) this.cursorCol = 0;
+        if (this.cursorCol >= this.cols) this.newLine();
+        this.lines[this.cursorRow][this.cursorCol] = ch;
+        this.cursorCol++;
+        if (this.cursorCol >= this.cols) this.newLine();
+      }
+      newLine() {
+        this.cursorCol = 0;
+        if (this.cursorRow >= this.rows - 1) {
+          this.lines.shift();
+          this.lines.push(Array.from({ length: this.cols }, () => " "));
+        } else {
+          this.cursorRow++;
+        }
+      }
+      clearLine(row, start, end) {
+        if (row < 0 || row >= this.rows) return;
+        for (let c = clamp(start, 0, this.cols - 1); c <= clamp(end, 0, this.cols - 1); c++) {
+          this.lines[row][c] = " ";
+        }
+      }
+      clearToEndOfScreen() {
+        this.clearLine(this.cursorRow, this.cursorCol, this.cols - 1);
+        for (let r = this.cursorRow + 1; r < this.rows; r++) {
+          this.clearLine(r, 0, this.cols - 1);
+        }
+      }
+      clearToStartOfScreen() {
+        for (let r = 0; r < this.cursorRow; r++) {
+          this.clearLine(r, 0, this.cols - 1);
+        }
+        this.clearLine(this.cursorRow, 0, this.cursorCol);
+      }
+      makeLines(rows, cols) {
+        return Array.from({ length: rows }, () => Array.from({ length: cols }, () => " "));
+      }
+    };
+  }
+});
+
 // src/cli-adapters/provider-cli-adapter.ts
 var provider_cli_adapter_exports = {};
 __export(provider_cli_adapter_exports, {
@@ -663,28 +903,19 @@ function parsePatternEntry(x) {
   }
   return null;
 }
-function coercePatternArray(raw, fallbacks) {
-  if (!Array.isArray(raw)) return [...fallbacks];
-  const parsed = raw.map(parsePatternEntry).filter((r) => r != null);
-  return parsed.length > 0 ? parsed : [...fallbacks];
-}
-function defaultCleanOutput(raw, _lastUserInput) {
-  return stripAnsi(raw).trim();
+function coercePatternArray(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map(parsePatternEntry).filter((r) => r != null);
 }
 function normalizeCliProviderForRuntime(raw) {
   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
+      approval: coercePatternArray(patterns.approval)
+    }
   };
 }
-var os11, path9, import_child_process5, pty, FALLBACK_PROMPT, FALLBACK_GENERATING, FALLBACK_APPROVAL, ProviderCliAdapter;
+var os11, path9, import_child_process5, pty, ProviderCliAdapter;
 var init_provider_cli_adapter = __esm({
   "src/cli-adapters/provider-cli-adapter.ts"() {
     "use strict";
@@ -692,6 +923,7 @@ var init_provider_cli_adapter = __esm({
     path9 = __toESM(require("path"));
     import_child_process5 = require("child_process");
     init_logger();
+    init_terminal_screen();
     try {
       pty = require("node-pty");
       if (os11.platform() !== "win32") {
@@ -713,40 +945,10 @@ var init_provider_cli_adapter = __esm({
     } catch {
       LOG.error("CLI", "[ProviderCliAdapter] node-pty not found. Terminal features disabled.");
     }
-    FALLBACK_PROMPT = [
-      /Type your message/i,
-      /for\s*shortcuts/i,
-      // Claude Code prompt
-      /\?\s*for\s*help/i,
-      // Claude Code help prompt
-      /Press enter/i,
-      /^[>›❯]\s*$/i,
-      // Prompt char as the complete evaluated string
-      /[>›❯]\s*$/
-      // Prompt char at the very end of evaluated string
-    ];
-    FALLBACK_GENERATING = [
-      /[\u2800-\u28ff]/,
-      // Braille spinner blocks (universal TUI)
-      /esc to (cancel|interrupt|stop)/i,
-      // Common TUI generation status line
-      /generating\.\.\./i,
-      /Claude is (?:thinking|processing|working)/i
-      // Specific Claude Code status
-    ];
-    FALLBACK_APPROVAL = [
-      /Allow\s*once/i,
-      // ANSI strip may remove spaces
-      /Always\s*allow/i,
-      /\(y\/n\)/i,
-      /\[Y\/n\]/i,
-      /Yes,?\s*don'?t\s*ask/i
-      // "Yes, don't ask again" (Claude Code)
-    ];
-    ProviderCliAdapter = class {
+    ProviderCliAdapter = class _ProviderCliAdapter {
       constructor(provider, workingDir, extraArgs = []) {
         this.extraArgs = extraArgs;
-        this.provider = normalizeCliProviderForRuntime(provider);
+        this.provider = provider;
         this.cliType = provider.type;
         this.cliName = provider.name;
         this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os11.homedir()) : workingDir;
@@ -763,6 +965,13 @@ var init_provider_cli_adapter = __esm({
         };
         const rawKeys = provider.approvalKeys;
         this.approvalKeys = rawKeys && typeof rawKeys === "object" ? rawKeys : {};
+        this.cliScripts = provider.scripts || {};
+        const scriptNames = Object.keys(this.cliScripts).filter((k) => typeof this.cliScripts[k] === "function");
+        if (scriptNames.length > 0) {
+          LOG.info("CLI", `[${this.cliType}] CLI scripts: [${scriptNames.join(", ")}]`);
+        } else {
+          LOG.warn("CLI", `[${this.cliType}] \u26A0 No CLI scripts loaded! Provider needs scripts/{version}/scripts.js`);
+        }
       }
       cliType;
       cliName;
@@ -770,6 +979,7 @@ var init_provider_cli_adapter = __esm({
       provider;
       ptyProcess = null;
       messages = [];
+      structuredMessages = [];
       currentStatus = "starting";
       onStatusChange = null;
       responseBuffer = "";
@@ -780,7 +990,6 @@ var init_provider_cli_adapter = __esm({
       idleTimeout = null;
       ready = false;
       startupBuffer = "";
-      /** After spawn: briefly skip generating/settle so splash/redraw does not flip status; not used to gate sendMessage */
       startupParseGate = false;
       spawnAt = 0;
       // PTY I/O
@@ -798,11 +1007,20 @@ var init_provider_cli_adapter = __esm({
       // Output settle debounce — fires after PTY output goes quiet
       settleTimer = null;
       settledBuffer = "";
-      // snapshot of recentOutputBuffer at settle time
       // Resize redraw suppression
       resizeSuppressUntil = 0;
       // Debug: status transition history
       statusHistory = [];
+      // ─── CLI Scripts (script-based parsing) ───
+      cliScripts;
+      /** Full accumulated ANSI-stripped PTY output */
+      accumulatedBuffer = "";
+      /** Full accumulated raw PTY output (with ANSI) */
+      accumulatedRawBuffer = "";
+      /** Current visible terminal screen snapshot */
+      terminalScreen = new TerminalScreen(40, 120);
+      /** Max accumulated buffer size (last 50KB) */
+      static MAX_ACCUMULATED_BUFFER = 5e4;
       setStatus(status, trigger) {
         const prev = this.currentStatus;
         if (prev === status) return;
@@ -811,10 +1029,16 @@ var init_provider_cli_adapter = __esm({
         if (this.statusHistory.length > 50) this.statusHistory.shift();
         LOG.info("CLI", `[${this.cliType}] status: ${prev} \u2192 ${status}${trigger ? ` (${trigger})` : ""}`);
       }
-      // Resolved timeouts (provider defaults + overrides)
+      // Resolved timeouts
       timeouts;
-      // Provider approval key mapping (e.g. { 0: '1', 1: '2', 2: '3' }) — loaded from provider.json
+      // Provider approval key mapping
       approvalKeys;
+      /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
+      setCliScripts(scripts) {
+        this.cliScripts = scripts;
+        const scriptNames = Object.keys(scripts).filter((k) => typeof scripts[k] === "function");
+        LOG.info("CLI", `[${this.cliType}] CLI scripts injected: [${scriptNames.join(", ")}]`);
+      }
       // ─── Lifecycle ─────────────────────────────────
       setServerConn(serverConn) {
         this.serverConn = serverConn;
@@ -903,15 +1127,19 @@ var init_provider_cli_adapter = __esm({
         this.spawnAt = Date.now();
         this.startupParseGate = true;
         this.startupBuffer = "";
+        this.terminalScreen.reset(40, 120);
         this.ready = true;
         this.setStatus("idle", "pty_ready");
         this.onStatusChange?.();
       }
-      // ─── Output state machine ────────────────────────────
+      // ─── Output Handling ────────────────────────────
       handleOutput(rawData) {
         if (Date.now() < this.resizeSuppressUntil) return;
+        this.terminalScreen.write(rawData);
         const cleanData = stripAnsi(rawData);
-        const { patterns } = this.provider;
+        if (this.isWaitingForResponse && cleanData) {
+          this.responseBuffer = (this.responseBuffer + cleanData).slice(-8e3);
+        }
         if (cleanData.trim()) {
           if (this.serverConn) {
             this.serverConn.sendMessage("log", { message: cleanData.trim(), level: "info" });
@@ -920,9 +1148,10 @@ var init_provider_cli_adapter = __esm({
           }
         }
         this.recentOutputBuffer = (this.recentOutputBuffer + cleanData).slice(-1e3);
+        this.accumulatedBuffer = (this.accumulatedBuffer + cleanData).slice(-_ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        this.accumulatedRawBuffer = (this.accumulatedRawBuffer + rawData).slice(-_ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
         if (this.startupParseGate) {
           this.startupBuffer += cleanData;
-          LOG.info("CLI", `[${this.cliType}] startup chunk (${cleanData.length} chars): ${cleanData.slice(0, 200).replace(/\n/g, "\\n")}`);
           const dialogPatterns = [
             /Do you want to connect/i,
             /Do you trust the files/i,
@@ -937,60 +1166,17 @@ var init_provider_cli_adapter = __esm({
           }
           const elapsed = Date.now() - this.spawnAt;
           const bufCap = this.startupBuffer.length > 12e3;
-          const promptMatched = patterns.prompt.some((p) => p.test(this.startupBuffer));
-          if (promptMatched || elapsed > 8e3 || bufCap) {
+          const scriptStatus = this.runDetectStatus(this.startupBuffer);
+          const isReady = scriptStatus === "idle" || elapsed > 8e3 || bufCap;
+          if (isReady) {
             this.startupParseGate = false;
-            if (promptMatched) {
-              LOG.info("CLI", `[${this.cliType}] \u2713 Startup gate end (prompt matched)`);
-            } else {
-              LOG.info("CLI", `[${this.cliType}] startup gate end (${elapsed}ms, cap=${bufCap}, prompt=${promptMatched})`);
-            }
+            LOG.info("CLI", `[${this.cliType}] Startup gate end (${elapsed}ms, scriptStatus=${scriptStatus})`);
           } else {
             return;
           }
         }
-        if (cleanData.trim().length > 5) {
-          LOG.debug("CLI", `[${this.cliType}] output chunk (${cleanData.length}): ${cleanData.slice(0, 300).replace(/\n/g, "\\n")}`);
-        }
-        if (!this.isWaitingForResponse) {
-          if (patterns.generating.some((p) => p.test(cleanData))) {
-            if (this.settleTimer) {
-              clearTimeout(this.settleTimer);
-              this.settleTimer = null;
-            }
-            this.isWaitingForResponse = true;
-            this.responseBuffer = "";
-            this.setStatus("generating", "autonomous_gen");
-            this.onStatusChange?.();
-          }
-        }
-        if (this.isWaitingForResponse) {
-          this.responseBuffer += cleanData;
-          if (this.idleTimeout) clearTimeout(this.idleTimeout);
-          if (patterns.generating.some((p) => p.test(cleanData))) {
-            this.setStatus("generating", "still_generating");
-            this.idleTimeout = setTimeout(() => {
-              if (this.isWaitingForResponse) this.finishResponse();
-            }, this.timeouts.generatingIdle);
-            this.onStatusChange?.();
-            if (this.settleTimer) {
-              clearTimeout(this.settleTimer);
-              this.settleTimer = null;
-            }
-            return;
-          }
-        }
-        if (this.currentStatus === "waiting_approval") {
-          this.approvalTransitionBuffer = (this.approvalTransitionBuffer + cleanData).slice(-500);
-          this.scheduleSettle();
-          return;
-        }
         this.scheduleSettle();
       }
-      /**
-       * Fired after output goes quiet for outputSettle ms.
-       * Evaluates the stabilised buffer for approval, prompt (idle), or timeout.
-       */
       scheduleSettle() {
         if (this.settleTimer) clearTimeout(this.settleTimer);
         this.settleTimer = setTimeout(() => {
@@ -1000,59 +1186,25 @@ var init_provider_cli_adapter = __esm({
         }, this.timeouts.outputSettle);
       }
       evaluateSettled() {
-        const { patterns } = this.provider;
-        const buf = this.settledBuffer;
-        if (this.currentStatus === "waiting_approval") {
-          const genResume = patterns.generating.some((p) => p.test(this.approvalTransitionBuffer));
-          const promptResume = patterns.prompt.some((p) => p.test(this.approvalTransitionBuffer));
-          if (genResume) {
-            if (this.approvalExitTimeout) {
-              clearTimeout(this.approvalExitTimeout);
-              this.approvalExitTimeout = null;
-            }
-            this.setStatus("generating", "approval_gen_resume");
-            this.activeModal = null;
-            this.recentOutputBuffer = "";
-            this.approvalTransitionBuffer = "";
-            this.lastApprovalResolvedAt = Date.now();
-            this.onStatusChange?.();
-          } else if (promptResume) {
-            if (this.approvalExitTimeout) {
-              clearTimeout(this.approvalExitTimeout);
-              this.approvalExitTimeout = null;
-            }
-            this.activeModal = null;
-            this.recentOutputBuffer = "";
-            this.approvalTransitionBuffer = "";
-            this.lastApprovalResolvedAt = Date.now();
-            this.finishResponse();
-          }
-          return;
-        }
-        const hasApproval = patterns.approval.some((p) => p.test(buf));
-        if (hasApproval) {
+        const tail = this.settledBuffer;
+        const scriptStatus = this.runDetectStatus(tail);
+        if (!scriptStatus) return;
+        const prevStatus = this.currentStatus;
+        if (scriptStatus === "waiting_approval") {
           const inCooldown = this.lastApprovalResolvedAt && Date.now() - this.lastApprovalResolvedAt < this.timeouts.approvalCooldown;
           if (!inCooldown) {
-            const ctxLines = buf.split("\n").map((l) => l.trim()).filter((l) => l && !/^[─═╭╮╰╯│]+$/.test(l));
             this.isWaitingForResponse = true;
-            this.setStatus("waiting_approval", "approval_pattern");
-            this.recentOutputBuffer = "";
-            this.approvalTransitionBuffer = "";
-            this.activeModal = {
-              message: ctxLines.slice(-5).join(" ").slice(0, 200) || "Approval required",
-              buttons: this.cliType === "claude-cli" ? ["Yes (y)", "Always allow (a)", "Deny (Esc)"] : ["Allow once", "Always allow", "Deny"]
-            };
+            this.setStatus("waiting_approval", "script_detect");
+            const modal = this.runParseApproval(tail);
+            this.activeModal = modal || { message: "Approval required", buttons: ["Allow", "Deny"] };
             if (this.idleTimeout) clearTimeout(this.idleTimeout);
             if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
             this.approvalExitTimeout = setTimeout(() => {
               if (this.currentStatus === "waiting_approval") {
-                LOG.warn("CLI", `[${this.cliType}] Approval timeout \u2014 auto-exiting waiting_approval`);
+                LOG.warn("CLI", `[${this.cliType}] Approval timeout \u2014 auto-clearing`);
                 this.activeModal = null;
                 this.lastApprovalResolvedAt = Date.now();
-                this.recentOutputBuffer = "";
-                this.approvalTransitionBuffer = "";
-                this.approvalExitTimeout = null;
-                this.setStatus(this.isWaitingForResponse ? "generating" : "idle", "approval_cleared");
+                this.setStatus("idle", "approval_timeout");
                 this.onStatusChange?.();
               }
             }, 6e4);
@@ -1060,19 +1212,42 @@ var init_provider_cli_adapter = __esm({
             return;
           }
         }
-        if (this.isWaitingForResponse) {
-          const trailingLines = buf.split("\n").slice(-3).join("\n");
-          if (patterns.prompt.some((p) => p.test(trailingLines)) && !hasApproval) {
-            this.finishResponse();
-          } else if (!patterns.generating.some((p) => p.test(buf))) {
-            if (this.idleTimeout) clearTimeout(this.idleTimeout);
-            this.idleTimeout = setTimeout(() => {
-              if (this.isWaitingForResponse && this.responseBuffer.trim()) {
-                this.finishResponse();
-              }
-            }, this.timeouts.idleFinish);
+        if (scriptStatus === "generating") {
+          if (prevStatus === "waiting_approval") {
+            if (this.approvalExitTimeout) {
+              clearTimeout(this.approvalExitTimeout);
+              this.approvalExitTimeout = null;
+            }
+            this.activeModal = null;
+            this.lastApprovalResolvedAt = Date.now();
+          }
+          if (!this.isWaitingForResponse) {
+            this.isWaitingForResponse = true;
+            this.responseBuffer = "";
           }
+          this.setStatus("generating", "script_detect");
+          if (this.idleTimeout) clearTimeout(this.idleTimeout);
+          this.idleTimeout = setTimeout(() => {
+            if (this.isWaitingForResponse) this.finishResponse();
+          }, this.timeouts.generatingIdle);
           this.onStatusChange?.();
+          return;
+        }
+        if (scriptStatus === "idle") {
+          if (prevStatus === "waiting_approval") {
+            if (this.approvalExitTimeout) {
+              clearTimeout(this.approvalExitTimeout);
+              this.approvalExitTimeout = null;
+            }
+            this.activeModal = null;
+            this.lastApprovalResolvedAt = Date.now();
+          }
+          if (this.isWaitingForResponse) {
+            this.finishResponse();
+          } else if (prevStatus !== "idle") {
+            this.setStatus("idle", "script_detect");
+            this.onStatusChange?.();
+          }
         }
       }
       finishResponse() {
@@ -1088,25 +1263,50 @@ var init_provider_cli_adapter = __esm({
           clearTimeout(this.approvalExitTimeout);
           this.approvalExitTimeout = null;
         }
-        const lastUserText = this.messages.filter((m) => m.role === "user").pop()?.content;
-        let response = this.provider.cleanOutput(this.responseBuffer, lastUserText);
-        if (lastUserText && response) {
-          const userTrimmed = lastUserText.trim();
-          response = response.split("\n").filter((l) => l.trim() !== userTrimmed).join("\n").trim();
-        }
-        if (response) {
-          this.messages.push({ role: "assistant", content: response, timestamp: Date.now() });
-          if (this.messages.length > 200) this.messages = this.messages.slice(-200);
-          LOG.info("CLI", `[${this.cliType}] Response (${response.length} chars)`);
-        }
         this.responseBuffer = "";
         this.isWaitingForResponse = false;
         this.activeModal = null;
         this.setStatus("idle", "response_finished");
         this.onStatusChange?.();
       }
-      // ─── Public API (CliAdapter interface) ──────────
+      // ─── Script Execution ──────────────────────────
+      runDetectStatus(text) {
+        if (!this.cliScripts?.detectStatus) return null;
+        try {
+          return this.cliScripts.detectStatus({ tail: text.slice(-500) });
+        } catch (e) {
+          LOG.warn("CLI", `[${this.cliType}] detectStatus error: ${e.message}`);
+          return null;
+        }
+      }
+      runParseApproval(tail) {
+        if (!this.cliScripts?.parseApproval) return null;
+        try {
+          return this.cliScripts.parseApproval({
+            buffer: this.terminalScreen.getText() || this.accumulatedBuffer,
+            rawBuffer: this.accumulatedRawBuffer,
+            tail
+          });
+        } catch (e) {
+          LOG.warn("CLI", `[${this.cliType}] parseApproval error: ${e.message}`);
+          return null;
+        }
+      }
+      // ─── Public API (CliAdapter) ───────────────────
       getStatus() {
+        const scriptResult = this.getScriptParsedStatus();
+        if (scriptResult) {
+          return {
+            status: this.currentStatus,
+            messages: (scriptResult.messages || []).map((m) => ({
+              role: m.role,
+              content: m.content,
+              timestamp: m.timestamp
+            })),
+            workingDir: this.workingDir,
+            activeModal: this.activeModal
+          };
+        }
         return {
           status: this.currentStatus,
           messages: [...this.messages],
@@ -1114,11 +1314,71 @@ var init_provider_cli_adapter = __esm({
           activeModal: this.activeModal
         };
       }
+      /**
+       * Script-based full parse — returns ReadChatResult.
+       * Called by command handler / dashboard for rich content rendering.
+       */
+      getScriptParsedStatus() {
+        if (!this.cliScripts?.parseOutput) return null;
+        try {
+          const input = {
+            buffer: this.accumulatedBuffer,
+            rawBuffer: this.accumulatedRawBuffer,
+            recentBuffer: this.recentOutputBuffer,
+            screenText: this.terminalScreen.getText(),
+            messages: [...this.structuredMessages.length > 0 ? this.structuredMessages : this.messages],
+            partialResponse: this.responseBuffer
+          };
+          const result = this.cliScripts.parseOutput(input);
+          if (result && typeof result === "object") {
+            if (Array.isArray(result.messages)) {
+              this.structuredMessages = result.messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+                timestamp: m.timestamp
+              }));
+            }
+            return result;
+          }
+        } catch (e) {
+          LOG.warn("CLI", `[${this.cliType}] parseOutput error: ${e.message}`);
+        }
+        return null;
+      }
+      /** Whether this adapter has CLI scripts loaded */
+      hasCliScripts() {
+        return typeof this.cliScripts?.detectStatus === "function";
+      }
+      /**
+       * Resolves an action (like 'fix' lint error) from the dashboard.
+       * Uses resolveAction script if available, otherwise falls back to standard text.
+       */
+      async resolveAction(data) {
+        let promptText = "";
+        if (this.cliScripts && typeof this.cliScripts.resolveAction === "function") {
+          try {
+            promptText = this.cliScripts.resolveAction(data);
+          } catch (e) {
+            LOG.warn("CLI", `[${this.cliType}] resolveAction error: ${e.message}`);
+          }
+        }
+        if (!promptText && data) {
+          promptText = `Please fix the following issue:
+${data.title || ""}
+${data.explanation || ""}
+
+${data.message || ""}`.trim();
+        }
+        if (promptText) {
+          await this.sendMessage(promptText);
+        }
+      }
       async sendMessage(text) {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
         if (this.isWaitingForResponse) return;
         this.messages.push({ role: "user", content: text, timestamp: Date.now() });
+        this.structuredMessages.push({ role: "user", content: text, timestamp: Date.now() });
         this.isWaitingForResponse = true;
         this.responseBuffer = "";
         this.setStatus("generating", "sendMessage");
@@ -1130,8 +1390,7 @@ var init_provider_cli_adapter = __esm({
       }
       getPartialResponse() {
         if (!this.isWaitingForResponse) return "";
-        const partial = this.provider.cleanOutput(this.responseBuffer);
-        return partial || (this.isWaitingForResponse ? "(generating...)" : "");
+        return this.responseBuffer;
       }
       cancel() {
         this.shutdown();
@@ -1163,6 +1422,10 @@ var init_provider_cli_adapter = __esm({
       }
       clearHistory() {
         this.messages = [];
+        this.structuredMessages = [];
+        this.accumulatedBuffer = "";
+        this.accumulatedRawBuffer = "";
+        this.terminalScreen.reset();
         this.onStatusChange?.();
       }
       isProcessing() {
@@ -1174,11 +1437,6 @@ var init_provider_cli_adapter = __esm({
       writeRaw(data) {
         this.ptyProcess?.write(data);
       }
-      /**
-      * Resolve an approval modal by navigating to the button at `buttonIndex` and pressing Enter.
-      * Index 0 = first option (already selected by default — just Enter).
-      * Index N = press Arrow Down N times, then Enter.
-      */
       resolveModal(buttonIndex) {
         if (!this.ptyProcess || this.currentStatus !== "waiting_approval") return;
         if (buttonIndex in this.approvalKeys) {
@@ -1193,25 +1451,13 @@ var init_provider_cli_adapter = __esm({
         if (this.ptyProcess) {
           try {
             this.ptyProcess.resize(cols, rows);
+            this.terminalScreen.resize(rows, cols);
             this.resizeSuppressUntil = Date.now() + 300;
           } catch {
           }
         }
       }
-      /**
-      * Full debug state — exposes all internal buffers, status, and patterns for debugging.
-      * Used by DevServer /api/cli/debug endpoint.
-      */
       getDebugState() {
-        const sb = this.startupBuffer;
-        const testOnStartup = (p) => {
-          const flags = p.flags.includes("g") ? p.flags.replace(/g/g, "") : p.flags;
-          return new RegExp(p.source, flags).test(sb);
-        };
-        const promptDiagnostics = this.provider.patterns.prompt.map((p) => ({
-          pattern: p.toString(),
-          matchedAgainstStartupBuffer: testOnStartup(p)
-        }));
         return {
           type: this.cliType,
           name: this.cliName,
@@ -1221,32 +1467,20 @@ var init_provider_cli_adapter = __esm({
           spawnAt: this.spawnAt,
           workingDir: this.workingDir,
           messages: this.messages.slice(-20),
+          structuredMessages: this.structuredMessages.slice(-20),
           messageCount: this.messages.length,
-          // Buffers (longer tails here than in periodic logs — for matching provider.json patterns)
-          startupBuffer: sb.slice(-4e3),
-          startupBufferLength: sb.length,
-          promptDiagnostics,
+          startupBuffer: this.startupBuffer.slice(-4e3),
           recentOutputBuffer: this.recentOutputBuffer.slice(-500),
           settledBuffer: this.settledBuffer.slice(-500),
-          responseBuffer: this.responseBuffer.slice(-500),
-          approvalTransitionBuffer: this.approvalTransitionBuffer.slice(-500),
-          // State
+          accumulatedBufferLength: this.accumulatedBuffer.length,
           isWaitingForResponse: this.isWaitingForResponse,
           activeModal: this.activeModal,
           lastApprovalResolvedAt: this.lastApprovalResolvedAt,
           resizeSuppressUntil: this.resizeSuppressUntil,
-          // Provider patterns (serialized)
-          patterns: {
-            prompt: this.provider.patterns.prompt.map((p) => p.toString()),
-            generating: this.provider.patterns.generating.map((p) => p.toString()),
-            approval: this.provider.patterns.approval.map((p) => p.toString()),
-            ready: this.provider.patterns.ready.map((p) => p.toString())
-          },
-          // Status history
+          hasCliScripts: this.hasCliScripts(),
+          scriptNames: Object.keys(this.cliScripts).filter((k) => typeof this.cliScripts[k] === "function"),
           statusHistory: this.statusHistory.slice(-30),
-          // Timeouts config
           timeouts: this.timeouts,
-          // PTY alive
           ptyAlive: !!this.ptyProcess
         };
       }
@@ -3987,6 +4221,9 @@ init_logger();
 
 // src/commands/chat-commands.ts
 init_logger();
+function getTargetedCliAdapter(h, args, providerType) {
+  return h.getCliAdapter(args?._targetInstance || h.currentIdeType || providerType);
+}
 async function handleChatHistory(h, args) {
   const { agentType, offset, limit, instanceId } = args;
   try {
@@ -3999,10 +4236,10 @@ async function handleChatHistory(h, args) {
   }
 }
 async function handleReadChat(h, args) {
-  const provider = h.getProvider();
+  const provider = h.getProvider(args?.agentType);
   const _log = (msg) => LOG.debug("Command", `[read_chat] ${msg}`);
   if (provider?.category === "cli" || provider?.category === "acp") {
-    const adapter = h.getCliAdapter(provider.type);
+    const adapter = getTargetedCliAdapter(h, args, provider.type);
     if (adapter) {
       _log(`${provider.category} adapter: ${adapter.cliType}`);
       const status = adapter.getStatus?.();
@@ -4118,7 +4355,7 @@ async function handleSendChat(h, args) {
   const text = args?.text || args?.message;
   if (!text) return { success: false, error: "text required" };
   const _log = (msg) => LOG.debug("Command", `[send_chat] ${msg}`);
-  const provider = h.getProvider();
+  const provider = h.getProvider(args?.agentType);
   const _logSendSuccess = (method, targetAgent) => {
     h.historyWriter.appendNewMessages(
       targetAgent || provider?.type || h.currentIdeType || "unknown_agent",
@@ -4130,7 +4367,7 @@ async function handleSendChat(h, args) {
     return { success: true, sent: true, method, targetAgent };
   };
   if (provider?.category === "cli" || provider?.category === "acp") {
-    const adapter = h.getCliAdapter(provider.type);
+    const adapter = getTargetedCliAdapter(h, args, provider.type);
     if (adapter) {
       _log(`${provider.category} adapter: ${adapter.cliType}`);
       try {
@@ -4283,7 +4520,7 @@ async function handleSendChat(h, args) {
   return { success: false, error: "No provider method could send the message" };
 }
 async function handleListChats(h, args) {
-  const provider = h.getProvider();
+  const provider = h.getProvider(args?.agentType);
   if (provider?.category === "extension" && h.agentStream && h.getCdp()) {
     try {
       const chats = await h.agentStream.listAgentChats(h.getCdp(), provider.type);
@@ -4335,7 +4572,16 @@ async function handleListChats(h, args) {
   return { success: false, error: "listSessions script not available for this provider" };
 }
 async function handleNewChat(h, args) {
-  const provider = h.getProvider();
+  const provider = h.getProvider(args?.agentType);
+  if (provider?.category === "cli") {
+    const adapter = getTargetedCliAdapter(h, args, provider.type);
+    if (!adapter) return { success: false, error: "CLI adapter not running" };
+    if (typeof adapter.clearHistory === "function") {
+      adapter.clearHistory();
+      return { success: true, cleared: true };
+    }
+    return { success: false, error: "new_chat not supported by this CLI provider" };
+  }
   if (provider?.category === "extension" && h.agentStream && h.getCdp()) {
     const ok = await h.agentStream.newAgentSession(h.getCdp(), provider.type, h.currentIdeType);
     return { success: ok };
@@ -4360,7 +4606,7 @@ async function handleNewChat(h, args) {
   return { success: false, error: "newSession script not available for this provider" };
 }
 async function handleSwitchChat(h, args) {
-  const provider = h.getProvider();
+  const provider = h.getProvider(args?.agentType);
   const ideType = h.currentIdeType;
   const sessionId = args?.sessionId || args?.id || args?.chatId;
   if (!sessionId) return { success: false, error: "sessionId required" };
@@ -4454,10 +4700,10 @@ async function handleSwitchChat(h, args) {
   }
 }
 async function handleSetMode(h, args) {
-  const provider = h.getProvider();
+  const provider = h.getProvider(args?.agentType);
   const mode = args?.mode || "agent";
   if (provider?.category === "acp") {
-    const adapter = h.getCliAdapter(provider.type);
+    const adapter = getTargetedCliAdapter(h, args, provider.type);
     if (adapter) {
       const acpInstance = adapter._acpInstance;
       if (acpInstance && typeof acpInstance.onEvent === "function") {
@@ -4509,11 +4755,11 @@ async function handleSetMode(h, args) {
   return { success: false, error: `setMode '${mode}' not supported by this provider` };
 }
 async function handleChangeModel(h, args) {
-  const provider = h.getProvider();
+  const provider = h.getProvider(args?.agentType);
   const model = args?.model;
   LOG.info("Command", `[change_model] model=${model} provider=${provider?.type} category=${provider?.category} ideType=${h.currentIdeType} providerType=${h.currentProviderType}`);
   if (provider?.category === "acp") {
-    const adapter = h.getCliAdapter(provider.type);
+    const adapter = getTargetedCliAdapter(h, args, provider.type);
     LOG.info("Command", `[change_model] ACP adapter found: ${!!adapter}, type=${adapter?.cliType}, hasAcpInstance=${!!adapter?._acpInstance}`);
     if (adapter) {
       const acpInstance = adapter._acpInstance;
@@ -4570,11 +4816,11 @@ async function handleSetThoughtLevel(h, args) {
   const configId = args?.configId;
   const value = args?.value;
   if (!configId || !value) return { success: false, error: "configId and value required" };
-  const provider = h.getProvider();
+  const provider = h.getProvider(args?.agentType);
   if (!provider || provider.category !== "acp") {
     return { success: false, error: "set_thought_level only for ACP providers" };
   }
-  const adapter = h.getCliAdapter(provider.type);
+  const adapter = getTargetedCliAdapter(h, args, provider.type);
   const acpInstance = adapter?._acpInstance;
   if (!acpInstance) return { success: false, error: "ACP instance not found" };
   try {
@@ -4586,13 +4832,22 @@ async function handleSetThoughtLevel(h, args) {
   }
 }
 async function handleResolveAction(h, args) {
-  const provider = h.getProvider();
+  const provider = h.getProvider(args?.agentType);
   const action = args?.action || "approve";
   const button = args?.button || args?.buttonText || (action === "approve" ? "Accept" : action === "reject" ? "Reject" : "Accept");
   LOG.info("Command", `[resolveAction] action=${action} button="${button}" provider=${provider?.type}`);
   if (provider?.category === "cli") {
-    const adapter = h.getCliAdapter(provider.type);
+    const adapter = getTargetedCliAdapter(h, args, provider.type);
     if (!adapter) return { success: false, error: "CLI adapter not running" };
+    if (args?.data && typeof adapter.resolveAction === "function") {
+      try {
+        await adapter.resolveAction(args.data);
+        LOG.info("Command", `[resolveAction] CLI PTY \u2192 resolveAction triggered with data payload`);
+        return { success: true, method: "cli-resolve-action" };
+      } catch (e) {
+        return { success: false, error: `CLI resolveAction failed: ${e.message}` };
+      }
+    }
     const status = adapter.getStatus?.();
     if (status?.status !== "waiting_approval") {
       return { success: false, error: "Not in approval state" };
@@ -6790,8 +7045,9 @@ var ProviderLoader = class _ProviderLoader {
     }
   }
   compareVersions(a, b) {
-    const pa = a.split(".").map(Number);
-    const pb = b.split(".").map(Number);
+    const normalize2 = (v) => v.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
+    const pa = normalize2(a);
+    const pb = normalize2(b);
     for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
       const va = pa[i] || 0;
       const vb = pb[i] || 0;
@@ -7868,21 +8124,27 @@ var CliProviderInstance = class {
   async onTick() {
   }
   getState() {
-    const adapterStatus = this.adapter.getStatus();
+    const rawStatus = this.adapter.getStatus();
+    const parsedStatus = this.adapter.getScriptParsedStatus();
+    const adapterStatus = parsedStatus ? {
+      ...rawStatus,
+      messages: parsedStatus.messages || rawStatus.messages,
+      activeModal: parsedStatus.activeModal || rawStatus.activeModal
+    } : rawStatus;
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
-    const recentMessages = adapterStatus.messages.slice(-50).map((m) => ({
-      role: m.role,
-      content: m.content.length > 2e3 ? m.content.slice(0, 2e3) + "\n... (truncated)" : m.content,
-      timestamp: m.timestamp
-    }));
+    const recentMessages = adapterStatus.messages.slice(-50).map((m) => {
+      const content = typeof m.content === "string" && m.content.length > 8e3 ? m.content.slice(0, 8e3) + "\n... (truncated)" : m.content;
+      return { ...m, content };
+    });
     const partial = this.adapter.getPartialResponse();
     if (adapterStatus.status === "generating" && partial) {
       const cleaned = partial.trim();
       if (cleaned && cleaned !== "(generating...)") {
         recentMessages.push({
           role: "assistant",
-          content: (cleaned.length > 2e3 ? cleaned.slice(0, 2e3) + "..." : cleaned) + "...",
-          timestamp: Date.now()
+          content: (cleaned.length > 8e3 ? cleaned.slice(0, 8e3) + "..." : cleaned) + "...",
+          timestamp: Date.now(),
+          meta: { streaming: true }
         });
       }
     }
@@ -7921,6 +8183,8 @@ var CliProviderInstance = class {
       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);
     }
   }
   dispose() {
@@ -8978,7 +9242,8 @@ var DaemonCliManager = class {
     const provider = this.providerLoader.getMeta(normalizedType);
     if (provider && provider.category === "cli" && provider.patterns && provider.spawn) {
       console.log(import_chalk.default.cyan(`  \u{1F4E6} Using provider: ${provider.name} (${provider.type})`));
-      return new ProviderCliAdapter(provider, workingDir, cliArgs);
+      const resolvedProvider = this.providerLoader.resolve(normalizedType) || provider;
+      return new ProviderCliAdapter(resolvedProvider, workingDir, cliArgs);
     }
     throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
   }
@@ -9063,7 +9328,8 @@ ${installInfo}`
     }
     const instanceManager = this.deps.getInstanceManager();
     if (provider && instanceManager) {
-      const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key);
+      const resolvedProvider = this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider;
+      const cliInstance = new CliProviderInstance(resolvedProvider, resolvedDir, cliArgs, key);
       try {
         await instanceManager.addInstance(key, cliInstance, {
           serverConn: this.deps.getServerConn(),
@@ -12261,6 +12527,46 @@ var DevServer = class _DevServer {
     }
   }
   // ─── Phase 2: Auto-Implement Backend ───
+  getDefaultAutoImplReference(category, type) {
+    if (category === "cli") {
+      return type === "codex-cli" ? "claude-cli" : "codex-cli";
+    }
+    return "antigravity";
+  }
+  resolveAutoImplReference(category, requestedReference, targetType) {
+    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) => p.category === category && p.type !== targetType);
+    return fallback?.type || null;
+  }
+  loadAutoImplReferenceScripts(category, referenceType) {
+    if (!referenceType) return {};
+    const builtinDir = this.providerLoader.getPrimaryBuiltinDir();
+    const refDir = path12.join(builtinDir, category, referenceType);
+    if (!fs9.existsSync(refDir)) return {};
+    const referenceScripts = {};
+    const scriptsDir = path12.join(refDir, "scripts");
+    if (!fs9.existsSync(scriptsDir)) return referenceScripts;
+    const versions = fs9.readdirSync(scriptsDir).filter((d) => {
+      try {
+        return fs9.statSync(path12.join(scriptsDir, d)).isDirectory();
+      } catch {
+        return false;
+      }
+    }).sort().reverse();
+    if (versions.length === 0) return referenceScripts;
+    const latestDir = path12.join(scriptsDir, versions[0]);
+    for (const file of fs9.readdirSync(latestDir)) {
+      if (!file.endsWith(".js")) continue;
+      try {
+        referenceScripts[file] = fs9.readFileSync(path12.join(latestDir, file), "utf-8");
+      } catch {
+      }
+    }
+    return referenceScripts;
+  }
   async handleAutoImplement(type, req, res) {
     const body = await this.readBody(req);
     const { agent = "claude-cli", functions, reference = "antigravity", model, comment } = body;
@@ -12283,36 +12589,26 @@ var DevServer = class _DevServer {
       return;
     }
     try {
-      this.sendAutoImplSSE({ event: "progress", data: { function: "_init", status: "analyzing", message: "\uC5D0\uC774\uC804\uD2B8 \uCD08\uAE30\uD654 (DOM \uD0D0\uC0C9 \uAD8C\uD55C \uBD80\uC5EC)..." } });
+      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;
-      this.sendAutoImplSSE({ event: "progress", data: { function: "_init", status: "loading_reference", message: `\uB808\uD37C\uB7F0\uC2A4 \uC2A4\uD06C\uB9BD\uD2B8 \uB85C\uB4DC \uC911 (${reference})...` } });
-      let referenceScripts = {};
-      const builtinDir = this.providerLoader.getPrimaryBuiltinDir();
-      const refDir = path12.join(builtinDir, "ide", reference);
-      if (fs9.existsSync(refDir)) {
-        const scriptsDir = path12.join(refDir, "scripts");
-        if (fs9.existsSync(scriptsDir)) {
-          const versions = fs9.readdirSync(scriptsDir).filter((d) => {
-            try {
-              return fs9.statSync(path12.join(scriptsDir, d)).isDirectory();
-            } catch {
-              return false;
-            }
-          }).sort().reverse();
-          if (versions.length > 0) {
-            const latestDir = path12.join(scriptsDir, versions[0]);
-            for (const file of fs9.readdirSync(latestDir)) {
-              if (file.endsWith(".js")) {
-                try {
-                  referenceScripts[file] = fs9.readFileSync(path12.join(latestDir, file), "utf-8");
-                } catch {
-                }
-              }
-            }
-          }
+      this.sendAutoImplSSE({
+        event: "progress",
+        data: {
+          function: "_init",
+          status: "loading_reference",
+          message: `Loading reference script (${resolvedReference || "none"})...`
         }
-      }
-      const prompt = this.buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts, comment);
+      });
+      const referenceScripts = this.loadAutoImplReferenceScripts(provider.category, resolvedReference);
+      const prompt = this.buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference);
       const tmpDir = path12.join(os14.tmpdir(), "adhdev-autoimpl");
       if (!fs9.existsSync(tmpDir)) fs9.mkdirSync(tmpDir, { recursive: true });
       const promptFile = path12.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
@@ -12330,7 +12626,7 @@ var DevServer = class _DevServer {
       }
       const agentCategory = agentProvider?.category;
       if (agentCategory === "acp") {
-        this.sendAutoImplSSE({ event: "progress", data: { function: "_init", status: "spawning", message: `ACP \uC5D0\uC774\uC804\uD2B8 \uC2E4\uD589 \uC911: ${spawn3.command} ${(spawn3.args || []).join(" ")}` } });
+        this.sendAutoImplSSE({ event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn3.command} ${(spawn3.args || []).join(" ")}` } });
         this.autoImplStatus = { running: true, type, progress: [] };
         const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await import("@agentclientprotocol/sdk");
         const { Readable: Readable2, Writable: Writable2 } = await import("stream");
@@ -12417,7 +12713,7 @@ var DevServer = class _DevServer {
           this.autoImplProcess = null;
           this.autoImplStatus.running = false;
           const success = code === 0;
-          this.sendAutoImplSSE({ event: "complete", data: { success, exitCode: code, functions, message: success ? "\u2705 ACP Auto-implement \uC644\uB8CC" : `\u274C ACP \uC5D0\uC774\uC804\uD2B8 \uC885\uB8CC (code: ${code})` } });
+          this.sendAutoImplSSE({ event: "complete", data: { success, exitCode: code, functions, message: success ? "\u2705 ACP Auto-implement complete" : `\u274C ACP agent exited (code: ${code})` } });
           try {
             this.providerLoader.reload();
           } catch {
@@ -12432,16 +12728,16 @@ var DevServer = class _DevServer {
           try {
             this.sendAutoImplSSE({ event: "progress", data: { function: "_init", status: "initializing", message: "ACP initialize..." } });
             await connection.initialize({ protocolVersion: PROTOCOL_VERSION2, clientCapabilities: {} });
-            this.sendAutoImplSSE({ event: "progress", data: { function: "_init", status: "session", message: "ACP session \uC0DD\uC131 \uC911..." } });
+            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: `\uD504\uB86C\uD504\uD2B8 \uC804\uC1A1 \uC911 (${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: "\u2705 ACP \uD504\uB86C\uD504\uD2B8 \uCC98\uB9AC \uC644\uB8CC" } });
+            this.sendAutoImplSSE({ event: "progress", data: { function: "_done", status: "complete", message: "\u2705 ACP prompt processing complete" } });
           } catch (e) {
             this.sendAutoImplSSE({ event: "output", data: { chunk: `[ACP Error] ${e.message}
 `, stream: "stderr" } });
@@ -12493,7 +12789,7 @@ var DevServer = class _DevServer {
         const escapedArgs = baseArgs.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ");
         shellCmd = `cat '${promptFile}' | ${command} ${escapedArgs}`;
       }
-      this.sendAutoImplSSE({ event: "progress", data: { function: "_init", status: "spawning", message: `\uC5D0\uC774\uC804\uD2B8 \uC2E4\uD589 \uC911: ${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();
       let child;
@@ -12589,7 +12885,7 @@ var DevServer = class _DevServer {
           const success = code === 0;
           this.sendAutoImplSSE({
             event: "complete",
-            data: { success, exitCode: code, functions, message: success ? "\u2705 Auto-implement \uC644\uB8CC" : `\u274C \uC5D0\uC774\uC804\uD2B8 \uC885\uB8CC (code: ${code})` }
+            data: { success, exitCode: code, functions, message: success ? "\u2705 Auto-implement complete" : `\u274C Agent exited (code: ${code})` }
           });
           try {
             this.providerLoader.reload();
@@ -12624,7 +12920,7 @@ var DevServer = class _DevServer {
               success,
               exitCode: code,
               functions,
-              message: success ? "\u2705 Auto-implement \uC644\uB8CC" : `\u274C \uC5D0\uC774\uC804\uD2B8 \uC885\uB8CC (code: ${code})`
+              message: success ? "\u2705 Auto-implement complete" : `\u274C Agent exited (code: ${code})`
             }
           });
           try {
@@ -12652,7 +12948,10 @@ var DevServer = class _DevServer {
       this.json(res, 500, { error: `Auto-implement failed: ${e.message}` });
     }
   }
-  buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts, userComment) {
+  buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts, userComment, referenceType) {
+    if (provider.category === "cli") {
+      return this.buildCliAutoImplPrompt(type, provider, providerDir, functions, referenceScripts, userComment, referenceType);
+    }
     const lines = [];
     lines.push("You are implementing browser automation scripts for an IDE provider.");
     lines.push("Be concise. Do NOT explain your reasoning. Just edit files directly.");
@@ -12715,7 +13014,7 @@ var DevServer = class _DevServer {
       setMode: "set_mode.js"
     };
     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) {
@@ -12864,6 +13163,150 @@ var DevServer = class _DevServer {
     lines.push("Start NOW. Do not ask for permission. Explore the DOM -> Code -> Test.");
     return lines.join("\n");
   }
+  buildCliAutoImplPrompt(type, provider, providerDir, functions, referenceScripts, userComment, referenceType) {
+    const lines = [];
+    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 = path12.join(providerDir, "scripts");
+    if (fs9.existsSync(scriptsDir)) {
+      const versions = fs9.readdirSync(scriptsDir).filter((d) => {
+        try {
+          return fs9.statSync(path12.join(scriptsDir, d)).isDirectory();
+        } catch {
+          return false;
+        }
+      }).sort().reverse();
+      if (versions.length > 0) {
+        const vDir = path12.join(scriptsDir, versions[0]);
+        lines.push(`Scripts version directory: \`${vDir}\``);
+        lines.push("");
+        for (const file of fs9.readdirSync(vDir)) {
+          if (!file.endsWith(".js")) continue;
+          try {
+            const content = fs9.readFileSync(path12.join(vDir, file), "utf-8");
+            lines.push(`### \`${file}\``);
+            lines.push("```javascript");
+            lines.push(content);
+            lines.push("```");
+            lines.push("");
+          } catch {
+          }
+        }
+      }
+    }
+    const funcToFile = {
+      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} \u2192 \`${fileName}\``);
+          lines.push("```javascript");
+          lines.push(referenceScripts[fileName]);
+          lines.push("```");
+          lines.push("");
+        }
+      }
+      if (referenceScripts["scripts.js"]) {
+        lines.push("### Router \u2192 `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 }` | `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("");
+    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("### 3. Send a rich test 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}","text":"Write a short python snippet, include a markdown table, and briefly explain what you did."}'`);
+    lines.push("```");
+    lines.push("");
+    lines.push("### 4. If approval appears, resolve it");
+    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}","buttonIndex":0}'`);
+    lines.push("```");
+    lines.push("");
+    lines.push("### 5. 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}"}'`);
+    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. Re-run the debug endpoints after edits. Do NOT finish until the parsed result looks correct.");
+    lines.push("");
+    if (userComment) {
+      lines.push("## \u26A0\uFE0F 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");
+  }
   handleAutoImplSSE(type, req, res) {
     res.writeHead(200, {
       "Content-Type": "text/event-stream",
@@ -12891,7 +13334,7 @@ data: ${JSON.stringify(p.data)}
       setTimeout(() => {
         if (this.autoImplProcess) this.autoImplProcess.kill("SIGKILL");
       }, 3e3);
-      this.sendAutoImplSSE({ event: "complete", data: { success: false, exitCode: -1, message: "\u26D4 \uC0AC\uC6A9\uC790\uC5D0 \uC758\uD574 \uC911\uB2E8\uB428" } });
+      this.sendAutoImplSSE({ event: "complete", data: { success: false, exitCode: -1, message: "\u26D4 Aborted by user" } });
       this.autoImplProcess = null;
       this.autoImplStatus.running = false;
       this.json(res, 200, { cancelled: true });