copilot-agent 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,11 +1,6 @@
-#!/usr/bin/env node
-
 // src/index.ts
 import { Command } from "commander";
 
-// src/commands/status.ts
-import chalk from "chalk";
-
 // src/lib/session.ts
 import {
   existsSync,
@@ -138,6 +133,7 @@ function findLatestIncomplete() {
 
 // src/lib/process.ts
 import { execSync as execSync2, spawn } from "child_process";
+import { resolve as resolve2 } from "path";
 
 // src/lib/logger.ts
 import { appendFileSync, mkdirSync } from "fs";
@@ -148,6 +144,9 @@ import { execSync } from "child_process";
 var RED = "\x1B[31m";
 var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
+var CYAN = "\x1B[36m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
 
 // src/lib/logger.ts
@@ -186,6 +185,11 @@ function fail(msg) {
   console.error(out);
   writeToFile(`\u2716 ${msg}`);
 }
+function info(msg) {
+  const out = `${CYAN}\u2139 ${msg}${RESET}`;
+  console.log(out);
+  writeToFile(`\u2139 ${msg}`);
+}
 function notify(message, title = "copilot-agent") {
   try {
     if (process.platform === "darwin") {
@@ -226,19 +230,31 @@ function findCopilotProcesses() {
   try {
     const output = execSync2("ps -eo pid,command", { encoding: "utf-8" });
     const results = [];
+    const myPid = process.pid;
+    const parentPid = process.ppid;
     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})/);
-          results.push({
-            pid: parseInt(match[1], 10),
-            command: cmd,
-            sessionId: sidMatch?.[1]
-          });
+          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 });
         }
       }
     }
@@ -252,6 +268,35 @@ function findPidForSession(sid) {
   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) {
+  const targetDir = resolve2(dir);
+  const start = Date.now();
+  let warned = false;
+  while (Date.now() - start < timeoutMs) {
+    const procs = findCopilotProcesses();
+    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...`);
+      for (const p of conflicting) {
+        log(`  PID ${p.pid}: ${p.command.slice(0, 80)}`);
+      }
+      warned = true;
+    }
+    await sleep(pollMs);
+  }
+  warn("Timeout waiting for copilot to finish in directory");
+}
+function assertSessionNotRunning(sid) {
+  const pid = findPidForSession(sid);
+  if (pid) {
+    fail(`Session ${sid.slice(0, 8)}\u2026 already has copilot running (PID ${pid}). Cannot resume \u2014 would corrupt the session.`);
+    process.exit(1);
+  }
+}
 async function waitForExit(pid, timeoutMs = 144e5) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
@@ -264,8 +309,10 @@ async function waitForExit(pid, timeoutMs = 144e5) {
   }
   return false;
 }
-function runCopilot(args, options) {
-  return new Promise((resolve4) => {
+async function runCopilot(args, options) {
+  const dir = options?.cwd ?? process.cwd();
+  await waitForCopilotInDir(dir);
+  return new Promise((resolve6) => {
     const child = spawn("copilot", args, {
       cwd: options?.cwd,
       stdio: "inherit",
@@ -275,18 +322,19 @@ function runCopilot(args, options) {
       await sleep(3e3);
       const sid = getLatestSessionId();
       const premium = sid ? getSessionPremium(sid) : 0;
-      resolve4({
+      resolve6({
         exitCode: code ?? 1,
         sessionId: sid,
         premium
       });
     });
     child.on("error", () => {
-      resolve4({ exitCode: 1, sessionId: null, premium: 0 });
+      resolve6({ exitCode: 1, sessionId: null, premium: 0 });
     });
   });
 }
 function runCopilotResume(sid, steps, message, cwd) {
+  assertSessionNotRunning(sid);
   const args = [
     `--resume=${sid}`,
     "--autopilot",
@@ -314,61 +362,77 @@ function sleep(ms) {
 }
 
 // src/commands/status.ts
-async function statusCommand(opts) {
-  if (opts.active) {
-    return showActive();
-  }
-  showRecent(opts.limit);
+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) => {
+    if (opts.active) {
+      showActive();
+    } else {
+      showRecent(parseInt(opts.limit, 10), opts.incomplete ?? false);
+    }
+  });
 }
-async function showActive() {
-  const procs = await findCopilotProcesses();
+function showActive() {
+  const procs = findCopilotProcesses();
   if (procs.length === 0) {
-    log("No active copilot processes.");
+    log(`${DIM}No active copilot processes.${RESET}`);
     return;
   }
-  console.log(
-    chalk.bold(
-      `
-${"PID".padEnd(8)} ${"Session".padEnd(40)} ${"Command".slice(0, 60)}`
-    )
-  );
-  console.log("\u2500".repeat(108));
+  log(`
+${BOLD}${"PID".padEnd(8)} ${"Session".padEnd(40)} Command${RESET}`);
+  log("\u2500".repeat(108));
   for (const p of procs) {
-    console.log(
-      `${String(p.pid).padEnd(8)} ${(p.sessionId ?? "\u2014").padEnd(40)} ${(p.command ?? "").slice(0, 60)}`
+    log(
+      `${CYAN}${String(p.pid).padEnd(8)}${RESET} ${(p.sessionId ?? "\u2014").padEnd(40)} ${truncate(p.command, 58)}`
     );
   }
-  console.log();
+  log("");
 }
-function showRecent(limit) {
-  const sessions = listSessions(limit);
+function showRecent(limit, incompleteOnly) {
+  let sessions = listSessions(limit);
+  if (incompleteOnly) {
+    sessions = sessions.filter((s) => !s.complete);
+  }
   if (sessions.length === 0) {
-    log("No sessions found.");
+    log(`${DIM}No sessions found.${RESET}`);
     return;
   }
-  console.log(
-    chalk.bold(
-      `
-${"Status".padEnd(10)} ${"Premium".padEnd(10)} ${"Last Event".padEnd(25)} ${"Summary".padEnd(40)} ${"ID"}`
-    )
+  log(
+    `
+${BOLD}${"Status".padEnd(10)} ${"Premium".padEnd(10)} ${"Last Event".padEnd(25)} ${"Summary".padEnd(40)} ID${RESET}`
   );
-  console.log("\u2500".repeat(120));
+  log("\u2500".repeat(120));
   for (const s of sessions) {
-    const done = hasTaskComplete(s.id);
-    const status = done ? chalk.green("\u2705 done") : chalk.yellow("\u23F8\uFE0F  stopped");
-    const premium = String(getSessionPremium(s.id));
-    const lastEvt = getLastEvent(s.id);
-    const summary = (s.summary ?? "\u2014").slice(0, 38);
-    console.log(
-      `${status.padEnd(20)} ${premium.padEnd(10)} ${lastEvt.padEnd(25)} ${summary.padEnd(40)} ${chalk.dim(s.id)}`
+    const status = s.complete ? `${GREEN}\u2714 done${RESET}` : `${YELLOW}\u23F8 stop${RESET}`;
+    const premium = String(s.premiumRequests);
+    const summary = truncate(s.summary || "\u2014", 38);
+    log(
+      `${status.padEnd(10 + 9)} ${premium.padEnd(10)} ${s.lastEvent.padEnd(25)} ${summary.padEnd(40)} ${DIM}${s.id}${RESET}`
     );
   }
-  console.log();
+  log(`
+${DIM}Total: ${sessions.length} session(s)${RESET}`);
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.substring(0, max - 1) + "\u2026";
 }
 
 // src/commands/watch.ts
-import chalk2 from "chalk";
-import ora from "ora";
+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) => {
+    try {
+      await watchCommand(sid, {
+        steps: parseInt(opts.steps, 10),
+        maxResumes: parseInt(opts.maxResumes, 10),
+        cooldown: parseInt(opts.cooldown, 10),
+        message: opts.message
+      });
+    } catch (err) {
+      fail(`Watch error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+}
 async function watchCommand(sid, opts) {
   assertCopilot();
   if (!sid) {
@@ -377,7 +441,7 @@ async function watchCommand(sid, opts) {
       fail("No incomplete session found.");
       process.exit(1);
     }
-    log(`Auto-detected incomplete session: ${chalk2.cyan(sid)}`);
+    info(`Auto-detected incomplete session: ${CYAN}${sid}${RESET}`);
   }
   if (!validateSession(sid)) {
     fail(`Invalid session: ${sid}`);
@@ -389,13 +453,10 @@ async function watchCommand(sid, opts) {
   }
   let resumes = 0;
   while (resumes < opts.maxResumes) {
-    const pid = await findPidForSession(sid);
+    const pid = findPidForSession(sid);
     if (pid) {
-      const spinner = ora(
-        `Watching PID ${pid} for session ${chalk2.cyan(sid.slice(0, 8))}\u2026`
-      ).start();
+      info(`Watching PID ${pid} for session ${CYAN}${sid.slice(0, 8)}${RESET}\u2026`);
       const exited = await waitForExit(pid);
-      spinner.stop();
       if (!exited) {
         warn("Timeout waiting for process exit.");
         break;
@@ -403,19 +464,25 @@ async function watchCommand(sid, opts) {
     }
     await sleep2(3e3);
     if (hasTaskComplete(sid)) {
-      ok(
-        `Task complete! Summary: ${getSessionSummary(sid) || "none"}`
-      );
+      ok(`Task complete! Summary: ${getSessionSummary(sid) || "none"}`);
       notify("Task completed!", `Session ${sid.slice(0, 8)}`);
       return;
     }
     resumes++;
-    log(
-      `Session interrupted (${getLastEvent(sid)}). Resume ${resumes}/${opts.maxResumes}\u2026`
+    log(`Session interrupted (${getLastEvent(sid)}). Resume ${resumes}/${opts.maxResumes}\u2026`);
+    if (opts.cooldown > 0 && resumes > 1) {
+      info(`Cooldown ${opts.cooldown}s...`);
+      await sleep2(opts.cooldown * 1e3);
+    }
+    const cwd = getSessionCwd(sid) || void 0;
+    const result = await runCopilotResume(
+      sid,
+      opts.steps,
+      opts.message ?? "Continue remaining work. Pick up where you left off and complete the task.",
+      cwd
     );
-    const result = await runCopilotResume(sid, opts.steps, opts.message);
     if (result.sessionId && result.sessionId !== sid) {
-      log(`New session created: ${chalk2.cyan(result.sessionId)}`);
+      info(`New session created: ${CYAN}${result.sessionId}${RESET}`);
       sid = result.sessionId;
     }
   }
@@ -426,13 +493,9 @@ function sleep2(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
-// src/commands/run.ts
-import chalk3 from "chalk";
-import ora2 from "ora";
-
 // src/lib/detect.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join2, basename, resolve as resolve2 } from "path";
+import { join as join2, basename, resolve as resolve3 } from "path";
 import { execSync as execSync3 } from "child_process";
 function detectProjectType(dir) {
   const exists = (f) => existsSync2(join2(dir, f));
@@ -477,7 +540,28 @@ function detectProjectName(dir) {
     if (pkg.name) return pkg.name;
   } catch {
   }
-  return basename(resolve2(dir));
+  return basename(resolve3(dir));
+}
+function detectMainBranch(dir) {
+  try {
+    const ref = execSync3("git symbolic-ref refs/remotes/origin/HEAD", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return ref.split("/").pop() ?? "main";
+  } catch {
+  }
+  try {
+    const branch = execSync3("git branch --show-current", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (branch) return branch;
+  } catch {
+  }
+  return "main";
 }
 
 // src/lib/tasks.ts
@@ -634,7 +718,7 @@ async function withLock(name, fn) {
 
 // src/lib/git.ts
 import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
+import { join as join4, resolve as resolve4 } from "path";
 import { execSync as execSync4 } from "child_process";
 function gitExec(dir, cmd) {
   try {
@@ -659,16 +743,41 @@ function gitStash(dir) {
 function gitCheckout(dir, branch) {
   return gitExec(dir, `git checkout ${branch} -q`) !== null;
 }
+function gitCreateBranch(dir, branch) {
+  return gitExec(dir, `git checkout -b ${branch}`) !== null;
+}
+function gitCountCommits(dir, from, to) {
+  const result = gitExec(dir, `git log ${from}..${to} --oneline`);
+  if (!result) return 0;
+  return result.split("\n").filter((l) => l.trim()).length;
+}
 function gitStatus(dir) {
   return gitExec(dir, "git status --porcelain") ?? "";
 }
 
 // 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").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
+      });
+    } catch (err) {
+      fail(`Run error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+}
 async function runCommand(dir, opts) {
   assertCopilot();
   const projectType = detectProjectType(dir);
   const name = detectProjectName(dir);
-  log(`Project: ${chalk3.cyan(name)} (${projectType})`);
+  const mainBranch = isGitRepo(dir) ? detectMainBranch(dir) : null;
+  info(`Project: ${CYAN}${name}${RESET} (${projectType})`);
+  if (mainBranch) info(`Main branch: ${mainBranch}`);
   const tasks = getTasksForProject(projectType).slice(0, opts.maxTasks);
   if (tasks.length === 0) {
     warn("No tasks found for this project type.");
@@ -676,594 +785,244 @@ async function runCommand(dir, opts) {
   }
   log(`Found ${tasks.length} tasks:`);
   for (const t of tasks) {
-    console.log(`  ${chalk3.dim("\u2022")} ${t.title}`);
+    log(`  ${DIM}\u2022${RESET} ${t.title}`);
   }
   if (opts.dryRun) {
-    log(chalk3.dim("(dry-run \u2014 not executing)"));
+    log(`${DIM}(dry-run \u2014 not executing)${RESET}`);
     return;
   }
   const originalBranch = isGitRepo(dir) ? gitCurrentBranch(dir) : null;
   let completed = 0;
   let premiumTotal = 0;
   for (const task of tasks) {
+    if (premiumTotal >= opts.maxPremium) {
+      warn(`Premium request limit reached (${premiumTotal}/${opts.maxPremium}).`);
+      break;
+    }
     log(`
 ${"\u2550".repeat(60)}`);
-    log(`Task: ${chalk3.bold(task.title)}`);
+    log(`${BOLD}${CYAN}Task: ${task.title}${RESET}`);
     log(`${"\u2550".repeat(60)}`);
-    if (originalBranch && isGitRepo(dir)) {
-      const branch = `copilot-agent/${task.title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
-      try {
-        if (gitStatus(dir)) gitStash(dir);
-        gitCheckout(dir, branch);
-      } catch (e) {
-        warn(`Could not create branch ${branch}, continuing on current.`);
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 6);
+    const branchName = `agent/fix-${completed + 1}-${timestamp}-${random}`;
+    if (mainBranch && isGitRepo(dir)) {
+      if (gitStatus(dir)) gitStash(dir);
+      gitCheckout(dir, mainBranch);
+      if (!gitCreateBranch(dir, branchName)) {
+        warn(`Could not create branch ${branchName}, continuing on current.`);
       }
     }
-    const spinner = ora2(`Running: ${task.title}\u2026`).start();
+    info(`Running: ${task.title}\u2026`);
     const result = await withLock(
       "copilot-run",
-      () => runCopilotTask(task.prompt, opts.steps)
+      () => runCopilotTask(task.prompt, opts.steps, dir)
     );
-    spinner.stop();
+    const commits = mainBranch ? gitCountCommits(dir, mainBranch, "HEAD") : 0;
     premiumTotal += result.premium;
     completed++;
-    ok(`${task.title} \u2014 exit ${result.exitCode}, premium: ${result.premium}`);
+    ok(`${task.title} \u2014 ${commits} commit(s), ${result.premium} premium`);
     if (originalBranch && isGitRepo(dir)) {
-      try {
-        gitCheckout(dir, originalBranch);
-      } catch {
-      }
+      gitCheckout(dir, mainBranch ?? originalBranch);
     }
   }
   log(`
-Completed ${completed}/${tasks.length} tasks. Total premium: ${premiumTotal}`);
+${BOLD}\u2550\u2550\u2550 Run Summary \u2550\u2550\u2550${RESET}`);
+  log(`Completed ${completed}/${tasks.length} tasks. Total premium: ${premiumTotal}`);
   notify(`Completed ${completed} tasks`, name);
 }
 
 // src/commands/overnight.ts
-import chalk4 from "chalk";
-import ora3 from "ora";
 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").action(async (dir, opts) => {
+    try {
+      await overnightCommand(dir ?? process.cwd(), {
+        until: parseInt(opts.until, 10),
+        steps: parseInt(opts.steps, 10),
+        cooldown: parseInt(opts.cooldown, 10),
+        maxPremium: parseInt(opts.maxPremium, 10),
+        dryRun: opts.dryRun ?? false
+      });
+    } catch (err) {
+      fail(`Overnight error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+}
+function isPastDeadline(untilHour) {
+  const hour = (/* @__PURE__ */ new Date()).getHours();
+  return hour >= untilHour && hour < 20;
+}
 async function overnightCommand(dir, opts) {
   assertCopilot();
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15);
-  const logPath = join5(
-    homedir3(),
-    ".copilot",
-    "auto-resume-logs",
-    `overnight-${ts}.log`
-  );
+  const logPath = join5(homedir3(), ".copilot", "auto-resume-logs", `overnight-${ts}.log`);
   setLogFile(logPath);
-  const deadline = parseDeadline(opts.until);
   const name = detectProjectName(dir);
   const projectType = detectProjectType(dir);
-  log(`Overnight runner for ${chalk4.cyan(name)} (${projectType})`);
-  log(`Deadline: ${opts.until} (${msToHuman(deadline - Date.now())} from now)`);
-  log(`Max premium: ${opts.maxPremium}, Steps: ${opts.steps}`);
-  log(`Log: ${logPath}`);
+  const mainBranch = isGitRepo(dir) ? detectMainBranch(dir) : null;
+  info(`Overnight runner for ${CYAN}${name}${RESET} (${projectType})`);
+  info(`Deadline: ${String(opts.until).padStart(2, "0")}:00`);
+  info(`Max premium: ${opts.maxPremium}, Steps: ${opts.steps}`);
+  info(`Log: ${logPath}`);
+  const tasks = getTasksForProject(projectType);
   if (opts.dryRun) {
-    const tasks2 = getTasksForProject(projectType);
     log(`
-Would run ${tasks2.length} tasks:`);
-    for (const t of tasks2) console.log(`  ${chalk4.dim("\u2022")} ${t.title}`);
+Would run ${tasks.length} tasks:`);
+    for (const t of tasks) log(`  ${DIM}\u2022${RESET} ${t.title}`);
     return;
   }
-  const tasks = getTasksForProject(projectType);
+  const existingSession = findLatestIncomplete();
+  if (existingSession && validateSession(existingSession)) {
+    info(`Found incomplete session: ${existingSession}`);
+    const pid = findPidForSession(existingSession);
+    if (pid) {
+      info(`Waiting for running copilot (PID ${pid})...`);
+      await waitForExit(pid);
+    }
+    if (!hasTaskComplete(existingSession) && !isPastDeadline(opts.until)) {
+      info("Resuming incomplete session...");
+      const cwd = getSessionCwd(existingSession) || dir;
+      await runCopilotResume(
+        existingSession,
+        opts.steps,
+        "Continue remaining work. Complete the task.",
+        cwd
+      );
+    }
+  }
+  const originalBranch = isGitRepo(dir) ? gitCurrentBranch(dir) : null;
   let taskIdx = 0;
   let totalPremium = 0;
-  let completedTasks = 0;
-  let cycle = 0;
-  while (Date.now() < deadline) {
+  let totalCommits = 0;
+  while (!isPastDeadline(opts.until) && taskIdx < tasks.length) {
     if (totalPremium >= opts.maxPremium) {
       warn(`Premium budget exhausted: ${totalPremium}/${opts.maxPremium}`);
       break;
     }
     const task = tasks[taskIdx % tasks.length];
-    cycle++;
     taskIdx++;
     log(`
 ${"\u2550".repeat(60)}`);
-    log(
-      `Cycle ${cycle} | Task: ${chalk4.bold(task.title)} | Premium: ${totalPremium}/${opts.maxPremium}`
-    );
-    log(`Time remaining: ${msToHuman(deadline - Date.now())}`);
+    log(`${BOLD}${CYAN}[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Task ${taskIdx}: ${task.title}${RESET}`);
+    log(`${DIM}Premium: ${totalPremium}/${opts.maxPremium}${RESET}`);
     log(`${"\u2550".repeat(60)}`);
-    const spinner = ora3(`Running: ${task.title}\u2026`).start();
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 6);
+    const branchName = `agent/overnight-${taskIdx}-${timestamp}-${random}`;
+    if (mainBranch && isGitRepo(dir)) {
+      gitStash(dir);
+      gitCheckout(dir, mainBranch);
+      gitCreateBranch(dir, branchName);
+    }
+    info(`Running: ${task.title}\u2026`);
     try {
       const result = await withLock(
         "copilot-overnight",
-        () => runCopilotTask(task.prompt, opts.steps)
+        () => runCopilotTask(task.prompt, opts.steps, dir)
       );
-      spinner.stop();
+      const commits = mainBranch ? gitCountCommits(dir, mainBranch, "HEAD") : 0;
       totalPremium += result.premium;
-      completedTasks++;
-      ok(
-        `${task.title} \u2014 exit ${result.exitCode}, premium: ${result.premium}`
-      );
+      totalCommits += commits;
+      if (commits > 0) {
+        ok(`${commits} commit(s) on ${branchName}`);
+      } else {
+        log(`${DIM}No commits on ${branchName}${RESET}`);
+      }
     } catch (err) {
-      spinner.stop();
       fail(`Task failed: ${err}`);
     }
-    if (Date.now() < deadline) {
-      log("Cooldown 30s\u2026");
-      await sleep3(3e4);
+    if (mainBranch && isGitRepo(dir)) {
+      gitCheckout(dir, mainBranch);
     }
+    if (!isPastDeadline(opts.until)) {
+      info(`Cooldown ${opts.cooldown}s\u2026`);
+      await sleep3(opts.cooldown * 1e3);
+    }
+  }
+  if (originalBranch && isGitRepo(dir)) {
+    gitCheckout(dir, originalBranch);
   }
-  const summary = `Overnight done. ${completedTasks} tasks, ${totalPremium} premium.`;
-  log(summary);
+  const summary = `Overnight done \u2014 ${taskIdx} tasks, ${totalCommits} commits, ${totalPremium} premium.`;
+  ok(summary);
   notify(summary, name);
 }
-function parseDeadline(hhmm) {
-  const [h, m] = hhmm.split(":").map(Number);
-  const now = /* @__PURE__ */ new Date();
-  const target = new Date(now);
-  target.setHours(h, m, 0, 0);
-  if (target <= now) target.setDate(target.getDate() + 1);
-  return target.getTime();
-}
-function msToHuman(ms) {
-  const h = Math.floor(ms / 36e5);
-  const m = Math.floor(ms % 36e5 / 6e4);
-  return `${h}h ${m}m`;
-}
 function sleep3(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
 // src/commands/research.ts
-import chalk5 from "chalk";
-var RESEARCH_PROMPTS = [
-  {
-    title: "Dependency updates",
-    prompt: "Research the latest versions of all dependencies. Check changelogs for breaking changes. Create a summary of what can be safely updated."
-  },
-  {
-    title: "Performance review",
-    prompt: "Profile the application for performance bottlenecks. Check startup time, memory usage, and hot paths. Suggest optimizations with benchmarks."
-  },
-  {
-    title: "Architecture review",
-    prompt: "Review the project architecture. Check for code smells, circular dependencies, and coupling issues. Suggest improvements following clean architecture."
-  },
-  {
-    title: "Accessibility audit",
-    prompt: "Audit the UI for accessibility issues. Check color contrast, screen reader support, and keyboard navigation. Create a report."
-  },
-  {
-    title: "Best practices",
-    prompt: "Compare the codebase against current best practices for this framework/language. Identify gaps and suggest improvements."
-  }
-];
-async function researchCommand(topic, opts) {
-  assertCopilot();
-  if (topic) {
-    log(`Research topic: ${chalk5.cyan(topic)}`);
-    const result = await withLock(
-      "copilot-research",
-      () => runCopilotTask(
-        `Research the following topic and create a detailed report: ${topic}`,
-        opts.steps
-      )
-    );
-    ok(`Research complete \u2014 premium: ${result.premium}`);
-    notify("Research complete", topic.slice(0, 30));
-    return;
-  }
-  log("Running predefined research tasks\u2026");
-  for (const r of RESEARCH_PROMPTS) {
-    log(`
-${chalk5.bold(r.title)}`);
-    try {
-      const result = await withLock(
-        "copilot-research",
-        () => runCopilotTask(r.prompt, opts.steps)
-      );
-      ok(`${r.title} \u2014 premium: ${result.premium}`);
-    } catch (err) {
-      fail(`${r.title} failed: ${err}`);
-    }
-  }
-  notify("All research tasks complete");
-}
-
-// src/commands/daemon.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync2, unlinkSync, statSync as statSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, copyFileSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join6, resolve as resolve5 } from "path";
 import { homedir as homedir4 } from "os";
-import { spawn as spawn2 } from "child_process";
-var PID_FILE = join6(homedir4(), ".copilot", "watchdog.pid");
-var LOG_FILE = join6(homedir4(), ".copilot", "auto-resume-logs", "watchdog.log");
-var SESSION_DIR2 = join6(homedir4(), ".copilot", "session-state");
-async function daemonCommand(action, opts) {
-  switch (action) {
-    case "start":
-      return startDaemon(opts);
-    case "stop":
-      return stopDaemon();
-    case "status":
-      return statusDaemon();
-    case "logs":
-      return showLogs();
-    default:
-      fail(`Unknown action: ${action}. Use: start, stop, status, logs`);
-      process.exit(1);
-  }
-}
-function isDaemonRunning() {
-  if (!existsSync5(PID_FILE)) return { running: false };
-  try {
-    const pid = parseInt(readFileSync4(PID_FILE, "utf-8").trim());
-    process.kill(pid, 0);
-    return { running: true, pid };
-  } catch {
-    return { running: false };
-  }
-}
-async function startDaemon(opts) {
-  assertCopilot();
-  const { running, pid } = isDaemonRunning();
-  if (running) {
-    fail(`Watchdog already running (PID: ${pid}). Use 'copilot-agent daemon stop' first.`);
-    process.exit(1);
-  }
-  if (existsSync5(PID_FILE)) {
-    unlinkSync(PID_FILE);
-  }
-  log(`\u{1F415} Starting watchdog daemon (poll: ${opts.poll}s, auto-resume: ${opts.resume})`);
-  log(`   Log: ${LOG_FILE}`);
-  const child = spawn2(
-    process.execPath,
-    [
-      process.argv[1],
-      "daemon",
-      "_loop",
-      "--poll",
-      String(opts.poll),
-      "--idle",
-      String(opts.idle),
-      "--steps",
-      String(opts.steps),
-      ...opts.resume ? ["--resume"] : []
-    ],
-    {
-      detached: true,
-      stdio: "ignore"
-    }
-  );
-  child.unref();
-  if (child.pid) {
-    writeFileSync2(PID_FILE, String(child.pid));
-    ok(`Watchdog started (PID: ${child.pid})`);
-  } else {
-    fail("Failed to start watchdog");
-  }
-}
-async function stopDaemon() {
-  const { running, pid } = isDaemonRunning();
-  if (!running) {
-    warn("Watchdog is not running.");
-    return;
-  }
-  try {
-    process.kill(pid, "SIGTERM");
-    ok(`Watchdog stopped (PID: ${pid})`);
-  } catch {
-    fail(`Could not stop PID ${pid}`);
-  }
-  try {
-    unlinkSync(PID_FILE);
-  } catch {
-  }
-}
-async function statusDaemon() {
-  const { running, pid } = isDaemonRunning();
-  if (running) {
-    ok(`Watchdog running (PID: ${pid})`);
-    if (existsSync5(LOG_FILE)) {
-      const stat = statSync2(LOG_FILE);
-      log(`Log: ${LOG_FILE} (${(stat.size / 1024).toFixed(1)} KB)`);
-    }
-  } else {
-    log("Watchdog is not running.");
-  }
-}
-async function showLogs() {
-  if (!existsSync5(LOG_FILE)) {
-    log("No log file found.");
-    return;
-  }
-  const lines = readFileSync4(LOG_FILE, "utf-8").trimEnd().split("\n");
-  const tail = lines.slice(-30);
-  for (const line of tail) console.log(line);
-}
-async function daemonLoop(opts) {
-  setLogFile(LOG_FILE);
-  log(`\u{1F415} Watchdog daemon loop started (PID: ${process.pid})`);
-  let lastAlertedSid = "";
-  const shutdown = () => {
-    log("Watchdog shutting down");
-    try {
-      unlinkSync(PID_FILE);
-    } catch {
-    }
-    process.exit(0);
-  };
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
-  while (true) {
-    await sleep4(opts.poll * 1e3);
+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) => {
     try {
-      const sid = getLatestSessionId();
-      if (!sid || !validateSession(sid)) continue;
-      if (sid === lastAlertedSid && hasTaskComplete(sid)) continue;
-      const pid = await findPidForSession(sid);
-      if (pid) continue;
-      if (hasTaskComplete(sid)) {
-        if (sid !== lastAlertedSid) {
-          log(`\u2705 Session ${sid.slice(0, 8)} completed: ${getSessionSummary(sid).slice(0, 60)}`);
-          notify("Task completed", `Session ${sid.slice(0, 8)}`);
-          lastAlertedSid = sid;
-        }
-        continue;
-      }
-      const eventsPath = join6(SESSION_DIR2, sid, "events.jsonl");
-      const mtime = statSync2(eventsPath).mtimeMs;
-      const idleMinutes = (Date.now() - mtime) / 6e4;
-      if (idleMinutes < opts.idle) continue;
-      log(`\u23F8\uFE0F  Session ${sid.slice(0, 8)} idle ${idleMinutes.toFixed(0)}m (last: ${getLastEvent(sid)})`);
-      if (opts.resume) {
-        log(`\u{1F504} Auto-resuming session ${sid.slice(0, 8)}\u2026`);
-        lastAlertedSid = sid;
-        try {
-          await withLock("watchdog-resume", async () => {
-            const result = await runCopilotResume(sid, opts.steps);
-            ok(`Resume done \u2014 exit ${result.exitCode}, premium: ${result.premium}`);
-          });
-        } catch (err) {
-          fail(`Resume failed: ${err}`);
-        }
-      } else {
-        if (sid !== lastAlertedSid) {
-          warn(`Session ${sid.slice(0, 8)} needs attention (idle ${idleMinutes.toFixed(0)}m)`);
-          notify("Session interrupted", `${sid.slice(0, 8)} idle ${idleMinutes.toFixed(0)}m`);
-          lastAlertedSid = sid;
-        }
-      }
+      await researchCommand(project ?? process.cwd(), {
+        steps: parseInt(opts.steps, 10)
+      });
     } catch (err) {
-      fail(`Watchdog error: ${err}`);
-    }
-  }
-}
-function sleep4(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-// src/commands/multi.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7, resolve as resolve3, basename as basename2 } from "path";
-import { homedir as homedir5 } from "os";
-import chalk6 from "chalk";
-var PROJECTS_FILE = join7(homedir5(), ".copilot", "autonomous-projects.txt");
-var LOG_DIR = join7(homedir5(), ".copilot", "auto-resume-logs");
-async function multiCommand(action, args, opts) {
-  ensureFiles();
-  switch (action) {
-    case "add":
-      return addProject(args[0]);
-    case "remove":
-      return removeProject(args[0]);
-    case "list":
-      return listProjects();
-    case "health":
-    case "research":
-      return runAll(action, opts);
-    default:
-      fail(`Unknown action: ${action}. Use: add, remove, list, health, research`);
+      fail(`Research error: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
-  }
-}
-function ensureFiles() {
-  mkdirSync3(LOG_DIR, { recursive: true });
-  if (!existsSync6(PROJECTS_FILE)) writeFileSync3(PROJECTS_FILE, "");
-}
-function readProjects() {
-  return readFileSync5(PROJECTS_FILE, "utf-8").split("\n").map((l) => l.trim()).filter(Boolean);
-}
-function writeProjects(projects) {
-  writeFileSync3(PROJECTS_FILE, projects.join("\n") + "\n");
-}
-async function addProject(path) {
-  if (!path) {
-    fail("Usage: copilot-agent multi add <path>");
-    process.exit(1);
-  }
-  const resolved = resolve3(path);
-  if (!existsSync6(resolved)) {
-    fail(`Not found: ${resolved}`);
-    process.exit(1);
-  }
-  await withLock("projects-file", async () => {
-    const projects = readProjects();
-    if (projects.includes(resolved)) {
-      warn(`Already registered: ${resolved}`);
-      return;
-    }
-    projects.push(resolved);
-    writeProjects(projects);
-    ok(`Added: ${resolved}`);
-  });
-}
-async function removeProject(path) {
-  if (!path) {
-    fail("Usage: copilot-agent multi remove <path>");
-    process.exit(1);
-  }
-  const resolved = resolve3(path);
-  await withLock("projects-file", async () => {
-    const projects = readProjects();
-    const filtered = projects.filter((p) => p !== resolved);
-    if (filtered.length === projects.length) {
-      warn(`Not registered: ${resolved}`);
-      return;
     }
-    writeProjects(filtered);
-    ok(`Removed: ${resolved}`);
   });
 }
-function listProjects() {
-  const projects = readProjects();
-  if (projects.length === 0) {
-    log("No projects registered. Add: copilot-agent multi add <path>");
-    return;
-  }
-  console.log(chalk6.bold("\nRegistered projects:"));
-  for (let i = 0; i < projects.length; i++) {
-    const exists = existsSync6(projects[i]);
-    const icon = exists ? chalk6.green("\u2705") : chalk6.red("\u274C");
-    const type = exists ? detectProjectType(projects[i]) : "?";
-    console.log(`  ${i + 1}. ${icon} ${projects[i]} ${chalk6.dim(`(${type})`)}`);
-  }
-  console.log();
+function buildResearchPrompt(projectType, projectName) {
+  return `You are a senior software architect. Analyze this ${projectType} project "${projectName}" thoroughly.
+
+Research and produce a file called RESEARCH-PROPOSALS.md with:
+
+1. **Architecture Assessment** \u2014 Current architecture, patterns used, strengths and weaknesses
+2. **Code Quality Report** \u2014 Common issues, anti-patterns, technical debt areas
+3. **Security Audit** \u2014 Potential vulnerabilities, dependency risks, configuration issues
+4. **Performance Analysis** \u2014 Bottlenecks, optimization opportunities, resource usage
+5. **Testing Gap Analysis** \u2014 Untested areas, test quality, coverage recommendations
+6. **Improvement Proposals** \u2014 Prioritized list of actionable improvements with effort estimates
+
+For each proposal, include:
+- Priority (P0/P1/P2)
+- Estimated effort (hours)
+- Impact description
+- Suggested implementation approach
+
+Write RESEARCH-PROPOSALS.md in the project root.`;
 }
-async function runAll(mode, opts) {
+async function researchCommand(dir, opts) {
   assertCopilot();
-  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15);
-  setLogFile(join7(LOG_DIR, `multi-${mode}-${ts}.log`));
-  const projects = readProjects();
-  if (projects.length === 0) {
-    fail("No projects registered. Add: copilot-agent multi add <path>");
-    process.exit(1);
-  }
-  log(`\u{1F3ED} Multi-project ${mode} \u2014 ${projects.length} projects`);
-  if (opts.dryRun) {
-    for (const p of projects) {
-      const type = existsSync6(p) ? detectProjectType(p) : "unknown";
-      const tasks = getTasksForProject(type);
-      console.log(`
-${chalk6.bold(basename2(p))} (${type})`);
-      for (const t of tasks.slice(0, 3)) {
-        console.log(`  ${chalk6.dim("\u2022")} ${t.title}`);
-      }
-    }
-    log(chalk6.dim("\n(dry-run \u2014 not executing)"));
-    return;
-  }
-  let total = 0;
-  let success = 0;
-  let failed = 0;
-  let skipped = 0;
-  const report = [];
-  for (const project of projects) {
-    total++;
-    if (!existsSync6(project)) {
-      warn(`Skipping (not found): ${project}`);
-      report.push(`\u23ED  ${basename2(project)} (not found)`);
-      skipped++;
-      continue;
-    }
-    const name = detectProjectName(project);
-    const type = detectProjectType(project);
-    log(`
-${"\u2550".repeat(50)}`);
-    log(`${chalk6.bold(name)} (${type}) \u2014 ${total}/${projects.length}`);
-    log(`${"\u2550".repeat(50)}`);
-    const tasks = mode === "research" ? [{ title: "Research", prompt: "Research latest best practices, dependency updates, and architecture improvements. Create a report.", priority: 1 }] : getTasksForProject(type).slice(0, 3);
-    let projectSuccess = true;
-    for (const task of tasks) {
-      try {
-        const result = await withLock(
-          "copilot-multi",
-          () => runCopilotTask(
-            `Project: ${project}
-
-${task.prompt}`,
-            opts.steps
-          )
-        );
-        ok(`${task.title} \u2014 exit ${result.exitCode}, premium: ${result.premium}`);
-      } catch (err) {
-        fail(`${task.title} failed: ${err}`);
-        projectSuccess = false;
-      }
-    }
-    if (projectSuccess) {
-      success++;
-      report.push(`\u2705 ${name}`);
-    } else {
-      failed++;
-      report.push(`\u274C ${name}`);
-    }
-    if (total < projects.length) {
-      log(`Cooldown ${opts.cooldown}s\u2026`);
-      await new Promise((r) => setTimeout(r, opts.cooldown * 1e3));
-    }
+  const projectDir = resolve5(dir);
+  const projectType = detectProjectType(projectDir);
+  const projectName = detectProjectName(projectDir);
+  info(`Researching: ${CYAN}${projectName}${RESET} (${projectType})`);
+  const prompt = buildResearchPrompt(projectType, projectName);
+  const result = await withLock(
+    "copilot-research",
+    () => runCopilotTask(prompt, opts.steps, projectDir)
+  );
+  log(`Copilot exited with code ${result.exitCode}`);
+  const proposalsFile = join6(projectDir, "RESEARCH-PROPOSALS.md");
+  if (existsSync5(proposalsFile)) {
+    ok("RESEARCH-PROPOSALS.md generated.");
+    const backupDir = join6(homedir4(), ".copilot", "research-reports");
+    mkdirSync3(backupDir, { recursive: true });
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupFile = join6(backupDir, `${projectName}-${timestamp}.md`);
+    copyFileSync(proposalsFile, backupFile);
+    ok(`Backup saved: ${backupFile}`);
+  } else {
+    warn("RESEARCH-PROPOSALS.md was not generated. Check copilot output.");
   }
-  console.log(`
-${"\u2550".repeat(50)}`);
-  log(`\u{1F4CA} Summary: ${success}/${total} succeeded, ${failed} failed, ${skipped} skipped`);
-  for (const line of report) console.log(`  ${line}`);
-  console.log();
-  notify(`Multi-${mode}: ${success}/${total} succeeded`, "copilot-agent");
+  notify("Research complete", projectName);
 }
 
 // src/index.ts
 var program = new Command();
-program.name("copilot-agent").description("Autonomous GitHub Copilot CLI agent \u2014 auto-resume, task discovery, overnight runner").version("0.2.0");
-program.command("status").description("Show copilot session status").option("-l, --limit <n>", "Number of sessions to show", "10").option("-a, --active", "Show only active (running) sessions").action(async (opts) => {
-  await statusCommand({
-    limit: parseInt(opts.limit),
-    active: opts.active ?? false
-  });
-});
-program.command("watch [session-id]").description("Watch a session and auto-resume when it stops").option("-s, --steps <n>", "Max autopilot continues per resume", "50").option("-r, --max-resumes <n>", "Max number of resumes", "20").option("-m, --message <msg>", "Message to send on resume").action(async (sid, opts) => {
-  await watchCommand(sid, {
-    steps: parseInt(opts.steps),
-    maxResumes: parseInt(opts.maxResumes),
-    message: opts.message
-  });
-});
-program.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("--dry-run", "Show tasks without executing").action(async (dir, opts) => {
-  await runCommand(dir ?? process.cwd(), {
-    steps: parseInt(opts.steps),
-    maxTasks: parseInt(opts.maxTasks),
-    dryRun: opts.dryRun ?? false
-  });
-});
-program.command("overnight [dir]").description("Run tasks continuously until a deadline").option("-u, --until <HH:MM>", "Deadline time (24h format)", "07:00").option("-s, --steps <n>", "Max autopilot continues per task", "50").option("-p, --max-premium <n>", "Max premium requests budget", "300").option("--dry-run", "Show plan without executing").action(async (dir, opts) => {
-  await overnightCommand(dir ?? process.cwd(), {
-    until: opts.until,
-    steps: parseInt(opts.steps),
-    maxPremium: parseInt(opts.maxPremium),
-    dryRun: opts.dryRun ?? false
-  });
-});
-program.command("research [topic]").description("Research improvements or a specific topic").option("-s, --steps <n>", "Max autopilot continues", "30").action(async (topic, opts) => {
-  await researchCommand(topic, {
-    steps: parseInt(opts.steps)
-  });
-});
-var daemon = program.command("daemon <action>").description("Background watchdog daemon (start, stop, status, logs)").option("--poll <n>", "Poll interval in seconds", "20").option("--idle <n>", "Minutes before considering session idle", "5").option("--resume", "Auto-resume interrupted sessions").option("-s, --steps <n>", "Max autopilot continues per resume", "50").action(async (action, opts) => {
-  const parsed = {
-    poll: parseInt(opts.poll),
-    idle: parseInt(opts.idle),
-    resume: opts.resume ?? false,
-    steps: parseInt(opts.steps)
-  };
-  if (action === "_loop") {
-    await daemonLoop(parsed);
-  } else {
-    await daemonCommand(action, parsed);
-  }
-});
-var multi = program.command("multi <action> [args...]").description("Multi-project orchestrator (add, remove, list, health, research)").option("-s, --steps <n>", "Max autopilot continues per task", "30").option("-c, --cooldown <n>", "Seconds between projects", "60").option("-p, --max-premium <n>", "Max premium per project", "30").option("--dry-run", "Show plan without executing").action(async (action, args, opts) => {
-  await multiCommand(action, args, {
-    mode: action,
-    cooldown: parseInt(opts.cooldown),
-    steps: parseInt(opts.steps),
-    maxPremium: parseInt(opts.maxPremium),
-    dryRun: opts.dryRun ?? false
-  });
-});
+program.name("copilot-agent").version("0.4.0").description("Autonomous GitHub Copilot CLI agent \u2014 auto-resume, task discovery, overnight runs");
+registerStatusCommand(program);
+registerWatchCommand(program);
+registerRunCommand(program);
+registerOvernightCommand(program);
+registerResearchCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map