@dmsdc-ai/aigentry-deliberation 0.0.13 → 0.0.15

package/README.md

@@ -1,6 +1,10 @@
 # @dmsdc-ai/aigentry-deliberation
 
-MCP Deliberation Server — Multi-session AI deliberation with smart speaker ordering and persona roles.
+Part of aigentry — the open-source engine that makes AI decisions auditable.
+
+**The only tool that lets multiple AIs debate before deciding.**
+
+MCP Deliberation Server — Multi-session AI deliberation with smart speaker ordering and persona roles. No competitor has this: aigentry-deliberation is the killer feature of the aigentry platform, enabling structured multi-AI debate with full audit trails before any decision is committed.
 
 ## Features
 
@@ -87,6 +91,17 @@ npx @dmsdc-ai/aigentry-deliberation uninstall
 | `researcher` | Data, benchmarks, references |
 | `free` | No role constraint (default) |
 
+## aigentry Ecosystem
+
+aigentry-deliberation is one component of the unified aigentry platform. All packages work together to make AI decisions transparent and auditable.
+
+| Package | Description |
+|---------|-------------|
+| [`@dmsdc-ai/aigentry-brain`](https://github.com/dmsdc-ai/aigentry-brain) | Cross-LLM memory OS |
+| [`@dmsdc-ai/aigentry-devkit`](https://github.com/dmsdc-ai/aigentry-devkit) | Developer tools and hooks |
+| [`aigentry-registry`](https://github.com/dmsdc-ai/aigentry-registry) | AI agent evaluation (Python) |
+| [`aigentry-ssot`](https://github.com/dmsdc-ai/aigentry-ssot) | MCP contract schemas |
+
 ## License
 
 MIT

package/browser-control-port.js

@@ -194,6 +194,7 @@ class DevToolsMcpAdapter extends BrowserControlPort {
       timing: selectorConfig.timing,
       pageUrl: foundTab.url,
       title: foundTab.title,
+      modelSelector: selectorConfig.modelSelector || null,
     });
 
     return makeResult(true, {
@@ -221,77 +222,290 @@ class DevToolsMcpAdapter extends BrowserControlPort {
     }
 
     try {
-      // Step 1: Focus input and insert text via execCommand for React/ProseMirror compatibility
+      // Capture baseline response count BEFORE send (for waitTurnResult to detect NEW responses)
+      const respContSel = JSON.stringify(binding.selectors.responseContainer);
+      const respSel = JSON.stringify(binding.selectors.responseSelector);
+      const baseline = await this._cdpEvaluate(binding, `
+        (function() {
+          var cc = 0, dc = 0;
+          ${respContSel}.split(',').forEach(function(s) {
+            try { cc += document.querySelectorAll(s.trim()).length; } catch(e) {}
+          });
+          ${respSel}.split(',').forEach(function(s) {
+            try { dc += document.querySelectorAll(s.trim()).length; } catch(e) {}
+          });
+          return { containerCount: cc, directCount: dc };
+        })()
+      `);
+      binding._baselineResponseCount = baseline.data?.containerCount || 0;
+      binding._baselineDirectCount = baseline.data?.directCount || 0;
+      binding._lastSentText = text; // Store for response filtering
+
+      // Step 1: Focus input and insert text
       const inputSel = JSON.stringify(binding.selectors.inputSelector);
       const sendBtnSel = JSON.stringify(binding.selectors.sendButton);
       const escapedText = JSON.stringify(text);
 
-      const result = await this._cdpEvaluate(binding, `
+      // Focus the input element first — use click() + focus() for full framework initialization
+      const focusInput = await this._cdpEvaluate(binding, `
         (function() {
-          const input = document.querySelector(${inputSel});
-          if (!input) return { ok: false, error: 'INPUT_NOT_FOUND' };
-
-          // Focus and select all existing content
-          input.focus();
-          if (input.isContentEditable) {
-            // For contenteditable (ChatGPT ProseMirror, Claude, etc.)
-            const sel = window.getSelection();
-            const range = document.createRange();
-            range.selectNodeContents(input);
-            sel.removeAllRanges();
-            sel.addRange(range);
-            // execCommand triggers framework state updates (React, ProseMirror, Quill)
-            document.execCommand('insertText', false, ${escapedText});
-          } else {
-            // For regular <textarea>/<input>
-            const nativeSetter = Object.getOwnPropertyDescriptor(
-              Object.getPrototypeOf(input), 'value'
-            )?.set || Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
-            if (nativeSetter) {
-              nativeSetter.call(input, ${escapedText});
-            } else {
-              input.value = ${escapedText};
+          var sels = ${inputSel}.split(',').map(function(s) { return s.trim(); });
+          for (var i = 0; i < sels.length; i++) {
+            var input = document.querySelector(sels[i]);
+            if (input) {
+              input.click();
+              input.focus();
+              return { ok: true, isContentEditable: input.isContentEditable, tagName: input.tagName };
             }
-            input.dispatchEvent(new Event('input', { bubbles: true }));
-            input.dispatchEvent(new Event('change', { bubbles: true }));
           }
-          return { ok: true };
+          return { ok: false, error: 'INPUT_NOT_FOUND' };
         })()
       `);
 
-      if (!result.ok) {
+      if (!focusInput.ok || focusInput.data?.error) {
         return makeResult(false, null, {
           code: "DOM_CHANGED",
           message: `Input selector not found: ${binding.selectors.inputSelector}`,
         });
       }
 
+      const isCE = focusInput.data?.isContentEditable;
+
+      if (isCE) {
+        // For contenteditable: use CDP Input.insertText (works with tiptap/ProseMirror/Quill)
+        // First clear existing content
+        await this._cdpEvaluate(binding, `
+          (function() {
+            var sels = ${inputSel}.split(',').map(function(s) { return s.trim(); });
+            var input = null;
+            for (var i = 0; i < sels.length; i++) { input = document.querySelector(sels[i]); if (input) break; }
+            if (!input) return { ok: true };
+            input.click();
+            input.focus();
+            var sel = window.getSelection();
+            var range = document.createRange();
+            range.selectNodeContents(input);
+            sel.removeAllRanges();
+            sel.addRange(range);
+            document.execCommand('delete', false);
+            return { ok: true };
+          })()
+        `);
+        await new Promise(r => setTimeout(r, 50));
+
+        // Use CDP Input.insertText — triggers all framework handlers (tiptap, ProseMirror, Quill)
+        try {
+          await this._cdpCommand(binding, "Input.insertText", { text });
+        } catch {
+          // Fallback: execCommand (works for tiptap when properly focused via click)
+          await this._cdpEvaluate(binding, `
+            (function() {
+              var sels = ${inputSel}.split(',').map(function(s) { return s.trim(); });
+              for (var i = 0; i < sels.length; i++) {
+                var input = document.querySelector(sels[i]);
+                if (input) { input.click(); input.focus(); document.execCommand('insertText', false, ${escapedText}); break; }
+              }
+              return { ok: true };
+            })()
+          `);
+        }
+      } else {
+        // For regular <textarea>/<input>: clear existing content, then use CDP Input.insertText
+        await this._cdpEvaluate(binding, `
+          (function() {
+            var input = document.querySelector(${inputSel});
+            if (!input) return { ok: true };
+            input.focus();
+            input.select ? input.select() : null;
+            input.value = '';
+            input.dispatchEvent(new Event('input', { bubbles: true }));
+            return { ok: true };
+          })()
+        `);
+        await new Promise(r => setTimeout(r, 50));
+
+        // CDP Input.insertText triggers OS-level text input
+        try {
+          await this._cdpCommand(binding, "Input.insertText", { text });
+        } catch {
+          // Fallback: nativeSetter approach
+          await this._cdpEvaluate(binding, `
+            (function() {
+              var input = document.querySelector(${inputSel});
+              if (!input) return { ok: true };
+              var nativeSetter = Object.getOwnPropertyDescriptor(
+                Object.getPrototypeOf(input), 'value'
+              );
+              if (nativeSetter && nativeSetter.set) {
+                nativeSetter.set.call(input, ${escapedText});
+              } else {
+                input.value = ${escapedText};
+              }
+              input.dispatchEvent(new Event('input', { bubbles: true }));
+              input.dispatchEvent(new Event('change', { bubbles: true }));
+              return { ok: true };
+            })()
+          `);
+        }
+
+        // Sync React/Vue state: CDP Input.insertText updates DOM but may not trigger React onChange.
+        // Re-set value via nativeSetter + dispatch input event to force framework state sync.
+        await this._cdpEvaluate(binding, `
+          (function() {
+            var sels = ${inputSel}.split(',').map(function(s) { return s.trim(); });
+            for (var i = 0; i < sels.length; i++) {
+              var input = document.querySelector(sels[i]);
+              if (input && input.value) {
+                var proto = Object.getPrototypeOf(input);
+                var desc = Object.getOwnPropertyDescriptor(proto, 'value');
+                if (desc && desc.set) {
+                  desc.set.call(input, input.value);
+                }
+                input.dispatchEvent(new Event('input', { bubbles: true }));
+                input.dispatchEvent(new Event('change', { bubbles: true }));
+                return { ok: true };
+              }
+            }
+            return { ok: true };
+          })()
+        `);
+      }
+
       // Small delay for framework state propagation
       await new Promise(r => setTimeout(r, binding.timing?.sendDelayMs || 200));
 
-      // Step 2: Send via Enter key (primary) + button click (fallback)
-      const sendResult = await this._cdpEvaluate(binding, `
-        (function() {
-          const input = document.querySelector(${inputSel});
-          if (!input) return { ok: false, error: 'INPUT_NOT_FOUND' };
-
-          // Primary: dispatch Enter key event on the input
-          input.focus();
-          const enterEvent = new KeyboardEvent('keydown', {
-            key: 'Enter', code: 'Enter',
-            keyCode: 13, which: 13,
-            bubbles: true, cancelable: true
+      // Step 2: Send — strategy depends on input type
+      if (isCE) {
+        // For contenteditable (ProseMirror/Quill/tiptap): click send button (Enter = newline)
+        // Retry up to 4 times with delay — send button may appear after framework state update
+        let sendAttempted = false;
+        for (let attempt = 0; attempt < 4 && !sendAttempted; attempt++) {
+          if (attempt > 0) await new Promise(r => setTimeout(r, 400));
+          const sendResult = await this._cdpEvaluate(binding, `
+            (function() {
+              var btnSels = ${sendBtnSel}.split(',').map(function(s) { return s.trim(); });
+              for (var i = 0; i < btnSels.length; i++) {
+                try {
+                  var btn = document.querySelector(btnSels[i]);
+                  if (!btn) continue;
+                  var isVisible = btn.offsetParent !== null || btn.getClientRects().length > 0;
+                  var isEnabled = btn.getAttribute('aria-disabled') !== 'true' && !btn.disabled;
+                  if (isVisible && isEnabled) {
+                    // Use MouseEvent dispatch (works with React, div[role=button], etc.)
+                    btn.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));
+                    btn.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true }));
+                    btn.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+                    return { ok: true, method: 'button', sel: btnSels[i], attempt: ${attempt} };
+                  }
+                } catch(e) {}
+              }
+              // Fallback: try form submit
+              var input = document.querySelector(${inputSel});
+              var form = input ? input.closest('form') : null;
+              if (form) {
+                form.requestSubmit ? form.requestSubmit() : form.submit();
+                return { ok: true, method: 'form-submit' };
+              }
+              return { ok: false, method: 'none' };
+            })()
+          `);
+          if (sendResult.data?.method !== 'none') {
+            sendAttempted = true;
+          }
+        }
+        // Last resort: try Enter key via CDP (may work for some editors)
+        if (!sendAttempted) {
+          try {
+            await this._cdpCommand(binding, "Input.dispatchKeyEvent", {
+              type: "rawKeyDown", key: "Enter", code: "Enter",
+              windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+            });
+            await this._cdpCommand(binding, "Input.dispatchKeyEvent", {
+              type: "keyUp", key: "Enter", code: "Enter",
+              windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+            });
+          } catch {}
+        }
+      } else {
+        // For regular textarea/input: try send button click FIRST (more reliable), Enter as fallback
+        // Step 2a: Try clicking send button (prefer LAST match — rightmost button is typically send)
+        let textareaSendClicked = false;
+        const btnClickResult = await this._cdpEvaluate(binding, `
+          (function() {
+            var btnSels = ${sendBtnSel}.split(',').map(function(s) { return s.trim(); });
+            // Collect ALL matching buttons
+            var allBtns = [];
+            for (var i = 0; i < btnSels.length; i++) {
+              try {
+                var matches = document.querySelectorAll(btnSels[i]);
+                for (var j = 0; j < matches.length; j++) allBtns.push({ el: matches[j], sel: btnSels[i] });
+              } catch(e) {}
+            }
+            // Try in REVERSE order — last matching button near input is typically the send button
+            for (var k = allBtns.length - 1; k >= 0; k--) {
+              var btn = allBtns[k].el;
+              var isVisible = btn.offsetParent !== null || btn.getClientRects().length > 0;
+              var isEnabled = btn.getAttribute('aria-disabled') !== 'true' && !btn.disabled;
+              if (isVisible && isEnabled) {
+                btn.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));
+                btn.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true }));
+                btn.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+                return { ok: true, method: 'button-reverse', sel: allBtns[k].sel, idx: k };
+              }
+            }
+            return { ok: false, method: 'none', btnCount: allBtns.length };
+          })()
+        `);
+        textareaSendClicked = btnClickResult.data?.method !== 'none';
+
+        // Step 2b: Also send Enter key (some providers need it in addition to or instead of button)
+        await new Promise(r => setTimeout(r, 100));
+        const focusResult = await this._cdpEvaluate(binding, `
+          (function() {
+            var sels = ${inputSel}.split(',').map(function(s) { return s.trim(); });
+            for (var i = 0; i < sels.length; i++) {
+              var input = document.querySelector(sels[i]);
+              if (input) { input.focus(); return { ok: true }; }
+            }
+            return { ok: false };
+          })()
+        `);
+
+        try {
+          await this._cdpCommand(binding, "Input.dispatchKeyEvent", {
+            type: "rawKeyDown", key: "Enter", code: "Enter",
+            windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+          });
+          await this._cdpCommand(binding, "Input.dispatchKeyEvent", {
+            type: "char", key: "\r", code: "Enter",
+            windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
           });
-          input.dispatchEvent(enterEvent);
+          await this._cdpCommand(binding, "Input.dispatchKeyEvent", {
+            type: "keyUp", key: "Enter", code: "Enter",
+            windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13,
+          });
+        } catch {
+          // JS fallback
+          await this._cdpEvaluate(binding, `
+            (function() {
+              var sels = ${inputSel}.split(',').map(function(s) { return s.trim(); });
+              for (var i = 0; i < sels.length; i++) {
+                var input = document.querySelector(sels[i]);
+                if (input) {
+                  input.focus();
+                  ['keydown','keypress','keyup'].forEach(function(t) {
+                    input.dispatchEvent(new KeyboardEvent(t, { key:'Enter', code:'Enter', keyCode:13, which:13, bubbles:true, cancelable:true }));
+                  });
+                  break;
+                }
+              }
+              return { ok: true };
+            })()
+          `);
+        }
+      }
 
-          // Fallback: also click send button if it exists and is enabled
-          const btn = document.querySelector(${sendBtnSel});
-          if (btn && !btn.disabled) {
-            btn.click();
-          }
-          return { ok: true };
-        })()
-      `);
+      const sendResult = { ok: true };
 
       if (!sendResult.ok) {
         return makeResult(false, null, {
@@ -323,22 +537,122 @@ class DevToolsMcpAdapter extends BrowserControlPort {
     const streamSel = JSON.stringify(binding.selectors.streamingIndicator);
     const respContSel = JSON.stringify(binding.selectors.responseContainer);
     const respSel = JSON.stringify(binding.selectors.responseSelector);
+    const baselineContainers = binding._baselineResponseCount || 0;
+    const baselineDirect = binding._baselineDirectCount || 0;
+    const sentText = JSON.stringify(binding._lastSentText || "");
+
+    let lastSeenText = '';
+    let stableCount = 0;
 
     try {
       while (Date.now() - startTime < timeoutMs) {
-        // Check if streaming is complete
+        const elapsed = Date.now() - startTime;
         const status = await this._cdpEvaluate(binding, `
           (function() {
-            const streaming = document.querySelector(${streamSel});
-            if (streaming) return { streaming: true };
-            const responses = document.querySelectorAll(${respContSel});
-            if (responses.length === 0) return { streaming: true };
-            const last = responses[responses.length - 1];
-            const content = last.querySelector(${respSel});
-            return {
-              streaming: false,
-              text: content ? content.textContent : last.textContent,
-            };
+            var sentMsg = ${sentText};
+
+            // Helper: check if text is actually a response (not user echo, placeholder, or UI noise)
+            function isResponse(txt) {
+              if (!txt || !txt.trim()) return false;
+              var t = txt.trim();
+              // Reject if text is exact match of sent message (user echo)
+              if (sentMsg && t === sentMsg) return false;
+              // Reject if text is >80% similar to sent message (likely echo with minor formatting diff)
+              if (sentMsg && t.length > 20 && (t.includes(sentMsg) || sentMsg === t.substring(0, sentMsg.length))) return false;
+              // Reject known loading/placeholder texts
+              var placeholders = ['...', '…', '생각 중...', '생각 중', '생각이 끝났습니다',
+                '조금만 더 기다려 주세요', '조금만 더 기다려 주세요.', 'Thinking', 'Thinking...',
+                'Loading', 'Loading...', 'Generating', 'Generating...'];
+              if (placeholders.indexOf(t) >= 0) return false;
+              // Reject very short text (likely placeholder dots or single chars)
+              if (t.length < 2) return false;
+              return true;
+            }
+
+            // Helper: clean container text (strip common UI noise like button labels, timestamps)
+            function cleanContainerText(txt) {
+              if (!txt) return '';
+              // Remove common UI text patterns appended by buttons
+              return txt.replace(/\s*(Copied|Copy|복사|복사됨|공유|Share)\s*$/gi, '')
+                        .replace(/\s*(오전|오후)\s+\d{1,2}:\d{2}\s*$/g, '') // Korean timestamps
+                        .replace(/\s*\d+\.\d+초\s*$/g, '') // Duration indicators
+                        .trim();
+            }
+
+            // Step 1: Check streaming indicators
+            var isStreaming = false;
+            var streamSels = ${streamSel}.split(',').map(function(s) { return s.trim(); });
+            for (var i = 0; i < streamSels.length; i++) {
+              try { if (document.querySelector(streamSels[i])) { isStreaming = true; break; } } catch(e) {}
+            }
+
+            // Step 2: Try to extract response text (even if streaming — for stabilization)
+            var candidateText = '';
+            var candidateStrategy = '';
+
+            var contSels = ${respContSel}.split(',').map(function(s) { return s.trim(); });
+            var allContainers = [];
+            for (var i = 0; i < contSels.length; i++) {
+              try {
+                var found = document.querySelectorAll(contSels[i]);
+                for (var j = 0; j < found.length; j++) allContainers.push(found[j]);
+              } catch(e) {}
+            }
+
+            if (allContainers.length > ${baselineContainers}) {
+              var last = allContainers[allContainers.length - 1];
+              // Scroll into view to force content-visibility rendering (ChatGPT workaround)
+              try { last.scrollIntoView({ block: 'end' }); } catch(e) {}
+              var respSels = ${respSel}.split(',').map(function(s) { return s.trim(); });
+              for (var i = 0; i < respSels.length; i++) {
+                try {
+                  var content = last.querySelector(respSels[i]);
+                  // Try textContent first, then innerText as fallback for content-visibility
+                  var txt = content ? (content.textContent || content.innerText || '') : '';
+                  if (isResponse(txt)) {
+                    candidateText = txt;
+                    candidateStrategy = 'container';
+                    break;
+                  }
+                } catch(e) {}
+              }
+              if (!candidateText) {
+                var rawTxt = cleanContainerText(last.textContent);
+                if (isResponse(rawTxt)) {
+                  candidateText = rawTxt;
+                  candidateStrategy = 'container-text';
+                }
+              }
+            }
+
+            // Step 3: Fallback — try responseSelector directly (after 3s)
+            if (!candidateText && ${elapsed} >= 3000) {
+              var respSels2 = ${respSel}.split(',').map(function(s) { return s.trim(); });
+              var allDirect = [];
+              for (var i = 0; i < respSels2.length; i++) {
+                try {
+                  var found = document.querySelectorAll(respSels2[i]);
+                  for (var j = 0; j < found.length; j++) allDirect.push(found[j]);
+                } catch(e) {}
+              }
+              if (allDirect.length > ${baselineDirect}) {
+                for (var k = allDirect.length - 1; k >= ${baselineDirect}; k--) {
+                  var txt = allDirect[k].textContent?.trim();
+                  if (isResponse(txt)) {
+                    candidateText = txt;
+                    candidateStrategy = 'direct';
+                    break;
+                  }
+                }
+              }
+            }
+
+            // If not streaming and we have text, done
+            if (!isStreaming && candidateText) {
+              return { streaming: false, text: candidateText, strategy: candidateStrategy };
+            }
+            // Return streaming status + candidate text for stabilization tracking
+            return { streaming: true, candidateText: candidateText || '' };
           })()
         `);
 
@@ -347,9 +661,28 @@ class DevToolsMcpAdapter extends BrowserControlPort {
             turnId,
             response: status.data.text.trim(),
             elapsedMs: Date.now() - startTime,
+            strategy: status.data.strategy,
           });
         }
 
+        // Text stabilization: if streaming indicator persists but text hasn't changed for 3+ polls, consider done
+        if (status.data?.candidateText) {
+          if (status.data.candidateText === lastSeenText) {
+            stableCount++;
+            if (stableCount >= 3) {
+              return makeResult(true, {
+                turnId,
+                response: status.data.candidateText.trim(),
+                elapsedMs: Date.now() - startTime,
+                strategy: 'stabilized',
+              });
+            }
+          } else {
+            lastSeenText = status.data.candidateText;
+            stableCount = 0;
+          }
+        }
+
         await new Promise(r => setTimeout(r, pollInterval));
       }
 
@@ -362,6 +695,120 @@ class DevToolsMcpAdapter extends BrowserControlPort {
     }
   }
 
+  async switchModel(sessionId, modelName) {
+    const binding = this.bindings.get(sessionId);
+    if (!binding) {
+      return makeResult(false, null, { code: "BIND_FAILED", message: "No binding for session. Call attach() first." });
+    }
+
+    const modelSel = binding.modelSelector;
+    if (!modelSel) {
+      return makeResult(true, { skipped: true, reason: "No model selector config for this provider" });
+    }
+
+    const triggerSel = JSON.stringify(modelSel.trigger);
+    const optionSel = JSON.stringify(modelSel.optionSelector || "[role='option'], [role='menuitem'], li");
+    const escapedModel = JSON.stringify(modelName.toLowerCase());
+
+    try {
+      const result = await this._cdpEvaluate(binding, `
+        (function() {
+          var trigger = document.querySelector(${triggerSel});
+          if (!trigger) return { ok: false, error: 'TRIGGER_NOT_FOUND' };
+          trigger.click();
+
+          return new Promise(function(resolve) {
+            setTimeout(function() {
+              var optSels = ${optionSel}.split(',').map(function(s) { return s.trim(); });
+              var allOptions = [];
+              for (var i = 0; i < optSels.length; i++) {
+                try {
+                  var found = document.querySelectorAll(optSels[i]);
+                  for (var j = 0; j < found.length; j++) allOptions.push(found[j]);
+                } catch(e) {}
+              }
+
+              var target = null;
+              for (var k = 0; k < allOptions.length; k++) {
+                var text = (allOptions[k].textContent || '').toLowerCase().trim();
+                if (text.indexOf(${escapedModel}) >= 0) {
+                  target = allOptions[k];
+                  break;
+                }
+              }
+
+              if (!target) {
+                resolve({ ok: false, error: 'MODEL_OPTION_NOT_FOUND', searched: allOptions.length });
+                return;
+              }
+
+              target.click();
+
+              setTimeout(function() {
+                resolve({ ok: true, matched: target.textContent.trim() });
+              }, 200);
+            }, 300);
+          });
+        })()
+      `);
+
+      if (!result.ok || (result.data && result.data.ok === false)) {
+        var errData = result.data || {};
+        return makeResult(false, null, {
+          code: "DOM_CHANGED",
+          message: errData.error || "Model switch failed",
+          detail: errData,
+        });
+      }
+
+      return makeResult(true, { modelName, matched: result.data?.matched });
+    } catch (err) {
+      return this._classifyError(err);
+    }
+  }
+
+  async checkLogin(sessionId) {
+    const binding = this.bindings.get(sessionId);
+    if (!binding) return null;
+
+    try {
+      const inputSel = JSON.stringify(binding.selectors.inputSelector);
+      const result = await this._cdpEvaluate(binding, `
+        (function() {
+          var url = location.href.toLowerCase();
+
+          // Check for login/auth URL patterns
+          var loginUrlPatterns = ['/login', '/signin', '/sign-in', '/auth', '/oauth', '/sso', '/accounts'];
+          var isLoginUrl = loginUrlPatterns.some(function(p) { return url.indexOf(p) >= 0; });
+
+          // Check for login form indicators
+          var hasPasswordField = !!document.querySelector('input[type="password"]');
+          var loginTexts = ['sign in', 'log in', 'login', '로그인', '登录', 'continue with google', 'continue with email'];
+          var bodyText = document.body ? document.body.textContent.substring(0, 2000).toLowerCase() : '';
+          var hasLoginText = loginTexts.some(function(t) { return bodyText.indexOf(t) >= 0; }) && hasPasswordField;
+
+          // Check if chat input exists (logged-in indicator)
+          var inputSels = ${inputSel}.split(',').map(function(s) { return s.trim(); });
+          var hasInput = false;
+          for (var i = 0; i < inputSels.length; i++) {
+            if (document.querySelector(inputSels[i])) { hasInput = true; break; }
+          }
+
+          if (hasInput) return { loggedIn: true };
+          if (isLoginUrl) return { loggedIn: false, reason: 'login_page_url', url: url.substring(0, 100) };
+          if (hasPasswordField && hasLoginText) return { loggedIn: false, reason: 'login_form_detected', url: url.substring(0, 100) };
+          if (!hasInput && document.readyState === 'complete') {
+            return { loggedIn: false, reason: 'no_chat_input_found', url: url.substring(0, 100) };
+          }
+          return { loggedIn: true };
+        })()
+      `);
+      return result.data;
+    } catch {
+      return null;
+    }
+  }
+
   async health(sessionId) {
     const binding = this.bindings.get(sessionId);
     if (!binding) {
@@ -561,6 +1008,14 @@ class OrchestratedBrowserPort {
     return this.adapter.waitTurnResult(sessionId, turnId, timeoutSec);
   }
 
+  async switchModel(sessionId, modelName) {
+    return this.adapter.switchModel(sessionId, modelName);
+  }
+
+  async checkLogin(sessionId) {
+    return this.adapter.checkLogin(sessionId);
+  }
+
   async health(sessionId) {
     return this.adapter.health(sessionId);
   }

package/index.js

@@ -66,6 +66,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 import os from "os";
 import { OrchestratedBrowserPort } from "./browser-control-port.js";
+import { getModelSelectionForTurn } from "./model-router.js";
 
 // ── Paths ──────────────────────────────────────────────────────
 
@@ -135,7 +136,7 @@ const DEFAULT_WEB_SPEAKERS = [
   { speaker: "web-gemini", provider: "gemini", name: "Gemini", url: "https://gemini.google.com" },
   { speaker: "web-copilot", provider: "copilot", name: "Copilot", url: "https://copilot.microsoft.com" },
   { speaker: "web-perplexity", provider: "perplexity", name: "Perplexity", url: "https://perplexity.ai" },
-  { speaker: "web-deepseek", provider: "deepseek", name: "DeepSeek", url: "https://deepseek.com" },
+  { speaker: "web-deepseek", provider: "deepseek", name: "DeepSeek", url: "https://chat.deepseek.com" },
   { speaker: "web-mistral", provider: "mistral", name: "Mistral", url: "https://mistral.ai" },
   { speaker: "web-poe", provider: "poe", name: "Poe", url: "https://poe.com" },
   { speaker: "web-grok", provider: "grok", name: "Grok", url: "https://grok.com" },
@@ -529,6 +530,37 @@ function shellQuote(value) {
   return `'${String(value).replace(/'/g, "'\\''")}'`;
 }
 
+function checkCliLiveness(command) {
+  const hint = CLI_INVOCATION_HINTS[command];
+  const env = { ...process.env };
+  // Unset CLAUDECODE to avoid nested session errors
+  if (hint?.envPrefix?.includes("CLAUDECODE=")) {
+    delete env.CLAUDECODE;
+  }
+  try {
+    execFileSync(command, ["--version"], {
+      stdio: "ignore",
+      windowsHide: true,
+      timeout: 5000,
+      env,
+    });
+    return true;
+  } catch {
+    // --version failed, try --help as fallback
+    try {
+      execFileSync(command, ["--help"], {
+        stdio: "ignore",
+        windowsHide: true,
+        timeout: 5000,
+        env,
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
 function discoverLocalCliSpeakers() {
   const found = [];
   for (const candidate of resolveCliCandidates()) {
@@ -1091,11 +1123,13 @@ async function collectSpeakerCandidates({ include_cli = true, include_browser =
 
   if (include_cli) {
     for (const cli of discoverLocalCliSpeakers()) {
+      const live = checkCliLiveness(cli);
       add({
         speaker: cli,
         type: "cli",
         label: cli,
         command: cli,
+        live,
       });
     }
   }
@@ -1198,6 +1232,31 @@ async function collectSpeakerCandidates({ include_cli = true, include_browser =
         cdp_available: cdpReachable,
       });
     }
+
+    // Second pass: match auto-registered speakers to individual CDP tabs
+    // (they were added after the first matching pass and only got the global cdpReachable flag)
+    if (cdpTabs.length > 0) {
+      for (const candidate of candidates) {
+        if (!candidate.auto_registered || candidate.cdp_tab_id) continue;
+        let candidateHost = "";
+        try {
+          candidateHost = new URL(candidate.url).hostname.toLowerCase();
+        } catch { continue; }
+        if (!candidateHost) continue;
+        const matches = cdpTabs.filter(t => {
+          try {
+            const tabHost = new URL(t.url).hostname.toLowerCase();
+            // Exact match or subdomain match (e.g., chat.deepseek.com matches deepseek.com)
+            return tabHost === candidateHost || tabHost.endsWith("." + candidateHost);
+          } catch { return false; }
+        });
+        if (matches.length >= 1) {
+          candidate.cdp_available = true;
+          candidate.cdp_tab_id = matches[0].id;
+          candidate.cdp_ws_url = matches[0].webSocketDebuggerUrl;
+        }
+      }
+    }
   }
 
   return { candidates, browserNote };
@@ -1213,7 +1272,10 @@ function formatSpeakerCandidatesReport({ candidates, browserNote }) {
   if (cli.length === 0) {
     out += "- (감지된 로컬 CLI 없음)\n\n";
   } else {
-    out += `${cli.map(c => `- \`${c.speaker}\` (command: ${c.command})`).join("\n")}\n\n`;
+    out += `${cli.map(c => {
+      const status = c.live === false ? " ❌ 실행 불가" : c.live === true ? " ✅ 실행 가능" : "";
+      return `- \`${c.speaker}\` (command: ${c.command})${status}`;
+    }).join("\n")}\n\n`;
   }
 
   out += "### Browser LLM (감지됨)\n";
@@ -1340,11 +1402,11 @@ function resolveTransportForSpeaker(state, speaker) {
 
 // CLI-specific invocation flags for non-interactive execution
 const CLI_INVOCATION_HINTS = {
-  claude: { cmd: "claude", flags: '-p --output-format text', example: 'claude -p --output-format text "프롬프트"' },
-  codex: { cmd: "codex", flags: 'exec', example: 'codex exec "프롬프트"' },
-  gemini: { cmd: "gemini", flags: '', example: 'gemini "프롬프트"' },
-  aider: { cmd: "aider", flags: '--message', example: 'aider --message "프롬프트"' },
-  cursor: { cmd: "cursor", flags: '', example: 'cursor "프롬프트"' },
+  claude: { cmd: "claude", flags: '-p --output-format text', example: 'CLAUDECODE= claude -p --output-format text "프롬프트"', envPrefix: 'CLAUDECODE=', modelFlag: '--model', provider: 'claude' },
+  codex: { cmd: "codex", flags: 'exec', example: 'codex exec "프롬프트"', modelFlag: '--model', provider: 'chatgpt' },
+  gemini: { cmd: "gemini", flags: '', example: 'gemini "프롬프트"', modelFlag: '--model', provider: 'gemini' },
+  aider: { cmd: "aider", flags: '--message', example: 'aider --message "프롬프트"', modelFlag: '--model', provider: 'chatgpt' },
+  cursor: { cmd: "cursor", flags: '', example: 'cursor "프롬프트"', modelFlag: null, provider: 'chatgpt' },
 };
 
 function formatTransportGuidance(transport, state, speaker) {
@@ -1352,18 +1414,27 @@ function formatTransportGuidance(transport, state, speaker) {
   switch (transport) {
     case "cli_respond": {
       const hint = CLI_INVOCATION_HINTS[speaker] || null;
-      const invocationGuide = hint
-        ? `\n\n**CLI 호출 방법:** \`${hint.example}\`\n(플래그: \`${hint.cmd} ${hint.flags}\`)`
-        : "";
-      return `CLI speaker입니다. \`deliberation_respond(session_id: "${sid}", speaker: "${speaker}", content: "...")\`로 직접 응답하세요.${invocationGuide}`;
+      let invocationGuide = "";
+      let modelGuide = "";
+      if (hint) {
+        const prefix = hint.envPrefix || '';
+        invocationGuide = `\n\n**CLI 호출 방법:** \`${hint.example}\`\n(플래그: \`${prefix}${hint.cmd} ${hint.flags}\`)`;
+        if (hint.modelFlag && hint.provider) {
+          const cliModel = getModelSelectionForTurn(state, speaker, hint.provider);
+          if (cliModel.model !== 'default') {
+            modelGuide = `\n**추천 모델:** ${cliModel.model} (${cliModel.reason})\n**모델 플래그:** \`${hint.modelFlag} ${cliModel.model}\``;
+          }
+        }
+      }
+      return `CLI speaker입니다. \`deliberation_respond(session_id: "${sid}", speaker: "${speaker}", content: "...")\`로 직접 응답하세요.${invocationGuide}${modelGuide}\n\n⛔ **API 호출 금지**: REST API, HTTP 요청, urllib, requests 등으로 LLM API를 직접 호출하지 마세요. 반드시 위 CLI 도구만 사용하세요.`;
     }
     case "clipboard":
-      return `브라우저 LLM speaker입니다. CDP 자동 연결 시도 중... Chrome이 이미 CDP 없이 실행 중이면 재시작이 필요할 수 있습니다.`;
+      return `브라우저 LLM speaker입니다. CDP 자동 연결 시도 중... Chrome이 이미 CDP 없이 실행 중이면 재시작이 필요할 수 있습니다.\n\n⛔ **API 호출 금지**: 이 speaker는 웹 브라우저로만 응답합니다. REST API, HTTP 요청으로 LLM을 호출하지 마세요.`;
     case "browser_auto":
-      return `자동 브라우저 speaker입니다. \`deliberation_browser_auto_turn(session_id: "${sid}")\`으로 자동 진행됩니다. CDP를 통해 브라우저 LLM에 직접 입력하고 응답을 읽습니다.`;
+      return `자동 브라우저 speaker입니다. \`deliberation_browser_auto_turn(session_id: "${sid}")\`으로 자동 진행됩니다. CDP를 통해 브라우저 LLM에 직접 입력하고 응답을 읽습니다.\n\n⛔ **API 호출 금지**: CDP 자동화로만 진행합니다. REST API, HTTP 요청 사용 금지.`;
     case "manual":
     default:
-      return `수동 speaker입니다. 응답을 직접 작성해 \`deliberation_respond(session_id: "${sid}", speaker: "${speaker}", content: "...")\`로 제출하세요.`;
+      return `수동 speaker입니다. 해당 LLM의 **웹 UI 또는 CLI 도구**를 통해 응답을 받아 \`deliberation_respond(session_id: "${sid}", speaker: "${speaker}", content: "...")\`로 제출하세요.\n\n⛔ **API 호출 절대 금지**: REST API, HTTP 요청(urllib, requests, fetch 등)으로 LLM API를 직접 호출하는 것은 금지됩니다. 반드시 웹 브라우저 UI 또는 CLI 도구만 사용하세요. API 키로 직접 호출하면 deliberation 참여가 거부됩니다.`;
   }
 }
 
@@ -1671,6 +1742,32 @@ function hasTmuxSession(name) {
   }
 }
 
+function hasTmuxWindow(sessionName, windowName) {
+  try {
+    const output = execFileSync("tmux", ["list-windows", "-t", sessionName, "-F", "#{window_name}"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    });
+    return String(output).split("\n").map(s => s.trim()).includes(windowName);
+  } catch {
+    return false;
+  }
+}
+
+function tmuxHasAttachedClients(sessionName) {
+  try {
+    const output = execFileSync("tmux", ["list-clients", "-t", sessionName], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    });
+    return String(output).trim().split("\n").filter(Boolean).length > 0;
+  } catch {
+    return false;
+  }
+}
+
 function tmuxWindowCount(name) {
   try {
     const output = execFileSync("tmux", ["list-windows", "-t", name], {
@@ -1733,6 +1830,17 @@ function openPhysicalTerminal(sessionId) {
   const winName = tmuxWindowName(sessionId);
   const attachCmd = `tmux attach -t "${TMUX_SESSION}" \\; select-window -t "${TMUX_SESSION}:${winName}"`;
 
+  // If a terminal is already attached to this tmux session, just switch to the right window
+  if (tmuxHasAttachedClients(TMUX_SESSION)) {
+    try {
+      execFileSync("tmux", ["select-window", "-t", `${TMUX_SESSION}:${winName}`], {
+        stdio: "ignore",
+        windowsHide: true,
+      });
+    } catch { /* window might not exist yet */ }
+    return { opened: true, windowIds: [] };
+  }
+
   if (process.platform === "darwin") {
     const before = new Set(listPhysicalTerminalWindowIds());
     try {
@@ -1840,6 +1948,10 @@ function spawnMonitorTerminal(sessionId) {
 
   try {
     if (hasTmuxSession(TMUX_SESSION)) {
+      // Skip if a window with the same name already exists (prevents duplicates)
+      if (hasTmuxWindow(TMUX_SESSION, winName)) {
+        return true;
+      }
       execFileSync("tmux", ["new-window", "-t", TMUX_SESSION, "-n", winName, cmd], {
         stdio: "ignore",
         windowsHide: true,
@@ -2223,9 +2335,18 @@ server.tool(
     rounds: z.coerce.number().optional().describe("라운드 수 (미지정 시 config 설정 따름, 기본 3)"),
     first_speaker: z.string().trim().min(1).max(64).optional().describe("첫 발언자 이름 (미지정 시 speakers의 첫 항목)"),
     speakers: z.preprocess(
-      (v) => (typeof v === "string" ? JSON.parse(v) : v),
+      (v) => {
+        const parsed = typeof v === "string" ? JSON.parse(v) : v;
+        if (!Array.isArray(parsed)) return parsed;
+        // Normalize: accept both string[] and {name, role?, instructions?}[]
+        return parsed.map(item => (typeof item === "object" && item !== null && item.name) ? item.name : item);
+      },
       z.array(z.string().trim().min(1).max(64)).min(1).optional()
-    ).describe("참가자 이름 목록 (예: codex, claude, web-chatgpt-1)"),
+    ).describe("참가자 이름 목록. 문자열 배열 또는 {name, role, instructions} 객체 배열 모두 지원"),
+    speaker_instructions: z.preprocess(
+      (v) => (typeof v === "string" ? JSON.parse(v) : v),
+      z.record(z.string(), z.string()).optional()
+    ).describe("speaker별 추가 지시사항 (예: {\"claude\": \"비판적으로 검토\"})"),
     require_manual_speakers: z.preprocess(
       (v) => (typeof v === "string" ? v === "true" : v),
       z.boolean().optional()
@@ -2247,7 +2368,7 @@ server.tool(
     role_preset: z.enum(["balanced", "debate", "research", "brainstorm", "review", "consensus"]).optional()
       .describe("역할 프리셋 (balanced/debate/research/brainstorm/review/consensus). speaker_roles가 명시되면 무시됨"),
   },
-  safeToolHandler("deliberation_start", async ({ topic, rounds, first_speaker, speakers, require_manual_speakers, auto_discover_speakers, participant_types, ordering_strategy, speaker_roles, role_preset }) => {
+  safeToolHandler("deliberation_start", async ({ topic, rounds, first_speaker, speakers, speaker_instructions, require_manual_speakers, auto_discover_speakers, participant_types, ordering_strategy, speaker_roles, role_preset }) => {
     // ── First-time onboarding guard ──
     const config = loadDeliberationConfig();
     if (!config.setup_complete) {
@@ -2327,6 +2448,42 @@ server.tool(
       || normalizeSpeaker(selectedSpeakers?.[0])
       || DEFAULT_SPEAKERS[0];
     const speakerOrder = buildSpeakerOrder(selectedSpeakers, normalizedFirstSpeaker, "front");
+
+    // Warn if only 1 speaker — deliberation requires 2+
+    if (speakerOrder.length < 2) {
+      const candidateSnapshot = await collectSpeakerCandidates({ include_cli: true, include_browser: true });
+      const candidateText = formatSpeakerCandidatesReport(candidateSnapshot);
+      return {
+        content: [{
+          type: "text",
+          text: `⚠️ Deliberation에는 최소 2명의 speaker가 필요합니다. 현재 ${speakerOrder.length}명만 지정됨: ${speakerOrder.join(", ")}\n\n사용 가능한 스피커 후보:\n${candidateText}\n\n예시:\ndeliberation_start(topic: "${topic.slice(0, 50)}...", speakers: ["claude", "codex", "web-gemini-1"])`,
+        }],
+      };
+    }
+
+    // Liveness check: verify CLI speakers are actually executable
+    const cliSpeakersInOrder = speakerOrder.filter(s => !s.startsWith("web-"));
+    const nonLiveCli = [];
+    for (const s of cliSpeakersInOrder) {
+      if (!checkCliLiveness(s)) {
+        nonLiveCli.push(s);
+      }
+    }
+    if (nonLiveCli.length > 0) {
+      const liveSpeakers = speakerOrder.filter(s => !nonLiveCli.includes(s));
+      const liveSnapshot = await collectSpeakerCandidates({ include_cli: true, include_browser: true });
+      const candidateText = formatSpeakerCandidatesReport(liveSnapshot);
+      const liveList = liveSpeakers.length > 0
+        ? `\n\n실행 가능한 스피커만으로 시작하려면:\ndeliberation_start(topic: "${topic.slice(0, 50)}...", speakers: ${JSON.stringify(liveSpeakers)})`
+        : "";
+      return {
+        content: [{
+          type: "text",
+          text: `⚠️ 일부 CLI 스피커가 현재 실행 불가합니다:\n${nonLiveCli.map(s => `  - \`${s}\` ❌`).join("\n")}\n\n실행 가능: ${liveSpeakers.length > 0 ? liveSpeakers.map(s => `\`${s}\``).join(", ") : "(없음)"}\n\n${candidateText}${liveList}\n\n실행 불가 원인: CLI가 설치되지 않았거나, 중첩 세션 제약, 또는 인증 만료일 수 있습니다.`,
+        }],
+      };
+    }
+
     const participantMode = hasManualSpeakers
       ? "수동 지정"
       : (autoDiscoveredSpeakers.length > 0 ? "자동 탐색(PATH)" : "기본값");
@@ -2557,6 +2714,9 @@ server.tool(
         const turnSpeaker = speaker;
         const turnProvider = profile?.provider || "chatgpt";
 
+        // Dynamic model selection
+        const modelSelection = getModelSelectionForTurn(state, turnSpeaker, turnProvider);
+
         // Build prompt
         const turnPrompt = buildClipboardTurnPrompt(state, turnSpeaker, prompt, include_history_entries);
 
@@ -2564,6 +2724,11 @@ server.tool(
         const attachResult = await port.attach(sessionId, { provider: turnProvider, url: profile?.url });
         if (!attachResult.ok) throw new Error(`attach failed: ${attachResult.error?.message}`);
 
+        // Switch model if needed
+        if (modelSelection.model !== 'default') {
+          await port.switchModel(sessionId, modelSelection.model);
+        }
+
         // Send turn
         const autoTurnId = turnId || `auto-${Date.now()}`;
         const sendResult = await port.sendTurnWithDegradation(sessionId, autoTurnId, turnPrompt);
@@ -2584,7 +2749,8 @@ server.tool(
             channel_used: "browser_auto",
             fallback_reason: null,
           });
-          extra = `\n\n⚡ 자동 실행 완료! 브라우저 LLM 응답이 자동으로 제출되었습니다. (${waitResult.data.elapsedMs}ms)`;
+          const routeModelInfo = modelSelection.model !== 'default' ? ` | 모델: ${modelSelection.model}` : "";
+          extra = `\n\n⚡ 자동 실행 완료! 브라우저 LLM 응답이 자동으로 제출되었습니다. (${waitResult.data.elapsedMs}ms${routeModelInfo})`;
         } else {
           throw new Error(waitResult.error?.message || "no response received");
         }
@@ -2641,6 +2807,12 @@ server.tool(
 
     const turnId = state.pending_turn_id || generateTurnId();
     const port = getBrowserPort();
+    const effectiveProvider = (state.participant_profiles || []).find(
+      p => normalizeSpeaker(p.speaker) === normalizeSpeaker(speaker)
+    )?.provider || provider;
+
+    // Dynamic model selection based on prompt context
+    const modelSelection = getModelSelectionForTurn(state, speaker, effectiveProvider);
 
     // Step 1: Attach (pass URL from participant profile for auto-tab-creation)
     const speakerProfile = (state.participant_profiles || []).find(
@@ -2655,6 +2827,18 @@ server.tool(
       return { content: [{ type: "text", text: `❌ 브라우저 탭 바인딩 실패: ${attachResult.error.message}\n\n**에러 코드:** ${attachResult.error.code}\n**도메인:** ${attachResult.error.domain}\n\nCDP 디버깅 포트가 활성화된 브라우저가 실행 중인지 확인하세요.\n\`google-chrome --remote-debugging-port=9222\`\n\n${PRODUCT_DISCLAIMER}` }] };
     }
 
+    // Step 1.2: Login detection — check if user is logged in to the web LLM
+    const loginCheck = await port.checkLogin(resolved);
+    if (loginCheck && !loginCheck.loggedIn) {
+      await port.detach(resolved);
+      return { content: [{ type: "text", text: `⚠️ **${speaker} 로그인 필요** — 웹 LLM에 로그인되어 있지 않습니다.\n\n**감지된 상태:** ${loginCheck.reason}\n**URL:** ${loginCheck.url || 'N/A'}\n\n이 speaker는 건너뜁니다. 브라우저에서 해당 LLM에 로그인한 후 다시 시도하세요.\n\n⛔ **API 호출로 대체하지 마세요.** 로그인되지 않은 speaker는 건너뛰는 것이 올바른 동작입니다.` }] };
+    }
+
+    // Step 1.5: Switch model based on context analysis
+    if (modelSelection.model !== 'default') {
+      await port.switchModel(resolved, modelSelection.model);
+    }
+
     // Step 2: Build turn prompt
     const turnPrompt = buildClipboardTurnPrompt(state, speaker, null, 3);
 
@@ -2697,10 +2881,14 @@ server.tool(
       ? `\n**Degradation:** ${JSON.stringify(degradationState)}`
       : "";
 
+    const modelInfo = modelSelection.model !== 'default'
+      ? `\n**모델:** ${modelSelection.model} (${modelSelection.reason})\n**분석:** category=${modelSelection.category}, complexity=${modelSelection.complexity}`
+      : "";
+
     return {
       content: [{
         type: "text",
-        text: `✅ 브라우저 자동 턴 완료!\n\n**Provider:** ${provider}\n**Turn ID:** ${turnId}\n**응답 길이:** ${response.length}자\n**소요 시간:** ${waitResult.data.elapsedMs}ms${degradationInfo}\n\n${result.content[0].text}`,
+        text: `✅ 브라우저 자동 턴 완료!\n\n**Provider:** ${effectiveProvider}\n**Turn ID:** ${turnId}${modelInfo}\n**응답 길이:** ${response.length}자\n**소요 시간:** ${waitResult.data.elapsedMs}ms${degradationInfo}\n\n${result.content[0].text}`,
       }],
     };
   })
@@ -2712,11 +2900,24 @@ server.tool(
   {
     session_id: z.string().optional().describe("세션 ID (여러 세션 진행 중이면 필수)"),
     speaker: z.string().trim().min(1).max(64).describe("응답자 이름"),
-    content: z.string().describe("응답 내용 (마크다운)"),
+    content: z.string().optional().describe("응답 내용 (마크다운). content 또는 content_file 중 하나 필수."),
+    content_file: z.string().optional().describe("응답 내용이 담긴 파일 경로. JSON 이스케이프 문제 회피용. 파일 내용이 그대로 content로 사용됩니다."),
     turn_id: z.string().optional().describe("턴 검증 ID (deliberation_route_turn에서 받은 값)"),
   },
-  safeToolHandler("deliberation_respond", async ({ session_id, speaker, content, turn_id }) => {
-    return submitDeliberationTurn({ session_id, speaker, content, turn_id, channel_used: "cli_respond" });
+  safeToolHandler("deliberation_respond", async ({ session_id, speaker, content, content_file, turn_id }) => {
+    // Support reading content from file to avoid JSON escaping issues
+    let finalContent = content;
+    if (content_file && !content) {
+      try {
+        finalContent = fs.readFileSync(content_file, "utf-8").trim();
+      } catch (e) {
+        return { content: [{ type: "text", text: `❌ content_file 읽기 실패: ${e.message}` }] };
+      }
+    }
+    if (!finalContent) {
+      return { content: [{ type: "text", text: "❌ content 또는 content_file 중 하나를 제공해야 합니다." }] };
+    }
+    return submitDeliberationTurn({ session_id, speaker, content: finalContent, turn_id, channel_used: "cli_respond" });
   })
 );
 

package/install.js

@@ -37,6 +37,7 @@ const FILES_TO_COPY = [
   "observer.js",
   "browser-control-port.js",
   "degradation-state-machine.js",
+  "model-router.js",
   "session-monitor.sh",
   "session-monitor-win.js",
   "package.json",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-deliberation",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "MCP Deliberation Server — Multi-session AI deliberation with smart speaker ordering and persona roles",
   "type": "module",
   "license": "MIT",

package/selectors/chatgpt.json

@@ -1,11 +1,11 @@
 {
   "provider": "chatgpt",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "domains": ["chat.openai.com", "chatgpt.com"],
   "selectors": {
     "inputSelector": "#prompt-textarea",
-    "sendButton": "button[data-testid='send-button']",
-    "responseSelector": ".markdown.prose",
+    "sendButton": "button.composer-submit-button-color, button[data-testid='send-button']",
+    "responseSelector": ".markdown.prose:not(.result-thinking), .result-thinking.markdown.prose",
     "responseContainer": "[data-message-author-role='assistant']",
     "streamingIndicator": ".result-streaming",
     "conversationList": "nav[aria-label='Chat history']"
@@ -14,7 +14,11 @@
     "inputDelayMs": 100,
     "sendDelayMs": 200,
     "pollIntervalMs": 500,
-    "streamingTimeoutMs": 45000
+    "streamingTimeoutMs": 120000
   },
-  "notes": "ChatGPT DOM selectors - update version when selectors change"
+  "modelSelector": {
+    "trigger": "button[data-testid='model-switcher-dropdown-button'], button[data-testid='model-selector-dropdown'], button[class*='model']",
+    "optionSelector": "[role='option'], [role='menuitem'], [data-testid*='model-selector']"
+  },
+  "notes": "ChatGPT verified via CDP 2026-03-01. Input: #prompt-textarea (ProseMirror contenteditable div). Send button: button.composer-submit-button-color (primary, aria-label='Voice 시작' in KR locale — this is the submit button despite misleading label). button[data-testid='send-button'] no longer exists. Container: [data-message-author-role='assistant'] (still valid). Response: .markdown.prose:not(.result-thinking). Streaming: .result-streaming. Note: existing conversation responses may have empty textContent due to content-visibility virtualization — only fresh/visible responses will have text."
 }

package/selectors/claude.json

@@ -1,12 +1,12 @@
 {
   "provider": "claude",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "domains": ["claude.ai"],
   "selectors": {
-    "inputSelector": "div.ProseMirror[contenteditable='true'], div.tiptap.ProseMirror",
-    "sendButton": "button[aria-label='Send Message'], button[aria-label='메시지 보내기'], button[aria-label='Send message']",
-    "responseSelector": ".font-claude-message .grid-cols-1 .grid .min-w-0",
-    "responseContainer": "[data-is-streaming]",
+    "inputSelector": "div[data-testid='chat-input'], div.tiptap.ProseMirror, div.ProseMirror[contenteditable='true'], textarea[data-testid='chat-input-ssr']",
+    "sendButton": "button[aria-label='메시지 보내기'], button[aria-label='Send Message'], button[aria-label*='보내'], button[aria-label*='Send'], fieldset button[type='submit']",
+    "responseSelector": ".font-claude-response-body, .standard-markdown, .font-claude-response",
+    "responseContainer": "[data-is-streaming='false'], [data-is-streaming]",
     "streamingIndicator": "[data-is-streaming='true']"
   },
   "timing": {
@@ -15,5 +15,9 @@
     "pollIntervalMs": 500,
     "streamingTimeoutMs": 60000
   },
-  "notes": "Claude web selectors - send button aria-label is locale-dependent (EN: 'Send Message', KR: '메시지 보내기'). Button only appears when input has text."
+  "modelSelector": {
+    "trigger": "button[data-testid='model-selector-dropdown']",
+    "optionSelector": "[role='option'], [role='menuitem'], [data-testid*='model']"
+  },
+  "notes": "Claude verified via CDP 2026-03-01. Input: div[data-testid='chat-input'] (tiptap ProseMirror contenteditable). Send button: aria-label='메시지 보내기' (KR) or 'Send Message' (EN). Container: [data-is-streaming='false'] (completed) or [data-is-streaming='true'] (streaming) — the data-is-streaming attribute is always present on the assistant message wrapper. Response text: .font-claude-response-body or .standard-markdown. Streaming indicator: [data-is-streaming='true'] only (NOT .font-claude-response which persists after completion). .font-claude-message no longer exists. data-testid='assistant-message' no longer exists. Model selector: data-testid='model-selector-dropdown'."
 }

package/selectors/deepseek.json

@@ -5,9 +5,9 @@
   "selectors": {
     "inputSelector": "textarea.ds-scroll-area, textarea[placeholder*='DeepSeek'], textarea[placeholder*='Send a message']",
     "sendButton": "div[role='button'].ds-icon-button, button[type='submit']",
-    "responseSelector": ".ds-markdown, .ds-markdown--block, .markdown-body",
-    "responseContainer": ".chat-message-content, [data-role='assistant']",
-    "streamingIndicator": ".chat-message--streaming, .typing-indicator"
+    "responseSelector": ".ds-markdown, .ds-markdown--block",
+    "responseContainer": ".ds-message",
+    "streamingIndicator": ".ds-message--streaming, [class*='streaming'], .typing-indicator"
   },
   "timing": {
     "inputDelayMs": 100,
@@ -15,5 +15,9 @@
     "pollIntervalMs": 500,
     "streamingTimeoutMs": 60000
   },
-  "notes": "DeepSeek verified via CDP. Input: textarea.ds-scroll-area (placeholder locale-dependent). Send: div[role='button'].ds-icon-button (no aria-label, Enter key is primary). Hashed class names (_27c9245, _7436101) may change."
+  "modelSelector": {
+    "trigger": "div[class*='model-selector'], button[class*='model']",
+    "optionSelector": "[role='option'], [role='menuitem'], [class*='model-item']"
+  },
+  "notes": "DeepSeek verified via CDP. Container: DIV.ds-message. Response: DIV.ds-markdown > P.ds-markdown-paragraph. Input: textarea.ds-scroll-area. Send: div[role='button'].ds-icon-button (Enter key primary). Hashed class names may change."
 }

package/selectors/gemini.json

@@ -1,19 +1,23 @@
 {
   "provider": "gemini",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "domains": ["gemini.google.com"],
   "selectors": {
     "inputSelector": ".ql-editor[contenteditable='true']",
-    "sendButton": "button.send-button, button[aria-label='Send message']",
+    "sendButton": "button.send, button.send-button, button[aria-label='Send message'], button[aria-label='전송']",
     "responseSelector": ".markdown.markdown-main-panel",
     "responseContainer": ".model-response-text",
-    "streamingIndicator": ".loading-indicator, .model-response-text .loading"
+    "streamingIndicator": "button[aria-label*='중지'], button[aria-label*='Stop generating'], .loading-spinner"
   },
   "timing": {
     "inputDelayMs": 100,
     "sendDelayMs": 300,
     "pollIntervalMs": 500,
-    "streamingTimeoutMs": 45000
+    "streamingTimeoutMs": 60000
   },
-  "notes": "Gemini web selectors - verify via DOM inspection if selectors change"
+  "modelSelector": {
+    "trigger": "button.input-area-switch, button[aria-label='모드 선택 도구 열기']",
+    "optionSelector": "[role='option'], [role='menuitem'], mat-option, .option-item"
+  },
+  "notes": "Gemini verified via CDP. Container: STRUCTURED-CONTENT-CONTAINER.model-response-text. Response: DIV.markdown.markdown-main-panel. Streaming: .model-response-text[class*='processing-state']. Model: button.input-area-switch."
 }

package/selectors/grok.json

@@ -5,8 +5,8 @@
   "selectors": {
     "inputSelector": "div.tiptap.ProseMirror[contenteditable='true'], div.ProseMirror[contenteditable='true']",
     "sendButton": "button[aria-label='제출'], button[aria-label='Submit'], button[type='submit']",
-    "responseSelector": ".markdown, .prose",
-    "responseContainer": "[data-role='assistant'], .message-assistant",
+    "responseSelector": ".response-content-markdown, .markdown",
+    "responseContainer": "div[id^='response-'], .message-bubble",
     "streamingIndicator": "[data-streaming='true'], .animate-pulse"
   },
   "timing": {
@@ -15,5 +15,9 @@
     "pollIntervalMs": 500,
     "streamingTimeoutMs": 60000
   },
-  "notes": "xAI Grok - uses tiptap ProseMirror contenteditable. Send button aria-label is locale-dependent (EN: 'Submit', KR: '제출')."
+  "modelSelector": {
+    "trigger": "button[class*='model'], [data-testid*='model']",
+    "optionSelector": "[role='option'], [role='menuitem'], [class*='model-option']"
+  },
+  "notes": "Grok verified via CDP. Container: div[id^='response-'] (unique response IDs). Response: .response-content-markdown. User messages use separate container without response- prefix. Send button locale-dependent (EN: 'Submit', KR: '제출')."
 }

package/selectors/huggingchat.json

@@ -5,8 +5,8 @@
   "selectors": {
     "inputSelector": "textarea[placeholder='Ask anything'], textarea[placeholder*='Ask']",
     "sendButton": "button[aria-label='Send message'], button[type='submit']",
-    "responseSelector": ".prose, .markdown",
-    "responseContainer": ".message-assistant, [data-role='assistant']",
+    "responseSelector": ".prose",
+    "responseContainer": "[data-message-role='assistant']",
     "streamingIndicator": ".animate-pulse, [data-streaming='true']"
   },
   "timing": {
@@ -15,5 +15,9 @@
     "pollIntervalMs": 500,
     "streamingTimeoutMs": 60000
   },
-  "notes": "HuggingChat - textarea with placeholder 'Ask anything'. Send button has aria-label='Send message'."
+  "modelSelector": {
+    "trigger": "button[class*='model'], [data-testid*='model-selector']",
+    "optionSelector": "[role='option'], [role='menuitem'], button[class*='model']"
+  },
+  "notes": "HuggingChat verified via CDP. Container: div[data-message-role='assistant'][data-message-id]. Response: DIV.prose inside container. SvelteKit-based app."
 }

package/selectors/poe.json

@@ -6,7 +6,7 @@
     "inputSelector": "textarea[class*='GrowingTextArea'], textarea[class*='textArea']",
     "sendButton": "button[aria-label='메시지 전송'], button[aria-label='Send message'], button[class*='button_primary']",
     "responseSelector": "[class*='Markdown_markdownContainer'], [class*='markdownContainer']",
-    "responseContainer": "[class*='botMessageBubble'], [class*='Message_bot']",
+    "responseContainer": "[class*='leftSideMessageBubble'], [class*='Message_bot']",
     "streamingIndicator": "[class*='streamingBotMessage'], [class*='ChatMessage_streaming']"
   },
   "timing": {
@@ -15,5 +15,5 @@
     "pollIntervalMs": 500,
     "streamingTimeoutMs": 45000
   },
-  "notes": "Poe verified via CDP. Input: textarea.GrowingTextArea_textArea__ZWQbP (hashed). Send: button[aria-label='메시지 전송'] (KR locale) / 'Send message' (EN). Hashed class names change between deployments."
+  "notes": "Poe verified via CDP. Container: Message_leftSideMessageBubble (bot only, right side is user). Response: Markdown_markdownContainer > Prose_prose. Hashed class suffixes change between deployments. Send: aria-label locale-dependent."
 }

package/selectors/qwen.json

@@ -5,9 +5,9 @@
   "selectors": {
     "inputSelector": "textarea.message-input-textarea, textarea[placeholder*='도와드릴까요'], textarea[placeholder*='help you']",
     "sendButton": "button.send-button, button[type='submit']",
-    "responseSelector": ".markdown-body, .message-content",
-    "responseContainer": ".message-assistant, [data-role='assistant']",
-    "streamingIndicator": ".typing-indicator, [data-streaming='true']"
+    "responseSelector": ".response-message-content, .markdown-body",
+    "responseContainer": ".qwen-chat-message-assistant, .chat-response-message",
+    "streamingIndicator": ".phase-thinking, .typing-indicator"
   },
   "timing": {
     "inputDelayMs": 100,
@@ -15,5 +15,5 @@
     "pollIntervalMs": 500,
     "streamingTimeoutMs": 60000
   },
-  "notes": "Alibaba Qwen Chat - uses textarea.message-input-textarea. Send button has class 'send-button'."
+  "notes": "Qwen verified via CDP. Container: .qwen-chat-message-assistant or .chat-response-message. Response: .response-message-content.phase-answer. Thinking phase: .phase-thinking class. '생각이 끝났습니다' indicates thinking complete."
 }