tagteam 0.2.0 → 0.4.1

package/dist/index.js

@@ -2,6 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
+import { createRequire } from "module";
 import { execSync as execSync2 } from "child_process";
 import chalk from "chalk";
 
@@ -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);
 }
@@ -655,6 +713,16 @@ function touchSession(id) {
     id
   );
 }
+function deleteSession(id) {
+  const db2 = getDb();
+  db2.prepare(`DELETE FROM messages WHERE session_id = ?`).run(id);
+  db2.prepare(`DELETE FROM sessions WHERE id = ?`).run(id);
+}
+function deleteAllSessions() {
+  const db2 = getDb();
+  db2.prepare(`DELETE FROM messages`).run();
+  db2.prepare(`DELETE FROM sessions`).run();
+}
 
 // src/db/messages.ts
 function insertMessage(params) {
@@ -684,44 +752,6 @@ 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})`;
-}
-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 discussionPrompt(agent, conversationHistory, pair) {
-  return `${collaborationPrompt(agent, pair)}
-
-Here is the conversation so far:
-
-${conversationHistory}
-
-Now provide your response for this discussion round. Build on what was said, highlight agreements, and address any disagreements constructively. Be concise.`;
-}
-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.
-
-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
-
-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.`;
-}
-function debateRoundPrompt(agent, conversationHistory, pair) {
-  const other = otherAgent(agent, pair);
-  return `${debatePrompt(agent, pair)}
-
-Here is the conversation so far:
-
-${conversationHistory}
-
-Respond to the latest round. If you agree with ${other}'s position on all key points, end with [CONSENSUS]. Otherwise, continue the discussion.`;
-}
 var CONSENSUS_MARKER = "[CONSENSUS]";
 function formatConversationHistory(messages) {
   return messages.map((m) => {
@@ -738,6 +768,264 @@ function formatConversationHistory(messages) {
     return `[${label}]: ${m.content}`;
   }).join("\n\n");
 }
+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 collaborationSystemPrompt(agent, pair) {
+  return `${basePrompt()}
+
+${rolePrompt(agent, pair)}`;
+}
+function discussionRoundPrompt(agent, conversationContext, pair) {
+  return `${basePrompt()}
+
+${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
+
+CONFIDENCE: HIGH | MEDIUM | LOW
+
+Keep it concise. Do not restate points already established.`;
+}
+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)}
+
+${conversationContext}
+
+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 steelmanPrompt() {
+  return `You and your peer appear to largely agree after Round 1. Before confirming
+consensus, steelman the opposing view:
+
+- 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?
+
+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.
+
+`;
+}
+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. Focus on your area of expertise:
+${focusAreas}
+
+Be concise and direct.`;
+}
+
+// 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" };
+      }
+    }
+  }
+  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
 import { useState } from "react";
@@ -887,12 +1175,35 @@ function startConfigEditor() {
 // src/ui.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 marked.use(markedTerminal());
-function parseInput(input, pair) {
+var PAIR_SEPARATORS = /^(\w+)\s*(?:and|&|\/|,)\s*(\w+)[\s,]\s*/i;
+function tryParsePair(text) {
+  const match = text.toLowerCase().match(PAIR_SEPARATORS);
+  if (!match) return null;
+  const [fullMatch, first, second] = match;
+  if (isValidAgentName(first) && isValidAgentName(second) && first !== second) {
+    return { pair: [first, second], rest: text.slice(fullMatch.length).trim() };
+  }
+  return null;
+}
+function parseInput(input) {
   const lower = input.toLowerCase();
   if (lower.startsWith("discuss ")) {
-    return { target: "both", prompt: input.slice(8).trim(), discuss: true };
+    const rest = input.slice(8).trim();
+    const adHoc2 = tryParsePair(rest);
+    if (adHoc2) {
+      return { target: adHoc2.pair, prompt: adHoc2.rest, discuss: true };
+    }
+    return { target: "both", prompt: rest, discuss: true };
   }
-  for (const agent of pair) {
+  const adHoc = tryParsePair(input);
+  if (adHoc) {
+    const adHocLower = adHoc.rest.toLowerCase();
+    if (adHocLower.startsWith("discuss ")) {
+      return { target: adHoc.pair, prompt: adHoc.rest.slice(8).trim(), discuss: true };
+    }
+    return { target: adHoc.pair, prompt: adHoc.rest, discuss: false };
+  }
+  for (const agent of getAllAgentNames()) {
     if (lower.startsWith(`${agent} `) || lower.startsWith(`${agent}, `)) {
       return { target: agent, prompt: input.slice(input.indexOf(" ") + 1).trim(), discuss: false };
     }
@@ -900,10 +1211,10 @@ function parseInput(input, pair) {
   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
@@ -925,7 +1236,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 " }),
@@ -935,7 +1246,24 @@ function Header({ sessionId }) {
     /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " " + "\u2500".repeat(35) })
   ] });
 }
-function UserMessage({ content }) {
+function QuickHelp() {
+  const col = 38;
+  const examples = [
+    ["ask anything", "sends to both agents"],
+    ["gemini explain this", "sends to one agent"],
+    ["discuss best approach", "multi-round debate"],
+    ["gemini and codex discuss review app", "pick agents + debate"]
+  ];
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: [
+    examples.map(([cmd, desc]) => /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      cmd.padEnd(col),
+      "\u2192 ",
+      desc
+    ] }, cmd)),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "/help for more" })
+  ] });
+}
+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:",
@@ -943,7 +1271,7 @@ function UserMessage({ content }) {
     ] }),
     /* @__PURE__ */ jsx2(Text2, { children: content })
   ] });
-}
+});
 function ThinkingIndicator({ agent }) {
   const descriptor = getAgent(agent);
   return /* @__PURE__ */ jsxs2(Box2, { marginLeft: 1, children: [
@@ -1020,11 +1348,14 @@ function App({
     }
     return 0;
   });
-  useEffect(() => {
-    if (!existingSessionId) {
-      createSession(sessionId, process.cwd());
+  const [committedCount, setCommittedCount] = useState2(showTranscript2?.length ?? 0);
+  const sessionCreatedRef = useRef(!!existingSessionId);
+  const ensureSession = (id) => {
+    if (!sessionCreatedRef.current) {
+      createSession(id, process.cwd());
+      sessionCreatedRef.current = true;
     }
-  }, []);
+  };
   useEffect(() => {
     if (initialPrompt && state === "running") {
       if (initialDiscuss) {
@@ -1048,7 +1379,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([]);
@@ -1057,8 +1390,8 @@ function App({
       setState("input");
     }
   });
-  const runAgents = async (currentMessages, round, target, promptOverride, isDebate = false) => {
-    const activeAgents = target === "both" ? [...pair] : [target];
+  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(
       currentMessages.map((m) => ({
@@ -1069,20 +1402,26 @@ function App({
     );
     const cwd = process.cwd();
     const isFirstRound = round === 0 && !existingSessionId;
+    const userPrompt = currentMessages[currentMessages.length - 1]?.content || "";
+    const isSingleAgent = !Array.isArray(target) && target !== "both";
+    const promptPair = Array.isArray(target) ? target : pair;
     const agentPrompt = (_agent) => {
       if (promptOverride) return promptOverride;
-      if (isFirstRound && target === "both") {
-        return currentMessages[currentMessages.length - 1]?.content || "";
-      }
+      if (isSingleAgent) return userPrompt;
+      if (isFirstRound) return userPrompt;
       return "Provide your response for this round.";
     };
     const agentSystemPrompt = (agent) => {
+      if (systemPromptPerAgent?.[agent]) return systemPromptPerAgent[agent];
+      if (isSingleAgent) {
+        return history ? directPrompt(agent, history) : void 0;
+      }
       if (isDebate) {
-        if (isFirstRound) return debatePrompt(agent, pair);
-        return debateRoundPrompt(agent, history, pair);
+        if (isFirstRound) return debateSystemPrompt(agent, promptPair);
+        return debateRoundPrompt(agent, history, promptPair);
       }
-      if (isFirstRound && target === "both") return collaborationPrompt(agent, pair);
-      return discussionPrompt(agent, history, pair);
+      if (isFirstRound) return collaborationSystemPrompt(agent, promptPair);
+      return discussionRoundPrompt(agent, history, promptPair);
     };
     const ac = new AbortController();
     abortRef.current = ac;
@@ -1116,22 +1455,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,
@@ -1149,13 +1492,19 @@ function App({
     return newMessages;
   };
   const runRound = async (rawInput) => {
-    const { target, prompt, discuss } = parseInput(rawInput, pair);
+    const { target, prompt, discuss } = parseInput(rawInput);
     if (discuss) {
-      return runDiscussion(prompt);
+      return runDiscussion(prompt, Array.isArray(target) ? target : void 0);
     }
     const currentRound = roundNum;
     runningRoundRef.current = currentRound;
+    ensureSession(sessionId);
+    if (currentRound === 0) {
+      const title = prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt;
+      updateSessionTitle(sessionId, title);
+    }
     const userMsg = {
+      id: `${currentRound}-user`,
       role: "user",
       content: rawInput,
       round: currentRound
@@ -1171,20 +1520,25 @@ 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;
-    if (currentRound === 0 && !existingSessionId) {
-      const title = prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt;
-      updateSessionTitle(sessionId, title);
-    }
     touchSession(sessionId);
     setState("input");
   };
-  const runDiscussion = async (prompt) => {
+  const runDiscussion = async (prompt, adHocPair) => {
+    const discussionTarget = adHocPair ?? "both";
+    const activePair = adHocPair ?? pair;
     setConsensusReached(false);
     let currentRound = roundNum;
     runningRoundRef.current = currentRound;
+    ensureSession(sessionId);
+    if (currentRound === 0) {
+      const title = prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt;
+      updateSessionTitle(sessionId, title);
+    }
     const userMsg = {
+      id: `${currentRound}-user`,
       role: "user",
       content: `discuss ${prompt}`,
       round: currentRound
@@ -1197,29 +1551,63 @@ function App({
       round: currentRound
     });
     let allMessages = [...messages, userMsg];
-    if (currentRound === 0 && !existingSessionId) {
-      const title = prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt;
-      updateSessionTitle(sessionId, title);
-    }
+    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,
-        "both",
+        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 consensusFlags = pair.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;
       }
     }
@@ -1256,9 +1644,10 @@ function App({
     }
     if (value === "/new") {
       const newId = nanoid(12);
-      createSession(newId, process.cwd());
+      sessionCreatedRef.current = false;
       setSessionId(newId);
       setMessages([]);
+      setCommittedCount(0);
       setRoundNum(0);
       setConsensusReached(false);
       setDiscussionRound(0);
@@ -1279,23 +1668,21 @@ function App({
     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 }),
-    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
-        );
-      }
+    /* @__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.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 }),
@@ -1341,6 +1728,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
@@ -1348,12 +1736,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;
       }),
@@ -1424,7 +1812,7 @@ function resolveAgentModels(pair, opts, config) {
   };
 }
 var program = new Command();
-program.name("tagteam").description("Tag Team - Orchestrate AI agents collaboratively").version("0.2.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);
@@ -1464,6 +1852,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
@@ -1514,6 +1903,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
@@ -1537,6 +1927,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
@@ -1550,13 +1941,51 @@ program.command("resume [id]").description("Resume a session by ID, or pick inte
   });
   await instance.waitUntilExit();
 });
-program.command("history").description("List recent sessions").option("-n, --limit <n>", "Number of sessions to show", parseInt, 20).action((opts) => {
+var historyCmd = program.command("history").description("List, remove, or clear sessions").option("-n, --limit <n>", "Number of sessions to show", parseInt, 20).action((opts) => {
   const sessions = listSessions(opts.limit);
   console.log(chalk.bold("\n Recent sessions:\n"));
   showSessionList(sessions);
   console.log();
   closeDb();
 });
+historyCmd.command("rm <id>").description("Delete a session by ID or prefix").action((id) => {
+  const session = getSession(id) || getSessionByPrefix(id);
+  if (!session) {
+    console.log(chalk.red(` Session not found: ${id}`));
+    process.exit(1);
+  }
+  deleteSession(session.id);
+  const sid = session.id.slice(0, 7);
+  const title = session.title || "(untitled)";
+  console.log(chalk.green(` Deleted session ${sid} \u2014 ${title}`));
+  closeDb();
+});
+historyCmd.command("clear").description("Delete all sessions").action(async () => {
+  const sessions = listSessions();
+  if (sessions.length === 0) {
+    console.log(chalk.yellow(" No sessions to delete."));
+    closeDb();
+    return;
+  }
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  rl.question(
+    chalk.yellow(` Delete all ${sessions.length} session(s)? [y/N] `),
+    (answer) => {
+      rl.close();
+      if (answer.trim().toLowerCase() === "y") {
+        deleteAllSessions();
+        console.log(chalk.green(` Deleted ${sessions.length} session(s).`));
+      } else {
+        console.log(" Cancelled.");
+      }
+      closeDb();
+    }
+  );
+});
 program.command("show <id>").description("Print full transcript for a session").option("-m, --markdown", "Output as GitHub-compatible markdown").action((id, opts) => {
   const session = getSession(id) || getSessionByPrefix(id);
   if (!session) {