copilot-agent 0.12.0 → 1.0.0

package/dist/index.js

@@ -639,7 +639,7 @@ async function runCopilot(args, options) {
   if (!options?.useWorktree) {
     await waitForAgentInDir(dir, "copilot");
   }
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn("copilot", args, {
       cwd: options?.cwd,
       stdio: "inherit",
@@ -649,10 +649,10 @@ async function runCopilot(args, options) {
       await sleep(3e3);
       const sid = getLatestSessionId();
       const premium = sid ? getSessionPremium(sid) : 0;
-      resolve7({ exitCode: code ?? 1, sessionId: sid, premium });
+      resolve8({ exitCode: code ?? 1, sessionId: sid, premium });
     });
     child.on("error", () => {
-      resolve7({ exitCode: 1, sessionId: null, premium: 0 });
+      resolve8({ exitCode: 1, sessionId: null, premium: 0 });
     });
   });
 }
@@ -685,7 +685,7 @@ async function runClaude(args, options) {
   if (!options?.useWorktree) {
     await waitForAgentInDir(dir, "claude");
   }
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn("claude", args, {
       cwd: options?.cwd,
       stdio: "inherit",
@@ -694,10 +694,10 @@ async function runClaude(args, options) {
     child.on("close", async (code) => {
       await sleep(2e3);
       const sid = getLatestClaudeSessionId(options?.cwd);
-      resolve7({ exitCode: code ?? 1, sessionId: sid, premium: 0 });
+      resolve8({ exitCode: code ?? 1, sessionId: sid, premium: 0 });
     });
     child.on("error", () => {
-      resolve7({ exitCode: 1, sessionId: null, premium: 0 });
+      resolve8({ exitCode: 1, sessionId: null, premium: 0 });
     });
   });
 }
@@ -1232,9 +1232,9 @@ async function runCommand(dir, opts) {
 ${"\u2550".repeat(60)}`);
     log(`${BOLD}${CYAN}Task: ${task.title}${RESET}`);
     log(`${"\u2550".repeat(60)}`);
-    const timestamp = Date.now().toString(36);
+    const timestamp2 = Date.now().toString(36);
     const random = Math.random().toString(36).substring(2, 6);
-    const branchName = `agent/fix-${completed + 1}-${timestamp}-${random}`;
+    const branchName = `agent/fix-${completed + 1}-${timestamp2}-${random}`;
     if (mainBranch && isGitRepo(dir)) {
       if (gitStatus(dir)) gitStash(dir);
       gitCheckout(dir, mainBranch);
@@ -1367,9 +1367,9 @@ ${"\u2550".repeat(60)}`);
     log(`${BOLD}${CYAN}[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Task ${taskIdx}: ${task.title}${RESET}`);
     log(`${DIM}Premium: ${totalPremium}/${opts.maxPremium}${RESET}`);
     log(`${"\u2550".repeat(60)}`);
-    const timestamp = Date.now().toString(36);
+    const timestamp2 = Date.now().toString(36);
     const random = Math.random().toString(36).substring(2, 6);
-    const branchName = `agent/overnight-${taskIdx}-${timestamp}-${random}`;
+    const branchName = `agent/overnight-${taskIdx}-${timestamp2}-${random}`;
     if (mainBranch && isGitRepo(dir)) {
       gitStash(dir);
       gitCheckout(dir, mainBranch);
@@ -1492,8 +1492,8 @@ async function researchCommand(dir, opts) {
     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`);
+    const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupFile = join6(backupDir, `${projectName}-${timestamp2}.md`);
     copyFileSync(proposalsFile, backupFile);
     ok(`Backup saved: ${backupFile}`);
   } else {
@@ -1826,11 +1826,16 @@ function cacheDetail(cache, s) {
 }
 function runBlessedDashboard(refreshSec, limit) {
   const cache = createCache();
+  const origTerm = process.env.TERM;
+  if (origTerm?.includes("256color")) {
+    process.env.TERM = "xterm";
+  }
   const screen = blessed.screen({
     smartCSR: true,
     title: "copilot-agent dashboard",
     fullUnicode: true
   });
+  if (origTerm) process.env.TERM = origTerm;
   const BG = "#0d1117";
   const FG = "#e6edf3";
   const BORDER_COLOR = "#30363d";
@@ -3611,9 +3616,681 @@ function fmtDur2(ms) {
   return `${Math.floor(ms / 36e5)}h ${Math.round(ms % 36e5 / 6e4)}m`;
 }
 
+// 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 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 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) => {
+    try {
+      await multiCommand(action, args, {
+        agent: resolveAgent(opts.agent),
+        parallel: opts.parallel ?? false,
+        cooldown: parseInt(opts.cooldown, 10),
+        steps: parseInt(opts.steps, 10),
+        maxPremium: parseInt(opts.maxPremium, 10),
+        dryRun: opts.dryRun ?? false
+      });
+    } catch (err) {
+      fail(`Multi error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+}
+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 "status":
+      return showStatus();
+    case "run":
+    case "health":
+      return runAll("health", opts);
+    case "research":
+      return runAll("research", opts);
+    default:
+      fail(`Unknown action: ${action}. Use: add, remove, list, run, status, research`);
+      process.exit(1);
+  }
+}
+function ensureFiles() {
+  mkdirSync8(LOG_DIR, { recursive: true });
+  mkdirSync8(CONFIG_DIR3, { recursive: true });
+  if (!existsSync11(PROJECTS_FILE)) writeFileSync7(PROJECTS_FILE, "");
+}
+function readProjects() {
+  return readFileSync8(PROJECTS_FILE, "utf-8").split("\n").map((l) => l.trim()).filter(Boolean);
+}
+function writeProjects(projects) {
+  writeFileSync7(PROJECTS_FILE, projects.join("\n") + "\n");
+}
+function readStatusFile() {
+  if (!existsSync11(STATUS_FILE)) return [];
+  try {
+    const raw = readFileSync8(STATUS_FILE, "utf-8");
+    const parsed = parseYaml4(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function writeStatusFile(statuses) {
+  writeFileSync7(STATUS_FILE, stringifyYaml3(statuses));
+}
+function upsertStatus(entry) {
+  const statuses = readStatusFile();
+  const idx = statuses.findIndex((s) => s.project === entry.project);
+  if (idx >= 0) {
+    statuses[idx] = entry;
+  } else {
+    statuses.push(entry);
+  }
+  writeStatusFile(statuses);
+}
+function formatDuration2(ms) {
+  const totalSec = Math.round(ms / 1e3);
+  const min = Math.floor(totalSec / 60);
+  const sec = totalSec % 60;
+  return min > 0 ? `${min}m ${sec}s` : `${sec}s`;
+}
+async function addProject(path) {
+  if (!path) {
+    fail("Usage: copilot-agent multi add <path>");
+    process.exit(1);
+  }
+  const resolved = resolve7(path);
+  if (!existsSync11(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 = resolve7(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;
+  }
+  const statuses = readStatusFile();
+  console.log(chalk10.bold("\nRegistered projects:"));
+  for (let i = 0; i < projects.length; i++) {
+    const p = projects[i];
+    const exists = existsSync11(p);
+    const icon = exists ? chalk10.green("\u2705") : chalk10.red("\u274C");
+    const type = exists ? detectProjectType(p) : "?";
+    const st = statuses.find((s) => s.project === p);
+    const statusTag = st ? chalk10.dim(` [${st.status} \u2014 ${st.agent} \u2014 ${st.duration}]`) : "";
+    console.log(`  ${i + 1}. ${icon} ${p} ${chalk10.dim(`(${type})`)}${statusTag}`);
+  }
+  console.log();
+}
+function showStatus() {
+  const statuses = readStatusFile();
+  if (statuses.length === 0) {
+    log("No run history. Execute: copilot-agent multi run");
+    return;
+  }
+  console.log(chalk10.bold("\nMulti-project status:"));
+  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)}`
+    );
+  }
+  console.log();
+}
+function createSemaphore(max) {
+  let running = 0;
+  const queue = [];
+  async function acquire() {
+    if (running < max) {
+      running++;
+      return;
+    }
+    return new Promise((resolve8) => {
+      queue.push(() => {
+        running++;
+        resolve8();
+      });
+    });
+  }
+  function release() {
+    running--;
+    const next = queue.shift();
+    if (next) next();
+  }
+  return { acquire, release };
+}
+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`));
+  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 \u2014 agent: ${opts.agent}${opts.parallel ? " (parallel)" : ""}`);
+  if (opts.dryRun) {
+    for (const p of projects) {
+      const type = existsSync11(p) ? detectProjectType(p) : "unknown";
+      const tasks = getTasksForProject(type);
+      console.log(`
+${chalk10.bold(basename3(p))} (${type})`);
+      for (const t of tasks.slice(0, 3)) {
+        console.log(`  ${chalk10.dim("\u2022")} ${t.title}`);
+      }
+    }
+    log(chalk10.dim("\n(dry-run \u2014 not executing)"));
+    return;
+  }
+  const results = [];
+  if (opts.parallel) {
+    const sem = createSemaphore(MAX_CONCURRENCY);
+    const promises = projects.map(async (project) => {
+      await sem.acquire();
+      try {
+        const res = await runSingleProject(project, mode, opts);
+        results.push(res);
+      } finally {
+        sem.release();
+      }
+    });
+    await Promise.all(promises);
+  } else {
+    for (let i = 0; i < projects.length; i++) {
+      const res = await runSingleProject(projects[i], mode, opts);
+      results.push(res);
+      if (i < projects.length - 1 && !res.skipped) {
+        log(`Cooldown ${opts.cooldown}s\u2026`);
+        await new Promise((r) => setTimeout(r, opts.cooldown * 1e3));
+      }
+    }
+  }
+  const success = results.filter((r) => r.success && !r.skipped).length;
+  const failed = results.filter((r) => !r.success && !r.skipped).length;
+  const skipped = results.filter((r) => r.skipped).length;
+  const total = results.length;
+  console.log(`
+${"\u2550".repeat(50)}`);
+  log(`\u{1F4CA} Summary: ${success}/${total} succeeded, ${failed} failed, ${skipped} skipped`);
+  for (const r of results) {
+    const icon = r.skipped ? "\u23ED " : r.success ? "\u2705" : "\u274C";
+    console.log(`  ${icon} ${r.name}`);
+  }
+  console.log();
+  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)) {
+    warn(`Skipping (not found): ${project}`);
+    return { name, success: false, skipped: true };
+  }
+  const type = detectProjectType(project);
+  log(`
+${"\u2550".repeat(50)}`);
+  log(`${chalk10.bold(name)} (${type}) \u2014 agent: ${opts.agent}`);
+  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);
+  const startTime = Date.now();
+  let projectSuccess = true;
+  upsertStatus({
+    project,
+    lastRun: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "running",
+    agent: opts.agent,
+    tasks: tasks.length,
+    duration: "\u2014"
+  });
+  for (const task of tasks) {
+    try {
+      const result = await withLock(
+        "agent-multi",
+        () => runAgentTask(opts.agent, `Project: ${project}
+
+${task.prompt}`, opts.steps, project)
+      );
+      ok(`${task.title} \u2014 exit ${result.exitCode}, premium: ${result.premium}`);
+    } catch (err) {
+      fail(`${task.title} failed: ${err}`);
+      projectSuccess = false;
+    }
+  }
+  const duration = formatDuration2(Date.now() - startTime);
+  upsertStatus({
+    project,
+    lastRun: (/* @__PURE__ */ new Date()).toISOString(),
+    status: projectSuccess ? "success" : "failed",
+    agent: opts.agent,
+    tasks: tasks.length,
+    duration
+  });
+  return { name, success: projectSuccess, skipped: false };
+}
+
+// src/commands/review.ts
+import chalk11 from "chalk";
+import { execSync as execSync6 } from "child_process";
+var MAX_DIFF_LENGTH = 15e3;
+var MAX_BUFFER = 1024 * 1024;
+function getSessionDiff(sessionId) {
+  const report = getAgentSessionReport(sessionId, "copilot") ?? getAgentSessionReport(sessionId, "claude");
+  if (!report || report.gitCommits.length === 0) {
+    return execSync6("git --no-pager diff HEAD~3", {
+      encoding: "utf-8",
+      maxBuffer: MAX_BUFFER
+    });
+  }
+  return execSync6("git --no-pager diff HEAD~" + report.gitCommits.length, {
+    encoding: "utf-8",
+    cwd: report.cwd || process.cwd(),
+    maxBuffer: MAX_BUFFER
+  });
+}
+function getWorkingDiff() {
+  const staged = execSync6("git --no-pager diff --cached", {
+    encoding: "utf-8",
+    maxBuffer: MAX_BUFFER
+  });
+  const unstaged = execSync6("git --no-pager diff", {
+    encoding: "utf-8",
+    maxBuffer: MAX_BUFFER
+  });
+  return staged + unstaged;
+}
+function getPrDiff(prNumber) {
+  return execSync6(`gh pr diff ${prNumber} --color=never`, {
+    encoding: "utf-8",
+    maxBuffer: MAX_BUFFER
+  });
+}
+var focusInstructions = {
+  all: "Review for bugs, security issues, performance problems, and code quality.",
+  security: "Focus exclusively on security vulnerabilities, injection risks, auth issues, and data exposure.",
+  performance: "Focus exclusively on performance issues: N+1 queries, memory leaks, unnecessary allocations, slow algorithms.",
+  bugs: "Focus exclusively on logic bugs, edge cases, null/undefined issues, race conditions.",
+  style: "Focus exclusively on code style, naming, readability, and consistency."
+};
+function buildReviewPrompt(diff, focus) {
+  const instruction = focusInstructions[focus] ?? focusInstructions.all;
+  const truncatedDiff = diff.length > MAX_DIFF_LENGTH ? diff.slice(0, MAX_DIFF_LENGTH) + "\n... (truncated)" : diff;
+  return `You are a senior code reviewer. ${instruction}
+
+Review this diff and provide:
+1. **Critical Issues** (bugs, security) \u2014 must fix
+2. **Suggestions** \u2014 should fix for quality
+3. **Positive Notes** \u2014 good patterns observed
+4. **Summary** \u2014 one paragraph overall assessment
+
+Be concise. Only flag real issues, not style nitpicks (unless focus is style).
+
+\`\`\`diff
+${truncatedDiff}
+\`\`\``;
+}
+async function runReview(label, diff, agent, focus, steps) {
+  if (!diff.trim()) {
+    fail("No changes found to review.");
+    process.exit(1);
+  }
+  info(`Reviewing: ${chalk11.cyan(label)}`);
+  log(`Focus: ${chalk11.yellow(focus)} | Agent: ${chalk11.yellow(agent)} | Steps: ${steps}`);
+  const prompt = buildReviewPrompt(diff, focus);
+  const result = await runAgentTask(agent, prompt, steps, process.cwd());
+  if (result.exitCode === 0) {
+    ok("Review complete.");
+  } else {
+    fail(`Agent exited with code ${result.exitCode}`);
+  }
+}
+function registerReviewCommand(program2) {
+  const cmd = program2.command("review [session-id]").description("AI-powered code review of agent changes or git diffs").option("-a, --agent <type>", "Agent to use: copilot or claude", "copilot").option(
+    "-f, --focus <area>",
+    "Focus area: all, security, performance, bugs, style",
+    "all"
+  ).option("-s, --steps <n>", "Max agent steps", "5").action(async (sessionId, opts) => {
+    try {
+      const agent = resolveAgent(opts.agent);
+      const steps = parseInt(opts.steps, 10);
+      let sid = sessionId;
+      if (!sid) {
+        const sessions = listAllSessions(1);
+        if (sessions.length === 0) {
+          fail('No sessions found. Use "review diff" to review working tree changes.');
+          process.exit(1);
+        }
+        sid = sessions[0].id;
+        log(`Using latest session: ${chalk11.dim(sid)}`);
+      }
+      const diff = getSessionDiff(sid);
+      await runReview(`session ${sid.slice(0, 8)}\u2026`, diff, agent, opts.focus, steps);
+    } catch (err) {
+      fail(`Review error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("diff").description("Review current working tree changes").option("-a, --agent <type>", "Agent to use: copilot or claude", "copilot").option(
+    "-f, --focus <area>",
+    "Focus area: all, security, performance, bugs, style",
+    "all"
+  ).option("-s, --steps <n>", "Max agent steps", "5").action(async (opts) => {
+    try {
+      const agent = resolveAgent(opts.agent);
+      const steps = parseInt(opts.steps, 10);
+      const diff = getWorkingDiff();
+      await runReview("working tree changes", diff, agent, opts.focus, steps);
+    } catch (err) {
+      fail(`Review error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("pr <number>").description("Review a GitHub Pull Request").option("-a, --agent <type>", "Agent to use: copilot or claude", "copilot").option(
+    "-f, --focus <area>",
+    "Focus area: all, security, performance, bugs, style",
+    "all"
+  ).option("-s, --steps <n>", "Max agent steps", "5").action(async (number, opts) => {
+    try {
+      const agent = resolveAgent(opts.agent);
+      const steps = parseInt(opts.steps, 10);
+      const diff = getPrDiff(number);
+      await runReview(`PR #${number}`, diff, agent, opts.focus, steps);
+    } catch (err) {
+      fail(`Review error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+}
+
+// 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 { parse as parseYaml5, stringify as stringifyYaml4 } from "yaml";
+var CONFIG_DIR4 = join14(homedir12(), ".copilot-agent");
+var SCHEDULES_FILE = join14(CONFIG_DIR4, "schedules.yaml");
+function ensureConfigDir2() {
+  if (!existsSync12(CONFIG_DIR4)) mkdirSync9(CONFIG_DIR4, { recursive: true });
+}
+function loadSchedules() {
+  if (!existsSync12(SCHEDULES_FILE)) return [];
+  try {
+    const raw = parseYaml5(readFileSync9(SCHEDULES_FILE, "utf-8"));
+    return Array.isArray(raw) ? raw : [];
+  } catch {
+    return [];
+  }
+}
+function saveSchedules(schedules) {
+  ensureConfigDir2();
+  writeFileSync8(SCHEDULES_FILE, stringifyYaml4(schedules), "utf-8");
+}
+function matchesCron(cron, date) {
+  const parts = cron.trim().split(/\s+/);
+  if (parts.length !== 5) return false;
+  const [minPart, hourPart, , , dowPart] = parts;
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dow = date.getDay();
+  if (!matchField(minPart, minute)) return false;
+  if (!matchField(hourPart, hour)) return false;
+  if (!matchField(dowPart, dow)) return false;
+  return true;
+}
+function matchField(pattern, value) {
+  if (pattern === "*") return true;
+  const stepMatch = pattern.match(/^\*\/(\d+)$/);
+  if (stepMatch) {
+    const step = parseInt(stepMatch[1], 10);
+    return step > 0 && value % step === 0;
+  }
+  const num = parseInt(pattern, 10);
+  if (!isNaN(num)) return value === num;
+  return false;
+}
+function nextRunTime(cron) {
+  const now = /* @__PURE__ */ new Date();
+  const limit = 7 * 24 * 60;
+  const candidate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours(), now.getMinutes());
+  for (let i = 1; i <= limit; i++) {
+    candidate.setMinutes(candidate.getMinutes() + 1);
+    if (matchesCron(cron, candidate)) return new Date(candidate);
+  }
+  return null;
+}
+function formatTime2(date) {
+  return date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", hour12: false });
+}
+function formatDateTime(date) {
+  const day = date.toLocaleDateString([], { weekday: "short", month: "short", day: "numeric" });
+  return `${day} ${formatTime2(date)}`;
+}
+function timestamp() {
+  return `${DIM}[${formatTime2(/* @__PURE__ */ new Date())}]${RESET}`;
+}
+function listCommand() {
+  const schedules = loadSchedules();
+  if (schedules.length === 0) {
+    info("No schedules configured.");
+    info(`Add one with: ${CYAN}copilot-agent schedule add <name> --cron "..." --prompt "..."${RESET}`);
+    return;
+  }
+  log(`
+${BOLD}Schedules${RESET} ${DIM}(${SCHEDULES_FILE})${RESET}
+`);
+  for (const s of schedules) {
+    const status = s.enabled ? `${GREEN}\u25CF${RESET}` : `${DIM}\u25CB${RESET}`;
+    const next = s.enabled ? nextRunTime(s.cron) : null;
+    const nextStr = next ? `${DIM}next: ${formatDateTime(next)}${RESET}` : "";
+    log(`  ${status} ${BOLD}${s.name}${RESET}  ${DIM}${s.cron}${RESET}  ${nextStr}`);
+    log(`    ${DIM}prompt:${RESET}  ${s.prompt.length > 60 ? s.prompt.slice(0, 57) + "..." : s.prompt}`);
+    log(`    ${DIM}project:${RESET} ${s.project}  ${DIM}agent:${RESET} ${s.agent}  ${DIM}steps:${RESET} ${s.maxSteps ?? 30}`);
+    log("");
+  }
+}
+function addCommand(name, opts) {
+  const schedules = loadSchedules();
+  if (schedules.some((s) => s.name === name)) {
+    fail(`Schedule "${name}" already exists. Remove it first or use a different name.`);
+    process.exit(1);
+  }
+  if (!opts.cron || opts.cron.trim().split(/\s+/).length !== 5) {
+    fail("Invalid cron expression. Expected 5 fields: minute hour day month weekday");
+    process.exit(1);
+  }
+  const schedule = {
+    name,
+    cron: opts.cron,
+    prompt: opts.prompt,
+    project: opts.project || process.cwd(),
+    agent: resolveAgent(opts.agent),
+    enabled: !opts.disabled,
+    maxSteps: parseInt(opts.steps, 10) || 30
+  };
+  schedules.push(schedule);
+  saveSchedules(schedules);
+  ok(`Added schedule "${name}"`);
+  const next = nextRunTime(schedule.cron);
+  if (next) {
+    info(`Next run: ${formatDateTime(next)}`);
+  }
+}
+function removeCommand(name) {
+  const schedules = loadSchedules();
+  const idx = schedules.findIndex((s) => s.name === name);
+  if (idx === -1) {
+    fail(`Schedule "${name}" not found.`);
+    process.exit(1);
+  }
+  schedules.splice(idx, 1);
+  saveSchedules(schedules);
+  ok(`Removed schedule "${name}"`);
+}
+function dryRunCommand() {
+  const schedules = loadSchedules().filter((s) => s.enabled);
+  if (schedules.length === 0) {
+    info("No enabled schedules.");
+    return;
+  }
+  log(`
+${BOLD}Dry run \u2014 what would run next${RESET}
+`);
+  for (const s of schedules) {
+    const next = nextRunTime(s.cron);
+    if (next) {
+      log(`  ${CYAN}${s.name}${RESET}  \u2192  ${formatDateTime(next)}`);
+      log(`    ${DIM}${s.agent}${RESET} in ${s.project}`);
+      log(`    ${DIM}prompt:${RESET} ${s.prompt.length > 70 ? s.prompt.slice(0, 67) + "..." : s.prompt}`);
+      log("");
+    }
+  }
+}
+async function runDaemon() {
+  const schedules = loadSchedules();
+  const enabled = schedules.filter((s) => s.enabled);
+  if (enabled.length === 0) {
+    fail("No enabled schedules. Add one first.");
+    process.exit(1);
+  }
+  for (const s of enabled) {
+    assertAgent(s.agent);
+  }
+  log(`
+${BOLD}${CYAN}Scheduler daemon started${RESET}`);
+  info(`${enabled.length} schedule(s) active. Press Ctrl+C to stop.
+`);
+  const lastRun = /* @__PURE__ */ new Map();
+  const showStatus2 = () => {
+    const now = /* @__PURE__ */ new Date();
+    let soonestName = "";
+    let soonestTime = null;
+    for (const s of enabled) {
+      const next = nextRunTime(s.cron);
+      if (next && (!soonestTime || next < soonestTime)) {
+        soonestTime = next;
+        soonestName = s.name;
+      }
+    }
+    const nextStr = soonestTime ? `next: ${CYAN}${soonestName}${RESET} at ${formatTime2(soonestTime)}` : "no upcoming runs";
+    log(`${timestamp()} ${DIM}Scheduler running \u2014 ${enabled.length} schedules, ${nextStr}${RESET}`);
+  };
+  showStatus2();
+  const check = async () => {
+    const now = /* @__PURE__ */ new Date();
+    const minuteKey = `${now.getFullYear()}-${now.getMonth()}-${now.getDate()}-${now.getHours()}-${now.getMinutes()}`;
+    for (const s of enabled) {
+      if (!matchesCron(s.cron, now)) continue;
+      const runKey = `${s.name}:${minuteKey}`;
+      if (lastRun.has(runKey)) continue;
+      lastRun.set(runKey, Date.now());
+      const cutoff = Date.now() - 2 * 60 * 1e3;
+      for (const [k, v] of lastRun) {
+        if (v < cutoff) lastRun.delete(k);
+      }
+      log(`
+${timestamp()} ${BOLD}${YELLOW}\u25B6 Running: ${s.name}${RESET}`);
+      log(`  ${DIM}cron:${RESET} ${s.cron}  ${DIM}agent:${RESET} ${s.agent}  ${DIM}project:${RESET} ${s.project}`);
+      log(`  ${DIM}prompt:${RESET} ${s.prompt}`);
+      try {
+        const result = await runAgentTask(
+          s.agent,
+          s.prompt,
+          s.maxSteps ?? 30,
+          s.project
+        );
+        if (result.exitCode === 0) {
+          ok(`${timestamp()} \u2713 ${s.name} completed (session: ${result.sessionId?.slice(0, 8) ?? "n/a"})`);
+        } else {
+          warn(`${timestamp()} ${s.name} exited with code ${result.exitCode}`);
+        }
+      } catch (err) {
+        fail(`${timestamp()} ${s.name} failed: ${err instanceof Error ? err.message : err}`);
+      }
+      showStatus2();
+    }
+  };
+  await check();
+  const interval = setInterval(() => {
+    check().catch((err) => {
+      fail(`Scheduler error: ${err instanceof Error ? err.message : err}`);
+    });
+  }, 6e4);
+  const shutdown = () => {
+    log(`
+${timestamp()} ${DIM}Scheduler stopped.${RESET}`);
+    clearInterval(interval);
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+function registerScheduleCommand(program2) {
+  const cmd = program2.command("schedule").description("Cron-like recurring task scheduler");
+  cmd.command("list").description("Show all configured schedules").action(() => {
+    listCommand();
+  });
+  cmd.command("add <name>").description("Add a recurring schedule").requiredOption("--cron <expression>", 'Cron expression (e.g. "0 */6 * * *")').requiredOption("--prompt <text>", "Agent prompt to execute").option("--project <path>", "Project directory", process.cwd()).option("-a, --agent <type>", "Agent: copilot or claude").option("-s, --steps <n>", "Max autopilot steps", "30").option("--disabled", "Add as disabled").action((name, opts) => {
+    addCommand(name, opts);
+  });
+  cmd.command("remove <name>").description("Remove a schedule").action((name) => {
+    removeCommand(name);
+  });
+  cmd.command("run").description("Start the scheduler daemon (foreground)").action(async () => {
+    try {
+      await runDaemon();
+    } catch (err) {
+      fail(`Scheduler error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("dry-run").description("Show what would run next for each schedule").action(() => {
+    dryRunCommand();
+  });
+}
+
 // src/index.ts
 var program = new Command();
-program.name("copilot-agent").version("0.12.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.0.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);
@@ -3631,5 +4308,8 @@ registerHooksCommand(program);
 registerPrCommand(program);
 registerLogCommand(program);
 registerTemplateCommand(program);
+registerMultiCommand(program);
+registerReviewCommand(program);
+registerScheduleCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map