copilot-agent 0.7.0 → 0.8.1

package/dist/index.js

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 // src/index.ts
 import { Command } from "commander";
 
@@ -8,9 +10,11 @@ import {
   readFileSync,
   statSync
 } from "fs";
-import { join, resolve } from "path";
+import { join, resolve, basename } from "path";
 import { homedir } from "os";
 var SESSION_DIR = join(homedir(), ".copilot", "session-state");
+var CLAUDE_DIR = join(homedir(), ".claude");
+var CLAUDE_PROJECTS_DIR = join(CLAUDE_DIR, "projects");
 function validateSession(sid) {
   const events = join(SESSION_DIR, sid, "events.jsonl");
   try {
@@ -41,7 +45,8 @@ function listSessions(limit = 20) {
     premiumRequests: getSessionPremium(s.id),
     summary: getSessionSummary(s.id),
     cwd: getSessionCwd(s.id),
-    complete: hasTaskComplete(s.id)
+    complete: hasTaskComplete(s.id),
+    agent: "copilot"
   }));
 }
 function getLatestSessionId() {
@@ -123,13 +128,6 @@ function getSessionSummary(sid) {
 function getSessionCwd(sid) {
   return readWorkspace(sid).cwd ?? "";
 }
-function findLatestIncomplete() {
-  const sessions = listSessions(50);
-  for (const s of sessions) {
-    if (!s.complete) return s.id;
-  }
-  return null;
-}
 function getSessionReport(sid) {
   if (!validateSession(sid)) return null;
   const ws = readWorkspace(sid);
@@ -156,7 +154,8 @@ function getSessionReport(sid) {
     filesCreated: [],
     filesEdited: [],
     errors: [],
-    taskCompletions: []
+    taskCompletions: [],
+    agent: "copilot"
   };
   for (const line of lines) {
     let event;
@@ -226,6 +225,245 @@ function getSessionReport(sid) {
   }
   return report;
 }
+function decodeClaudePath(encoded) {
+  return encoded.replace(/^-/, "/").replace(/-/g, "/");
+}
+function encodeClaudePath(fsPath) {
+  return fsPath.replace(/\//g, "-");
+}
+function listClaudeSessions(limit = 20) {
+  if (!existsSync(CLAUDE_PROJECTS_DIR)) return [];
+  const sessions = [];
+  try {
+    const projectDirs = readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const projDir of projectDirs) {
+      const projPath = join(CLAUDE_PROJECTS_DIR, projDir.name);
+      const cwd = decodeClaudePath(projDir.name);
+      const files = readdirSync(projPath).filter((f) => f.endsWith(".jsonl"));
+      for (const file of files) {
+        const filePath = join(projPath, file);
+        const sid = basename(file, ".jsonl");
+        try {
+          const stat = statSync(filePath);
+          const { lastEvent, complete, summary } = parseClaudeSessionMeta(filePath);
+          sessions.push({
+            id: sid,
+            dir: projPath,
+            mtime: stat.mtimeMs,
+            lastEvent,
+            premiumRequests: 0,
+            summary,
+            cwd,
+            complete,
+            agent: "claude"
+          });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  sessions.sort((a, b) => b.mtime - a.mtime);
+  return sessions.slice(0, limit);
+}
+function parseClaudeSessionMeta(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8").trimEnd();
+    const lines = content.split("\n");
+    let lastEvent = "unknown";
+    let complete = false;
+    let summary = "";
+    for (let i = lines.length - 1; i >= Math.max(0, lines.length - 5); i--) {
+      try {
+        const event = JSON.parse(lines[i]);
+        if (i === lines.length - 1) {
+          lastEvent = event.type ?? event.role ?? "unknown";
+        }
+        if (event.type === "result" || event.type === "assistant" && event.stop_reason === "end_turn") {
+          complete = true;
+        }
+      } catch {
+      }
+    }
+    for (const line of lines.slice(0, 10)) {
+      try {
+        const event = JSON.parse(line);
+        if ((event.type === "human" || event.role === "human") && event.message) {
+          summary = typeof event.message === "string" ? event.message.slice(0, 100) : JSON.stringify(event.message).slice(0, 100);
+          break;
+        }
+      } catch {
+      }
+    }
+    return { lastEvent, complete, summary };
+  } catch {
+    return { lastEvent: "error", complete: false, summary: "" };
+  }
+}
+function getLatestClaudeSessionId(projectDir) {
+  if (!existsSync(CLAUDE_PROJECTS_DIR)) return null;
+  let searchDirs;
+  if (projectDir) {
+    const encoded = encodeClaudePath(resolve(projectDir));
+    const projPath = join(CLAUDE_PROJECTS_DIR, encoded);
+    searchDirs = existsSync(projPath) ? [projPath] : [];
+  } else {
+    try {
+      searchDirs = readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join(CLAUDE_PROJECTS_DIR, d.name));
+    } catch {
+      return null;
+    }
+  }
+  let latest = null;
+  for (const dir of searchDirs) {
+    try {
+      const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+      for (const file of files) {
+        const stat = statSync(join(dir, file));
+        if (!latest || stat.mtimeMs > latest.mtime) {
+          latest = { id: basename(file, ".jsonl"), mtime: stat.mtimeMs };
+        }
+      }
+    } catch {
+    }
+  }
+  return latest?.id ?? null;
+}
+function getClaudeSessionCwd(sid) {
+  if (!existsSync(CLAUDE_PROJECTS_DIR)) return "";
+  try {
+    const projectDirs = readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const projDir of projectDirs) {
+      const filePath = join(CLAUDE_PROJECTS_DIR, projDir.name, `${sid}.jsonl`);
+      if (existsSync(filePath)) {
+        return decodeClaudePath(projDir.name);
+      }
+    }
+  } catch {
+  }
+  return "";
+}
+function getClaudeSessionReport(sid) {
+  if (!existsSync(CLAUDE_PROJECTS_DIR)) return null;
+  let filePath = null;
+  let cwd = "";
+  try {
+    const projectDirs = readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const projDir of projectDirs) {
+      const candidate = join(CLAUDE_PROJECTS_DIR, projDir.name, `${sid}.jsonl`);
+      if (existsSync(candidate)) {
+        filePath = candidate;
+        cwd = decodeClaudePath(projDir.name);
+        break;
+      }
+    }
+  } catch {
+  }
+  if (!filePath) return null;
+  let lines;
+  try {
+    lines = readFileSync(filePath, "utf-8").trimEnd().split("\n");
+  } catch {
+    return null;
+  }
+  const report = {
+    id: sid,
+    cwd,
+    summary: "",
+    startTime: "",
+    endTime: "",
+    durationMs: 0,
+    complete: false,
+    userMessages: 0,
+    assistantTurns: 0,
+    outputTokens: 0,
+    premiumRequests: 0,
+    toolUsage: {},
+    gitCommits: [],
+    filesCreated: [],
+    filesEdited: [],
+    errors: [],
+    taskCompletions: [],
+    agent: "claude"
+  };
+  for (const line of lines) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const type = event.type ?? event.role ?? "";
+    const ts = event.timestamp;
+    if (ts && !report.startTime) report.startTime = ts;
+    if (ts) report.endTime = ts;
+    if (type === "human" || type === "user") {
+      report.userMessages++;
+      if (!report.summary) {
+        const msg = event.message ?? event.content;
+        report.summary = (typeof msg === "string" ? msg : JSON.stringify(msg ?? "")).slice(0, 100);
+      }
+    }
+    if (type === "assistant") {
+      report.assistantTurns++;
+      const usage = event.usage;
+      if (usage?.output_tokens) report.outputTokens += usage.output_tokens;
+      if (event.stop_reason === "end_turn") report.complete = true;
+    }
+    if (type === "tool_use") {
+      const toolName = event.name ?? event.tool ?? "unknown";
+      report.toolUsage[toolName] = (report.toolUsage[toolName] ?? 0) + 1;
+      if (toolName === "Bash" || toolName === "bash") {
+        const input = event.input ?? "";
+        const cmd = typeof input === "string" ? input : input?.command ?? "";
+        if (cmd.includes("git") && cmd.includes("commit") && cmd.includes("-m")) {
+          const msgMatch = cmd.match(/-m\s+"([^"]{1,120})/);
+          if (msgMatch) report.gitCommits.push(msgMatch[1]);
+        }
+      }
+      if (toolName === "Write" || toolName === "Create") {
+        const path = event.input?.file_path ?? event.input?.path;
+        if (path) report.filesCreated.push(path);
+      }
+      if (toolName === "Edit") {
+        const path = event.input?.file_path ?? event.input?.path;
+        if (path && !report.filesEdited.includes(path)) report.filesEdited.push(path);
+      }
+    }
+    if (type === "result") {
+      report.complete = true;
+      const result = event.result ?? event.content ?? "";
+      if (result) report.taskCompletions.push(typeof result === "string" ? result.slice(0, 200) : "(completed)");
+    }
+    if (type === "error") {
+      const msg = event.error ?? event.message ?? "unknown error";
+      report.errors.push(typeof msg === "string" ? msg : JSON.stringify(msg));
+    }
+  }
+  if (report.startTime && report.endTime) {
+    report.durationMs = new Date(report.endTime).getTime() - new Date(report.startTime).getTime();
+  }
+  return report;
+}
+function listAllSessions(limit = 20, agentFilter) {
+  const copilot = agentFilter === "claude" ? [] : listSessions(limit);
+  const claude = agentFilter === "copilot" ? [] : listClaudeSessions(limit);
+  const all = [...copilot, ...claude];
+  all.sort((a, b) => b.mtime - a.mtime);
+  return all.slice(0, limit);
+}
+function getAgentSessionReport(sid, agent) {
+  if (agent === "claude") return getClaudeSessionReport(sid);
+  if (agent === "copilot") return getSessionReport(sid);
+  return getSessionReport(sid) ?? getClaudeSessionReport(sid);
+}
+function findLatestIncompleteForAgent(agent) {
+  const sessions = listAllSessions(50, agent);
+  for (const s of sessions) {
+    if (!s.complete) return { id: s.id, agent: s.agent };
+  }
+  return null;
+}
 
 // src/lib/process.ts
 import { execSync as execSync2, spawn } from "child_process";
@@ -308,21 +546,7 @@ function notify(message, title = "copilot-agent") {
 }
 
 // src/lib/process.ts
-function isCopilotInstalled() {
-  try {
-    execSync2("which copilot", { stdio: "pipe", encoding: "utf-8" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function assertCopilot() {
-  if (!isCopilotInstalled()) {
-    fail("copilot CLI not found. Install with: npm i -g @githubnext/copilot");
-    process.exit(1);
-  }
-}
-function findCopilotProcesses() {
+function findAgentProcesses(agentFilter) {
   try {
     const output = execSync2("ps -eo pid,command", { encoding: "utf-8" });
     const results = [];
@@ -331,52 +555,56 @@ function findCopilotProcesses() {
     for (const line of output.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
-      if ((trimmed.includes("copilot") || trimmed.includes("@githubnext/copilot")) && !trimmed.includes("ps -eo") && !trimmed.includes("copilot-agent") && !trimmed.includes("grep")) {
-        const match = trimmed.match(/^(\d+)\s+(.+)$/);
-        if (match) {
-          const pid = parseInt(match[1], 10);
-          if (pid === myPid || pid === parentPid) continue;
-          const cmd = match[2];
-          const sidMatch = cmd.match(/resume[= ]+([a-f0-9-]{36})/);
-          let cwd;
-          try {
-            cwd = execSync2(`lsof -p ${pid} -Fn 2>/dev/null | grep '^n/' | head -1`, {
-              encoding: "utf-8",
-              stdio: ["pipe", "pipe", "pipe"]
-            }).trim().slice(1) || void 0;
-          } catch {
-          }
-          const sid = sidMatch?.[1];
-          if (!cwd && sid) {
-            cwd = getSessionCwd(sid) || void 0;
-          }
-          results.push({ pid, command: cmd, sessionId: sid, cwd });
-        }
+      const isCopilot = (trimmed.includes("copilot") || trimmed.includes("@githubnext/copilot")) && !trimmed.includes("copilot-agent") && !trimmed.includes("copilot-api");
+      const isClaude = trimmed.includes("claude") && !trimmed.includes("claude-code") && !trimmed.includes("copilot-agent");
+      if (!isCopilot && !isClaude) continue;
+      if (trimmed.includes("ps -eo") || trimmed.includes("grep")) continue;
+      const agent = isClaude ? "claude" : "copilot";
+      if (agentFilter && agent !== agentFilter) continue;
+      const match = trimmed.match(/^(\d+)\s+(.+)$/);
+      if (!match) continue;
+      const pid = parseInt(match[1], 10);
+      if (pid === myPid || pid === parentPid) continue;
+      const cmd = match[2];
+      const sidMatch = agent === "copilot" ? cmd.match(/resume[= ]+([a-f0-9-]{36})/) : cmd.match(/(?:--resume|--session-id)[= ]+([a-f0-9-]{36})/);
+      let cwd;
+      try {
+        cwd = execSync2(`lsof -p ${pid} -Fn 2>/dev/null | grep '^n/' | head -1`, {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim().slice(1) || void 0;
+      } catch {
+      }
+      const sid = sidMatch?.[1];
+      if (!cwd && sid) {
+        cwd = (agent === "copilot" ? getSessionCwd(sid) : getClaudeSessionCwd(sid)) || void 0;
       }
+      results.push({ pid, command: cmd, sessionId: sid, cwd, agent });
     }
     return results;
   } catch {
     return [];
   }
 }
-function findPidForSession(sid) {
-  const procs = findCopilotProcesses();
+function findPidForSession(sid, agent) {
+  const procs = findAgentProcesses(agent);
   const matching = procs.filter((p) => p.command.includes(sid)).sort((a, b) => b.pid - a.pid);
   return matching[0]?.pid ?? null;
 }
-async function waitForCopilotInDir(dir, timeoutMs = 144e5, pollMs = 1e4) {
+async function waitForAgentInDir(dir, agent, timeoutMs = 144e5, pollMs = 1e4) {
   const targetDir = resolve2(dir);
   const start = Date.now();
   let warned = false;
+  const label = agent ?? "agent";
   while (Date.now() - start < timeoutMs) {
-    const procs = findCopilotProcesses();
+    const procs = findAgentProcesses(agent);
     const conflicting = procs.filter((p) => {
       if (!p.cwd) return false;
       return resolve2(p.cwd) === targetDir;
     });
     if (conflicting.length === 0) return;
     if (!warned) {
-      warn(`Waiting for copilot in ${targetDir} to finish...`);
+      warn(`Waiting for ${label} in ${targetDir} to finish...`);
       for (const p of conflicting) {
         log(`  PID ${p.pid}: ${p.command.slice(0, 80)}`);
       }
@@ -384,12 +612,13 @@ async function waitForCopilotInDir(dir, timeoutMs = 144e5, pollMs = 1e4) {
     }
     await sleep(pollMs);
   }
-  warn("Timeout waiting for copilot to finish in directory");
+  warn(`Timeout waiting for ${label} to finish in directory`);
 }
-function assertSessionNotRunning(sid) {
-  const pid = findPidForSession(sid);
+function assertSessionNotRunning(sid, agent) {
+  const pid = findPidForSession(sid, agent);
   if (pid) {
-    fail(`Session ${sid.slice(0, 8)}\u2026 already has copilot running (PID ${pid}). Cannot resume \u2014 would corrupt the session.`);
+    const label = agent ?? "agent";
+    fail(`Session ${sid.slice(0, 8)}\u2026 already has ${label} running (PID ${pid}). Cannot resume.`);
     process.exit(1);
   }
 }
@@ -407,9 +636,8 @@ async function waitForExit(pid, timeoutMs = 144e5) {
 }
 async function runCopilot(args, options) {
   const dir = options?.cwd ?? process.cwd();
-  if (options?.useWorktree) {
-  } else {
-    await waitForCopilotInDir(dir);
+  if (!options?.useWorktree) {
+    await waitForAgentInDir(dir, "copilot");
   }
   return new Promise((resolve7) => {
     const child = spawn("copilot", args, {
@@ -421,11 +649,7 @@ async function runCopilot(args, options) {
       await sleep(3e3);
       const sid = getLatestSessionId();
       const premium = sid ? getSessionPremium(sid) : 0;
-      resolve7({
-        exitCode: code ?? 1,
-        sessionId: sid,
-        premium
-      });
+      resolve7({ exitCode: code ?? 1, sessionId: sid, premium });
     });
     child.on("error", () => {
       resolve7({ exitCode: 1, sessionId: null, premium: 0 });
@@ -433,7 +657,7 @@ async function runCopilot(args, options) {
   });
 }
 function runCopilotResume(sid, steps, message, cwd) {
-  assertSessionNotRunning(sid);
+  assertSessionNotRunning(sid, "copilot");
   const args = [
     `--resume=${sid}`,
     "--autopilot",
@@ -456,38 +680,82 @@ function runCopilotTask(prompt, steps, cwd, useWorktree) {
     "--no-ask-user"
   ], { cwd, useWorktree });
 }
+async function runClaude(args, options) {
+  const dir = options?.cwd ?? process.cwd();
+  if (!options?.useWorktree) {
+    await waitForAgentInDir(dir, "claude");
+  }
+  return new Promise((resolve7) => {
+    const child = spawn("claude", args, {
+      cwd: options?.cwd,
+      stdio: "inherit",
+      env: { ...process.env }
+    });
+    child.on("close", async (code) => {
+      await sleep(2e3);
+      const sid = getLatestClaudeSessionId(options?.cwd);
+      resolve7({ exitCode: code ?? 1, sessionId: sid, premium: 0 });
+    });
+    child.on("error", () => {
+      resolve7({ exitCode: 1, sessionId: null, premium: 0 });
+    });
+  });
+}
+function runClaudeResume(sid, _steps, message, cwd) {
+  assertSessionNotRunning(sid, "claude");
+  const args = ["--resume", sid, "--dangerously-skip-permissions"];
+  if (message) args.push(message);
+  return runClaude(args, { cwd });
+}
+function runClaudeTask(prompt, _steps, cwd, useWorktree) {
+  return runClaude([
+    "--print",
+    "--dangerously-skip-permissions",
+    "--output-format",
+    "text",
+    prompt
+  ], { cwd, useWorktree });
+}
+function runAgentTask(agent, prompt, steps, cwd, useWorktree) {
+  return agent === "claude" ? runClaudeTask(prompt, steps, cwd, useWorktree) : runCopilotTask(prompt, steps, cwd, useWorktree);
+}
+function runAgentResume(agent, sid, steps, message, cwd) {
+  return agent === "claude" ? runClaudeResume(sid, steps, message, cwd) : runCopilotResume(sid, steps, message, cwd);
+}
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
 // src/commands/status.ts
 function registerStatusCommand(program2) {
-  program2.command("status").description("Show copilot session status").option("-l, --limit <n>", "Number of sessions to show", "10").option("-a, --active", "Show only active (running) processes").option("-i, --incomplete", "Only show incomplete sessions").action((opts) => {
+  program2.command("status").description("Show agent session status (copilot + claude)").option("-l, --limit <n>", "Number of sessions to show", "10").option("-a, --active", "Show only active (running) processes").option("-i, --incomplete", "Only show incomplete sessions").option("--agent <type>", "Filter by agent: copilot or claude").action((opts) => {
+    const agentFilter = opts.agent;
     if (opts.active) {
-      showActive();
+      showActive(agentFilter);
     } else {
-      showRecent(parseInt(opts.limit, 10), opts.incomplete ?? false);
+      showRecent(parseInt(opts.limit, 10), opts.incomplete ?? false, agentFilter);
     }
   });
 }
-function showActive() {
-  const procs = findCopilotProcesses();
+function showActive(agentFilter) {
+  const procs = findAgentProcesses(agentFilter);
   if (procs.length === 0) {
-    log(`${DIM}No active copilot processes.${RESET}`);
+    log(`${DIM}No active agent processes.${RESET}`);
     return;
   }
   log(`
-${BOLD}${"PID".padEnd(8)} ${"Session".padEnd(40)} Command${RESET}`);
-  log("\u2500".repeat(108));
+${BOLD}${"Agent".padEnd(9)} ${"PID".padEnd(8)} ${"Session".padEnd(40)} Command${RESET}`);
+  log("\u2500".repeat(118));
   for (const p of procs) {
+    const agentLabel = p.agent === "claude" ? `${CYAN}claude${RESET} ` : `${GREEN}copilot${RESET}`;
     log(
-      `${CYAN}${String(p.pid).padEnd(8)}${RESET} ${(p.sessionId ?? "\u2014").padEnd(40)} ${truncate(p.command, 58)}`
+      `${agentLabel.padEnd(9 + 9)} ${String(p.pid).padEnd(8)} ${(p.sessionId ?? "\u2014").padEnd(40)} ${truncate(p.command, 50)}`
     );
   }
   log("");
 }
-function showRecent(limit, incompleteOnly) {
-  let sessions = listSessions(limit);
+function showRecent(limit, incompleteOnly, agentFilter) {
+  let sessions = listAllSessions(limit, agentFilter);
   if (incompleteOnly) {
     sessions = sessions.filter((s) => !s.complete);
   }
@@ -497,15 +765,16 @@ function showRecent(limit, incompleteOnly) {
   }
   log(
     `
-${BOLD}${"Status".padEnd(10)} ${"Premium".padEnd(10)} ${"Last Event".padEnd(25)} ${"Summary".padEnd(40)} ID${RESET}`
+${BOLD}${"Agent".padEnd(9)} ${"Status".padEnd(10)} ${"Premium".padEnd(10)} ${"Last Event".padEnd(22)} ${"Summary".padEnd(35)} ID${RESET}`
   );
-  log("\u2500".repeat(120));
+  log("\u2500".repeat(130));
   for (const s of sessions) {
+    const agentLabel = s.agent === "claude" ? `${CYAN}claude${RESET} ` : `${GREEN}copilot${RESET}`;
     const status = s.complete ? `${GREEN}\u2714 done${RESET}` : `${YELLOW}\u23F8 stop${RESET}`;
-    const premium = String(s.premiumRequests);
-    const summary = truncate(s.summary || "\u2014", 38);
+    const premium = s.agent === "claude" ? "\u2014" : String(s.premiumRequests);
+    const summary = truncate(s.summary || "\u2014", 33);
     log(
-      `${status.padEnd(10 + 9)} ${premium.padEnd(10)} ${s.lastEvent.padEnd(25)} ${summary.padEnd(40)} ${DIM}${s.id}${RESET}`
+      `${agentLabel.padEnd(9 + 9)} ${status.padEnd(10 + 9)} ${premium.padEnd(10)} ${s.lastEvent.padEnd(22)} ${summary.padEnd(35)} ${DIM}${s.id.slice(0, 12)}\u2026${RESET}`
     );
   }
   log(`
@@ -516,15 +785,55 @@ function truncate(s, max) {
   return s.substring(0, max - 1) + "\u2026";
 }
 
+// src/lib/provider.ts
+import { execSync as execSync3 } from "child_process";
+function detectAvailableAgents() {
+  const agents = [];
+  try {
+    execSync3("which copilot", { stdio: "pipe" });
+    agents.push("copilot");
+  } catch {
+  }
+  try {
+    execSync3("which claude", { stdio: "pipe" });
+    agents.push("claude");
+  } catch {
+  }
+  return agents;
+}
+function resolveAgent(explicit) {
+  if (explicit === "copilot" || explicit === "claude") return explicit;
+  const available = detectAvailableAgents();
+  if (available.includes("copilot")) return "copilot";
+  if (available.includes("claude")) return "claude";
+  return "copilot";
+}
+function isAgentInstalled(agent) {
+  try {
+    execSync3(`which ${agent}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertAgent(agent) {
+  if (!isAgentInstalled(agent)) {
+    const installHint = agent === "copilot" ? "npm i -g @githubnext/copilot" : "npm i -g @anthropic-ai/claude-code";
+    console.error(`\u2716 ${agent} CLI not found. Install with: ${installHint}`);
+    process.exit(1);
+  }
+}
+
 // src/commands/watch.ts
 function registerWatchCommand(program2) {
-  program2.command("watch [session-id]").description("Watch a session and auto-resume when it stops").option("-s, --steps <n>", "Max autopilot continues per resume", "30").option("-r, --max-resumes <n>", "Max number of resumes", "10").option("-c, --cooldown <n>", "Seconds between resumes", "10").option("-m, --message <msg>", "Message to send on resume").action(async (sid, opts) => {
+  program2.command("watch [session-id]").description("Watch a session and auto-resume when it stops").option("-s, --steps <n>", "Max autopilot continues per resume", "30").option("-r, --max-resumes <n>", "Max number of resumes", "10").option("-c, --cooldown <n>", "Seconds between resumes", "10").option("-m, --message <msg>", "Message to send on resume").option("-a, --agent <type>", "Agent to use: copilot or claude").action(async (sid, opts) => {
     try {
       await watchCommand(sid, {
         steps: parseInt(opts.steps, 10),
         maxResumes: parseInt(opts.maxResumes, 10),
         cooldown: parseInt(opts.cooldown, 10),
-        message: opts.message
+        message: opts.message,
+        agent: resolveAgent(opts.agent)
       });
     } catch (err) {
       fail(`Watch error: ${err instanceof Error ? err.message : err}`);
@@ -533,14 +842,15 @@ function registerWatchCommand(program2) {
   });
 }
 async function watchCommand(sid, opts) {
-  assertCopilot();
+  assertAgent(opts.agent);
   if (!sid) {
-    sid = findLatestIncomplete() ?? void 0;
+    const result = findLatestIncompleteForAgent(opts.agent);
+    sid = result?.id;
     if (!sid) {
       fail("No incomplete session found.");
       process.exit(1);
     }
-    info(`Auto-detected incomplete session: ${CYAN}${sid}${RESET}`);
+    info(`Auto-detected incomplete ${opts.agent} session: ${CYAN}${sid}${RESET}`);
   }
   if (!validateSession(sid)) {
     fail(`Invalid session: ${sid}`);
@@ -552,9 +862,9 @@ async function watchCommand(sid, opts) {
   }
   let resumes = 0;
   while (resumes < opts.maxResumes) {
-    const pid = findPidForSession(sid);
+    const pid = findPidForSession(sid, opts.agent);
     if (pid) {
-      info(`Watching PID ${pid} for session ${CYAN}${sid.slice(0, 8)}${RESET}\u2026`);
+      info(`Watching PID ${pid} for ${opts.agent} session ${CYAN}${sid.slice(0, 8)}${RESET}\u2026`);
       const exited = await waitForExit(pid);
       if (!exited) {
         warn("Timeout waiting for process exit.");
@@ -574,7 +884,8 @@ async function watchCommand(sid, opts) {
       await sleep2(opts.cooldown * 1e3);
     }
     const cwd = getSessionCwd(sid) || void 0;
-    const result = await runCopilotResume(
+    const result = await runAgentResume(
+      opts.agent,
       sid,
       opts.steps,
       opts.message ?? "Continue remaining work. Pick up where you left off and complete the task.",
@@ -594,8 +905,8 @@ function sleep2(ms) {
 
 // src/lib/detect.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join2, basename, resolve as resolve3 } from "path";
-import { execSync as execSync3 } from "child_process";
+import { join as join2, basename as basename2, resolve as resolve3 } from "path";
+import { execSync as execSync4 } from "child_process";
 function detectProjectType(dir) {
   const exists = (f) => existsSync2(join2(dir, f));
   if (exists("build.gradle.kts") || exists("build.gradle")) {
@@ -639,11 +950,11 @@ function detectProjectName(dir) {
     if (pkg.name) return pkg.name;
   } catch {
   }
-  return basename(resolve3(dir));
+  return basename2(resolve3(dir));
 }
 function detectMainBranch(dir) {
   try {
-    const ref = execSync3("git symbolic-ref refs/remotes/origin/HEAD", {
+    const ref = execSync4("git symbolic-ref refs/remotes/origin/HEAD", {
       cwd: dir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -652,7 +963,7 @@ function detectMainBranch(dir) {
   } catch {
   }
   try {
-    const branch = execSync3("git branch --show-current", {
+    const branch = execSync4("git branch --show-current", {
       cwd: dir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -818,10 +1129,10 @@ async function withLock(name, fn) {
 // src/lib/git.ts
 import { existsSync as existsSync4 } from "fs";
 import { join as join4, resolve as resolve4 } from "path";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 function gitExec(dir, cmd) {
   try {
-    return execSync4(cmd, {
+    return execSync5(cmd, {
       cwd: dir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -873,14 +1184,15 @@ function removeWorktree(repoDir, worktreePath) {
 
 // src/commands/run.ts
 function registerRunCommand(program2) {
-  program2.command("run [dir]").description("Discover and fix issues in a project").option("-s, --steps <n>", "Max autopilot continues per task", "30").option("-t, --max-tasks <n>", "Max number of tasks to run", "5").option("-p, --max-premium <n>", "Max total premium requests", "50").option("--dry-run", "Show tasks without executing").option("--worktree", "Use git worktree for parallel execution (default: wait for idle)").action(async (dir, opts) => {
+  program2.command("run [dir]").description("Discover and fix issues in a project").option("-s, --steps <n>", "Max autopilot continues per task", "30").option("-t, --max-tasks <n>", "Max number of tasks to run", "5").option("-p, --max-premium <n>", "Max total premium requests", "50").option("--dry-run", "Show tasks without executing").option("--worktree", "Use git worktree for parallel execution (default: wait for idle)").option("-a, --agent <type>", "Agent to use: copilot or claude").action(async (dir, opts) => {
     try {
       await runCommand(dir ?? process.cwd(), {
         steps: parseInt(opts.steps, 10),
         maxTasks: parseInt(opts.maxTasks, 10),
         maxPremium: parseInt(opts.maxPremium, 10),
         dryRun: opts.dryRun ?? false,
-        useWorktree: opts.worktree ?? false
+        useWorktree: opts.worktree ?? false,
+        agent: resolveAgent(opts.agent)
       });
     } catch (err) {
       fail(`Run error: ${err instanceof Error ? err.message : err}`);
@@ -889,11 +1201,11 @@ function registerRunCommand(program2) {
   });
 }
 async function runCommand(dir, opts) {
-  assertCopilot();
+  assertAgent(opts.agent);
   const projectType = detectProjectType(dir);
   const name = detectProjectName(dir);
   const mainBranch = isGitRepo(dir) ? detectMainBranch(dir) : null;
-  info(`Project: ${CYAN}${name}${RESET} (${projectType})`);
+  info(`Project: ${CYAN}${name}${RESET} (${projectType}) \u2014 agent: ${opts.agent}`);
   if (mainBranch) info(`Main branch: ${mainBranch}`);
   const tasks = getTasksForProject(projectType).slice(0, opts.maxTasks);
   if (tasks.length === 0) {
@@ -935,9 +1247,14 @@ ${"\u2550".repeat(60)}`);
     let worktreeCreated = false;
     if (opts.useWorktree && isGitRepo(dir)) {
       try {
-        taskDir = createWorktree(dir, branchName, mainBranch ?? void 0);
-        worktreeCreated = true;
-        info(`Created worktree: ${taskDir}`);
+        const wt = createWorktree(dir, branchName);
+        if (wt) {
+          taskDir = wt;
+          worktreeCreated = true;
+          info(`Created worktree: ${taskDir}`);
+        } else {
+          warn("Worktree creation returned null, falling back to main dir");
+        }
       } catch (err) {
         warn(`Worktree creation failed, falling back to main dir: ${err}`);
         taskDir = dir;
@@ -945,7 +1262,7 @@ ${"\u2550".repeat(60)}`);
     }
     const result = await withLock(
       "copilot-run",
-      () => runCopilotTask(task.prompt, opts.steps, taskDir, opts.useWorktree)
+      () => runAgentTask(opts.agent, task.prompt, opts.steps, taskDir, opts.useWorktree)
     );
     const commitRef = worktreeCreated ? taskDir : dir;
     const commits = mainBranch ? gitCountCommits(commitRef, mainBranch, "HEAD") : 0;
@@ -973,7 +1290,7 @@ ${BOLD}\u2550\u2550\u2550 Run Summary \u2550\u2550\u2550${RESET}`);
 import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 function registerOvernightCommand(program2) {
-  program2.command("overnight [dir]").description("Run tasks continuously until a deadline").option("-u, --until <HH>", "Stop at this hour (24h format)", "07").option("-s, --steps <n>", "Max autopilot continues per task", "50").option("-c, --cooldown <n>", "Seconds between tasks", "15").option("-p, --max-premium <n>", "Max premium requests budget", "300").option("--dry-run", "Show plan without executing").option("--worktree", "Use git worktree for parallel execution (default: wait for idle)").action(async (dir, opts) => {
+  program2.command("overnight [dir]").description("Run tasks continuously until a deadline").option("-u, --until <HH>", "Stop at this hour (24h format)", "07").option("-s, --steps <n>", "Max autopilot continues per task", "50").option("-c, --cooldown <n>", "Seconds between tasks", "15").option("-p, --max-premium <n>", "Max premium requests budget", "300").option("--dry-run", "Show plan without executing").option("--worktree", "Use git worktree for parallel execution (default: wait for idle)").option("-a, --agent <type>", "Agent to use: copilot or claude").action(async (dir, opts) => {
     try {
       await overnightCommand(dir ?? process.cwd(), {
         until: parseInt(opts.until, 10),
@@ -981,7 +1298,8 @@ function registerOvernightCommand(program2) {
         cooldown: parseInt(opts.cooldown, 10),
         maxPremium: parseInt(opts.maxPremium, 10),
         dryRun: opts.dryRun ?? false,
-        useWorktree: opts.worktree ?? false
+        useWorktree: opts.worktree ?? false,
+        agent: resolveAgent(opts.agent)
       });
     } catch (err) {
       fail(`Overnight error: ${err instanceof Error ? err.message : err}`);
@@ -994,14 +1312,14 @@ function isPastDeadline(untilHour) {
   return hour >= untilHour && hour < 20;
 }
 async function overnightCommand(dir, opts) {
-  assertCopilot();
+  assertAgent(opts.agent);
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15);
   const logPath = join5(homedir3(), ".copilot", "auto-resume-logs", `overnight-${ts}.log`);
   setLogFile(logPath);
   const name = detectProjectName(dir);
   const projectType = detectProjectType(dir);
   const mainBranch = isGitRepo(dir) ? detectMainBranch(dir) : null;
-  info(`Overnight runner for ${CYAN}${name}${RESET} (${projectType})`);
+  info(`Overnight runner for ${CYAN}${name}${RESET} (${projectType}) \u2014 agent: ${opts.agent}`);
   info(`Deadline: ${String(opts.until).padStart(2, "0")}:00`);
   info(`Max premium: ${opts.maxPremium}, Steps: ${opts.steps}`);
   info(`Log: ${logPath}`);
@@ -1012,18 +1330,20 @@ Would run ${tasks.length} tasks:`);
     for (const t of tasks) log(`  ${DIM}\u2022${RESET} ${t.title}`);
     return;
   }
-  const existingSession = findLatestIncomplete();
+  const existingResult = findLatestIncompleteForAgent(opts.agent);
+  const existingSession = existingResult?.id;
   if (existingSession && validateSession(existingSession)) {
     info(`Found incomplete session: ${existingSession}`);
-    const pid = findPidForSession(existingSession);
+    const pid = findPidForSession(existingSession, opts.agent);
     if (pid) {
-      info(`Waiting for running copilot (PID ${pid})...`);
+      info(`Waiting for running ${opts.agent} (PID ${pid})...`);
       await waitForExit(pid);
     }
     if (!hasTaskComplete(existingSession) && !isPastDeadline(opts.until)) {
       info("Resuming incomplete session...");
       const cwd = getSessionCwd(existingSession) || dir;
-      await runCopilotResume(
+      await runAgentResume(
+        opts.agent,
         existingSession,
         opts.steps,
         "Continue remaining work. Complete the task.",
@@ -1060,9 +1380,14 @@ ${"\u2550".repeat(60)}`);
     let worktreeCreated = false;
     if (opts.useWorktree && isGitRepo(dir)) {
       try {
-        taskDir = createWorktree(dir, branchName, mainBranch ?? void 0);
-        worktreeCreated = true;
-        info(`Created worktree: ${taskDir}`);
+        const wt = createWorktree(dir, branchName);
+        if (wt) {
+          taskDir = wt;
+          worktreeCreated = true;
+          info(`Created worktree: ${taskDir}`);
+        } else {
+          warn("Worktree creation returned null, falling back to main dir");
+        }
       } catch (err) {
         warn(`Worktree creation failed, falling back to main dir: ${err}`);
         taskDir = dir;
@@ -1071,7 +1396,7 @@ ${"\u2550".repeat(60)}`);
     try {
       const result = await withLock(
         "copilot-overnight",
-        () => runCopilotTask(task.prompt, opts.steps, taskDir, opts.useWorktree)
+        () => runAgentTask(opts.agent, task.prompt, opts.steps, taskDir, opts.useWorktree)
       );
       const commitRef = worktreeCreated ? taskDir : dir;
       const commits = mainBranch ? gitCountCommits(commitRef, mainBranch, "HEAD") : 0;
@@ -1117,10 +1442,12 @@ import { existsSync as existsSync5, copyFileSync, mkdirSync as mkdirSync3 } from
 import { join as join6, resolve as resolve5 } from "path";
 import { homedir as homedir4 } from "os";
 function registerResearchCommand(program2) {
-  program2.command("research [project]").description("Research improvements or a specific topic").option("-s, --steps <n>", "Max autopilot continues", "50").action(async (project, opts) => {
+  program2.command("research [project]").description("Research improvements or a specific topic").option("-s, --steps <n>", "Max autopilot continues", "50").option("-a, --agent <type>", "Agent to use: copilot or claude").action(async (project, opts) => {
     try {
+      const agent = resolveAgent(opts.agent);
       await researchCommand(project ?? process.cwd(), {
-        steps: parseInt(opts.steps, 10)
+        steps: parseInt(opts.steps, 10),
+        agent
       });
     } catch (err) {
       fail(`Research error: ${err instanceof Error ? err.message : err}`);
@@ -1149,15 +1476,15 @@ For each proposal, include:
 Write RESEARCH-PROPOSALS.md in the project root.`;
 }
 async function researchCommand(dir, opts) {
-  assertCopilot();
+  assertAgent(opts.agent);
   const projectDir = resolve5(dir);
   const projectType = detectProjectType(projectDir);
   const projectName = detectProjectName(projectDir);
-  info(`Researching: ${CYAN}${projectName}${RESET} (${projectType})`);
+  info(`Researching: ${CYAN}${projectName}${RESET} (${projectType}) \u2014 agent: ${opts.agent}`);
   const prompt = buildResearchPrompt(projectType, projectName);
   const result = await withLock(
     "copilot-research",
-    () => runCopilotTask(prompt, opts.steps, projectDir)
+    () => runAgentTask(opts.agent, prompt, opts.steps, projectDir)
   );
   log(`Copilot exited with code ${result.exitCode}`);
   const proposalsFile = join6(projectDir, "RESEARCH-PROPOSALS.md");
@@ -1178,12 +1505,12 @@ async function researchCommand(dir, opts) {
 // src/commands/report.ts
 import { resolve as resolve6 } from "path";
 function registerReportCommand(program2) {
-  program2.command("report [session-id]").description("Show what copilot did \u2014 timeline, tools, commits, files changed").option("-l, --limit <n>", "Number of recent sessions to report (when no ID given)", "1").option("--project <dir>", "Filter sessions by project directory").option("--json", "Output raw JSON").action((sessionId, opts) => {
+  program2.command("report [session-id]").description("Show what an agent did \u2014 timeline, tools, commits, files changed").option("-l, --limit <n>", "Number of recent sessions to report (when no ID given)", "1").option("--project <dir>", "Filter sessions by project directory").option("--json", "Output raw JSON").option("-a, --agent <type>", "Filter by agent: copilot or claude").action((sessionId, opts) => {
     try {
       if (sessionId) {
-        reportSingle(sessionId, opts.json ?? false);
+        reportSingle(sessionId, opts.json ?? false, opts.agent);
       } else {
-        reportRecent(parseInt(opts.limit, 10), opts.project, opts.json ?? false);
+        reportRecent(parseInt(opts.limit, 10), opts.project, opts.json ?? false, opts.agent);
       }
     } catch (err) {
       fail(`Report error: ${err instanceof Error ? err.message : err}`);
@@ -1191,8 +1518,8 @@ function registerReportCommand(program2) {
     }
   });
 }
-function reportRecent(limit, projectDir, json = false) {
-  let sessions = listSessions(limit * 3);
+function reportRecent(limit, projectDir, json = false, agentFilter) {
+  let sessions = listAllSessions(limit * 3, agentFilter);
   if (projectDir) {
     const target = resolve6(projectDir);
     sessions = sessions.filter((s) => s.cwd && resolve6(s.cwd) === target);
@@ -1203,11 +1530,11 @@ function reportRecent(limit, projectDir, json = false) {
     return;
   }
   for (const s of sessions) {
-    reportSingle(s.id, json);
+    reportSingle(s.id, json, s.agent);
   }
 }
-function reportSingle(sid, json = false) {
-  const report = getSessionReport(sid);
+function reportSingle(sid, json = false, agent) {
+  const report = getAgentSessionReport(sid, agent);
   if (!report) {
     warn(`Session ${sid} not found or invalid.`);
     return;
@@ -1244,7 +1571,7 @@ function renderReport(r) {
   const projectName = r.cwd.split("/").pop() ?? r.cwd;
   log("");
   log(`${BOLD}\u2554${"\u2550".repeat(62)}\u2557${RESET}`);
-  log(`${BOLD}\u2551${RESET}  \u{1F4CB} Session Report: ${CYAN}${r.id.slice(0, 8)}\u2026${RESET}${" ".repeat(62 - 28 - r.id.slice(0, 8).length)}${BOLD}\u2551${RESET}`);
+  log(`${BOLD}\u2551${RESET}  \u{1F4CB} Session Report: ${CYAN}${r.id.slice(0, 8)}\u2026${RESET} (${r.agent})${" ".repeat(Math.max(0, 62 - 32 - r.id.slice(0, 8).length - r.agent.length))}${BOLD}\u2551${RESET}`);
   log(`${BOLD}\u255A${"\u2550".repeat(62)}\u255D${RESET}`);
   log("");
   log(`${BOLD}  Overview${RESET}`);
@@ -1384,20 +1711,21 @@ function buildScreen(limit) {
   lines.push(`  ${BOLD}${CYAN}\u2502${RESET}  \u{1F916} ${BOLD}Copilot Agent Dashboard${RESET}${" ".repeat(Math.max(0, cols - 37 - timeStr.length))}${DIM}${timeStr}${RESET}  ${BOLD}${CYAN}\u2502${RESET}`);
   lines.push(`  ${BOLD}${CYAN}\u2514${"\u2500".repeat(cols - 6)}\u2518${RESET}`);
   lines.push("");
-  const procs = findCopilotProcesses();
+  const procs = findAgentProcesses();
   lines.push(`  ${BOLD}${GREEN}\u25CF Active Processes (${procs.length})${RESET}`);
   lines.push(`  ${"\u2500".repeat(Math.min(cols - 4, 70))}`);
   if (procs.length === 0) {
-    lines.push(`  ${DIM}No copilot processes running${RESET}`);
+    lines.push(`  ${DIM}No agent processes running${RESET}`);
   } else {
     for (const p of procs) {
+      const agentTag = p.agent === "claude" ? `${CYAN}[claude]${RESET}` : `${GREEN}[copilot]${RESET}`;
       const sid = p.sessionId ? p.sessionId.slice(0, 8) + "\u2026" : "\u2014";
       const cwdShort = p.cwd ? "~/" + p.cwd.split("/").slice(-2).join("/") : "\u2014";
-      lines.push(`  ${GREEN}\u2B24${RESET} PID ${BOLD}${p.pid}${RESET}  ${CYAN}${sid}${RESET}  ${DIM}${cwdShort}${RESET}`);
+      lines.push(`  ${GREEN}\u2B24${RESET} ${agentTag} PID ${BOLD}${p.pid}${RESET}  ${CYAN}${sid}${RESET}  ${DIM}${cwdShort}${RESET}`);
     }
   }
   lines.push("");
-  const sessions = listSessions(limit);
+  const sessions = listAllSessions(limit);
   lines.push(`  ${BOLD}${CYAN}\u25CF Recent Sessions (${sessions.length})${RESET}`);
   lines.push(`  ${"\u2500".repeat(Math.min(cols - 4, 70))}`);
   const headerCols = [
@@ -1409,7 +1737,7 @@ function buildScreen(limit) {
   ];
   lines.push(`  ${DIM}${headerCols.join(" ")}${RESET}`);
   for (const s of sessions) {
-    const report = getSessionReport(s.id);
+    const report = getAgentSessionReport(s.id, s.agent);
     const statusIcon = s.complete ? `${GREEN}\u2714 done  ${RESET}` : `${YELLOW}\u23F8 stop  ${RESET}`;
     const premium = pad(String(s.premiumRequests), 8);
     const duration = report ? pad(formatDuration2(report.durationMs), 10) : pad("\u2014", 10);
@@ -1419,7 +1747,7 @@ function buildScreen(limit) {
   }
   lines.push("");
   if (sessions.length > 0) {
-    const latest = getSessionReport(sessions[0].id);
+    const latest = getAgentSessionReport(sessions[0].id, sessions[0].agent);
     if (latest) {
       lines.push(`  ${BOLD}${CYAN}\u25CF Latest Session Detail${RESET}  ${DIM}${latest.id.slice(0, 8)}\u2026${RESET}`);
       lines.push(`  ${"\u2500".repeat(Math.min(cols - 4, 70))}`);
@@ -1545,6 +1873,8 @@ body{background:var(--bg);color:var(--text);font-family:var(--font-sans);font-si
 .badge{font-size:10px;padding:1px 6px;border-radius:4px;font-weight:600;font-family:var(--font-mono);text-transform:uppercase}
 .badge-done{background:rgba(63,185,80,.12);color:var(--green)}
 .badge-stop{background:rgba(210,153,34,.12);color:var(--yellow)}
+.badge-claude{background:rgba(217,119,6,.15);color:#f59e0b}
+.badge-copilot{background:rgba(56,189,248,.12);color:#38bdf8}
 .detail{padding:20px;overflow-y:auto}
 .detail-head{display:flex;align-items:center;justify-content:space-between;margin-bottom:16px}
 .detail-title{font-size:18px;font-weight:700}
@@ -1572,8 +1902,6 @@ body{background:var(--bg);color:var(--text);font-family:var(--font-sans);font-si
 .error-list li{padding:5px 0;font-size:12px;color:var(--red)}
 .more{font-size:11px;color:var(--text3);padding:4px 0}
 .empty-detail{display:flex;align-items:center;justify-content:center;height:100%;color:var(--text3)}
-.htmx-settling{opacity:0}
-.htmx-added{opacity:0;transition:opacity .3s ease}
 @media(max-width:768px){.main{grid-template-columns:1fr}.stats{grid-template-columns:repeat(2,1fr)}}
 `;
 var layoutHead = `<!DOCTYPE html>
@@ -1643,11 +1971,13 @@ function renderStats(sessions) {
   ).join("");
 }
 function renderProcesses(procs) {
-  if (procs.length === 0) return '<div class="empty">No active copilot processes</div>';
+  if (procs.length === 0) return '<div class="empty">No active agent processes</div>';
   return procs.map((p) => {
     const sid = p.sessionId ? p.sessionId.slice(0, 8) + "\u2026" : "\u2014";
+    const agentBadge = p.agent === "claude" ? '<span class="badge badge-claude">claude</span>' : '<span class="badge badge-copilot">copilot</span>';
     return `<div class="proc">
       <div class="proc-dot"></div>
+      ${agentBadge}
       <span class="proc-pid">PID ${p.pid}</span>
       <span class="proc-sid">${esc(sid)}</span>
       <span class="proc-cwd">${esc(p.cwd ?? "")}</span>
@@ -1658,16 +1988,17 @@ function renderSessionList(sessions, selectedId) {
   return sessions.map((s) => {
     const proj = (s.cwd ?? "").split("/").pop() ?? "\u2014";
     const isActive = s.id === selectedId;
+    const agentBadge = s.agent === "claude" ? '<span class="badge badge-claude">claude</span>' : '<span class="badge badge-copilot">copilot</span>';
     return `<div class="s-item${isActive ? " active" : ""}"
       hx-get="/partial/detail/${s.id}" hx-target="#detail" hx-swap="innerHTML"
       onclick="document.querySelectorAll('.s-item').forEach(e=>e.classList.remove('active'));this.classList.add('active')">
       <div class="s-row">
         <span class="s-icon">${s.complete ? "\u2705" : "\u23F8\uFE0F"}</span>
         <div class="s-info">
-          <div class="s-title">${esc(proj)} \u2014 ${esc(s.summary || "(no summary)")}</div>
+          <div class="s-title">${agentBadge} ${esc(proj)} \u2014 ${esc(s.summary || "(no summary)")}</div>
           <div class="s-meta">
             <span>${fmtDur(s.durationMs)}</span>
-            <span>${fmt(s.premiumRequests)} premium</span>
+            <span>${s.agent === "claude" ? "" : fmt(s.premiumRequests) + " premium"}</span>
             <span>${fmtAgo(s.endTime)}</span>
             <span class="badge ${s.complete ? "badge-done" : "badge-stop"}">${s.complete ? "done" : "stopped"}</span>
           </div>
@@ -1682,8 +2013,9 @@ function renderDetail(s) {
   const toolEntries = Object.entries(s.toolUsage ?? {}).sort((a, b) => b[1] - a[1]);
   const maxTool = toolEntries[0]?.[1] ?? 1;
   let html = "";
+  const agentBadge = s.agent === "claude" ? '<span class="badge badge-claude" style="margin-left:8px">claude</span>' : '<span class="badge badge-copilot" style="margin-left:8px">copilot</span>';
   html += `<div class="detail-head">
-    <div class="detail-title">${esc(proj)}</div>
+    <div class="detail-title">${esc(proj)}${agentBadge}</div>
     <div class="detail-id">${s.id}</div>
   </div>`;
   html += `<div class="detail-time">${fmtTime(s.startTime)} \u2192 ${fmtTime(s.endTime)}</div>`;
@@ -1758,41 +2090,51 @@ function registerWebCommand(program2) {
   });
 }
 function getData() {
-  const sessions = listSessions(20);
-  const reports = sessions.map((s) => getSessionReport(s.id)).filter((r) => r !== null);
-  const processes = findCopilotProcesses();
+  const sessions = listAllSessions(20);
+  const reports = sessions.map((s) => getAgentSessionReport(s.id, s.agent)).filter((r) => r !== null);
+  const processes = findAgentProcesses();
   return { sessions: reports, processes };
 }
+function simpleHash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) - h + s.charCodeAt(i) | 0;
+  }
+  return h.toString(36);
+}
 function startWebServer(port, autoOpen) {
   const app = new Hono();
   app.get("/api/sessions", (c) => c.json(getData()));
   app.get("/api/session/:id", (c) => {
-    const report = getSessionReport(c.req.param("id"));
+    const report = getAgentSessionReport(c.req.param("id"));
     if (!report) return c.json({ error: "Not found" }, 404);
     return c.json(report);
   });
   app.get("/events", (c) => {
     return streamSSE(c, async (stream) => {
+      let prevStatsHash = "";
+      let prevProcsHash = "";
       while (true) {
         const { sessions, processes } = getData();
-        await stream.writeSSE({
-          event: "stats",
-          data: renderStats(sessions)
-        });
-        await stream.writeSSE({
-          event: "procs",
-          data: renderProcesses(processes)
-        });
-        await stream.writeSSE({
-          event: "proc-count",
-          data: String(processes.length)
-        });
+        const statsHtml = renderStats(sessions);
+        const procsHtml = renderProcesses(processes);
+        const statsHash = simpleHash(statsHtml);
+        const procsHash = simpleHash(procsHtml);
+        if (statsHash !== prevStatsHash) {
+          await stream.writeSSE({ event: "stats", data: statsHtml });
+          prevStatsHash = statsHash;
+        }
+        if (procsHash !== prevProcsHash) {
+          await stream.writeSSE({ event: "procs", data: procsHtml });
+          await stream.writeSSE({ event: "proc-count", data: String(processes.length) });
+          prevProcsHash = procsHash;
+        }
         await stream.sleep(5e3);
       }
     });
   });
   app.get("/partial/detail/:id", (c) => {
-    const report = getSessionReport(c.req.param("id"));
+    const report = getAgentSessionReport(c.req.param("id"));
     if (!report) return c.html('<div class="empty-detail">Session not found</div>');
     return c.html(renderDetail(report));
   });
@@ -1815,17 +2157,17 @@ function startWebServer(port, autoOpen) {
 
     <div class="stats"
       sse-swap="stats"
-      hx-swap="innerHTML">
+      hx-swap="innerHTML settle:0s swap:0s">
       ${renderStats(sessions)}
     </div>
 
     <div class="procs">
       <div class="procs-header">
-        \u2B24 Active Processes <span class="count" sse-swap="proc-count" hx-swap="innerHTML">${processes.length}</span>
+        \u2B24 Active Processes <span class="count" sse-swap="proc-count" hx-swap="innerHTML settle:0s swap:0s">${processes.length}</span>
       </div>
       <div class="procs-body"
         sse-swap="procs"
-        hx-swap="innerHTML">
+        hx-swap="innerHTML settle:0s swap:0s">
         ${renderProcesses(processes)}
       </div>
     </div>
@@ -1869,7 +2211,7 @@ ${layoutFoot}`);
 
 // src/index.ts
 var program = new Command();
-program.name("copilot-agent").version("0.7.0").description("Autonomous GitHub Copilot CLI agent \u2014 auto-resume, task discovery, overnight runs");
+program.name("copilot-agent").version("0.8.0").description("Autonomous AI agent manager \u2014 auto-resume, task discovery, overnight runs. Supports GitHub Copilot CLI + Claude Code.");
 registerStatusCommand(program);
 registerWatchCommand(program);
 registerRunCommand(program);