diff --git a/v2/sidecar/aider-runner.ts b/v2/sidecar/aider-runner.ts
index d1eb14b..313ece4 100644
--- a/v2/sidecar/aider-runner.ts
+++ b/v2/sidecar/aider-runner.ts
@@ -145,19 +145,83 @@ function shouldSuppress(line: string): boolean {
   return t === '' || SUPPRESS_RE.some(p => p.test(t));
 }
 
-// --- Output line classification ---
-// Thinking blocks: ► THINKING ... ► ANSWER
-let inThinking = false;
+// --- Turn output parsing ---
+// Parses complete turn output into structured blocks:
+// thinking, answer text, shell commands, cost info
 
-function classifyLine(line: string): 'thinking' | 'shell' | 'cost' | 'prompt' | 'text' {
-  const t = line.trim();
-  if (t === '► THINKING' || t === '►  THINKING') { inThinking = true; return 'thinking'; }
-  if (t === '► ANSWER' || t === '►  ANSWER') { inThinking = false; return 'thinking'; }
-  if (inThinking) return 'thinking';
-  if (t.startsWith('$ ') || t.startsWith('Running ')) return 'shell';
-  if (/^Tokens: .+Cost:/.test(t)) return 'cost';
-  if (PROMPT_RE.test(t)) return 'prompt';
-  return 'text';
+interface TurnBlock {
+  type: 'thinking' | 'text' | 'shell' | 'cost';
+  content: string;
+}
+
+function parseTurnOutput(buffer: string): TurnBlock[] {
+  const blocks: TurnBlock[] = [];
+  const lines = buffer.split('\n');
+
+  let thinkingLines: string[] = [];
+  let answerLines: string[] = [];
+  let inThinking = false;
+  let inAnswer = false;
+
+  for (const line of lines) {
+    const t = line.trim();
+
+    // Skip suppressed lines
+    if (shouldSuppress(line)) continue;
+
+    // Prompt markers — skip
+    if (PROMPT_RE.test(t)) continue;
+
+    // Thinking block markers
+    if (t === '► THINKING' || t === '►  THINKING') {
+      inThinking = true;
+      inAnswer = false;
+      continue;
+    }
+    if (t === '► ANSWER' || t === '►  ANSWER') {
+      if (thinkingLines.length > 0) {
+        blocks.push({ type: 'thinking', content: thinkingLines.join('\n') });
+        thinkingLines = [];
+      }
+      inThinking = false;
+      inAnswer = true;
+      continue;
+    }
+
+    // Cost line
+    if (/^Tokens: .+Cost:/.test(t)) {
+      blocks.push({ type: 'cost', content: t });
+      continue;
+    }
+
+    // Shell command
+    if (t.startsWith('$ ') || t.startsWith('Running ')) {
+      // Flush accumulated answer text first
+      if (answerLines.length > 0) {
+        blocks.push({ type: 'text', content: answerLines.join('\n') });
+        answerLines = [];
+      }
+      blocks.push({ type: 'shell', content: t.replace(/^(Running |\$ )/, '') });
+      continue;
+    }
+
+    // Accumulate into thinking or answer
+    if (inThinking) {
+      thinkingLines.push(line);
+    } else {
+      answerLines.push(line);
+    }
+  }
+
+  // Flush remaining
+  if (thinkingLines.length > 0) {
+    blocks.push({ type: 'thinking', content: thinkingLines.join('\n') });
+  }
+  if (answerLines.length > 0) {
+    blocks.push({ type: 'text', content: answerLines.join('\n').trim() });
+  }
+
+  return blocks;
 }
 
 // --- Main query handler ---
@@ -182,7 +246,6 @@ async function handleQuery(msg: QueryMessage) {
     existing.lineBuffer = '';
     existing.turnStartTime = Date.now();
     existing.turns++;
-    inThinking = false;
 
     send({ type: 'agent_started', sessionId });
 
@@ -277,95 +340,82 @@ async function handleQuery(msg: QueryMessage) {
         session.ready = true;
         session.turns = 1;
         session.turnStartTime = Date.now();
-        inThinking = false;
         log(`Aider ready, sending initial prompt (${fullPrompt.length} chars)`);
         child.stdin?.write(fullPrompt + '\n');
       }
       return;
     }
 
-    // Phase 2: accumulate output, emit complete lines
-    session.lineBuffer += text;
+    // Phase 2: accumulate entire turn output, emit as batched blocks
     session.turnBuffer += text;
 
-    // Process complete lines only
-    const parts = session.lineBuffer.split('\n');
-    session.lineBuffer = parts.pop() || ''; // keep incomplete last part
+    // Only process when turn is complete (aider shows prompt again)
+    if (!looksLikePrompt(session.turnBuffer)) return;
 
-    for (const line of parts) {
-      if (shouldSuppress(line)) continue;
+    const duration = Date.now() - session.turnStartTime;
+    const blocks = parseTurnOutput(session.turnBuffer);
 
-      const cls = classifyLine(line);
-
-      switch (cls) {
+    // Emit structured blocks
+    for (const block of blocks) {
+      switch (block.type) {
         case 'thinking':
-          // Emit thinking as a collapsed block
           send({
             type: 'agent_event',
             sessionId,
-            event: { type: 'assistant', message: { role: 'assistant', content: line } },
+            event: { type: 'thinking', content: block.content },
           });
           break;
 
+        case 'text':
+          if (block.content) {
+            send({
+              type: 'agent_event',
+              sessionId,
+              event: { type: 'assistant', message: { role: 'assistant', content: block.content } },
+            });
+          }
+          break;
+
         case 'shell':
           send({
             type: 'agent_event',
             sessionId,
             event: {
-              type: 'tool_call',
-              content: {
-                toolName: 'shell',
-                toolUseId: `shell-${Date.now()}`,
-                input: { command: line.replace(/^(Running |\$ )/, '') },
-              },
+              type: 'tool_use',
+              id: `shell-${Date.now()}`,
+              name: 'Bash',
+              input: { command: block.content },
             },
           });
           break;
 
         case 'cost':
-          // Parse cost and include in result
-          break;
-
-        case 'prompt':
-          // Prompt marker — turn is complete
-          break;
-
-        case 'text':
-          send({
-            type: 'agent_event',
-            sessionId,
-            event: { type: 'assistant', message: { role: 'assistant', content: line } },
-          });
+          // Parsed below for the result event
           break;
       }
     }
 
-    // Check if turn is complete (aider showing prompt again)
-    if (looksLikePrompt(session.turnBuffer)) {
-      const duration = Date.now() - session.turnStartTime;
-      const costMatch = session.turnBuffer.match(/Cost: \$([0-9.]+) message, \$([0-9.]+) session/);
-      const costUsd = costMatch ? parseFloat(costMatch[2]) : 0;
+    // Extract cost and emit result
+    const costMatch = session.turnBuffer.match(/Cost: \$([0-9.]+) message, \$([0-9.]+) session/);
+    const costUsd = costMatch ? parseFloat(costMatch[2]) : 0;
 
-      send({
-        type: 'agent_event',
-        sessionId,
-        event: {
-          type: 'result',
-          subtype: 'result',
-          result: '',
-          cost_usd: costUsd,
-          duration_ms: duration,
-          num_turns: session.turns,
-          is_error: false,
-          session_id: sessionId,
-        },
-      });
+    send({
+      type: 'agent_event',
+      sessionId,
+      event: {
+        type: 'result',
+        subtype: 'result',
+        result: '',
+        cost_usd: costUsd,
+        duration_ms: duration,
+        num_turns: session.turns,
+        is_error: false,
+        session_id: sessionId,
+      },
+    });
 
-      send({ type: 'agent_stopped', sessionId, exitCode: 0, signal: null });
-      session.turnBuffer = '';
-      session.lineBuffer = '';
-      inThinking = false;
-    }
+    send({ type: 'agent_stopped', sessionId, exitCode: 0, signal: null });
+    session.turnBuffer = '';
   });
 
   child.stderr?.on('data', (data: Buffer) => {
diff --git a/v2/src-tauri/sidecar/aider-runner.mjs b/v2/src-tauri/sidecar/aider-runner.mjs
new file mode 100644
index 0000000..f4ae5a4
--- /dev/null
+++ b/v2/src-tauri/sidecar/aider-runner.mjs
@@ -0,0 +1,356 @@
+// sidecar/aider-runner.ts
+import { stdin, stdout, stderr } from "process";
+import { createInterface } from "readline";
+import { spawn, execSync } from "child_process";
+import { accessSync, constants } from "fs";
+import { join } from "path";
+var rl = createInterface({ input: stdin });
+var sessions = /* @__PURE__ */ new Map();
+function send(msg) {
+  stdout.write(JSON.stringify(msg) + "\n");
+}
+function log(message) {
+  stderr.write(`[aider-sidecar] ${message}
+`);
+}
+rl.on("line", (line) => {
+  try {
+    const msg = JSON.parse(line);
+    handleMessage(msg).catch((err) => {
+      log(`Unhandled error in message handler: ${err}`);
+    });
+  } catch {
+    log(`Invalid JSON: ${line}`);
+  }
+});
+async function handleMessage(msg) {
+  switch (msg.type) {
+    case "ping":
+      send({ type: "pong" });
+      break;
+    case "query":
+      await handleQuery(msg);
+      break;
+    case "stop":
+      handleStop(msg);
+      break;
+    default:
+      send({ type: "error", message: `Unknown message type: ${msg.type}` });
+  }
+}
+function runCmd(cmd, env, cwd) {
+  try {
+    const result = execSync(cmd, { env, cwd, timeout: 5e3, encoding: "utf-8" }).trim();
+    log(`[prefetch] ${cmd} \u2192 ${result.length} chars`);
+    return result || null;
+  } catch (e) {
+    log(`[prefetch] ${cmd} FAILED: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+function prefetchContext(env, cwd) {
+  log(`[prefetch] BTMSG_AGENT_ID=${env.BTMSG_AGENT_ID ?? "NOT SET"}, cwd=${cwd}`);
+  const parts = [];
+  const inbox = runCmd("btmsg inbox", env, cwd);
+  if (inbox) {
+    parts.push(`## Your Inbox
+\`\`\`
+${inbox}
+\`\`\``);
+  } else {
+    parts.push("## Your Inbox\nNo messages (or btmsg unavailable).");
+  }
+  const board = runCmd("bttask board", env, cwd);
+  if (board) {
+    parts.push(`## Task Board
+\`\`\`
+${board}
+\`\`\``);
+  } else {
+    parts.push("## Task Board\nNo tasks (or bttask unavailable).");
+  }
+  return parts.join("\n\n");
+}
+var PROMPT_RE = /^[a-zA-Z0-9._-]*> $/;
+function looksLikePrompt(buffer) {
+  const lines = buffer.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const l = lines[i];
+    if (l.trim() === "") continue;
+    return PROMPT_RE.test(l);
+  }
+  return false;
+}
+var SUPPRESS_RE = [
+  /^Aider v\d/,
+  /^Main model:/,
+  /^Weak model:/,
+  /^Git repo:/,
+  /^Repo-map:/,
+  /^Use \/help/
+];
+function shouldSuppress(line) {
+  const t = line.trim();
+  return t === "" || SUPPRESS_RE.some((p) => p.test(t));
+}
+function parseTurnOutput(buffer) {
+  const blocks = [];
+  const lines = buffer.split("\n");
+  let thinkingLines = [];
+  let answerLines = [];
+  let inThinking = false;
+  let inAnswer = false;
+  for (const line of lines) {
+    const t = line.trim();
+    if (shouldSuppress(line)) continue;
+    if (PROMPT_RE.test(t)) continue;
+    if (t === "\u25BA THINKING" || t === "\u25BA  THINKING") {
+      inThinking = true;
+      inAnswer = false;
+      continue;
+    }
+    if (t === "\u25BA ANSWER" || t === "\u25BA  ANSWER") {
+      if (thinkingLines.length > 0) {
+        blocks.push({ type: "thinking", content: thinkingLines.join("\n") });
+        thinkingLines = [];
+      }
+      inThinking = false;
+      inAnswer = true;
+      continue;
+    }
+    if (/^Tokens: .+Cost:/.test(t)) {
+      blocks.push({ type: "cost", content: t });
+      continue;
+    }
+    if (t.startsWith("$ ") || t.startsWith("Running ")) {
+      if (answerLines.length > 0) {
+        blocks.push({ type: "text", content: answerLines.join("\n") });
+        answerLines = [];
+      }
+      blocks.push({ type: "shell", content: t.replace(/^(Running |\$ )/, "") });
+      continue;
+    }
+    if (inThinking) {
+      thinkingLines.push(line);
+    } else {
+      answerLines.push(line);
+    }
+  }
+  if (thinkingLines.length > 0) {
+    blocks.push({ type: "thinking", content: thinkingLines.join("\n") });
+  }
+  if (answerLines.length > 0) {
+    blocks.push({ type: "text", content: answerLines.join("\n").trim() });
+  }
+  return blocks;
+}
+async function handleQuery(msg) {
+  const { sessionId, prompt, cwd: cwdOpt, model, systemPrompt, extraEnv, providerConfig } = msg;
+  const cwd = cwdOpt || process.cwd();
+  const env = { ...process.env };
+  if (extraEnv) Object.assign(env, extraEnv);
+  if (providerConfig?.openrouterApiKey && typeof providerConfig.openrouterApiKey === "string") {
+    env.OPENROUTER_API_KEY = providerConfig.openrouterApiKey;
+  }
+  const existing = sessions.get(sessionId);
+  if (existing && existing.process.exitCode === null) {
+    log(`Continuing session ${sessionId} with follow-up prompt`);
+    existing.turnBuffer = "";
+    existing.lineBuffer = "";
+    existing.turnStartTime = Date.now();
+    existing.turns++;
+    send({ type: "agent_started", sessionId });
+    const ctx = prefetchContext(existing.env, existing.cwd);
+    const fullPrompt2 = `${ctx}
+
+Now act on the above. Your current task:
+${prompt}`;
+    existing.process.stdin?.write(fullPrompt2 + "\n");
+    return;
+  }
+  const aiderPath = which("aider");
+  if (!aiderPath) {
+    send({ type: "agent_error", sessionId, message: "Aider not found. Install with: pipx install aider-chat" });
+    return;
+  }
+  const aiderModel = model || "openrouter/anthropic/claude-sonnet-4";
+  log(`Starting Aider session ${sessionId} with model ${aiderModel}`);
+  const controller = new AbortController();
+  const args = [
+    "--model",
+    aiderModel,
+    "--yes-always",
+    "--no-pretty",
+    "--no-fancy-input",
+    "--no-stream",
+    // Complete responses (no token fragments)
+    "--no-git",
+    "--no-auto-commits",
+    "--suggest-shell-commands",
+    "--no-check-model-accepts-settings"
+  ];
+  if (providerConfig?.editFormat && typeof providerConfig.editFormat === "string") {
+    args.push("--edit-format", providerConfig.editFormat);
+  }
+  if (providerConfig?.architect === true) {
+    args.push("--architect");
+  }
+  send({ type: "agent_started", sessionId });
+  send({
+    type: "agent_event",
+    sessionId,
+    event: { type: "system", subtype: "init", session_id: sessionId, model: aiderModel, cwd }
+  });
+  const child = spawn(aiderPath, args, {
+    cwd,
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+    signal: controller.signal
+  });
+  const session = {
+    process: child,
+    controller,
+    sessionId,
+    model: aiderModel,
+    lineBuffer: "",
+    turnBuffer: "",
+    turnStartTime: Date.now(),
+    turns: 0,
+    ready: false,
+    env,
+    cwd
+  };
+  sessions.set(sessionId, session);
+  const prefetched = prefetchContext(env, cwd);
+  const promptParts = [];
+  promptParts.push(`IMPORTANT: You are an autonomous agent in a multi-agent system. Your PRIMARY job is to act on messages and tasks below, NOT to ask the user for files. You can run shell commands to accomplish tasks. If you need to read files, use shell commands like \`cat\`, \`find\`, \`ls\`. If you need to send messages, use \`btmsg send <agent-id> "message"\`. If you need to update tasks, use \`bttask status <task-id> done\`.`);
+  if (systemPrompt) promptParts.push(systemPrompt);
+  promptParts.push(prefetched);
+  promptParts.push(`---
+
+Now act on the above. Your current task:
+${prompt}`);
+  const fullPrompt = promptParts.join("\n\n");
+  let startupBuffer = "";
+  child.stdout?.on("data", (data) => {
+    const text = data.toString();
+    if (!session.ready) {
+      startupBuffer += text;
+      if (looksLikePrompt(startupBuffer)) {
+        session.ready = true;
+        session.turns = 1;
+        session.turnStartTime = Date.now();
+        log(`Aider ready, sending initial prompt (${fullPrompt.length} chars)`);
+        child.stdin?.write(fullPrompt + "\n");
+      }
+      return;
+    }
+    session.turnBuffer += text;
+    if (!looksLikePrompt(session.turnBuffer)) return;
+    const duration = Date.now() - session.turnStartTime;
+    const blocks = parseTurnOutput(session.turnBuffer);
+    for (const block of blocks) {
+      switch (block.type) {
+        case "thinking":
+          send({
+            type: "agent_event",
+            sessionId,
+            event: { type: "thinking", content: block.content }
+          });
+          break;
+        case "text":
+          if (block.content) {
+            send({
+              type: "agent_event",
+              sessionId,
+              event: { type: "assistant", message: { role: "assistant", content: block.content } }
+            });
+          }
+          break;
+        case "shell":
+          send({
+            type: "agent_event",
+            sessionId,
+            event: {
+              type: "tool_use",
+              id: `shell-${Date.now()}`,
+              name: "Bash",
+              input: { command: block.content }
+            }
+          });
+          break;
+        case "cost":
+          break;
+      }
+    }
+    const costMatch = session.turnBuffer.match(/Cost: \$([0-9.]+) message, \$([0-9.]+) session/);
+    const costUsd = costMatch ? parseFloat(costMatch[2]) : 0;
+    send({
+      type: "agent_event",
+      sessionId,
+      event: {
+        type: "result",
+        subtype: "result",
+        result: "",
+        cost_usd: costUsd,
+        duration_ms: duration,
+        num_turns: session.turns,
+        is_error: false,
+        session_id: sessionId
+      }
+    });
+    send({ type: "agent_stopped", sessionId, exitCode: 0, signal: null });
+    session.turnBuffer = "";
+  });
+  child.stderr?.on("data", (data) => {
+    for (const line of data.toString().split("\n")) {
+      if (line.trim()) log(`[stderr] ${line}`);
+    }
+  });
+  child.on("close", (code, signal) => {
+    sessions.delete(sessionId);
+    if (controller.signal.aborted) {
+      send({ type: "agent_stopped", sessionId, exitCode: null, signal: "SIGTERM" });
+    } else if (code !== 0 && code !== null) {
+      send({ type: "agent_error", sessionId, message: `Aider exited with code ${code}` });
+    } else {
+      send({ type: "agent_stopped", sessionId, exitCode: code, signal });
+    }
+  });
+  child.on("error", (err) => {
+    sessions.delete(sessionId);
+    log(`Aider spawn error: ${err.message}`);
+    send({ type: "agent_error", sessionId, message: `Failed to start Aider: ${err.message}` });
+  });
+}
+function handleStop(msg) {
+  const { sessionId } = msg;
+  const session = sessions.get(sessionId);
+  if (!session) {
+    send({ type: "error", sessionId, message: "Session not found" });
+    return;
+  }
+  log(`Stopping Aider session ${sessionId}`);
+  session.process.stdin?.write("/exit\n");
+  const killTimer = setTimeout(() => {
+    session.controller.abort();
+    session.process.kill("SIGTERM");
+  }, 3e3);
+  session.process.once("close", () => clearTimeout(killTimer));
+}
+function which(name) {
+  const pathDirs = (process.env.PATH || "").split(":");
+  for (const dir of pathDirs) {
+    const full = join(dir, name);
+    try {
+      accessSync(full, constants.X_OK);
+      return full;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+log("Aider sidecar started");
+log(`Found aider at: ${which("aider") ?? "NOT FOUND"}`);
+send({ type: "ready" });
diff --git a/v2/src/lib/adapters/aider-messages.ts b/v2/src/lib/adapters/aider-messages.ts
index 5f8c3b1..71e8ab7 100644
--- a/v2/src/lib/adapters/aider-messages.ts
+++ b/v2/src/lib/adapters/aider-messages.ts
@@ -5,6 +5,8 @@ import type {
   AgentMessage,
   InitContent,
   TextContent,
+  ThinkingContent,
+  ToolCallContent,
   CostContent,
   ErrorContent,
 } from './claude-messages';
@@ -16,8 +18,10 @@ import { str, num } from '../utils/type-guards';
  *
  * The Aider runner emits events in this format:
  * - {type:'system', subtype:'init', model, session_id, cwd}
- * - {type:'assistant', message:{role:'assistant', content:'...'}}
- * - {type:'result', subtype:'result', result:'...', cost_usd, duration_ms, is_error}
+ * - {type:'assistant', message:{role:'assistant', content:'...'}} — batched text block
+ * - {type:'thinking', content:'...'} — thinking/reasoning block
+ * - {type:'tool_use', id, name, input} — shell command execution
+ * - {type:'result', subtype:'result', cost_usd, duration_ms, is_error}
  * - {type:'error', message:'...'}
  */
 export function adaptAiderMessage(raw: Record<string, unknown>): AgentMessage[] {
@@ -46,6 +50,14 @@ export function adaptAiderMessage(raw: Record<string, unknown>): AgentMessage[]
         timestamp,
       }];
 
+    case 'thinking':
+      return [{
+        id: uuid,
+        type: 'thinking',
+        content: { text: str(raw.content) } satisfies ThinkingContent,
+        timestamp,
+      }];
+
     case 'assistant': {
       const msg = typeof raw.message === 'object' && raw.message !== null
         ? raw.message as Record<string, unknown>
@@ -60,6 +72,18 @@ export function adaptAiderMessage(raw: Record<string, unknown>): AgentMessage[]
       }];
     }
 
+    case 'tool_use':
+      return [{
+        id: uuid,
+        type: 'tool_call',
+        content: {
+          toolUseId: str(raw.id),
+          name: str(raw.name, 'shell'),
+          input: raw.input,
+        } satisfies ToolCallContent,
+        timestamp,
+      }];
+
     case 'result':
       return [{
         id: uuid,