tagteam 0.3.0 → 0.4.2

package/dist/index.js

@@ -2,7 +2,8 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { execSync as execSync2 } from "child_process";
+import { createRequire } from "module";
+import { execSync as execSync3 } from "child_process";
 import chalk from "chalk";
 
 // src/config.ts
@@ -22,7 +23,7 @@ var DEFAULT_CONFIG = {
     model: "gemini-2.5-pro"
   },
   discussion: {
-    max_rounds: 10
+    max_rounds: 5
   }
 };
 function getConfigDir() {
@@ -111,8 +112,8 @@ function setConfigValue(key, value) {
 }
 
 // src/ui.tsx
-import { useState as useState2, useEffect, useCallback, useRef } from "react";
-import { render as render2, Box as Box2, Text as Text2, useApp as useApp2, useInput as useInput2 } from "ink";
+import React2, { useState as useState2, useEffect, useCallback, useRef, useMemo } from "react";
+import { render as render2, Box as Box2, Text as Text2, useApp as useApp2, useInput as useInput2, Static } from "ink";
 import TextInput2 from "ink-text-input";
 import Spinner from "ink-spinner";
 import { marked } from "marked";
@@ -458,6 +459,16 @@ var AGENTS = {
     cliBinary: "claude",
     installUrl: "https://docs.anthropic.com/en/docs/claude-code",
     org: "Anthropic",
+    profile: {
+      strength: "architecture-implementation",
+      role: "The Builder",
+      focus: [
+        "multi-file coherence and refactoring",
+        "production-quality implementation",
+        "design patterns and maintainability",
+        "comprehensive working solutions"
+      ]
+    },
     run: runClaude
   },
   codex: {
@@ -467,6 +478,16 @@ var AGENTS = {
     cliBinary: "codex",
     installUrl: "https://github.com/openai/codex",
     org: "OpenAI",
+    profile: {
+      strength: "correctness-verification",
+      role: "The Verifier",
+      focus: [
+        "algorithmic correctness and edge cases",
+        "test coverage and failure modes",
+        "standards compliance and best practices",
+        "performance characteristics and benchmarks"
+      ]
+    },
     run: runCodex
   },
   gemini: {
@@ -476,12 +497,49 @@ var AGENTS = {
     cliBinary: "gemini",
     installUrl: "https://github.com/google-gemini/gemini-cli",
     org: "Google",
+    profile: {
+      strength: "context-strategy",
+      role: "The Strategist",
+      focus: [
+        "broad codebase context and upstream/downstream effects",
+        "current ecosystem conventions and documentation",
+        "architectural fit and scope assessment",
+        "planning, decomposition, and tradeoff analysis"
+      ]
+    },
     run: runGemini
   }
 };
+var PEER_ROLES = {
+  "claude,codex": {
+    claude: "Correctness & Standards \u2014 they verify edge cases, test coverage, and standards compliance",
+    codex: "Architecture & Implementation \u2014 they propose complete solutions and assess structural coherence",
+    gemini: ""
+    // not in this pair
+  },
+  "claude,gemini": {
+    claude: "Strategic Context \u2014 they assess broad codebase fit, ecosystem conventions, and architectural tradeoffs",
+    gemini: "Architecture & Implementation \u2014 they propose complete solutions and assess structural coherence",
+    codex: ""
+    // not in this pair
+  },
+  "codex,gemini": {
+    codex: "Strategic Context \u2014 they assess broad codebase fit, ecosystem conventions, and architectural tradeoffs",
+    gemini: "Correctness & Standards \u2014 they verify edge cases, test coverage, and standards compliance",
+    claude: ""
+    // not in this pair
+  }
+};
 function getAgent(name) {
   return AGENTS[name];
 }
+function getAgentProfile(name) {
+  return AGENTS[name].profile;
+}
+function getPeerRoleDescription(agent, pair) {
+  const key = [...pair].sort().join(",");
+  return PEER_ROLES[key]?.[agent] ?? "";
+}
 function getAllAgentNames() {
   return Object.keys(AGENTS);
 }
@@ -569,6 +627,34 @@ function copyToClipboard(text) {
   }
 }
 
+// src/gist.ts
+import { execSync as execSync2 } from "child_process";
+function createGist(content, filename) {
+  try {
+    execSync2("gh auth status", { stdio: "ignore" });
+  } catch {
+    try {
+      execSync2("which gh", { stdio: "ignore" });
+    } catch {
+      throw new Error(
+        "gh CLI not found. Install it from https://cli.github.com"
+      );
+    }
+    throw new Error(
+      "gh CLI is not authenticated. Run: gh auth login"
+    );
+  }
+  try {
+    const result = execSync2(
+      `gh gist create --private --filename "${filename}" -`,
+      { input: content, stdio: ["pipe", "pipe", "ignore"] }
+    );
+    return result.toString().trim();
+  } catch {
+    throw new Error("Failed to create gist.");
+  }
+}
+
 // src/db/index.ts
 import Database from "better-sqlite3";
 import { join as join2 } from "path";
@@ -694,66 +780,279 @@ function deleteMessagesFromRound(sessionId, fromRound) {
 }
 
 // src/prompts.ts
-function otherAgent(agent, pair) {
-  const other = pair[0] === agent ? pair[1] : pair[0];
-  const desc = getAgent(other);
-  return `${desc.displayName} (${desc.org})`;
+var CONSENSUS_MARKER = "[CONSENSUS]";
+function formatConversationHistory(messages) {
+  return messages.map((m) => {
+    let label;
+    if (m.role === "user") {
+      label = "User";
+    } else if (isValidAgentName(m.role)) {
+      label = getAgent(m.role).displayName;
+    } else if (m.agent && isValidAgentName(m.agent)) {
+      label = getAgent(m.agent).displayName;
+    } else {
+      label = m.role;
+    }
+    return `[${label}]: ${m.content}`;
+  }).join("\n\n");
 }
-function collaborationPrompt(agent, pair) {
-  return `You are in a collaborative session with ${otherAgent(agent, pair)}. You'll both respond to the user's prompt independently, then see each other's responses. In discussion rounds: highlight where you agree, constructively address disagreements, and build on each other's ideas. Be concise - avoid repeating what was already said.`;
+function basePrompt() {
+  return `You are one of two expert coding agents in a structured technical discussion.
+You will independently analyze the problem, then engage in focused rounds of
+critique and refinement with your peer.
+
+Ground rules:
+- You are evaluated on the ACCURACY and QUALITY of your final position, not
+  on agreement with your peer.
+- When you change your position, you MUST name the specific argument that
+  changed your mind and explain why your previous reasoning was flawed.
+  Changing position without this justification is not acceptable.
+- Each response must either: (a) introduce new evidence or a new argument,
+  (b) identify a specific logical flaw or unsupported claim in your peer's
+  reasoning, or (c) concede a point with explicit justification. Restating
+  or paraphrasing existing points is not acceptable.
+- Your peer is a different AI model with different training. Their perspective
+  may reveal genuine blind spots in yours \u2014 and vice versa.`;
+}
+var ROLE_TEMPLATES = {
+  claude: `Your role: Architecture & Implementation Reviewer.
+
+Focus your analysis on:
+- Code structure, design patterns, and maintainability
+- Multi-file coherence \u2014 how changes ripple across the codebase
+- Production readiness \u2014 error handling, logging, edge cases in real usage
+- Proposing complete, working implementations (not just pseudocode)
+
+When you propose a solution, provide the actual implementation. When you
+critique, point to specific structural issues and show what the fix looks
+like. Your peer's role is {peerRole} \u2014 they will stress-test your proposals
+from a different angle.`,
+  codex: `Your role: Correctness & Standards Reviewer.
+
+Focus your analysis on:
+- Algorithmic correctness \u2014 does the logic actually work for all inputs?
+- Edge cases and failure modes \u2014 what breaks, what's untested?
+- Standards compliance \u2014 does this follow language/framework conventions?
+- Performance characteristics \u2014 time/space complexity, benchmarks
+
+When you critique, provide specific test cases or inputs that demonstrate
+the issue. When you propose alternatives, explain the correctness guarantees.
+Your peer's role is {peerRole} \u2014 they will focus on different aspects of the
+same problem.`,
+  gemini: `Your role: Strategic Context Analyst.
+
+Focus your analysis on:
+- Broad codebase context \u2014 how does this change fit the larger system?
+- Current ecosystem conventions \u2014 what do the docs, community, and recent
+  releases recommend?
+- Upstream and downstream effects \u2014 what will this break or enable elsewhere?
+- Scope and planning \u2014 is this the right approach at the right level of
+  abstraction?
+
+When you critique, ground your position in the broader context your peer may
+be missing. When you propose alternatives, explain the architectural tradeoffs.
+Your peer's role is {peerRole} \u2014 they will focus on different aspects of the
+same problem.`
+};
+function rolePrompt(agent, pair) {
+  const template = ROLE_TEMPLATES[agent];
+  const peerRole = getPeerRoleDescription(agent, pair);
+  return template.replace("{peerRole}", peerRole);
 }
-function discussionPrompt(agent, conversationHistory, pair) {
-  return `${collaborationPrompt(agent, pair)}
+function collaborationSystemPrompt(agent, pair) {
+  return `${basePrompt()}
 
-Here is the conversation so far:
+${rolePrompt(agent, pair)}`;
+}
+function discussionRoundPrompt(agent, conversationContext, pair) {
+  return `${basePrompt()}
 
-${conversationHistory}
+${rolePrompt(agent, pair)}
+
+Here is the discussion so far:
+
+${conversationContext}
+
+For this round:
+1. What is the strongest point in your peer's response?
+2. What is the weakest point, or what claim lacks supporting evidence?
+3. Has your position changed? State one of: HELD / PARTIALLY_CHANGED / CHANGED
+   \u2014 with explicit reasoning for why.
+4. If proposing code, show the specific implementation and explain tradeoffs
+   versus your peer's approach.
+5. Confidence in your current position: LOW | MEDIUM | HIGH
 
-Now provide your response for this discussion round. Build on what was said, highlight agreements, and address any disagreements constructively. Be concise.`;
+CONFIDENCE: HIGH | MEDIUM | LOW
+
+Keep it concise. Do not restate points already established.`;
 }
-function debatePrompt(agent, pair) {
-  const other = otherAgent(agent, pair);
-  return `You are in a structured debate with ${other}. You'll both respond to the user's prompt, then see each other's responses and discuss.
+function debateSystemPrompt(agent, pair) {
+  return `${basePrompt()}
+
+${rolePrompt(agent, pair)}
+
+This is a structured discussion aimed at reaching a well-reasoned position
+through genuine deliberation.
+
+Additional rules for discussion mode:
+- Structure your arguments: STATE your claim, provide EVIDENCE (code examples,
+  documentation, benchmarks), explain your REASONING connecting evidence to
+  claim, and note CAVEATS (when your claim doesn't hold).
+- Express confidence: end your response with CONFIDENCE: HIGH | MEDIUM | LOW
+  and a one-line explanation of what would change your mind.
+- Consensus signaling: when you believe you and your peer agree on all key
+  points AND your confidence is HIGH, end your response with ${CONSENSUS_MARKER} on
+  its own line. Only signal consensus when:
+  (a) You can state the shared position in one sentence
+  (b) You have HIGH confidence
+  (c) You are not just deferring \u2014 you genuinely agree with the reasoning`;
+}
+function debateRoundPrompt(agent, conversationContext, pair) {
+  return `${debateSystemPrompt(agent, pair)}
 
-Your goal is to reach consensus through constructive discussion. In each round:
-- Address specific points of agreement and disagreement
-- Refine your position based on valid arguments from ${other}
-- Be concise \u2014 don't repeat points already established
+${conversationContext}
 
-When you believe you and ${other} have reached substantial agreement on the key points, end your response with [CONSENSUS] on its own line. Only do this when you genuinely agree \u2014 don't force premature consensus.`;
+For this round:
+1. Address your peer's strongest argument directly \u2014 do you accept it? Why or
+   why not?
+2. If your peer identified a flaw in your reasoning, acknowledge it explicitly
+   or defend with new evidence.
+3. State your current position with EVIDENCE and REASONING.
+4. CONFIDENCE: HIGH | MEDIUM | LOW \u2014 what specific evidence would change
+   your remaining position?
+5. If consensus: state the shared position in one sentence, then ${CONSENSUS_MARKER}.
+
+POSITION: HELD | PARTIALLY_CHANGED | CHANGED`;
 }
-function debateRoundPrompt(agent, conversationHistory, pair) {
-  const other = otherAgent(agent, pair);
-  return `${debatePrompt(agent, pair)}
+function steelmanPrompt() {
+  return `You and your peer appear to largely agree after Round 1. Before confirming
+consensus, steelman the opposing view:
 
-Here is the conversation so far:
+- What is the strongest argument AGAINST your shared position?
+- What context or edge case might make a different approach better?
+- Is there a tradeoff you're both overlooking?
 
-${conversationHistory}
+If after considering the counterarguments you still hold your position, explain
+why the counterarguments don't apply here. Then proceed with your normal round
+response.
 
-Respond to the latest round. If you agree with ${other}'s position on all key points, end with [CONSENSUS]. Otherwise, continue the discussion.`;
+`;
 }
-function directPrompt(conversationHistory) {
-  return `You are being addressed directly in a multi-agent session. Here is the conversation so far:
+function directPrompt(agent, conversationHistory) {
+  const profile = getAgentProfile(agent);
+  const focusAreas = profile.focus.map((f) => `- ${f}`).join("\n");
+  return `You are being addressed directly in a multi-agent session. The user wants YOUR
+specific perspective.
 
+Here is the conversation so far:
 ${conversationHistory}
 
-Respond to the user's latest message. Be concise.`;
+Respond to the user's latest message. Focus on your area of expertise:
+${focusAreas}
+
+Be concise and direct.`;
 }
-var CONSENSUS_MARKER = "[CONSENSUS]";
-function formatConversationHistory(messages) {
-  return messages.map((m) => {
-    let label;
-    if (m.role === "user") {
-      label = "User";
-    } else if (isValidAgentName(m.role)) {
-      label = getAgent(m.role).displayName;
-    } else if (m.agent && isValidAgentName(m.agent)) {
-      label = getAgent(m.agent).displayName;
-    } else {
-      label = m.role;
+
+// src/discussion.ts
+var CONFIDENCE_RE = /CONFIDENCE:\s*(HIGH|MEDIUM|LOW)/i;
+var POSITION_RE = /POSITION:\s*(HELD|PARTIALLY_CHANGED|CHANGED)/i;
+var CONSENSUS_RE = /\[CONSENSUS\]/;
+function parseRoundAnalysis(agent, responseText) {
+  const confidenceMatch = responseText.match(CONFIDENCE_RE);
+  const positionMatch = responseText.match(POSITION_RE);
+  const signaledConsensus = CONSENSUS_RE.test(responseText);
+  const stripped = responseText.replace(CONFIDENCE_RE, "").replace(POSITION_RE, "").replace(CONSENSUS_RE, "").trim();
+  const hasNovelContent = stripped.length > 100;
+  return {
+    agent,
+    confidence: confidenceMatch?.[1]?.toUpperCase() ?? "MEDIUM",
+    positionChange: positionMatch?.[1]?.toUpperCase() ?? "HELD",
+    signaledConsensus,
+    hasNovelContent
+  };
+}
+function checkTermination(state, maxRounds) {
+  const { round, analyses } = state;
+  if (analyses.length > 0) {
+    const latest = analyses[analyses.length - 1];
+    if (latest && latest.length >= 2) {
+      const allConsensus = latest.every((a) => a.signaledConsensus);
+      const allHigh = latest.every((a) => a.confidence === "HIGH");
+      if (allConsensus && allHigh) {
+        return { terminated: true, reason: "mutual-consensus" };
+      }
     }
-    return `[${label}]: ${m.content}`;
-  }).join("\n\n");
+  }
+  if (analyses.length >= 2) {
+    const prev = analyses[analyses.length - 2];
+    const curr = analyses[analyses.length - 1];
+    if (prev && curr && prev.length >= 2 && curr.length >= 2) {
+      const prevStale = prev.every((a) => a.positionChange === "HELD" && !a.hasNovelContent);
+      const currStale = curr.every((a) => a.positionChange === "HELD" && !a.hasNovelContent);
+      if (prevStale && currStale) {
+        return { terminated: true, reason: "stale-no-progress" };
+      }
+    }
+  }
+  if (analyses.length >= 2) {
+    const prev = analyses[analyses.length - 2];
+    const curr = analyses[analyses.length - 1];
+    if (prev && curr && prev.length >= 2 && curr.length >= 2) {
+      const prevSwap = prev.every((a) => a.positionChange === "CHANGED");
+      const currSwap = curr.every((a) => a.positionChange === "CHANGED");
+      if (prevSwap && currSwap) {
+        return { terminated: true, reason: "cyclic-swap" };
+      }
+    }
+  }
+  if (round >= maxRounds) {
+    return { terminated: true, reason: "max-rounds" };
+  }
+  return { terminated: false };
+}
+function terminationMessage(reason) {
+  switch (reason) {
+    case "mutual-consensus":
+      return "Consensus reached.";
+    case "stale-no-progress":
+      return "Discussion stalled \u2014 no new arguments. Showing final positions.";
+    case "cyclic-swap":
+      return "Agents are trading positions. Showing both perspectives.";
+    case "max-rounds":
+      return "Maximum rounds reached. Showing final positions.";
+  }
+}
+function shouldInjectSteelman(state) {
+  return state.round === 1 && state.analyses.length === 1;
+}
+function buildConversationContext(allMessages, analyses, currentRound, _pair) {
+  if (currentRound <= 2) {
+    return formatConversationHistory(allMessages);
+  }
+  const summaryParts = [];
+  for (let i = 0; i < analyses.length - 1; i++) {
+    const roundAnalyses = analyses[i];
+    if (!roundAnalyses) continue;
+    const roundSummary = roundAnalyses.map((a) => {
+      return `${a.agent}: confidence=${a.confidence}, position=${a.positionChange}${a.signaledConsensus ? ", signaled consensus" : ""}`;
+    }).join("; ");
+    summaryParts.push(`Round ${i + 1}: ${roundSummary}`);
+  }
+  const latestMessages = allMessages.slice(-3);
+  const summary = summaryParts.length > 0 ? `Previous rounds summary:
+${summaryParts.join("\n")}
+
+Latest exchange:
+${formatConversationHistory(latestMessages)}` : formatConversationHistory(allMessages);
+  return summary;
+}
+function analysisToMetadata(analysis) {
+  return {
+    confidence: analysis.confidence,
+    positionChange: analysis.positionChange,
+    signaledConsensus: analysis.signaledConsensus,
+    hasNovelContent: analysis.hasNovelContent
+  };
 }
 
 // src/config-editor.tsx
@@ -940,10 +1239,10 @@ function parseInput(input) {
   return { target: "both", prompt: input, discuss: false };
 }
 function RenderedMarkdown({ text }) {
-  const rendered = marked.parse(text).trimEnd();
+  const rendered = useMemo(() => marked.parse(text).trimEnd(), [text]);
   return /* @__PURE__ */ jsx2(Text2, { children: rendered });
 }
-function AgentResponseBlock({
+var AgentResponseBlock = React2.memo(function AgentResponseBlock2({
   agent,
   content,
   error
@@ -965,7 +1264,7 @@ function AgentResponseBlock({
     ] }),
     /* @__PURE__ */ jsx2(Box2, { marginLeft: 1, children: /* @__PURE__ */ jsx2(RenderedMarkdown, { text: content }) })
   ] });
-}
+});
 function Header({ sessionId }) {
   return /* @__PURE__ */ jsxs2(Box2, { marginBottom: 1, children: [
     /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2500\u2500 " }),
@@ -992,7 +1291,7 @@ function QuickHelp() {
     /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "/help for more" })
   ] });
 }
-function UserMessage({ content }) {
+var UserMessage = React2.memo(function UserMessage2({ content }) {
   return /* @__PURE__ */ jsxs2(Box2, { marginLeft: 1, marginBottom: 1, children: [
     /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "white", children: [
       "You:",
@@ -1000,7 +1299,7 @@ function UserMessage({ content }) {
     ] }),
     /* @__PURE__ */ jsx2(Text2, { children: content })
   ] });
-}
+});
 function ThinkingIndicator({ agent }) {
   const descriptor = getAgent(agent);
   return /* @__PURE__ */ jsxs2(Box2, { marginLeft: 1, children: [
@@ -1077,6 +1376,7 @@ function App({
     }
     return 0;
   });
+  const [committedCount, setCommittedCount] = useState2(showTranscript2?.length ?? 0);
   const sessionCreatedRef = useRef(!!existingSessionId);
   const ensureSession = (id) => {
     if (!sessionCreatedRef.current) {
@@ -1107,7 +1407,9 @@ function App({
       if (runningRoundRef.current !== null) {
         deleteMessagesFromRound(sessionId, runningRoundRef.current);
         const fromRound = runningRoundRef.current;
-        setMessages((prev) => prev.filter((m) => m.round < fromRound));
+        const remaining = messages.filter((m) => m.round < fromRound);
+        setMessages(remaining);
+        setCommittedCount(remaining.length);
         runningRoundRef.current = null;
       }
       setThinkingAgents([]);
@@ -1116,7 +1418,7 @@ function App({
       setState("input");
     }
   });
-  const runAgents = async (currentMessages, round, target, promptOverride, isDebate = false) => {
+  const runAgents = async (currentMessages, round, target, promptOverride, isDebate = false, systemPromptPerAgent) => {
     const activeAgents = Array.isArray(target) ? target : target === "both" ? [...pair] : [target];
     setThinkingAgents(activeAgents);
     const history = formatConversationHistory(
@@ -1138,15 +1440,16 @@ function App({
       return "Provide your response for this round.";
     };
     const agentSystemPrompt = (agent) => {
+      if (systemPromptPerAgent?.[agent]) return systemPromptPerAgent[agent];
       if (isSingleAgent) {
-        return history ? directPrompt(history) : void 0;
+        return history ? directPrompt(agent, history) : void 0;
       }
       if (isDebate) {
-        if (isFirstRound) return debatePrompt(agent, promptPair);
+        if (isFirstRound) return debateSystemPrompt(agent, promptPair);
         return debateRoundPrompt(agent, history, promptPair);
       }
-      if (isFirstRound) return collaborationPrompt(agent, promptPair);
-      return discussionPrompt(agent, history, promptPair);
+      if (isFirstRound) return collaborationSystemPrompt(agent, promptPair);
+      return discussionRoundPrompt(agent, history, promptPair);
     };
     const ac = new AbortController();
     abortRef.current = ac;
@@ -1180,22 +1483,26 @@ function App({
       if (result.status === "fulfilled") {
         const resp = result.value;
         const msg = {
+          id: `${round}-${agent}`,
           role: agent,
           content: resp.error || resp.text,
           round,
           error: !!resp.error
         };
         newMessages.push(msg);
+        const metadata = isDebate && !resp.error ? analysisToMetadata(parseRoundAnalysis(agent, resp.text)) : void 0;
         insertMessage({
           sessionId,
           role: agent,
           content: resp.error || resp.text,
           round,
-          durationMs: resp.durationMs
+          durationMs: resp.durationMs,
+          metadata
         });
       } else {
         const errorMsg = result.reason?.message || "Failed to run";
         const msg = {
+          id: `${round}-${agent}`,
           role: agent,
           content: errorMsg,
           round,
@@ -1225,6 +1532,7 @@ function App({
       updateSessionTitle(sessionId, title);
     }
     const userMsg = {
+      id: `${currentRound}-user`,
       role: "user",
       content: rawInput,
       round: currentRound
@@ -1240,6 +1548,7 @@ function App({
     const newMessages = await runAgents(allMessages, currentRound, target);
     if (newMessages.length === 0) return;
     setMessages((prev) => [...prev, ...newMessages]);
+    setCommittedCount((prev) => prev + 1 + newMessages.length);
     setRoundNum(currentRound + 1);
     runningRoundRef.current = null;
     touchSession(sessionId);
@@ -1247,6 +1556,7 @@ function App({
   };
   const runDiscussion = async (prompt, adHocPair) => {
     const discussionTarget = adHocPair ?? "both";
+    const activePair = adHocPair ?? pair;
     setConsensusReached(false);
     let currentRound = roundNum;
     runningRoundRef.current = currentRound;
@@ -1256,6 +1566,7 @@ function App({
       updateSessionTitle(sessionId, title);
     }
     const userMsg = {
+      id: `${currentRound}-user`,
       role: "user",
       content: `discuss ${prompt}`,
       round: currentRound
@@ -1268,26 +1579,63 @@ function App({
       round: currentRound
     });
     let allMessages = [...messages, userMsg];
+    const discState = {
+      round: 0,
+      analyses: [],
+      terminated: false
+    };
     for (let disc = 1; disc <= config.discussion.max_rounds; disc++) {
       setDiscussionRound(disc);
+      discState.round = disc;
+      let perAgentPrompts;
+      if (disc >= 2) {
+        const context = buildConversationContext(
+          allMessages.map((m) => ({
+            role: m.role,
+            agent: isValidAgentName(m.role) ? m.role : void 0,
+            content: m.content
+          })),
+          discState.analyses,
+          disc,
+          activePair
+        );
+        perAgentPrompts = {};
+        for (const agent of activePair) {
+          let prompt_text = "";
+          if (shouldInjectSteelman(discState)) {
+            prompt_text += steelmanPrompt();
+          }
+          prompt_text += debateRoundPrompt(agent, context, activePair);
+          perAgentPrompts[agent] = prompt_text;
+        }
+      }
       const newMessages = await runAgents(
         allMessages,
         currentRound,
         discussionTarget,
         disc === 1 ? prompt : "Provide your response for this round.",
-        true
+        true,
+        perAgentPrompts
       );
       if (newMessages.length === 0) break;
       setMessages((prev) => [...prev, ...newMessages]);
+      setCommittedCount((prev) => prev + (disc === 1 ? 1 : 0) + newMessages.length);
       allMessages = [...allMessages, ...newMessages];
       currentRound++;
-      const activePair = adHocPair ?? pair;
-      const consensusFlags = activePair.map((agent) => {
+      const roundAnalyses = activePair.map((agent) => {
         const msg = newMessages.find((m) => m.role === agent && !m.error);
-        return msg?.content.includes(CONSENSUS_MARKER) ?? false;
-      });
-      if (consensusFlags.every(Boolean)) {
-        setConsensusReached(true);
+        if (!msg) return null;
+        return parseRoundAnalysis(agent, msg.content);
+      }).filter((a) => a !== null);
+      discState.analyses.push(roundAnalyses);
+      const termResult = checkTermination(discState, config.discussion.max_rounds);
+      if (termResult.terminated && termResult.reason) {
+        discState.terminated = true;
+        discState.terminationReason = termResult.reason;
+        setStatusMessage(terminationMessage(termResult.reason));
+        if (termResult.reason === "mutual-consensus") {
+          setConsensusReached(true);
+        }
         break;
       }
     }
@@ -1311,6 +1659,7 @@ function App({
           "/config  Edit configuration",
           "/new     Start a new session",
           "/copy    Copy conversation to clipboard",
+          "/gist    Create a private GitHub gist",
           "/exit    Exit the app",
           "",
           "Esc      Interrupt running agents"
@@ -1327,6 +1676,7 @@ function App({
       sessionCreatedRef.current = false;
       setSessionId(newId);
       setMessages([]);
+      setCommittedCount(0);
       setRoundNum(0);
       setConsensusReached(false);
       setDiscussionRound(0);
@@ -1343,28 +1693,40 @@ function App({
       }
       return;
     }
+    if (value === "/gist") {
+      if (messages.length === 0) {
+        setStatusMessage("Nothing to gist.");
+        return;
+      }
+      try {
+        const md = formatAsMarkdown(messages);
+        const filename = `tagteam-${sessionId.slice(0, 7)}.md`;
+        const url = createGist(md, filename);
+        setStatusMessage(`Gist created: ${url}`);
+      } catch (e) {
+        setStatusMessage(e.message || "Failed to create gist.");
+      }
+      return;
+    }
     setConsensusReached(false);
     setState("running");
     runRound(value);
   };
+  const staticItems = useMemo(() => [
+    { id: `header-${sessionId}`, role: "__header", content: "", round: -1 },
+    ...messages.slice(0, committedCount)
+  ], [sessionId, messages, committedCount]);
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx2(Header, { sessionId }),
+    /* @__PURE__ */ jsx2(Static, { items: staticItems, children: (item) => {
+      if (item.role === "__header") return /* @__PURE__ */ jsx2(Header, { sessionId }, item.id);
+      if (item.role === "user") return /* @__PURE__ */ jsx2(UserMessage, { content: item.content }, item.id);
+      if (isValidAgentName(item.role)) return /* @__PURE__ */ jsx2(AgentResponseBlock, { agent: item.role, content: item.content, error: item.error }, item.id);
+      return /* @__PURE__ */ jsx2(Box2, {}, item.id);
+    } }),
     messages.length === 0 && state === "input" && /* @__PURE__ */ jsx2(QuickHelp, {}),
-    messages.map((msg, i) => {
-      if (msg.role === "user") {
-        return /* @__PURE__ */ jsx2(UserMessage, { content: msg.content }, i);
-      }
-      if (isValidAgentName(msg.role)) {
-        return /* @__PURE__ */ jsx2(
-          AgentResponseBlock,
-          {
-            agent: msg.role,
-            content: msg.content,
-            error: msg.error
-          },
-          i
-        );
-      }
+    messages.slice(committedCount).map((msg) => {
+      if (msg.role === "user") return /* @__PURE__ */ jsx2(UserMessage, { content: msg.content }, msg.id);
+      if (isValidAgentName(msg.role)) return /* @__PURE__ */ jsx2(AgentResponseBlock, { agent: msg.role, content: msg.content, error: msg.error }, msg.id);
       return null;
     }),
     discussionRound > 0 && thinkingAgents.length > 0 && /* @__PURE__ */ jsx2(DiscussionStatus, { round: discussionRound, maxRounds: config.discussion.max_rounds }),
@@ -1410,6 +1772,7 @@ function showTranscriptMarkdown(sessionId) {
 function showTranscript(sessionId) {
   const dbMessages = getMessages(sessionId);
   const messages = dbMessages.map((m) => ({
+    id: `${m.round}-${m.role}`,
     role: m.role,
     content: m.content,
     round: m.round
@@ -1417,12 +1780,12 @@ function showTranscript(sessionId) {
   const { unmount } = render2(
     /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
       /* @__PURE__ */ jsx2(Header, { sessionId }),
-      messages.map((msg, i) => {
+      messages.map((msg) => {
         if (msg.role === "user") {
-          return /* @__PURE__ */ jsx2(UserMessage, { content: msg.content }, i);
+          return /* @__PURE__ */ jsx2(UserMessage, { content: msg.content }, msg.id);
         }
         if (isValidAgentName(msg.role)) {
-          return /* @__PURE__ */ jsx2(AgentResponseBlock, { agent: msg.role, content: msg.content }, i);
+          return /* @__PURE__ */ jsx2(AgentResponseBlock, { agent: msg.role, content: msg.content }, msg.id);
         }
         return null;
       }),
@@ -1457,7 +1820,7 @@ process.on("SIGINT", () => {
 });
 function checkCli(name, installUrl) {
   try {
-    execSync2(`${name} --version`, { stdio: "ignore" });
+    execSync3(`${name} --version`, { stdio: "ignore" });
     return true;
   } catch {
     console.error(
@@ -1493,7 +1856,7 @@ function resolveAgentModels(pair, opts, config) {
   };
 }
 var program = new Command();
-program.name("tagteam").description("Tag Team - Orchestrate AI agents collaboratively").version("0.3.0").option("--agents <pair>", "Agent pair to use (comma-separated, e.g. claude,gemini)").option("--claude-model <model>", "Claude model to use").option("--codex-model <model>", "Codex model to use").option("--gemini-model <model>", "Gemini model to use").argument("[prompt...]", "Prompt to send to both agents").action(async (promptParts, opts) => {
+program.name("tagteam").description("Tag Team - Orchestrate AI agents collaboratively").version(createRequire(import.meta.url)("../package.json").version).option("--agents <pair>", "Agent pair to use (comma-separated, e.g. claude,gemini)").option("--claude-model <model>", "Claude model to use").option("--codex-model <model>", "Codex model to use").option("--gemini-model <model>", "Gemini model to use").argument("[prompt...]", "Prompt to send to both agents").action(async (promptParts, opts) => {
   const config = loadConfig();
   const pair = resolveAgentPair(opts, config);
   preflight(pair);
@@ -1533,6 +1896,7 @@ program.command("continue").description("Resume the most recent session").action
   }
   const dbMessages = getMessages(session.id);
   const transcript = dbMessages.map((m) => ({
+    id: `${m.round}-${m.role}`,
     role: m.role,
     content: m.content,
     round: m.round
@@ -1583,6 +1947,7 @@ program.command("resume [id]").description("Resume a session by ID, or pick inte
         const session2 = sessions[num - 1];
         const dbMessages2 = getMessages(session2.id);
         const transcript2 = dbMessages2.map((m) => ({
+          id: `${m.round}-${m.role}`,
           role: m.role,
           content: m.content,
           round: m.round
@@ -1606,6 +1971,7 @@ program.command("resume [id]").description("Resume a session by ID, or pick inte
   }
   const dbMessages = getMessages(session.id);
   const transcript = dbMessages.map((m) => ({
+    id: `${m.round}-${m.role}`,
     role: m.role,
     content: m.content,
     round: m.round