copilot-agent 1.0.0 → 1.1.0

package/dist/index.js

@@ -31,8 +31,8 @@ function listSessions(limit = 20) {
     const dirPath = join(SESSION_DIR, entry.name);
     if (!existsSync(join(dirPath, "events.jsonl"))) continue;
     try {
-      const stat = statSync(dirPath);
-      dirs.push({ id: entry.name, dir: dirPath, mtime: stat.mtimeMs });
+      const stat2 = statSync(dirPath);
+      dirs.push({ id: entry.name, dir: dirPath, mtime: stat2.mtimeMs });
     } catch {
     }
   }
@@ -55,9 +55,9 @@ function getLatestSessionId() {
   let latest = null;
   for (const entry of entries) {
     try {
-      const stat = statSync(join(SESSION_DIR, entry.name));
-      if (!latest || stat.mtimeMs > latest.mtime) {
-        latest = { id: entry.name, mtime: stat.mtimeMs };
+      const stat2 = statSync(join(SESSION_DIR, entry.name));
+      if (!latest || stat2.mtimeMs > latest.mtime) {
+        latest = { id: entry.name, mtime: stat2.mtimeMs };
       }
     } catch {
     }
@@ -244,12 +244,12 @@ function listClaudeSessions(limit = 20) {
         const filePath = join(projPath, file);
         const sid = basename(file, ".jsonl");
         try {
-          const stat = statSync(filePath);
+          const stat2 = statSync(filePath);
           const { lastEvent, complete, summary } = parseClaudeSessionMeta(filePath);
           sessions.push({
             id: sid,
             dir: projPath,
-            mtime: stat.mtimeMs,
+            mtime: stat2.mtimeMs,
             lastEvent,
             premiumRequests: 0,
             summary,
@@ -319,9 +319,9 @@ function getLatestClaudeSessionId(projectDir) {
     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 };
+        const stat2 = statSync(join(dir, file));
+        if (!latest || stat2.mtimeMs > latest.mtime) {
+          latest = { id: basename(file, ".jsonl"), mtime: stat2.mtimeMs };
         }
       }
     } catch {
@@ -1658,6 +1658,427 @@ function renderReport(r) {
   log("");
 }
 
+// src/lib/reactive.ts
+import { EventEmitter } from "events";
+import { readFile, readdir, stat } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { exec } from "child_process";
+import { join as join7, basename as basename3 } from "path";
+import { homedir as homedir5 } from "os";
+var SESSION_DIR2 = join7(homedir5(), ".copilot", "session-state");
+var CLAUDE_PROJECTS_DIR2 = join7(homedir5(), ".claude", "projects");
+function execAsync(cmd) {
+  return new Promise((resolve8, reject) => {
+    exec(cmd, { encoding: "utf-8", maxBuffer: 512 * 1024 }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve8(stdout);
+    });
+  });
+}
+function parseSimpleYaml2(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const idx = line.indexOf(": ");
+    if (idx === -1) continue;
+    const key = line.substring(0, idx).trim();
+    const value = line.substring(idx + 2).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+async function parseJsonlChunked(content, handler) {
+  const lines = content.trimEnd().split("\n");
+  const CHUNK = 200;
+  for (let i = 0; i < lines.length; i++) {
+    try {
+      handler(JSON.parse(lines[i]));
+    } catch {
+    }
+    if (i % CHUNK === 0 && i > 0) {
+      await new Promise((r) => setImmediate(r));
+    }
+  }
+}
+async function readWorkspaceAsync(sid) {
+  const wsPath = join7(SESSION_DIR2, sid, "workspace.yaml");
+  try {
+    const content = await readFile(wsPath, "utf-8");
+    return parseSimpleYaml2(content);
+  } catch {
+    return {};
+  }
+}
+async function listCopilotSessionsAsync(limit) {
+  if (!existsSync6(SESSION_DIR2)) return [];
+  try {
+    const entries = await readdir(SESSION_DIR2, { withFileTypes: true });
+    const dirs = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const dirPath = join7(SESSION_DIR2, entry.name);
+      const eventsPath = join7(dirPath, "events.jsonl");
+      if (!existsSync6(eventsPath)) continue;
+      try {
+        const s = await stat(dirPath);
+        dirs.push({ id: entry.name, dir: dirPath, mtime: s.mtimeMs });
+      } catch {
+      }
+    }
+    dirs.sort((a, b) => b.mtime - a.mtime);
+    const top = dirs.slice(0, limit);
+    return Promise.all(top.map(async (s) => {
+      const ws = await readWorkspaceAsync(s.id);
+      let premiumRequests = 0;
+      let complete = false;
+      let lastEvent = "unknown";
+      try {
+        const evPath = join7(SESSION_DIR2, s.id, "events.jsonl");
+        const fileStat = await stat(evPath);
+        const fullContent = await readFile(evPath, "utf-8");
+        const lines = fullContent.trimEnd().split("\n");
+        for (let i = lines.length - 1; i >= Math.max(0, lines.length - 10); i--) {
+          try {
+            const ev = JSON.parse(lines[i]);
+            if (i === lines.length - 1) lastEvent = ev.type ?? "unknown";
+            if (ev.type === "session.shutdown" && ev.data?.totalPremiumRequests != null) {
+              premiumRequests = ev.data.totalPremiumRequests;
+            }
+            if (ev.type === "session.task_complete") complete = true;
+          } catch {
+          }
+        }
+        if (!complete && fullContent.includes('"session.task_complete"')) complete = true;
+      } catch {
+      }
+      return {
+        id: s.id,
+        dir: s.dir,
+        mtime: s.mtime,
+        lastEvent,
+        premiumRequests,
+        summary: ws.summary ?? "",
+        cwd: ws.cwd ?? "",
+        complete,
+        agent: "copilot"
+      };
+    }));
+  } catch {
+    return [];
+  }
+}
+async function listClaudeSessionsAsync(limit) {
+  if (!existsSync6(CLAUDE_PROJECTS_DIR2)) return [];
+  const sessions = [];
+  try {
+    const projectDirs = await readdir(CLAUDE_PROJECTS_DIR2, { withFileTypes: true });
+    for (const projDir of projectDirs.filter((d) => d.isDirectory())) {
+      const projPath = join7(CLAUDE_PROJECTS_DIR2, projDir.name);
+      const cwd = projDir.name.replace(/^-/, "/").replace(/-/g, "/");
+      const files = (await readdir(projPath)).filter((f) => f.endsWith(".jsonl"));
+      for (const file of files) {
+        const filePath = join7(projPath, file);
+        const sid = basename3(file, ".jsonl");
+        try {
+          const s = await stat(filePath);
+          sessions.push({
+            id: sid,
+            dir: projPath,
+            mtime: s.mtimeMs,
+            lastEvent: "unknown",
+            premiumRequests: 0,
+            summary: "",
+            cwd,
+            complete: false,
+            agent: "claude"
+          });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  sessions.sort((a, b) => b.mtime - a.mtime);
+  return sessions.slice(0, limit);
+}
+async function findProcessesAsync() {
+  try {
+    const output = await execAsync("ps -eo pid,command");
+    const results = [];
+    const myPid = process.pid;
+    const parentPid = process.ppid;
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      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";
+      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})/);
+      results.push({ pid, command: cmd, sessionId: sidMatch?.[1], agent });
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+async function loadReportAsync(sid, agent) {
+  if (agent === "claude") return loadClaudeReportAsync(sid);
+  return loadCopilotReportAsync(sid);
+}
+async function loadCopilotReportAsync(sid) {
+  const eventsPath = join7(SESSION_DIR2, sid, "events.jsonl");
+  if (!existsSync6(eventsPath)) return null;
+  const ws = await readWorkspaceAsync(sid);
+  let content;
+  try {
+    content = await readFile(eventsPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const report = {
+    id: sid,
+    cwd: ws.cwd ?? "",
+    summary: ws.summary ?? "",
+    startTime: "",
+    endTime: "",
+    durationMs: 0,
+    complete: false,
+    userMessages: 0,
+    assistantTurns: 0,
+    outputTokens: 0,
+    premiumRequests: 0,
+    toolUsage: {},
+    gitCommits: [],
+    filesCreated: [],
+    filesEdited: [],
+    errors: [],
+    taskCompletions: [],
+    agent: "copilot"
+  };
+  await parseJsonlChunked(content, (event) => {
+    const type = event.type;
+    const ts = event.timestamp;
+    const data = event.data ?? {};
+    if (ts && !report.startTime) report.startTime = ts;
+    if (ts) report.endTime = ts;
+    switch (type) {
+      case "user.message":
+        report.userMessages++;
+        break;
+      case "assistant.message":
+        report.assistantTurns++;
+        report.outputTokens += data.outputTokens ?? 0;
+        break;
+      case "tool.execution_start": {
+        const toolName = data.toolName;
+        if (toolName) report.toolUsage[toolName] = (report.toolUsage[toolName] ?? 0) + 1;
+        if (toolName === "bash") {
+          const args = data.arguments;
+          const cmd = args?.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 === "create") {
+          const args = data.arguments;
+          if (args?.path) report.filesCreated.push(args.path);
+        }
+        if (toolName === "edit") {
+          const args = data.arguments;
+          if (args?.path && !report.filesEdited.includes(args.path)) report.filesEdited.push(args.path);
+        }
+        break;
+      }
+      case "session.task_complete": {
+        report.taskCompletions.push(data.summary ?? "(task completed)");
+        report.complete = true;
+        break;
+      }
+      case "session.error": {
+        const msg = data.message;
+        if (msg) report.errors.push(msg);
+        break;
+      }
+      case "session.shutdown": {
+        const prem = data.totalPremiumRequests;
+        if (prem != null) report.premiumRequests = prem;
+        break;
+      }
+    }
+  });
+  if (report.startTime && report.endTime) {
+    report.durationMs = new Date(report.endTime).getTime() - new Date(report.startTime).getTime();
+  }
+  return report;
+}
+async function loadClaudeReportAsync(sid) {
+  if (!existsSync6(CLAUDE_PROJECTS_DIR2)) return null;
+  let filePath = null;
+  let cwd = "";
+  try {
+    const projectDirs = await readdir(CLAUDE_PROJECTS_DIR2, { withFileTypes: true });
+    for (const projDir of projectDirs.filter((d) => d.isDirectory())) {
+      const candidate = join7(CLAUDE_PROJECTS_DIR2, projDir.name, `${sid}.jsonl`);
+      if (existsSync6(candidate)) {
+        filePath = candidate;
+        cwd = projDir.name.replace(/^-/, "/").replace(/-/g, "/");
+        break;
+      }
+    }
+  } catch {
+  }
+  if (!filePath) return null;
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } 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"
+  };
+  await parseJsonlChunked(content, (event) => {
+    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 (type === "assistant") {
+      report.assistantTurns++;
+      if (event.stop_reason === "end_turn") report.complete = true;
+    }
+    if (type === "result") report.complete = true;
+    if (type === "tool_use" || type === "tool_result") {
+      const name = event.name ?? "tool";
+      report.toolUsage[name] = (report.toolUsage[name] ?? 0) + 1;
+    }
+  });
+  if (report.startTime && report.endTime) {
+    report.durationMs = new Date(report.endTime).getTime() - new Date(report.startTime).getTime();
+  }
+  return report;
+}
+var DashboardStore = class extends EventEmitter {
+  sessions = [];
+  processes = [];
+  details = /* @__PURE__ */ new Map();
+  limit;
+  sessionsTimer = null;
+  procsTimer = null;
+  detailPending = null;
+  detailDebounce = null;
+  refreshing = { sessions: false, procs: false, detail: false };
+  constructor(limit = 20) {
+    super();
+    this.limit = limit;
+  }
+  // ── Start auto-refresh loops ───────────────────────────────────
+  start(sessionIntervalMs = 2e3, procsIntervalMs = 3e3) {
+    this.refreshSessions();
+    this.refreshProcesses();
+    this.sessionsTimer = setInterval(() => this.refreshSessions(), sessionIntervalMs);
+    this.procsTimer = setInterval(() => this.refreshProcesses(), procsIntervalMs);
+  }
+  stop() {
+    if (this.sessionsTimer) clearInterval(this.sessionsTimer);
+    if (this.procsTimer) clearInterval(this.procsTimer);
+    if (this.detailDebounce) clearTimeout(this.detailDebounce);
+  }
+  // ── Async session refresh (non-blocking) ───────────────────────
+  async refreshSessions() {
+    if (this.refreshing.sessions) return;
+    this.refreshing.sessions = true;
+    try {
+      const [copilot, claude] = await Promise.all([
+        listCopilotSessionsAsync(this.limit),
+        listClaudeSessionsAsync(this.limit)
+      ]);
+      const merged = [...copilot, ...claude].sort((a, b) => b.mtime - a.mtime).slice(0, this.limit);
+      this.sessions = merged;
+      this.emit("sessions");
+    } catch {
+    }
+    this.refreshing.sessions = false;
+  }
+  // ── Async process refresh (non-blocking) ───────────────────────
+  async refreshProcesses() {
+    if (this.refreshing.procs) return;
+    this.refreshing.procs = true;
+    try {
+      this.processes = await findProcessesAsync();
+      this.emit("processes");
+    } catch {
+    }
+    this.refreshing.procs = false;
+  }
+  // ── Request detail for a session (debounced 150ms) ─────────────
+  requestDetail(sessionId, agent, force = false) {
+    if (!force && this.details.has(sessionId)) {
+      this.emit("detail", sessionId);
+      return;
+    }
+    this.detailPending = sessionId;
+    if (this.detailDebounce) clearTimeout(this.detailDebounce);
+    this.detailDebounce = setTimeout(() => {
+      this.detailDebounce = null;
+      if (this.detailPending !== sessionId) return;
+      this.loadDetail(sessionId, agent);
+    }, 150);
+  }
+  // ── Force-load detail immediately (Enter key) ──────────────────
+  requestDetailNow(sessionId, agent) {
+    if (this.detailDebounce) clearTimeout(this.detailDebounce);
+    this.detailPending = sessionId;
+    this.loadDetail(sessionId, agent);
+  }
+  // ── Async detail loading (non-blocking JSONL parse) ────────────
+  async loadDetail(sessionId, agent) {
+    if (this.refreshing.detail) return;
+    this.refreshing.detail = true;
+    try {
+      const report = await loadReportAsync(sessionId, agent);
+      this.details.set(sessionId, report);
+      if (this.details.size > 15) {
+        const first = this.details.keys().next().value;
+        if (first && first !== sessionId) this.details.delete(first);
+      }
+      this.emit("detail", sessionId);
+    } catch {
+    }
+    this.refreshing.detail = false;
+  }
+  // ── Force full refresh (r key) ─────────────────────────────────
+  forceRefresh() {
+    this.details.clear();
+    this.refreshSessions();
+    this.refreshProcesses();
+  }
+};
+
 // src/tui/widgets.ts
 function agentLabel(agent) {
   return agent === "claude" ? "{yellow-fg}claude{/}" : "{cyan-fg}copilot{/}";
@@ -1779,53 +2200,13 @@ async function loadBlessed() {
   blessed = mod.default || mod;
 }
 function registerDashboardCommand(program2) {
-  program2.command("dashboard").alias("tui").description("Real-time terminal dashboard for copilot sessions (htop-style)").option("-r, --refresh <n>", "Refresh interval in seconds", "5").option("-l, --limit <n>", "Number of sessions to show", "20").action(async (opts) => {
+  program2.command("dashboard").alias("tui").description("Real-time terminal dashboard for copilot sessions (htop-style)").option("-r, --refresh <n>", "Session refresh interval in seconds", "2").option("-l, --limit <n>", "Number of sessions to show", "20").action(async (opts) => {
     await loadBlessed();
-    runBlessedDashboard(parseInt(opts.refresh, 10), parseInt(opts.limit, 10));
+    runReactiveDashboard(parseInt(opts.refresh, 10), parseInt(opts.limit, 10));
   });
 }
-function createCache() {
-  return { sessions: [], sessionsTs: 0, procs: [], procsTs: 0, details: /* @__PURE__ */ new Map() };
-}
-function cacheSessions(cache, limit) {
-  const now = Date.now();
-  if (now - cache.sessionsTs > 2e3) {
-    try {
-      cache.sessions = listAllSessions(limit);
-    } catch {
-    }
-    cache.sessionsTs = now;
-  }
-  return cache.sessions;
-}
-function cacheProcs(cache) {
-  const now = Date.now();
-  if (now - cache.procsTs > 3e3) {
-    try {
-      cache.procs = findAgentProcesses();
-    } catch {
-    }
-    cache.procsTs = now;
-  }
-  return cache.procs;
-}
-function cacheDetail(cache, s) {
-  const entry = cache.details.get(s.id);
-  if (entry && Date.now() - entry.ts < 1e4) return entry.report;
-  let report = null;
-  try {
-    report = getAgentSessionReport(s.id, s.agent);
-  } catch {
-  }
-  cache.details.set(s.id, { report, ts: Date.now() });
-  if (cache.details.size > 15) {
-    const oldest = [...cache.details.entries()].sort((a, b) => a[1].ts - b[1].ts)[0];
-    if (oldest) cache.details.delete(oldest[0]);
-  }
-  return report;
-}
-function runBlessedDashboard(refreshSec, limit) {
-  const cache = createCache();
+function runReactiveDashboard(refreshSec, limit) {
+  const store = new DashboardStore(limit);
   const origTerm = process.env.TERM;
   if (origTerm?.includes("256color")) {
     process.env.TERM = "xterm";
@@ -1849,8 +2230,7 @@ function runBlessedDashboard(refreshSec, limit) {
     height: 3,
     tags: true,
     style: { fg: FG, bg: "#161b22", border: { fg: BORDER_COLOR } },
-    border: { type: "line" },
-    content: ""
+    border: { type: "line" }
   });
   const processBox = blessed.box({
     parent: screen,
@@ -1862,8 +2242,7 @@ function runBlessedDashboard(refreshSec, limit) {
     label: " {cyan-fg}{bold}Active Processes{/} ",
     scrollable: true,
     style: { fg: FG, bg: BG, border: { fg: BORDER_COLOR }, label: { fg: ACCENT } },
-    border: { type: "line" },
-    content: ""
+    border: { type: "line" }
   });
   const sessionList = blessed.list({
     parent: screen,
@@ -1905,7 +2284,7 @@ function runBlessedDashboard(refreshSec, limit) {
     scrollbar: { ch: "\u2502", style: { fg: ACCENT } },
     content: "{gray-fg}Select a session with \u2191\u2193 keys{/}"
   });
-  const footer = blessed.box({
+  blessed.box({
     parent: screen,
     bottom: 0,
     left: 0,
@@ -1916,19 +2295,18 @@ function runBlessedDashboard(refreshSec, limit) {
     border: { type: "line" },
     content: " {bold}\u2191\u2193{/} Navigate  {bold}Enter{/} Detail  {bold}Tab{/} Switch panel  {bold}r{/} Refresh  {bold}q{/} Quit"
   });
-  let sessions = [];
-  let procs = [];
   let selectedIdx = 0;
   let focusedPanel = "sessions";
-  let lastDetailId = "";
   function renderHeader() {
     const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB");
+    const sessions = store.sessions;
     const totalPremium = sessions.reduce((s, x) => s + x.premiumRequests, 0);
     const completedCount = sessions.filter((s) => s.complete).length;
-    const stats = headerStats(procs.length, sessions.length, totalPremium, completedCount);
+    const stats = headerStats(store.processes.length, sessions.length, totalPremium, completedCount);
     headerBox.setContent(` {bold}{cyan-fg}\u26A1 copilot-agent{/}  ${stats}  {gray-fg}${time}{/}`);
   }
   function renderProcesses2() {
+    const procs = store.processes;
     if (procs.length === 0) {
       processBox.setContent(" {gray-fg}No agent processes running{/}");
       return;
@@ -1939,51 +2317,65 @@ function runBlessedDashboard(refreshSec, limit) {
 ${rows.join("\n")}`);
   }
   function renderSessions() {
-    const items = sessions.map((s) => sessionRow(s));
+    const items = store.sessions.map((s) => sessionRow(s));
     sessionList.setItems(items);
     if (selectedIdx >= 0 && selectedIdx < items.length) {
       sessionList.select(selectedIdx);
     }
-    sessionList.setLabel(` {cyan-fg}{bold}Sessions (${sessions.length}){/} `);
-  }
-  function renderDetail2(force = false) {
-    if (sessions.length === 0 || selectedIdx < 0 || selectedIdx >= sessions.length) {
-      detailBox.setContent("{gray-fg}No session selected{/}");
-      lastDetailId = "";
-      return;
-    }
-    const s = sessions[selectedIdx];
-    if (!force && s.id === lastDetailId) return;
-    lastDetailId = s.id;
-    const report = cacheDetail(cache, s);
+    sessionList.setLabel(` {cyan-fg}{bold}Sessions (${store.sessions.length}){/} `);
+  }
+  function showQuickPreview(s) {
+    const project = s.cwd?.split("/").pop() || s.id.slice(0, 12);
+    const agent = s.agent === "claude" ? "{yellow-fg}claude{/}" : "{cyan-fg}copilot{/}";
+    const status = s.complete ? "{green-fg}\u2714 complete{/}" : "{yellow-fg}\u23F3 incomplete{/}";
+    detailBox.setContent([
+      `{bold}${project}{/}  ${agent}`,
+      `{gray-fg}${s.id}{/}`,
+      "",
+      ` Status     ${status}`,
+      ` Premium    {yellow-fg}${s.premiumRequests}{/}`,
+      ` Activity   ${fmtTimeAgo(s.mtime)}`,
+      ` Directory  {gray-fg}${s.cwd || "\u2014"}{/}`,
+      "",
+      "{gray-fg}Loading\u2026{/}"
+    ].join("\n"));
+    detailBox.setLabel(` {cyan-fg}{bold}Detail \u2014 ${s.id.slice(0, 12)}\u2026{/} `);
+  }
+  store.on("sessions", () => {
+    renderHeader();
+    renderSessions();
+    const s = store.sessions[selectedIdx];
+    if (s) store.requestDetail(s.id, s.agent);
+    screen.render();
+  });
+  store.on("processes", () => {
+    renderHeader();
+    renderProcesses2();
+    screen.render();
+  });
+  store.on("detail", (sessionId) => {
+    const currentSession = store.sessions[selectedIdx];
+    if (!currentSession || currentSession.id !== sessionId) return;
+    const report = store.details.get(sessionId);
     if (report) {
       detailBox.setContent(detailContent(report));
-      detailBox.setLabel(` {cyan-fg}{bold}Detail \u2014 ${s.id.slice(0, 12)}\u2026{/} `);
+      detailBox.setLabel(` {cyan-fg}{bold}Detail \u2014 ${sessionId.slice(0, 12)}\u2026{/} `);
     } else {
-      detailBox.setContent(`{gray-fg}Could not load report for ${s.id.slice(0, 8)}\u2026{/}`);
+      detailBox.setContent(`{gray-fg}No report data for ${sessionId.slice(0, 8)}\u2026{/}`);
     }
-  }
-  function render() {
-    sessions = cacheSessions(cache, limit);
-    procs = cacheProcs(cache);
+    screen.render();
+  });
+  const clockTimer = setInterval(() => {
     renderHeader();
-    renderProcesses2();
-    renderSessions();
-    renderDetail2();
     screen.render();
-  }
-  function forceRefresh() {
-    cache.sessionsTs = 0;
-    cache.procsTs = 0;
-    cache.details.clear();
-    lastDetailId = "";
-    render();
-  }
+  }, 5e3);
   screen.key(["q", "C-c"], () => {
+    store.stop();
+    clearInterval(clockTimer);
     screen.destroy();
     process.exit(0);
   });
-  screen.key(["r"], () => forceRefresh());
+  screen.key(["r"], () => store.forceRefresh());
   screen.key(["tab"], () => {
     if (focusedPanel === "sessions") {
       focusedPanel = "detail";
@@ -1998,29 +2390,40 @@ ${rows.join("\n")}`);
     }
     screen.render();
   });
+  function onNavigate() {
+    sessionList.select(selectedIdx);
+    const s = store.sessions[selectedIdx];
+    if (s) {
+      const cached = store.details.get(s.id);
+      if (cached) {
+        detailBox.setContent(detailContent(cached));
+        detailBox.setLabel(` {cyan-fg}{bold}Detail \u2014 ${s.id.slice(0, 12)}\u2026{/} `);
+      } else {
+        showQuickPreview(s);
+      }
+      store.requestDetail(s.id, s.agent);
+    }
+    screen.render();
+  }
   sessionList.on("select item", (_item, index) => {
     selectedIdx = index;
-    renderDetail2();
-    screen.render();
+    onNavigate();
   });
   sessionList.key(["up", "k"], () => {
     if (selectedIdx > 0) {
       selectedIdx--;
-      sessionList.select(selectedIdx);
-      renderDetail2();
-      screen.render();
+      onNavigate();
     }
   });
   sessionList.key(["down", "j"], () => {
-    if (selectedIdx < sessions.length - 1) {
+    if (selectedIdx < store.sessions.length - 1) {
       selectedIdx++;
-      sessionList.select(selectedIdx);
-      renderDetail2();
-      screen.render();
+      onNavigate();
     }
   });
   sessionList.key(["enter"], () => {
-    renderDetail2(true);
+    const s = store.sessions[selectedIdx];
+    if (s) store.requestDetailNow(s.id, s.agent);
     focusedPanel = "detail";
     detailBox.focus();
     sessionList.style.border.fg = BORDER_COLOR;
@@ -2029,9 +2432,7 @@ ${rows.join("\n")}`);
   });
   sessionList.focus();
   sessionList.style.border.fg = ACCENT;
-  render();
-  const timer = setInterval(render, refreshSec * 1e3);
-  screen.on("destroy", () => clearInterval(timer));
+  store.start(refreshSec * 1e3, 3e3);
 }
 
 // src/commands/web.ts
@@ -2434,19 +2835,19 @@ ${layoutFoot}`);
 import chalk from "chalk";
 
 // src/lib/config.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir5 } from "os";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir6 } from "os";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { findUpSync } from "find-up";
-var CONFIG_DIR = join7(homedir5(), ".copilot-agent");
-var GLOBAL_CONFIG = join7(CONFIG_DIR, "config.yaml");
+var CONFIG_DIR = join8(homedir6(), ".copilot-agent");
+var GLOBAL_CONFIG = join8(CONFIG_DIR, "config.yaml");
 var PROJECT_CONFIG_NAME = ".copilot-agent.yaml";
 function ensureConfigDir() {
-  if (!existsSync6(CONFIG_DIR)) mkdirSync4(CONFIG_DIR, { recursive: true });
+  if (!existsSync7(CONFIG_DIR)) mkdirSync4(CONFIG_DIR, { recursive: true });
 }
 function loadGlobalConfig() {
-  if (!existsSync6(GLOBAL_CONFIG)) return {};
+  if (!existsSync7(GLOBAL_CONFIG)) return {};
   try {
     return parseYaml(readFileSync4(GLOBAL_CONFIG, "utf-8")) || {};
   } catch {
@@ -2493,7 +2894,7 @@ function deleteConfigValue(key) {
   saveGlobalConfig(config);
 }
 function resetConfig() {
-  if (existsSync6(GLOBAL_CONFIG)) {
+  if (existsSync7(GLOBAL_CONFIG)) {
     writeFileSync2(GLOBAL_CONFIG, "", "utf-8");
   }
 }
@@ -2550,18 +2951,18 @@ function registerConfigCommand(program2) {
 // src/commands/proxy.ts
 import chalk2 from "chalk";
 import { execa } from "execa";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync5, unlinkSync } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir6 } from "os";
-var PID_FILE = join8(homedir6(), ".copilot-agent", "proxy.pid");
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync5, unlinkSync } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir7 } from "os";
+var PID_FILE = join9(homedir7(), ".copilot-agent", "proxy.pid");
 var DEFAULT_PORT = 4141;
 function ensureDir() {
-  const dir = join8(homedir6(), ".copilot-agent");
-  if (!existsSync7(dir)) mkdirSync5(dir, { recursive: true });
+  const dir = join9(homedir7(), ".copilot-agent");
+  if (!existsSync8(dir)) mkdirSync5(dir, { recursive: true });
 }
 function findCopilotToken() {
-  const appsPath = join8(homedir6(), ".config", "github-copilot", "apps.json");
-  if (!existsSync7(appsPath)) return null;
+  const appsPath = join9(homedir7(), ".config", "github-copilot", "apps.json");
+  if (!existsSync8(appsPath)) return null;
   try {
     const apps = JSON.parse(readFileSync5(appsPath, "utf-8"));
     for (const key of Object.keys(apps)) {
@@ -2574,7 +2975,7 @@ function findCopilotToken() {
   }
 }
 function readPid() {
-  if (!existsSync7(PID_FILE)) return null;
+  if (!existsSync8(PID_FILE)) return null;
   try {
     const pid = parseInt(readFileSync5(PID_FILE, "utf-8").trim(), 10);
     return isNaN(pid) ? null : pid;
@@ -2662,12 +3063,12 @@ function registerProxyCommand(program2) {
     }
     if (!isProcessRunning(pid)) {
       console.log(chalk2.dim(`  Proxy (PID ${pid}) is not running`));
-      if (existsSync7(PID_FILE)) unlinkSync(PID_FILE);
+      if (existsSync8(PID_FILE)) unlinkSync(PID_FILE);
       return;
     }
     try {
       process.kill(pid, "SIGTERM");
-      if (existsSync7(PID_FILE)) unlinkSync(PID_FILE);
+      if (existsSync8(PID_FILE)) unlinkSync(PID_FILE);
       console.log(chalk2.green(`  \u2714 Proxy stopped (PID ${pid})`));
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -2801,10 +3202,10 @@ function showDiff(sessionId, opts) {
 import chalk4 from "chalk";
 
 // src/lib/quota.ts
-import { join as join9 } from "path";
-import { homedir as homedir7 } from "os";
-var DATA_DIR = join9(homedir7(), ".copilot-agent");
-var USAGE_FILE = join9(DATA_DIR, "usage.jsonl");
+import { join as join10 } from "path";
+import { homedir as homedir8 } from "os";
+var DATA_DIR = join10(homedir8(), ".copilot-agent");
+var USAGE_FILE = join10(DATA_DIR, "usage.jsonl");
 function buildUsageSummary(days) {
   const sessions = listAllSessions(500);
   const cutoff = days ? Date.now() - days * 864e5 : 0;
@@ -2899,12 +3300,12 @@ function registerQuotaCommand(program2) {
 import chalk5 from "chalk";
 
 // src/lib/compact.ts
-import { writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
-import { join as join10 } from "path";
-import { homedir as homedir8 } from "os";
-var COMPACT_DIR = join10(homedir8(), ".copilot-agent", "compacts");
+import { writeFileSync as writeFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir9 } from "os";
+var COMPACT_DIR = join11(homedir9(), ".copilot-agent", "compacts");
 function ensureDir2() {
-  if (!existsSync8(COMPACT_DIR)) mkdirSync6(COMPACT_DIR, { recursive: true });
+  if (!existsSync9(COMPACT_DIR)) mkdirSync6(COMPACT_DIR, { recursive: true });
 }
 function compactSession(sessionId, agent) {
   const report = getAgentSessionReport(sessionId, agent);
@@ -2997,7 +3398,7 @@ function compactSession(sessionId, agent) {
 function saveCompact(compact) {
   ensureDir2();
   const filename = `${compact.sessionId.slice(0, 12)}.md`;
-  const filepath = join10(COMPACT_DIR, filename);
+  const filepath = join11(COMPACT_DIR, filename);
   writeFileSync4(filepath, compact.markdown, "utf-8");
   return filepath;
 }
@@ -3105,17 +3506,17 @@ function showCompact(sessionId, opts) {
 import chalk6 from "chalk";
 
 // src/lib/hooks.ts
-import { readFileSync as readFileSync6, existsSync as existsSync9 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir9 } from "os";
+import { readFileSync as readFileSync6, existsSync as existsSync10 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir10 } from "os";
 import { parse as parseYaml2 } from "yaml";
 import { findUpSync as findUpSync2 } from "find-up";
 import { execaCommand } from "execa";
-var GLOBAL_HOOKS = join11(homedir9(), ".copilot-agent", "hooks.yaml");
+var GLOBAL_HOOKS = join12(homedir10(), ".copilot-agent", "hooks.yaml");
 var PROJECT_HOOKS = ".copilot-agent/hooks.yaml";
 function loadHooksConfig(cwd) {
   const configs = [];
-  if (existsSync9(GLOBAL_HOOKS)) {
+  if (existsSync10(GLOBAL_HOOKS)) {
     try {
       const parsed = parseYaml2(readFileSync6(GLOBAL_HOOKS, "utf-8"));
       if (parsed) configs.push(parsed);
@@ -3377,17 +3778,17 @@ function formatDur(ms) {
 
 // src/commands/template.ts
 import chalk8 from "chalk";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
-import { join as join12 } from "path";
-import { homedir as homedir10 } from "os";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync11, mkdirSync as mkdirSync7 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir11 } from "os";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
-var CONFIG_DIR2 = join12(homedir10(), ".copilot-agent");
-var TEMPLATES_FILE = join12(CONFIG_DIR2, "templates.yaml");
+var CONFIG_DIR2 = join13(homedir11(), ".copilot-agent");
+var TEMPLATES_FILE = join13(CONFIG_DIR2, "templates.yaml");
 function ensureDir3() {
-  if (!existsSync10(CONFIG_DIR2)) mkdirSync7(CONFIG_DIR2, { recursive: true });
+  if (!existsSync11(CONFIG_DIR2)) mkdirSync7(CONFIG_DIR2, { recursive: true });
 }
 function loadTemplates() {
-  if (!existsSync10(TEMPLATES_FILE)) return [];
+  if (!existsSync11(TEMPLATES_FILE)) return [];
   try {
     const data = parseYaml3(readFileSync7(TEMPLATES_FILE, "utf-8"));
     return Array.isArray(data) ? data : [];
@@ -3617,15 +4018,15 @@ function fmtDur2(ms) {
 }
 
 // src/commands/multi.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
-import { join as join13, resolve as resolve7, basename as basename3 } from "path";
-import { homedir as homedir11 } from "os";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join14, resolve as resolve7, basename as basename4 } from "path";
+import { homedir as homedir12 } from "os";
 import chalk10 from "chalk";
 import { parse as parseYaml4, stringify as stringifyYaml3 } from "yaml";
-var CONFIG_DIR3 = join13(homedir11(), ".copilot-agent");
-var PROJECTS_FILE = join13(CONFIG_DIR3, "multi-projects.txt");
-var STATUS_FILE = join13(CONFIG_DIR3, "multi-status.yaml");
-var LOG_DIR = join13(CONFIG_DIR3, "multi-logs");
+var CONFIG_DIR3 = join14(homedir12(), ".copilot-agent");
+var PROJECTS_FILE = join14(CONFIG_DIR3, "multi-projects.txt");
+var STATUS_FILE = join14(CONFIG_DIR3, "multi-status.yaml");
+var LOG_DIR = join14(CONFIG_DIR3, "multi-logs");
 var MAX_CONCURRENCY = 3;
 function registerMultiCommand(program2) {
   program2.command("multi <action> [args...]").description("Multi-project orchestration \u2014 add/remove/list/run/status/research").option("-a, --agent <type>", "Agent to use (copilot or claude)", "copilot").option("--parallel", "Run projects in parallel (max 3 concurrent)").option("--cooldown <n>", "Cooldown between projects in seconds", "30").option("-s, --steps <n>", "Max steps per task", "10").option("--max-premium <n>", "Premium budget per project", "50").option("--dry-run", "Preview without executing").action(async (action, args, opts) => {
@@ -3668,7 +4069,7 @@ async function multiCommand(action, args, opts) {
 function ensureFiles() {
   mkdirSync8(LOG_DIR, { recursive: true });
   mkdirSync8(CONFIG_DIR3, { recursive: true });
-  if (!existsSync11(PROJECTS_FILE)) writeFileSync7(PROJECTS_FILE, "");
+  if (!existsSync12(PROJECTS_FILE)) writeFileSync7(PROJECTS_FILE, "");
 }
 function readProjects() {
   return readFileSync8(PROJECTS_FILE, "utf-8").split("\n").map((l) => l.trim()).filter(Boolean);
@@ -3677,7 +4078,7 @@ function writeProjects(projects) {
   writeFileSync7(PROJECTS_FILE, projects.join("\n") + "\n");
 }
 function readStatusFile() {
-  if (!existsSync11(STATUS_FILE)) return [];
+  if (!existsSync12(STATUS_FILE)) return [];
   try {
     const raw = readFileSync8(STATUS_FILE, "utf-8");
     const parsed = parseYaml4(raw);
@@ -3711,7 +4112,7 @@ async function addProject(path) {
     process.exit(1);
   }
   const resolved = resolve7(path);
-  if (!existsSync11(resolved)) {
+  if (!existsSync12(resolved)) {
     fail(`Not found: ${resolved}`);
     process.exit(1);
   }
@@ -3753,7 +4154,7 @@ function listProjects() {
   console.log(chalk10.bold("\nRegistered projects:"));
   for (let i = 0; i < projects.length; i++) {
     const p = projects[i];
-    const exists = existsSync11(p);
+    const exists = existsSync12(p);
     const icon = exists ? chalk10.green("\u2705") : chalk10.red("\u274C");
     const type = exists ? detectProjectType(p) : "?";
     const st = statuses.find((s) => s.project === p);
@@ -3772,7 +4173,7 @@ function showStatus() {
   for (const s of statuses) {
     const icon = s.status === "success" ? chalk10.green("\u2705") : s.status === "failed" ? chalk10.red("\u274C") : chalk10.yellow("\u{1F504}");
     console.log(
-      `  ${icon} ${chalk10.bold(basename3(s.project))} \u2014 ${s.agent} \u2014 ${s.tasks} tasks \u2014 ${s.duration} \u2014 ${chalk10.dim(s.lastRun)}`
+      `  ${icon} ${chalk10.bold(basename4(s.project))} \u2014 ${s.agent} \u2014 ${s.tasks} tasks \u2014 ${s.duration} \u2014 ${chalk10.dim(s.lastRun)}`
     );
   }
   console.log();
@@ -3802,7 +4203,7 @@ function createSemaphore(max) {
 async function runAll(mode, opts) {
   assertAgent(opts.agent);
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15);
-  setLogFile(join13(LOG_DIR, `multi-${mode}-${ts}.log`));
+  setLogFile(join14(LOG_DIR, `multi-${mode}-${ts}.log`));
   const projects = readProjects();
   if (projects.length === 0) {
     fail("No projects registered. Add: copilot-agent multi add <path>");
@@ -3811,10 +4212,10 @@ async function runAll(mode, opts) {
   log(`\u{1F3ED} Multi-project ${mode} \u2014 ${projects.length} projects \u2014 agent: ${opts.agent}${opts.parallel ? " (parallel)" : ""}`);
   if (opts.dryRun) {
     for (const p of projects) {
-      const type = existsSync11(p) ? detectProjectType(p) : "unknown";
+      const type = existsSync12(p) ? detectProjectType(p) : "unknown";
       const tasks = getTasksForProject(type);
       console.log(`
-${chalk10.bold(basename3(p))} (${type})`);
+${chalk10.bold(basename4(p))} (${type})`);
       for (const t of tasks.slice(0, 3)) {
         console.log(`  ${chalk10.dim("\u2022")} ${t.title}`);
       }
@@ -3860,8 +4261,8 @@ ${"\u2550".repeat(50)}`);
   notify(`Multi-${mode}: ${success}/${total} succeeded`, "copilot-agent");
 }
 async function runSingleProject(project, mode, opts) {
-  const name = existsSync11(project) ? detectProjectName(project) : basename3(project);
-  if (!existsSync11(project)) {
+  const name = existsSync12(project) ? detectProjectName(project) : basename4(project);
+  if (!existsSync12(project)) {
     warn(`Skipping (not found): ${project}`);
     return { name, success: false, skipped: true };
   }
@@ -4041,17 +4442,17 @@ function registerReviewCommand(program2) {
 }
 
 // src/commands/schedule.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync9 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir12 } from "os";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, existsSync as existsSync13, mkdirSync as mkdirSync9 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir13 } from "os";
 import { parse as parseYaml5, stringify as stringifyYaml4 } from "yaml";
-var CONFIG_DIR4 = join14(homedir12(), ".copilot-agent");
-var SCHEDULES_FILE = join14(CONFIG_DIR4, "schedules.yaml");
+var CONFIG_DIR4 = join15(homedir13(), ".copilot-agent");
+var SCHEDULES_FILE = join15(CONFIG_DIR4, "schedules.yaml");
 function ensureConfigDir2() {
-  if (!existsSync12(CONFIG_DIR4)) mkdirSync9(CONFIG_DIR4, { recursive: true });
+  if (!existsSync13(CONFIG_DIR4)) mkdirSync9(CONFIG_DIR4, { recursive: true });
 }
 function loadSchedules() {
-  if (!existsSync12(SCHEDULES_FILE)) return [];
+  if (!existsSync13(SCHEDULES_FILE)) return [];
   try {
     const raw = parseYaml5(readFileSync9(SCHEDULES_FILE, "utf-8"));
     return Array.isArray(raw) ? raw : [];
@@ -4290,7 +4691,7 @@ function registerScheduleCommand(program2) {
 
 // src/index.ts
 var program = new Command();
-program.name("copilot-agent").version("1.0.0").description("Autonomous AI agent manager \u2014 auto-resume, task discovery, overnight runs. Supports GitHub Copilot CLI + Claude Code.");
+program.name("copilot-agent").version("1.1.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);