@dmsdc-ai/aigentry-deliberation 0.0.29 → 0.0.31

package/index.js

@@ -74,6 +74,7 @@ import { fileURLToPath } from "url";
 import os from "os";
 import { OrchestratedBrowserPort } from "./browser-control-port.js";
 import { getModelSelectionForTurn } from "./model-router.js";
+import { readClipboardText, writeClipboardText, hasClipboardImage, captureClipboardImage } from "./clipboard.js";
 import {
   DECISION_STAGES, STAGE_TRANSITIONS,
   createDecisionSession, advanceStage, buildConflictMap,
@@ -383,6 +384,18 @@ function formatRuntimeError(error) {
 function appendRuntimeLog(level, message) {
   try {
     fs.mkdirSync(path.dirname(GLOBAL_RUNTIME_LOG), { recursive: true });
+    
+    // Simple rotation: if log > 1MB, truncate it
+    try {
+      if (fs.existsSync(GLOBAL_RUNTIME_LOG)) {
+        const stats = fs.statSync(GLOBAL_RUNTIME_LOG);
+        if (stats.size > 1024 * 1024) { // 1MB
+          const oldLog = GLOBAL_RUNTIME_LOG + ".old";
+          fs.renameSync(GLOBAL_RUNTIME_LOG, oldLog);
+        }
+      }
+    } catch { /* ignore rotation failures */ }
+
     const line = `${new Date().toISOString()} [${level}] ${message}\n`;
     fs.appendFileSync(GLOBAL_RUNTIME_LOG, line, "utf-8");
   } catch {
@@ -624,80 +637,6 @@ function detectCallerSpeaker() {
   return null;
 }
 
-function resolveClipboardReader() {
-  if (process.platform === "darwin" && commandExistsInPath("pbpaste")) {
-    return { cmd: "pbpaste", args: [] };
-  }
-  if (process.platform === "win32") {
-    const windowsShell = ["powershell.exe", "powershell", "pwsh.exe", "pwsh"]
-      .find(cmd => commandExistsInPath(cmd));
-    if (windowsShell) {
-      return { cmd: windowsShell, args: ["-NoProfile", "-Command", "Get-Clipboard -Raw"] };
-    }
-  }
-  if (commandExistsInPath("wl-paste")) {
-    return { cmd: "wl-paste", args: ["-n"] };
-  }
-  if (commandExistsInPath("xclip")) {
-    return { cmd: "xclip", args: ["-selection", "clipboard", "-o"] };
-  }
-  if (commandExistsInPath("xsel")) {
-    return { cmd: "xsel", args: ["--clipboard", "--output"] };
-  }
-  return null;
-}
-
-function resolveClipboardWriter() {
-  if (process.platform === "darwin" && commandExistsInPath("pbcopy")) {
-    return { cmd: "pbcopy", args: [] };
-  }
-  if (process.platform === "win32") {
-    if (commandExistsInPath("clip.exe") || commandExistsInPath("clip")) {
-      return { cmd: "clip", args: [] };
-    }
-    const windowsShell = ["powershell.exe", "powershell", "pwsh.exe", "pwsh"]
-      .find(cmd => commandExistsInPath(cmd));
-    if (windowsShell) {
-      return { cmd: windowsShell, args: ["-NoProfile", "-Command", "[Console]::In.ReadToEnd() | Set-Clipboard"] };
-    }
-  }
-  if (commandExistsInPath("wl-copy")) {
-    return { cmd: "wl-copy", args: [] };
-  }
-  if (commandExistsInPath("xclip")) {
-    return { cmd: "xclip", args: ["-selection", "clipboard"] };
-  }
-  if (commandExistsInPath("xsel")) {
-    return { cmd: "xsel", args: ["--clipboard", "--input"] };
-  }
-  return null;
-}
-
-function readClipboardText() {
-  const tool = resolveClipboardReader();
-  if (!tool) {
-    throw new Error("No supported clipboard read command found (pbpaste/wl-paste/xclip/xsel etc).");
-  }
-  return execFileSync(tool.cmd, tool.args, {
-    encoding: "utf-8",
-    stdio: ["ignore", "pipe", "pipe"],
-    maxBuffer: 5 * 1024 * 1024,
-  });
-}
-
-function writeClipboardText(text) {
-  const tool = resolveClipboardWriter();
-  if (!tool) {
-    throw new Error("No supported clipboard write command found (pbcopy/wl-copy/xclip/xsel etc).");
-  }
-  execFileSync(tool.cmd, tool.args, {
-    input: text,
-    encoding: "utf-8",
-    stdio: ["pipe", "ignore", "pipe"],
-    maxBuffer: 5 * 1024 * 1024,
-  });
-}
-
 function isLlmUrl(url = "") {
   const value = String(url || "").trim();
   if (!value) return false;
@@ -719,7 +658,10 @@ function dedupeBrowserTabs(tabs = []) {
     const title = String(tab?.title || "").trim();
     const url = String(tab?.url || "").trim();
     if (!url || (!isLlmUrl(url) && !isExtensionLlmTab(url, title))) continue;
-    const key = `${browser}\t${title}\t${url}`;
+    // Dedup by title+url (ignore browser name) so that the same tab detected
+    // via both AppleScript and CDP is not duplicated. The first occurrence wins,
+    // so callers should add preferred sources first (e.g., CDP before AppleScript).
+    const key = `${title}\t${url}`;
     if (seen.has(key)) continue;
     seen.add(key);
     out.push({
@@ -1145,6 +1087,16 @@ async function collectBrowserLlmTabs() {
     };
   }
 
+  // CDP first: CDP-detected tabs are preferred over AppleScript-detected ones
+  // because they carry CDP metadata (tab ID, WebSocket URL) for browser_auto transport.
+  // Since dedupeBrowserTabs keeps the first occurrence, CDP entries win the dedup.
+  const shouldUseCdp = mode === "auto" || mode === "cdp";
+  if (shouldUseCdp) {
+    const cdp = await collectBrowserLlmTabsViaCdp();
+    tabs.push(...cdp.tabs);
+    if (cdp.note) notes.push(cdp.note);
+  }
+
   const shouldUseAppleScript = mode === "auto" || mode === "applescript";
   if (shouldUseAppleScript && process.platform === "darwin") {
     const mac = collectBrowserLlmTabsViaAppleScript();
@@ -1154,13 +1106,6 @@ async function collectBrowserLlmTabs() {
     notes.push("AppleScript scanning is macOS only. Switch to CDP scanning.");
   }
 
-  const shouldUseCdp = mode === "auto" || mode === "cdp";
-  if (shouldUseCdp) {
-    const cdp = await collectBrowserLlmTabsViaCdp();
-    tabs.push(...cdp.tabs);
-    if (cdp.note) notes.push(cdp.note);
-  }
-
   const uniqTabs = dedupeBrowserTabs(tabs);
   return {
     tabs: uniqTabs,
@@ -1345,6 +1290,17 @@ async function collectSpeakerCandidates({ include_cli = true, include_browser =
         }
       }
     }
+
+    // Third pass: upgrade browser-detected candidates that missed the first hostname match.
+    // When CDP is reachable, AppleScript-detected speakers should also get browser_auto
+    // transport. The OrchestratedBrowserPort will create/navigate tabs on demand if needed.
+    if (cdpReachable) {
+      for (const candidate of candidates) {
+        if (candidate.type !== "browser" || candidate.auto_registered) continue;
+        if (candidate.cdp_available) continue; // already matched
+        candidate.cdp_available = true;
+      }
+    }
   }
 
   return { candidates, browserNote };
@@ -1406,10 +1362,16 @@ function mapParticipantProfiles(speakers, candidates, typeOverrides) {
     // Check for explicit type override
     const overrideType = overrides[speaker] || overrides[raw];
     if (overrideType) {
+      const candidate = bySpeaker.get(speaker);
       profiles.push({
         speaker,
         type: overrideType,
-        ...(overrideType === "browser_auto" ? { provider: "chatgpt" } : {}),
+        ...(overrideType === "browser_auto" || overrideType === "browser" ? {
+          provider: candidate?.provider || null,
+          browser: candidate?.browser || null,
+          title: candidate?.title || null,
+          url: candidate?.url || null,
+        } : {}),
       });
       continue;
     }
@@ -1491,7 +1453,7 @@ 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: 'CLAUDECODE= claude -p --output-format text "prompt"', envPrefix: 'CLAUDECODE=', modelFlag: '--model', provider: 'claude' },
-  codex: { cmd: "codex", flags: 'exec --model gpt-5.4-codex', example: 'codex exec --model gpt-5.4-codex "prompt"', modelFlag: '--model', defaultModel: 'gpt-5.4-codex', provider: 'chatgpt' },
+  codex: { cmd: "codex", flags: 'exec -', example: 'echo "prompt" | codex exec -', stdinMode: true, modelFlag: '--model', defaultModel: 'default', provider: 'chatgpt' },
   gemini: { cmd: "gemini", flags: '', example: 'gemini "prompt"', modelFlag: '--model', provider: 'gemini' },
   aider: { cmd: "aider", flags: '--message', example: 'aider --message "prompt"', modelFlag: '--model', provider: 'chatgpt' },
   cursor: { cmd: "cursor", flags: '', example: 'cursor "prompt"', modelFlag: null, provider: 'chatgpt' },
@@ -1517,12 +1479,18 @@ function formatTransportGuidance(transport, state, speaker) {
       return `CLI speaker. Respond directly via \`deliberation_respond(session_id: "${sid}", speaker: "${speaker}", content: "...")\`.${invocationGuide}${modelGuide}\n\n⛔ **No API calls**: Do not call LLM APIs directly via REST API, HTTP requests, urllib, requests, etc. Only use the CLI tools above.`;
     }
     case "clipboard":
-      return `Browser LLM speaker. Attempting CDP auto-connect... Chrome may need to be restarted if already running without CDP.\n\n⛔ **No API calls**: This speaker responds only via web browser. Do not call LLMs via REST API or HTTP requests.`;
+      return `Browser LLM speaker. Copy the prompt below and paste it into the browser LLM using **Cmd+V (ㅍ)**, then submit the response via \`deliberation_respond(session_id: "${sid}", speaker: "${speaker}", use_clipboard: true)\` after copying the LLM's response with **Cmd+C (ㅊ)**.\n\n` +
+             `📋 **Prompt has been copied to your clipboard.** (If not, copy the [turn_prompt] section below manually).\n` +
+             `🖼️ **To include an image:** Copy the image to your clipboard and use \`include_clipboard_image: true\` in \`deliberation_respond\`.\n\n` +
+             `⛔ **No API calls**: This speaker responds only via web browser. Do not call LLMs via REST API or HTTP requests.`;
     case "browser_auto":
       return `Auto browser speaker. Proceed automatically with \`deliberation_browser_auto_turn(session_id: "${sid}")\`. Inputs directly to browser LLM via CDP and reads responses.\n\n⛔ **No API calls**: Proceeds only via CDP automation. No REST API or HTTP requests.`;
     case "manual":
     default:
-      return `Manual speaker. Get a response from the LLM's **web UI or CLI tool** and submit via \`deliberation_respond(session_id: "${sid}", speaker: "${speaker}", content: "...")\`.\n\n⛔ **Absolutely no API calls**: Calling LLM APIs directly via REST API, HTTP requests (urllib, requests, fetch, etc.) is forbidden. Only use web browser UI or CLI tools. Direct API key calls will result in deliberation participation being rejected.`;
+      return `Manual speaker. Get a response from the LLM's **web UI or CLI tool** and submit via \`deliberation_respond(session_id: "${sid}", speaker: "${speaker}", content: "...")\`.\n\n` +
+             `📋 **Copy the [turn_prompt] section below** to the web UI.\n` +
+             `🖼️ **To include an image:** Copy the image to your clipboard and use \`include_clipboard_image: true\` in \`deliberation_respond\`.\n\n` +
+             `⛔ **Absolutely no API calls**: Calling LLM APIs directly via REST API, HTTP requests (urllib, requests, fetch, etc.) is forbidden. Only use web browser UI or CLI tools. Direct API key calls will result in deliberation participation being rejected.`;
   }
 }
 
@@ -1763,7 +1731,15 @@ tags: [deliberation]
       if (entry.fallback_reason) parts.push(`fallback: ${entry.fallback_reason}`);
       md += `> _${parts.join(" | ")}_\n\n`;
     }
-    md += `${entry.content}\n\n---\n\n`;
+    md += `${entry.content}\n\n`;
+    if (entry.attachments && entry.attachments.length > 0) {
+      for (const att of entry.attachments) {
+        if (att.type === "image") {
+          md += `![Attachment](${att.path})\n\n`;
+        }
+      }
+    }
+    md += `---\n\n`;
   }
   return md;
 }
@@ -1856,6 +1832,22 @@ function tmuxHasAttachedClients(sessionName) {
   }
 }
 
+function isTmuxWindowViewed(sessionName, windowName) {
+  try {
+    // List all clients and check for matching window name.
+    // Grouped sessions (created via 'new-session -t') share the same windows,
+    // so checking for the window name anywhere in the client list is sufficient.
+    const output = execFileSync("tmux", ["list-clients", "-F", "#{window_name}"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    });
+    return String(output).split("\n").map(s => s.trim()).filter(Boolean).includes(windowName);
+  } catch {
+    return false;
+  }
+}
+
 function tmuxWindowCount(name) {
   try {
     const output = execFileSync("tmux", ["list-windows", "-t", name], {
@@ -1921,9 +1913,20 @@ function openPhysicalTerminal(sessionId) {
   // Use grouped session (new-session -t) for independent active window per client
   const attachCmd = `tmux new-session -t "${TMUX_SESSION}" \\; select-window -t "${TMUX_SESSION}:${winName}"`;
 
-  // If a terminal is already attached, open a NEW grouped session instead of
-  // select-window (which would hijack all attached clients' views).
-  // Grouped sessions share windows but each has independent active window tracking.
+  // Prevent duplicate windows for the SAME session:
+  // If a client is already viewing this specific window, just activate Terminal.app
+  if (isTmuxWindowViewed(TMUX_SESSION, winName)) {
+    appendRuntimeLog("INFO", `TMUX_WINDOW_ALREADY_VIEWED: ${winName}. Activating existing Terminal.`);
+    if (process.platform === "darwin") {
+      try {
+        execFileSync("osascript", ["-e", 'tell application "Terminal" to activate'], { stdio: "ignore" });
+      } catch { /* ignore */ }
+    }
+    return { opened: true, windowIds: [] };
+  }
+
+  // If a terminal is already attached to OTHER windows, open a NEW grouped session
+  // instead of select-window (which would hijack all attached clients' views).
   if (tmuxHasAttachedClients(TMUX_SESSION)) {
     if (process.platform === "darwin") {
       const groupAttachCmd = `tmux new-session -t "${TMUX_SESSION}" \\; select-window -t "${TMUX_SESSION}:${winName}"`;
@@ -2055,17 +2058,20 @@ function spawnMonitorTerminal(sessionId) {
     if (hasTmuxSession(TMUX_SESSION)) {
       // Skip if a window with the same name already exists (prevents duplicates)
       if (hasTmuxWindow(TMUX_SESSION, winName)) {
+        appendRuntimeLog("INFO", `TMUX_WINDOW_EXISTS: ${winName} in ${TMUX_SESSION}`);
         return true;
       }
       execFileSync("tmux", ["new-window", "-t", TMUX_SESSION, "-n", winName, cmd], {
         stdio: "ignore",
         windowsHide: true,
       });
+      appendRuntimeLog("INFO", `TMUX_WINDOW_CREATED: ${winName} in existing ${TMUX_SESSION}`);
     } else {
       execFileSync("tmux", ["new-session", "-d", "-s", TMUX_SESSION, "-n", winName, cmd], {
         stdio: "ignore",
         windowsHide: true,
       });
+      appendRuntimeLog("INFO", `TMUX_SESSION_CREATED: ${TMUX_SESSION} with window ${winName}`);
     }
     return true;
   } catch {
@@ -2302,7 +2308,7 @@ ${recent}
 `;
 }
 
-function submitDeliberationTurn({ session_id, speaker, content, turn_id, channel_used, fallback_reason }) {
+function submitDeliberationTurn({ session_id, speaker, content, turn_id, channel_used, fallback_reason, attachments }) {
   const resolved = resolveSessionId(session_id);
   if (!resolved) {
     return { content: [{ type: "text", text: t("No active deliberation.", "활성 deliberation이 없습니다.", "en") }] };
@@ -2367,8 +2373,9 @@ function submitDeliberationTurn({ session_id, speaker, content, turn_id, channel
       votes: votes.length > 0 ? votes : undefined,
       suggested_next_role: suggestedRole !== "free" ? suggestedRole : undefined,
       role_drift: roleDrift || undefined,
+      attachments: attachments || undefined,
     });
-    appendRuntimeLog("INFO", `TURN: ${state.id} | R${state.current_round} | speaker: ${normalizedSpeaker} | votes: ${votes.length > 0 ? votes.map(v => v.vote).join(",") : "none"} | channel: ${channel_used || "respond"} | suggested_role: ${suggestedRole} | role_drift: ${roleDrift || false}`);
+    appendRuntimeLog("INFO", `TURN: ${state.id} | R${state.current_round} | speaker: ${normalizedSpeaker} | votes: ${votes.length > 0 ? votes.map(v => v.vote).join(",") : "none"} | channel: ${channel_used || "respond"} | attachments: ${attachments ? attachments.length : 0}`);
 
     state.current_speaker = selectNextSpeaker(state);
 
@@ -2442,6 +2449,7 @@ server.tool(
   "Start a new deliberation. Multiple deliberations can run simultaneously.",
   {
     topic: z.string().describe("Discussion topic"),
+    session_id: z.string().trim().min(1).max(64).optional().describe("Explicit session ID to use. If omitted, one is generated from topic."),
     rounds: z.coerce.number().optional().describe("Number of rounds (defaults to config setting, default 3)"),
     first_speaker: z.string().trim().min(1).max(64).optional().describe("First speaker name (defaults to first item in speakers)"),
     speakers: z.preprocess(
@@ -2476,9 +2484,9 @@ server.tool(
       z.record(z.string(), z.enum(["critic", "implementer", "mediator", "researcher", "free"])).optional()
     ).describe("Per-speaker role assignment (e.g., {\"claude\": \"critic\", \"codex\": \"implementer\"})"),
     role_preset: z.enum(["balanced", "debate", "research", "brainstorm", "review", "consensus"]).optional()
-      .describe("Role preset (balanced/debate/research/brainstorm/review/consensus). Ignored if speaker_roles is specified"),
-  },
-  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 }) => {
+    .describe("Role preset (balanced/debate/research/brainstorm/review/consensus). Ignored if speaker_roles is specified"),
+    },
+    safeToolHandler("deliberation_start", async ({ topic, session_id, 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) {
@@ -2492,7 +2500,13 @@ server.tool(
       };
     }
 
-    const sessionId = generateSessionId(topic);
+    const sessionId = session_id || generateSessionId(topic);
+    if (session_id) {
+      const existing = loadSession(session_id);
+      if (existing && existing.status === "active") {
+        return { content: [{ type: "text", text: `❌ Session "${session_id}" is already active. Please use a different ID or reset it first.` }] };
+      }
+    }
     const candidateSnapshot = await collectSpeakerCandidates({ include_cli: true, include_browser: true });
 
     // Resolve effective settings from config
@@ -2804,7 +2818,7 @@ server.tool(
     }
 
     const speaker = state.current_speaker;
-    const { transport, profile, reason } = resolveTransportForSpeaker(state, speaker);
+    let { transport, profile, reason } = resolveTransportForSpeaker(state, speaker);
     const turnId = state.pending_turn_id || null;
 
     // ── Self-speaker detection ──
@@ -2816,14 +2830,25 @@ server.tool(
 
     let guidance;
     if (isSelfSpeaker) {
-      guidance = `🟢 **It's your turn.** You (${speaker}) are the current speaker.\n\n` +
+      guidance = t(
+        `🟢 **It's your turn.** You (${speaker}) are the current speaker.\n\n` +
         `Write your response and submit via \`deliberation_respond(session_id: "${state.id}", speaker: "${speaker}", content: "...")\`.\n\n` +
-        `⚠️ **Do not use cli_auto_turn**: Recursively calling yourself will cause a timeout. You must use deliberation_respond directly.`;
+        `⚠️ **Wait! Why can't I use cli_auto_turn?**\n` +
+        `You are currently the **orchestrator** (the AI running this tool). If you try to spawn yourself automatically, it would create an infinite loop (you calling yourself calling yourself...) and timeout.\n\n` +
+        `Please analyze the topic and history above, formulate your response, and call \`deliberation_respond\` directly.`,
+        `🟢 **당신의 차례입니다.** 당신(${speaker})이 현재 발언자입니다.\n\n` +
+        `응답을 작성하고 \`deliberation_respond(session_id: "${state.id}", speaker: "${speaker}", content: "...")\`를 통해 제출하세요.\n\n` +
+        `⚠️ **잠깐! 왜 cli_auto_turn을 쓸 수 없나요?**\n` +
+        `당신은 현재 **오케스트레이터**(이 도구를 실행 중인 AI)입니다. 자기 자신을 자동으로 spawn하려고 하면 무한 루프(자신이 자신을 호출하고 다시 호출하는...)가 발생하여 타임아웃이 됩니다.\n\n` +
+        `위의 주제와 이력을 분석하여 응답을 작성한 뒤, \`deliberation_respond\`를 직접 호출해 주세요.`,
+        state?.lang
+      );
     } else {
       guidance = formatTransportGuidance(transport, state, speaker);
     }
 
     let extra = "";
+    let turnPrompt = "";
 
     if (transport === "browser_auto") {
       // Auto-execute browser_auto_turn
@@ -2837,7 +2862,7 @@ server.tool(
         const modelSelection = getModelSelectionForTurn(state, turnSpeaker, turnProvider);
 
         // Build prompt
-        const turnPrompt = buildClipboardTurnPrompt(state, turnSpeaker, prompt, include_history_entries);
+        turnPrompt = buildClipboardTurnPrompt(state, turnSpeaker, prompt, include_history_entries);
 
         // Attach
         const attachResult = await port.attach(sessionId, { provider: turnProvider, url: profile?.url });
@@ -2876,7 +2901,28 @@ server.tool(
       } catch (autoErr) {
         const errMsg = autoErr instanceof Error ? autoErr.message : String(autoErr);
         extra = `\n\n⚠️ Auto-execution failed (${errMsg}). Restart Chrome with --remote-debugging-port=9222.`;
+        // Fallback to clipboard preparation
+        transport = "clipboard";
+        // Re-generate guidance for the new transport
+        if (!isSelfSpeaker) {
+          guidance = formatTransportGuidance(transport, state, speaker);
+        }
+      }
+    }
+
+    if (transport === "clipboard" || transport === "manual") {
+      // Prepare prompt for manual/clipboard transport
+      turnPrompt = buildClipboardTurnPrompt(state, speaker, prompt, include_history_entries);
+
+      if (auto_prepare_clipboard) {
+        try {
+          writeClipboardText(turnPrompt);
+        } catch (clipErr) {
+          extra += `\n\n⚠️ Failed to copy to clipboard: ${clipErr.message}`;
+        }
       }
+
+      extra += `\n\n### [turn_prompt]\n\`\`\`markdown\n${turnPrompt}\n\`\`\``;
     }
 
     const profileInfo = profile
@@ -3044,13 +3090,19 @@ server.tool(
       return { content: [{ type: "text", text: t(`Speaker "${speaker}" is not a CLI type (transport: ${transport}). Browser speakers should use deliberation_browser_auto_turn.`, `speaker "${speaker}"는 CLI 타입이 아닙니다 (transport: ${transport}). 브라우저 speaker는 deliberation_browser_auto_turn을 사용하세요.`, state?.lang) }] };
     }
 
-    // Block recursive self-spawn: if the speaker is the same CLI as the caller,
-    // spawning it would create infinite recursion and timeout.
     const callerSpeaker = detectCallerSpeaker();
     if (callerSpeaker && speaker === callerSpeaker) {
       return { content: [{ type: "text", text: t(
-        `⚠️ **Recursive call blocked**: Speaker "${speaker}" is the same CLI as the current orchestrator.\n\nSpawning yourself with cli_auto_turn will cause a timeout.\nWrite your response and submit via \`deliberation_respond(session_id: "${resolved}", speaker: "${speaker}", content: "...")\`.`,
-        `⚠️ **재귀 호출 차단**: speaker "${speaker}"는 현재 오케스트레이터와 동일한 CLI입니다.\n\ncli_auto_turn으로 자기 자신을 spawn하면 타임아웃이 발생합니다.\n직접 응답을 작성하여 \`deliberation_respond(session_id: "${resolved}", speaker: "${speaker}", content: "...")\`로 제출하세요.`,
+        `🟢 **It's your turn.** You (${speaker}) are the current speaker.\n\n` +
+        `Write your response and submit via \`deliberation_respond(session_id: "${resolved}", speaker: "${speaker}", content: "...")\`.\n\n` +
+        `⚠️ **Wait! Why can't I use cli_auto_turn?**\n` +
+        `You are currently the **orchestrator** (the AI running this tool). If you try to spawn yourself automatically, it would create an infinite loop (you calling yourself calling yourself...) and timeout.\n\n` +
+        `Please analyze the topic and history above, formulate your response, and call \`deliberation_respond\` directly.`,
+        `🟢 **당신의 차례입니다.** 당신(${speaker})이 현재 발언자입니다.\n\n` +
+        `응답을 작성하고 \`deliberation_respond(session_id: "${resolved}", speaker: "${speaker}", content: "...")\`를 통해 제출하세요.\n\n` +
+        `⚠️ **잠깐! 왜 cli_auto_turn을 쓸 수 없나요?**\n` +
+        `당신은 현재 **오케스트레이터**(이 도구를 실행 중인 AI)입니다. 자기 자신을 자동으로 spawn하려고 하면 무한 루프(자신이 자신을 호출하고 다시 호출하는...)가 발생하여 타임아웃이 됩니다.\n\n` +
+        `위의 주제와 이력을 분석하여 응답을 작성한 뒤, \`deliberation_respond\`를 직접 호출해 주세요.`,
         state?.lang)
       }] };
     }
@@ -3094,7 +3146,9 @@ server.tool(
             child.stdin.end();
             break;
           case "codex":
-            child = spawn("codex", ["exec", "--model", "gpt-5.4-codex", turnPrompt], { env, windowsHide: true });
+            child = spawn("codex", ["exec", "-"], { env, windowsHide: true });
+            child.stdin.write(turnPrompt);
+            child.stdin.end();
             break;
           case "gemini":
             child = spawn("gemini", ["-p", turnPrompt], { env, windowsHide: true });
@@ -3123,12 +3177,23 @@ server.tool(
             // Clean up output noise
             let cleaned = stdout;
             if (speaker === "codex") {
-              cleaned = stdout.split("\n")
-                .filter(line => !/^(OpenAI Codex|--------|workdir:|model:|provider:|approval:|sandbox:|reasoning|session id:|user$|mcp:|thinking$|tokens used$|^[0-9,]*$)/.test(line))
-                .join("\n");
+              // Codex output includes the prompt and metadata.
+              // Find the line starting with "codex" and take everything after it.
+              const lines = stdout.split("\n");
+              const codexLineIdx = lines.findIndex(l => l.trim() === "codex");
+              if (codexLineIdx !== -1) {
+                cleaned = lines.slice(codexLineIdx + 1)
+                  .filter(line => !/^(tokens used$|^[0-9,]*$)/.test(line))
+                  .join("\n");
+              } else {
+                // Fallback regex cleaning
+                cleaned = stdout.split("\n")
+                  .filter(line => !/^(OpenAI Codex|--------|workdir:|model:|provider:|approval:|sandbox:|reasoning|session id:|user$|mcp:|thinking$|tokens used$|^[0-9,]*$)/.test(line))
+                  .join("\n");
+              }
             } else if (speaker === "gemini") {
               cleaned = stdout.split("\n")
-                .filter(line => !/^(Loaded cached|Error during discovery)/.test(line))
+                .filter(line => !/^(Loaded cached|Error during discovery|\[MCP error\]| {4}at| {2}errno:| {2}code:| {2}syscall:| {2}path:| {2}spawnargs:|MCP issues detected|Server .* supports tool updates)/.test(line))
                 .join("\n");
             }
             resolve(cleaned.trim());
@@ -3184,9 +3249,11 @@ server.tool(
     speaker: z.string().trim().min(1).max(64).describe("Responder name"),
     content: z.string().optional().describe("Response content (markdown). Either content or content_file is required."),
     content_file: z.string().optional().describe("File path containing response content. For avoiding JSON escape issues. File content is used as-is for content."),
+    use_clipboard: z.boolean().optional().describe("Read content from system clipboard (alternative to content/content_file)"),
+    include_clipboard_image: z.boolean().optional().describe("Capture and include image from system clipboard"),
     turn_id: z.string().optional().describe("Turn verification ID (value received from deliberation_route_turn)"),
   },
-  safeToolHandler("deliberation_respond", async ({ session_id, speaker, content, content_file, turn_id }) => {
+  safeToolHandler("deliberation_respond", async ({ session_id, speaker, content, content_file, use_clipboard, include_clipboard_image, turn_id }) => {
     // Guard: prevent orchestrator from fabricating responses for CLI/browser speakers
     const resolved = resolveSessionId(session_id);
     if (resolved && resolved !== "MULTIPLE") {
@@ -3212,22 +3279,125 @@ server.tool(
       }
     }
 
-    // Support reading content from file to avoid JSON escaping issues
+    // Support reading content from file or clipboard to avoid JSON escaping issues
     let finalContent = content;
-    if (content_file && !content) {
+    if (use_clipboard && !content) {
+      try {
+        finalContent = readClipboardText();
+      } catch (e) {
+        return { content: [{ type: "text", text: t(`❌ Failed to read from clipboard: ${e.message}`, `❌ 클립보드 읽기 실패: ${e.message}`, state?.lang) }] };
+      }
+    } else if (content_file && !content) {
       try {
         finalContent = fs.readFileSync(content_file, "utf-8").trim();
       } catch (e) {
         return { content: [{ type: "text", text: t(`❌ Failed to read content_file: ${e.message}`, `❌ content_file 읽기 실패: ${e.message}`, state?.lang) }] };
       }
     }
-    if (!finalContent) {
-      return { content: [{ type: "text", text: t("❌ Either content or content_file must be provided.", "❌ content 또는 content_file 중 하나를 제공해야 합니다.", "en") }] };
+    if (!finalContent && !include_clipboard_image) {
+      return { content: [{ type: "text", text: t("❌ Either content, content_file, or include_clipboard_image must be provided.", "❌ content, content_file 또는 include_clipboard_image 중 하나를 제공해야 합니다.", "en") }] };
+    }
+
+    const attachments = [];
+    if (include_clipboard_image) {
+      if (process.platform !== "darwin") {
+        return { content: [{ type: "text", text: "❌ Clipboard image capture is currently only supported on macOS." }] };
+      }
+      if (!hasClipboardImage()) {
+        return { content: [{ type: "text", text: t("❌ No image found on clipboard.", "❌ 클립보드에서 이미지를 찾을 수 없습니다.", state?.lang) }] };
+      }
+
+      const attachmentsDir = path.join(getSessionsDir(), `${resolved}_attachments`);
+      if (!fs.existsSync(attachmentsDir)) fs.mkdirSync(attachmentsDir, { recursive: true });
+      
+      const imgName = `img_${Date.now()}.png`;
+      const imgPath = path.join(attachmentsDir, imgName);
+      
+      if (captureClipboardImage(imgPath)) {
+        attachments.push({ type: "image", path: `attachments/${imgName}`, localPath: imgPath });
+      } else {
+        return { content: [{ type: "text", text: "❌ Failed to capture image from clipboard." }] };
+      }
+    }
+
+    return submitDeliberationTurn({ session_id, speaker, content: finalContent || "(Image response)", turn_id, channel_used: "cli_respond", attachments });
+  })
+);
+
+server.tool(
+  "deliberation_inject_context",
+  "Inject additional context or instructions into a specific active session. (Useful for local or remote context injection via Tailscale)",
+  {
+    session_id: z.string().describe("Session ID to inject context into"),
+    context: z.string().describe("The context text to inject"),
+    speaker: z.string().default("system").describe("Optional label for who injected the context (default: 'system')"),
+  },
+  safeToolHandler("deliberation_inject_context", async ({ session_id, context, speaker }) => {
+    const resolved = resolveSessionId(session_id);
+    if (!resolved) {
+      return { content: [{ type: "text", text: t("No active deliberation.", "활성 deliberation이 없습니다.", "en") }] };
     }
-    return submitDeliberationTurn({ session_id, speaker, content: finalContent, turn_id, channel_used: "cli_respond" });
+    if (resolved === "MULTIPLE") {
+      return { content: [{ type: "text", text: multipleSessionsError() }] };
+    }
+
+    return withSessionLock(resolved, () => {
+      const state = loadSession(resolved);
+      if (!state || state.status !== "active") {
+        return { content: [{ type: "text", text: t(`Session "${resolved}" is not active.`, `세션 "${resolved}"이 활성 상태가 아닙니다.`, "en") }] };
+      }
+
+      state.log.push({
+        round: state.current_round,
+        speaker: speaker || "system",
+        content: `[Context Injection]\n${context}`,
+        timestamp: new Date().toISOString(),
+        event: "context_injection",
+      });
+
+      appendRuntimeLog("INFO", `CONTEXT_INJECTION: ${state.id} | speaker: ${speaker || "system"} | length: ${context.length}`);
+      saveSession(state);
+
+      return {
+        content: [{
+          type: "text",
+          text: `✅ Context successfully injected into session "${state.id}".`,
+        }],
+      };
+    });
   })
 );
 
+server.tool(
+  "deliberation_copy_last_turn",
+  "Copy the last turn's response to the system clipboard.",
+  {
+    session_id: z.string().optional().describe("Session ID (required if multiple sessions are active)"),
+  },
+  async ({ session_id }) => {
+    const resolved = resolveSessionId(session_id);
+    if (!resolved || resolved === "MULTIPLE") {
+      return { content: [{ type: "text", text: t("No unique active deliberation found.", "고유한 활성 deliberation을 찾을 수 없습니다.", "en") }] };
+    }
+    const state = loadSession(resolved);
+    if (!state || state.log.length === 0) {
+      return { content: [{ type: "text", text: t("No responses yet.", "아직 응답이 없습니다.", "en") }] };
+    }
+    const last = state.log[state.log.length - 1];
+    try {
+      writeClipboardText(last.content);
+      let imgMsg = "";
+      if (last.attachments && last.attachments.length > 0) {
+        const hasImg = last.attachments.some(a => a.type === "image");
+        if (hasImg) imgMsg = "\n\n⚠️ Note: This response included images, but only text was copied to the clipboard.";
+      }
+      return { content: [{ type: "text", text: `📋 **[${last.speaker}]'s response copied to clipboard.** (Round ${last.round})${imgMsg}\n\nYou can now paste it into other tools using Cmd+V (ㅍ).` }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: `❌ Failed to copy to clipboard: ${e.message}` }] };
+    }
+  }
+);
+
 server.tool(
   "deliberation_history",
   "Return the deliberation history.",
@@ -3295,6 +3465,9 @@ server.tool(
       saveSession(loaded);
       archivePath = archiveState(loaded);
       cleanupSyncMarkdown(loaded);
+      // Clean up the active session JSON file upon completion
+      const sessionFile = getSessionFile(loaded.id);
+      try { if (fs.existsSync(sessionFile)) fs.unlinkSync(sessionFile); } catch { /* ignore */ }
       state = loaded;
       return null;
     });
@@ -3528,7 +3701,7 @@ server.tool(
 function invokeCliReviewer(command, prompt, timeoutMs) {
   const hint = CLI_INVOCATION_HINTS[command];
   let args;
-  let opts = { encoding: "utf-8", timeout: timeoutMs, stdio: ["pipe", "pipe", "pipe"], maxBuffer: 5 * 1024 * 1024, windowsHide: true };
+  let opts = { encoding: "utf-8", timeout: timeoutMs, stdio: ["pipe", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024, windowsHide: true };
   const env = { ...process.env };
 
   switch (command) {
@@ -3536,11 +3709,10 @@ function invokeCliReviewer(command, prompt, timeoutMs) {
       if (hint?.envPrefix?.includes("CLAUDECODE=")) delete env.CLAUDECODE;
       args = ["-p", "--output-format", "text", "--no-input"];
       opts.input = prompt;
-      opts.stdio = ["pipe", "pipe", "pipe"];
       break;
     case "codex":
-      args = ["exec", prompt];
-      opts.stdio = ["ignore", "pipe", "pipe"];
+      args = ["exec", "-"];
+      opts.input = prompt;
       break;
     case "gemini":
       args = ["-p", prompt];
@@ -3556,7 +3728,17 @@ function invokeCliReviewer(command, prompt, timeoutMs) {
 
   try {
     const result = execFileSync(command, args, { ...opts, env });
-    return { ok: true, response: result.trim() };
+    let cleaned = result;
+    if (command === "codex") {
+      const lines = result.split("\n");
+      const codexLineIdx = lines.findIndex(l => l.trim() === "codex");
+      if (codexLineIdx !== -1) {
+        cleaned = lines.slice(codexLineIdx + 1)
+          .filter(line => !/^(tokens used$|^[0-9,]*$)/.test(line))
+          .join("\n");
+      }
+    }
+    return { ok: true, response: cleaned.trim() };
   } catch (error) {
     if (error && error.killed) {
       return { ok: false, error: "timeout" };
@@ -3896,24 +4078,24 @@ server.tool(
           let stdout = "";
           let stderr = "";
 
-          const args = [];
+          let proc;
+          const env = { ...process.env, NO_COLOR: "1" };
+          
           if (speaker === "claude") {
-            args.push("-p", "--output-format", "text", opinionPrompt);
+            proc = spawn("claude", ["-p", "--output-format", "text", "--no-input"], { env, windowsHide: true });
+            proc.stdin.write(opinionPrompt);
+            proc.stdin.end();
           } else if (speaker === "codex") {
-            args.push("exec", opinionPrompt);
+            proc = spawn("codex", ["exec", "-"], { env, windowsHide: true });
+            proc.stdin.write(opinionPrompt);
+            proc.stdin.end();
           } else if (speaker === "gemini") {
-            args.push("-p", opinionPrompt);
+            proc = spawn("gemini", ["-p", opinionPrompt], { env, windowsHide: true });
           } else {
-            const flags = hint?.flags || [];
-            args.push(...flags, opinionPrompt);
+            const flags = hint?.flags ? (Array.isArray(hint.flags) ? hint.flags : hint.flags.split(/\s+/)) : [];
+            proc = spawn(cmd, [...flags, opinionPrompt], { env, windowsHide: true });
           }
 
-          const proc = spawn(cmd, args, {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env, NO_COLOR: "1" },
-            timeout: 180000,
-          });
-
           proc.stdout?.on("data", (d) => { stdout += d.toString(); });
           proc.stderr?.on("data", (d) => { stderr += d.toString(); });
 
@@ -3924,7 +4106,21 @@ server.tool(
 
           proc.on("close", (code) => {
             clearTimeout(timer);
-            resolve(stdout.trim() || stderr.trim());
+            let cleaned = stdout.trim() || stderr.trim();
+            if (speaker === "codex") {
+              const lines = cleaned.split("\n");
+              const codexLineIdx = lines.findIndex(l => l.trim() === "codex");
+              if (codexLineIdx !== -1) {
+                cleaned = lines.slice(codexLineIdx + 1)
+                  .filter(line => !/^(tokens used$|^[0-9,]*$)/.test(line))
+                  .join("\n").trim();
+              }
+            } else if (speaker === "gemini") {
+              cleaned = cleaned.split("\n")
+                .filter(line => !/^(Loaded cached|Error during discovery|\[MCP error\]| {4}at| {2}errno:| {2}code:| {2}syscall:| {2}path:| {2}spawnargs:|MCP issues detected|Server .* supports tool updates)/.test(line))
+                .join("\n").trim();
+            }
+            resolve(cleaned);
           });
 
           proc.on("error", (err) => {