agent-auto-resume 0.1.0

package/dist/cli.js

@@ -0,0 +1,1641 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/core/session-store.ts
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import { nanoid } from "nanoid";
+var DEFAULT_BASE_DIR = path.join(os.homedir(), ".agent-auto-resume");
+var BASE_DIR = process.env.AAR_BASE_DIR || DEFAULT_BASE_DIR;
+var SESSIONS_DIR = path.join(BASE_DIR, "sessions");
+var EVENTS_DIR = path.join(BASE_DIR, "events");
+var SHIMS_DIR = path.join(BASE_DIR, "shims");
+var CONFIG_FILE = path.join(BASE_DIR, "config.json");
+function resolveHome(filepath) {
+  if (filepath.startsWith("~")) {
+    return path.join(os.homedir(), filepath.slice(1));
+  }
+  return filepath;
+}
+async function ensureDirs() {
+  await fs.ensureDir(BASE_DIR);
+  await fs.ensureDir(SESSIONS_DIR);
+  await fs.ensureDir(EVENTS_DIR);
+  await fs.ensureDir(SHIMS_DIR);
+}
+var DEFAULT_CONFIG = {
+  version: 1,
+  bufferSeconds: 120,
+  maxAttempts: 5,
+  providers: {
+    claude: {
+      enabled: true,
+      command: "claude",
+      watchTranscripts: true,
+      transcriptDirs: ["~/.claude/projects"]
+    },
+    codex: {
+      enabled: true,
+      command: "codex",
+      watchTranscripts: true,
+      transcriptDirs: ["~/.codex/sessions"]
+    },
+    antigravity: {
+      enabled: true,
+      command: "agy",
+      experimental: true,
+      watchTranscripts: false,
+      transcriptDirs: []
+    }
+  },
+  tmux: {
+    enabled: false,
+    pollIntervalMs: 5e3
+  },
+  daemon: {
+    pollIntervalMs: 5e3
+  }
+};
+async function loadConfig() {
+  await ensureDirs();
+  if (await fs.pathExists(CONFIG_FILE)) {
+    try {
+      const data = await fs.readJson(CONFIG_FILE);
+      return {
+        ...DEFAULT_CONFIG,
+        ...data,
+        providers: {
+          claude: { ...DEFAULT_CONFIG.providers.claude, ...data.providers?.claude },
+          codex: { ...DEFAULT_CONFIG.providers.codex, ...data.providers?.codex },
+          antigravity: { ...DEFAULT_CONFIG.providers.antigravity, ...data.providers?.antigravity }
+        },
+        tmux: { ...DEFAULT_CONFIG.tmux, ...data.tmux },
+        daemon: { ...DEFAULT_CONFIG.daemon, ...data.daemon }
+      };
+    } catch {
+      return DEFAULT_CONFIG;
+    }
+  }
+  await fs.writeJson(CONFIG_FILE, DEFAULT_CONFIG, { spaces: 2 });
+  return DEFAULT_CONFIG;
+}
+async function createSession(state) {
+  await ensureDirs();
+  const id = state.id || nanoid(10);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const session = {
+    ...state,
+    id,
+    createdAt: now,
+    updatedAt: now
+  };
+  const sessionPath = path.join(SESSIONS_DIR, `${id}.json`);
+  await fs.writeJson(sessionPath, session, { spaces: 2 });
+  return session;
+}
+async function updateSession(id, updates) {
+  await ensureDirs();
+  const session = await getSession(id);
+  if (!session) {
+    throw new Error(`Session ${id} not found`);
+  }
+  const updated = {
+    ...session,
+    ...updates,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const sessionPath = path.join(SESSIONS_DIR, `${id}.json`);
+  await fs.writeJson(sessionPath, updated, { spaces: 2 });
+  return updated;
+}
+async function getSession(id) {
+  await ensureDirs();
+  const sessionPath = path.join(SESSIONS_DIR, `${id}.json`);
+  if (!await fs.pathExists(sessionPath)) {
+    return void 0;
+  }
+  try {
+    return await fs.readJson(sessionPath);
+  } catch {
+    return void 0;
+  }
+}
+async function listSessions() {
+  await ensureDirs();
+  const files = await fs.readdir(SESSIONS_DIR);
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  const sessions = [];
+  for (const file of jsonFiles) {
+    try {
+      const session = await fs.readJson(path.join(SESSIONS_DIR, file));
+      sessions.push(session);
+    } catch {
+    }
+  }
+  return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+async function getLastSession() {
+  const sessions = await listSessions();
+  return sessions[0];
+}
+async function getRecoverableSessions() {
+  const sessions = await listSessions();
+  const recoverableStatuses = ["waiting_limit_reset", "ready_to_resume", "failed", "resuming"];
+  return sessions.filter((s) => recoverableStatuses.includes(s.status));
+}
+async function getWaitingSessions() {
+  const sessions = await listSessions();
+  return sessions.filter((s) => s.status === "waiting_limit_reset");
+}
+
+// src/core/shell-setup.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+function detectShell() {
+  const shellEnv = process.env.SHELL || "";
+  if (shellEnv.includes("zsh")) {
+    return "zsh";
+  }
+  if (shellEnv.includes("fish")) {
+    return "fish";
+  }
+  return "bash";
+}
+function getShellRcPath(shell) {
+  if (shell === "zsh") {
+    return resolveHome("~/.zshrc");
+  }
+  if (shell === "fish") {
+    return resolveHome("~/.config/fish/config.fish");
+  }
+  return resolveHome("~/.bashrc");
+}
+var ZSH_BASH_SNIPPET = `
+# agent-auto-resume
+if command -v aar >/dev/null 2>&1; then
+  claude() { aar managed claude -- claude "$@"; }
+  codex() { aar managed codex -- codex "$@"; }
+  agy() { aar managed antigravity -- agy "$@"; }
+fi
+`;
+var FISH_SNIPPET = `
+# agent-auto-resume
+function claude
+  aar managed claude -- claude $argv
+end
+
+function codex
+  aar managed codex -- codex $argv
+end
+
+function agy
+  aar managed antigravity -- agy $argv
+end
+`;
+function getSnippet(shell) {
+  return shell === "fish" ? FISH_SNIPPET.trim() : ZSH_BASH_SNIPPET.trim();
+}
+async function setupShell(shell, noModify = false) {
+  const targetShell = shell || detectShell();
+  const rcPath = getShellRcPath(targetShell);
+  const snippet = getSnippet(targetShell);
+  if (noModify) {
+    return `Please manually append the following snippet to your shell config file (${rcPath}):
+
+${snippet}`;
+  }
+  await fs2.ensureDir(path2.dirname(rcPath));
+  let exists = false;
+  let content = "";
+  if (await fs2.pathExists(rcPath)) {
+    content = await fs2.readFile(rcPath, "utf-8");
+    if (content.includes("agent-auto-resume") || content.includes("aar managed")) {
+      exists = true;
+    }
+  }
+  if (exists) {
+    return `Shell integration snippet already exists in ${rcPath}. Skipping configuration.`;
+  }
+  const newContent = content ? `${content.trimEnd()}
+
+${snippet}
+` : `${snippet}
+`;
+  await fs2.writeFile(rcPath, newContent, "utf-8");
+  return `Successfully updated shell configuration at ${rcPath}.
+Restart your terminal or run: source ${rcPath}`;
+}
+
+// src/commands/setup.ts
+import { execSync } from "child_process";
+import chalk from "chalk";
+async function runSetup(options) {
+  console.log(chalk.bold("Starting agent-auto-resume setup...\n"));
+  await ensureDirs();
+  console.log(chalk.green("\u2713 Initialized state directory at ~/.agent-auto-resume/"));
+  await loadConfig();
+  console.log(chalk.green("\u2713 Created configuration file config.json"));
+  const providers = [
+    { name: "Claude Code", cmd: "claude" },
+    { name: "OpenAI Codex CLI", cmd: "codex" },
+    { name: "Google Antigravity CLI", cmd: "agy" }
+  ];
+  console.log("\nChecking provider CLI commands:");
+  for (const p of providers) {
+    try {
+      execSync(`which ${p.cmd}`, { stdio: "ignore" });
+      console.log(chalk.green(`  \u2713 ${p.name} (${p.cmd}) is installed.`));
+    } catch {
+      console.log(chalk.yellow(`  \u26A0 ${p.name} (${p.cmd}) was not found in your PATH.`));
+    }
+  }
+  if (options.printShellSnippet) {
+    const shell = options.shell || "zsh";
+    console.log(`
+--- Shell Snippet for ${shell} ---`);
+    console.log(getSnippet(shell));
+    console.log("---------------------------------");
+    return;
+  }
+  console.log("");
+  const resultMessage = await setupShell(options.shell, options.noShellModify);
+  console.log(resultMessage);
+}
+
+// src/core/daemon-client.ts
+import { spawn } from "child_process";
+import fs5 from "fs-extra";
+
+// src/core/daemon-ipc.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+var PID_FILE = path3.join(BASE_DIR, "daemon.pid");
+async function writePid(pid) {
+  await ensureDirs();
+  await fs3.writeFile(PID_FILE, pid.toString(), "utf-8");
+}
+async function readPid() {
+  if (!await fs3.pathExists(PID_FILE)) {
+    return void 0;
+  }
+  try {
+    const content = await fs3.readFile(PID_FILE, "utf-8");
+    const pid = parseInt(content.trim(), 10);
+    return isNaN(pid) ? void 0 : pid;
+  } catch {
+    return void 0;
+  }
+}
+async function clearPid() {
+  if (await fs3.pathExists(PID_FILE)) {
+    await fs3.remove(PID_FILE);
+  }
+}
+async function isDaemonRunning() {
+  const pid = await readPid();
+  if (!pid) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "ESRCH") {
+      await clearPid();
+      return false;
+    }
+    return err.code === "EPERM";
+  }
+}
+
+// src/core/logger.ts
+import path4 from "path";
+import fs4 from "fs-extra";
+import chalk2 from "chalk";
+var LOG_FILE = path4.join(BASE_DIR, "daemon.log");
+var currentLogLevel = 1 /* INFO */;
+async function writeToFile(message) {
+  try {
+    await ensureDirs();
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const cleanMsg = message.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+    await fs4.appendFile(LOG_FILE, `[${ts}] ${cleanMsg}
+`, "utf-8");
+  } catch {
+  }
+}
+function formatMessage(prefix, message, colorFn) {
+  const cleanPrefix = prefix ? `[${prefix}] ` : "";
+  const formatted = `${cleanPrefix}${message}`;
+  return colorFn ? colorFn(formatted) : formatted;
+}
+var logger = {
+  debug(message, prefix = "aar") {
+    if (currentLogLevel <= 0 /* DEBUG */) {
+      const msg = formatMessage(prefix, message, chalk2.gray);
+      console.log(msg);
+      writeToFile(msg);
+    }
+  },
+  info(message, prefix = "aar") {
+    if (currentLogLevel <= 1 /* INFO */) {
+      const msg = formatMessage(prefix, message, chalk2.blue);
+      console.log(msg);
+      writeToFile(msg);
+    }
+  },
+  warn(message, prefix = "aar") {
+    if (currentLogLevel <= 2 /* WARN */) {
+      const msg = formatMessage(prefix, message, chalk2.yellow);
+      console.warn(msg);
+      writeToFile(msg);
+    }
+  },
+  error(message, prefix = "aar") {
+    if (currentLogLevel <= 3 /* ERROR */) {
+      const msg = formatMessage(prefix, message, chalk2.red);
+      console.error(msg);
+      writeToFile(msg);
+    }
+  }
+};
+
+// src/core/daemon-client.ts
+async function startDaemonProcess(options = {}) {
+  if (await isDaemonRunning()) {
+    const pid = await readPid();
+    console.log(`Daemon is already running (PID: ${pid}).`);
+    return;
+  }
+  await ensureDirs();
+  const nodeBin = process.argv[0];
+  const originalArgs = process.argv.slice(1);
+  const args = originalArgs.map((arg) => {
+    if (arg === "start") return "run";
+    return arg;
+  });
+  if (!args.includes("run")) {
+    const daemonIdx = args.indexOf("daemon");
+    if (daemonIdx !== -1) {
+      args.splice(daemonIdx + 1, 0, "run");
+    }
+  }
+  const cleanArgs = args.filter((a) => a !== "start" && a !== "restart");
+  if (options.tmux && !cleanArgs.includes("--tmux")) {
+    cleanArgs.push("--tmux");
+  }
+  console.log("Starting agent-auto-resume daemon in background...");
+  const outFd = fs5.openSync(LOG_FILE, "a");
+  const errFd = fs5.openSync(LOG_FILE, "a");
+  const child = spawn(nodeBin, cleanArgs, {
+    detached: true,
+    stdio: ["ignore", outFd, errFd],
+    env: {
+      ...process.env
+    }
+  });
+  child.unref();
+  for (let i = 0; i < 4; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    if (await isDaemonRunning()) {
+      const pid = await readPid();
+      console.log(`Daemon started successfully (PID: ${pid}). Log file: ${LOG_FILE}`);
+      return;
+    }
+  }
+  console.error("Failed to start daemon. Please check the log file for errors:");
+  console.error(LOG_FILE);
+}
+async function stopDaemonProcess() {
+  const pid = await readPid();
+  if (!pid || !await isDaemonRunning()) {
+    console.log("Daemon is not running.");
+    return;
+  }
+  console.log(`Stopping daemon (PID: ${pid})...`);
+  try {
+    process.kill(pid, "SIGTERM");
+    for (let i = 0; i < 10; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      if (!await isDaemonRunning()) {
+        console.log("Daemon stopped successfully.");
+        return;
+      }
+    }
+    console.warn("Daemon did not respond to SIGTERM. Force killing...");
+    process.kill(pid, "SIGKILL");
+    console.log("Daemon force killed.");
+  } catch (err) {
+    console.error(`Failed to stop daemon: ${err.message}`);
+  }
+}
+
+// src/core/transcript-watcher.ts
+import chokidar from "chokidar";
+import path5 from "path";
+import fs6 from "fs-extra";
+
+// src/core/time-parser.ts
+function parseTimeString(str, referenceDate = /* @__PURE__ */ new Date()) {
+  const retryAfterRegex = /(?:retry_after|retry after)["'\s]*:?\s*(\d+)/i;
+  const retryAfterMatch = str.match(retryAfterRegex);
+  if (retryAfterMatch) {
+    const seconds = parseInt(retryAfterMatch[1], 10);
+    if (!isNaN(seconds)) {
+      return new Date(referenceDate.getTime() + seconds * 1e3);
+    }
+  }
+  const isoRegex = /(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)/i;
+  const isoMatch = str.match(isoRegex);
+  if (isoMatch) {
+    const parsed = Date.parse(isoMatch[1]);
+    if (!isNaN(parsed)) {
+      return new Date(parsed);
+    }
+  }
+  const dateStrRegex = /(\d{4})-(\d{2})-(\d{2})\s+(\d{1,2}):(\d{2})(?::(\d{2}))?/;
+  const dateStrMatch = str.match(dateStrRegex);
+  if (dateStrMatch) {
+    const year = parseInt(dateStrMatch[1], 10);
+    const month = parseInt(dateStrMatch[2], 10) - 1;
+    const day = parseInt(dateStrMatch[3], 10);
+    const hour = parseInt(dateStrMatch[4], 10);
+    const minute = parseInt(dateStrMatch[5], 10);
+    const second = dateStrMatch[6] ? parseInt(dateStrMatch[6], 10) : 0;
+    const date = new Date(year, month, day, hour, minute, second);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  const keywordTimeRegex = /(?:reset|resets|resets_at|try again|try\s+again\s+at|at|resets\s+at|will\s+reset\s+at)\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i;
+  const keywordTimeMatch = str.match(keywordTimeRegex);
+  let hourStr = "";
+  let minStr = "";
+  let ampmStr = "";
+  if (keywordTimeMatch) {
+    hourStr = keywordTimeMatch[1];
+    minStr = keywordTimeMatch[2] || "0";
+    ampmStr = keywordTimeMatch[3] || "";
+  } else {
+    const exactTimeRegex = /^\s*(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*$/i;
+    const exactMatch = str.match(exactTimeRegex);
+    if (exactMatch) {
+      hourStr = exactMatch[1];
+      minStr = exactMatch[2] || "0";
+      ampmStr = exactMatch[3] || "";
+    } else {
+      const partialTimeRegex = /\b(\d{1,2}):(\d{2})\s*(am|pm)?\b|\b(\d{1,2})\s*(am|pm)\b/i;
+      const partialMatch = str.match(partialTimeRegex);
+      if (partialMatch) {
+        if (partialMatch[1] !== void 0) {
+          hourStr = partialMatch[1];
+          minStr = partialMatch[2];
+          ampmStr = partialMatch[3] || "";
+        } else {
+          hourStr = partialMatch[4];
+          minStr = "0";
+          ampmStr = partialMatch[5];
+        }
+      }
+    }
+  }
+  if (hourStr) {
+    let hour = parseInt(hourStr, 10);
+    const minute = parseInt(minStr, 10);
+    const ampm = ampmStr.toLowerCase();
+    if (ampm === "pm" && hour < 12) {
+      hour += 12;
+    } else if (ampm === "am" && hour === 12) {
+      hour = 0;
+    }
+    if (hour >= 0 && hour < 24 && minute >= 0 && minute < 60) {
+      const date = new Date(referenceDate);
+      date.setHours(hour, minute, 0, 0);
+      if (date.getTime() <= referenceDate.getTime()) {
+        date.setDate(date.getDate() + 1);
+      }
+      return date;
+    }
+  }
+  return void 0;
+}
+
+// src/providers/claude.ts
+var claudeProvider = {
+  name: "claude",
+  displayName: "Claude Code",
+  defaultCommand: ["claude"],
+  detectLimit(output) {
+    const lines = output.split(/\r?\n/);
+    const patterns = [
+      /5-hour limit reached/i,
+      /usage limit reached/i,
+      /rate limit reached/i,
+      /limit will reset at/i
+    ];
+    for (const line of lines) {
+      const matched = patterns.some((p) => p.test(line));
+      if (matched) {
+        const resetAt = parseTimeString(line);
+        return {
+          matched: true,
+          provider: "claude",
+          reason: line.trim(),
+          resetAt,
+          raw: line
+        };
+      }
+    }
+    return { matched: false, provider: "claude" };
+  },
+  getResumeCommand(state) {
+    return ["claude", "--continue"];
+  },
+  getResumeInput(state) {
+    return "continue\n";
+  },
+  getTranscriptDirs() {
+    return ["~/.claude/projects"];
+  },
+  parseTranscriptEvent(line) {
+    try {
+      const data = JSON.parse(line);
+      if (data && typeof data === "object") {
+        let text = data.text || data.message || data.content;
+        if (!text && data.input && typeof data.input === "object") {
+          text = data.input.text;
+        }
+        if (!text && data.output && typeof data.output === "object") {
+          text = data.output.text;
+        }
+        return {
+          text: typeof text === "string" ? text : void 0,
+          cwd: typeof data.cwd === "string" ? data.cwd : void 0,
+          sessionId: typeof data.sessionId === "string" ? data.sessionId : typeof data.uuid === "string" ? data.uuid : void 0,
+          timestamp: typeof data.timestamp === "string" ? data.timestamp : typeof data.createdAt === "string" ? data.createdAt : void 0
+        };
+      }
+    } catch {
+    }
+    return void 0;
+  }
+};
+
+// src/prompts/safe-resume.ts
+var CODEX_SAFE_RESUME_PROMPT = `
+Continue the previous task from where it stopped.
+
+Before making changes:
+1. Inspect the current repository state.
+2. Run git status.
+3. Inspect git diff.
+4. Read AGENT_PROGRESS.md if it exists.
+5. Identify what was already completed and what remains.
+6. Do not overwrite user changes.
+7. Continue only the remaining work.
+8. Run relevant tests if available.
+9. Summarize what changed and what remains.
+`;
+var ANTIGRAVITY_SAFE_RESUME_PROMPT = `
+Continue the previous task from where it stopped.
+
+Before making changes:
+1. Inspect the current workspace state.
+2. Run git status.
+3. Inspect git diff.
+4. Read AGENT_PROGRESS.md if it exists.
+5. Identify what was already completed and what remains.
+6. Do not overwrite user changes.
+7. Continue only the remaining work.
+8. Ask for confirmation before destructive operations.
+9. Run relevant tests if available.
+10. Summarize what changed and what remains.
+`;
+
+// src/providers/codex.ts
+var codexProvider = {
+  name: "codex",
+  displayName: "OpenAI Codex CLI",
+  defaultCommand: ["codex"],
+  detectLimit(output) {
+    const lines = output.split(/\r?\n/);
+    const patterns = [
+      /usage limit reached/i,
+      /rate limit reached/i,
+      /try again at/i,
+      /resets_at/i,
+      /usage_limit_reached/i
+    ];
+    for (const line of lines) {
+      const matched = patterns.some((p) => p.test(line));
+      if (matched) {
+        const resetAt = parseTimeString(line);
+        return {
+          matched: true,
+          provider: "codex",
+          reason: line.trim(),
+          resetAt,
+          raw: line
+        };
+      }
+    }
+    return { matched: false, provider: "codex" };
+  },
+  getResumeCommand(state) {
+    return [
+      "codex",
+      "exec",
+      "resume",
+      "--last",
+      CODEX_SAFE_RESUME_PROMPT.trim()
+    ];
+  },
+  getTranscriptDirs() {
+    return ["~/.codex/sessions"];
+  },
+  parseTranscriptEvent(line) {
+    try {
+      const data = JSON.parse(line);
+      if (data && typeof data === "object") {
+        const text = data.text || data.message || data.content;
+        return {
+          text: typeof text === "string" ? text : void 0,
+          cwd: typeof data.cwd === "string" ? data.cwd : void 0,
+          sessionId: typeof data.sessionId === "string" ? data.sessionId : void 0,
+          timestamp: typeof data.timestamp === "string" ? data.timestamp : void 0
+        };
+      }
+    } catch {
+    }
+    return void 0;
+  }
+};
+
+// src/providers/antigravity.ts
+import { execSync as execSync2 } from "child_process";
+var antigravityProvider = {
+  name: "antigravity",
+  displayName: "Google Antigravity CLI",
+  defaultCommand: ["agy"],
+  detectLimit(output) {
+    const lines = output.split(/\r?\n/);
+    const patterns = [
+      /usage limit reached/i,
+      /rate limit reached/i,
+      /quota exceeded/i,
+      /quota exhausted/i,
+      /daily limit reached/i,
+      /5-hour limit reached/i,
+      /reached your Antigravity limit/i,
+      /Antigravity usage limit reached/i,
+      /try again at/i,
+      /reset at/i,
+      /resets at/i,
+      /resets_at/i,
+      /retry after/i,
+      /retry_after/i
+    ];
+    for (const line of lines) {
+      const matched = patterns.some((p) => p.test(line));
+      if (matched) {
+        const resetAt = parseTimeString(line);
+        return {
+          matched: true,
+          provider: "antigravity",
+          reason: line.trim(),
+          resetAt,
+          raw: line
+        };
+      }
+    }
+    return { matched: false, provider: "antigravity" };
+  },
+  async getResumeCommand(state) {
+    let helpOutput = "";
+    try {
+      helpOutput = execSync2("agy --help", {
+        cwd: state.cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+    } catch {
+    }
+    if (helpOutput) {
+      if (helpOutput.includes("resume") && helpOutput.includes("--last")) {
+        return ["agy", "resume", "--last"];
+      }
+      if (helpOutput.includes("continue")) {
+        return ["agy", "continue"];
+      }
+      const lines = helpOutput.split("\n");
+      const hasC = lines.some((line) => {
+        const trimmed = line.trim();
+        return trimmed.startsWith("c ") || trimmed.startsWith("c	");
+      });
+      if (hasC) {
+        return ["agy", "c"];
+      }
+      if (helpOutput.includes("conversation") && helpOutput.includes("--last")) {
+        return ["agy", "conversation", "--last"];
+      }
+    }
+    return ["agy"];
+  },
+  getResumeInput(state) {
+    if (state.resumeCommand && state.resumeCommand.length === 1 && state.resumeCommand[0] === "agy") {
+      return ANTIGRAVITY_SAFE_RESUME_PROMPT.trim() + "\n";
+    }
+    return void 0;
+  },
+  getTranscriptDirs() {
+    return [];
+  }
+};
+
+// src/providers/index.ts
+function getProvider(name) {
+  const normalized = name.toLowerCase();
+  if (normalized === "agy" || normalized === "antigravity") {
+    return antigravityProvider;
+  }
+  if (normalized === "claude") {
+    return claudeProvider;
+  }
+  if (normalized === "codex") {
+    return codexProvider;
+  }
+  throw new Error(`Unsupported provider: ${name}`);
+}
+
+// src/core/detector.ts
+function detectLimit(output, providerName) {
+  if (providerName) {
+    try {
+      const provider = getProvider(providerName);
+      return provider.detectLimit(output);
+    } catch {
+    }
+  }
+  const allProviders = ["claude", "codex", "antigravity"];
+  for (const name of allProviders) {
+    const provider = getProvider(name);
+    const detection = provider.detectLimit(output);
+    if (detection.matched) {
+      return detection;
+    }
+  }
+  return { matched: false, provider: providerName || "claude" };
+}
+
+// src/core/transcript-watcher.ts
+var fileCursors = /* @__PURE__ */ new Map();
+async function startTranscriptWatcher(abortSignal) {
+  const config = await loadConfig();
+  const watchers = [];
+  const providersToWatch = ["claude", "codex"];
+  for (const providerName of providersToWatch) {
+    const providerConfig = config.providers[providerName];
+    if (!providerConfig || !providerConfig.enabled || !providerConfig.watchTranscripts) {
+      continue;
+    }
+    const provider = getProvider(providerName);
+    if (!provider.parseTranscriptEvent || !provider.getTranscriptDirs) {
+      continue;
+    }
+    const dirs = providerConfig.transcriptDirs.map(resolveHome);
+    for (const dir of dirs) {
+      if (!await fs6.pathExists(dir)) {
+        logger.debug(`Transcript watch directory does not exist: ${dir}, skipping`, "aar");
+        continue;
+      }
+      logger.info(`Starting transcript watcher for ${provider.displayName} at ${dir}`, "aar");
+      const watcher = chokidar.watch(dir, {
+        persistent: true,
+        ignoreInitial: false
+      });
+      watcher.on("add", (filePath) => handleFileChange(filePath, providerName));
+      watcher.on("change", (filePath) => handleFileChange(filePath, providerName));
+      watchers.push(watcher);
+    }
+  }
+  abortSignal?.addEventListener("abort", () => {
+    for (const w of watchers) {
+      w.close();
+    }
+    logger.info("Transcript watchers stopped.", "aar");
+  });
+}
+async function handleFileChange(filePath, providerName) {
+  const ext = path5.extname(filePath).toLowerCase();
+  if (ext !== ".json" && ext !== ".jsonl" && ext !== "") {
+    return;
+  }
+  try {
+    const stat = await fs6.stat(filePath);
+    const startCursor = fileCursors.get(filePath) || 0;
+    if (stat.size <= startCursor) {
+      fileCursors.set(filePath, stat.size);
+      return;
+    }
+    const fd = await fs6.open(filePath, "r");
+    const buffer = Buffer.alloc(stat.size - startCursor);
+    await fs6.read(fd, buffer, 0, buffer.length, startCursor);
+    await fs6.close(fd);
+    fileCursors.set(filePath, stat.size);
+    const content = buffer.toString("utf-8");
+    const lines = content.split(/\r?\n/);
+    const provider = getProvider(providerName);
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const event = provider.parseTranscriptEvent(line);
+      if (event && event.text) {
+        const detection = detectLimit(event.text, providerName);
+        if (detection.matched) {
+          logger.warn(`Limit detected via transcript watcher in file ${filePath}: ${detection.reason}`, "aar");
+          const sessions = await listSessions();
+          const matchedSession = sessions.find(
+            (s) => s.status === "running" && s.provider === providerName && (event.cwd ? s.cwd === event.cwd : true)
+          );
+          const resetAtStr = detection.resetAt ? detection.resetAt.toISOString() : void 0;
+          if (matchedSession) {
+            if (matchedSession.status !== "waiting_limit_reset") {
+              await updateSession(matchedSession.id, {
+                status: "waiting_limit_reset",
+                lastLimitDetectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                resetAt: resetAtStr,
+                lastOutputSnippet: event.text.slice(-1e3),
+                transcriptPath: filePath
+              });
+              logger.info(`Updated existing session ${matchedSession.id} to waiting_limit_reset`, "aar");
+            }
+          } else {
+            const config = await loadConfig();
+            const newSession = await createSession({
+              provider: providerName,
+              cwd: event.cwd || process.cwd(),
+              originalCommand: provider.defaultCommand,
+              resumeStrategy: providerName === "claude" ? "pty-input" : "command",
+              status: "waiting_limit_reset",
+              lastLimitDetectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              resetAt: resetAtStr,
+              attempts: 0,
+              maxAttempts: config.maxAttempts,
+              bufferSeconds: config.bufferSeconds,
+              lastOutputSnippet: event.text.slice(-1e3),
+              managedByAar: false,
+              source: "transcript-watcher",
+              transcriptPath: filePath
+            });
+            logger.info(`Created new session ${newSession.id} via transcript-watcher`, "aar");
+          }
+        }
+      }
+    }
+  } catch (err) {
+    logger.debug(`Error reading transcript file ${filePath}: ${err.message}`, "aar");
+  }
+}
+
+// src/core/tmux-watcher.ts
+import { execSync as execSync3 } from "child_process";
+var tmuxTimer;
+async function startTmuxWatcher(abortSignal) {
+  const config = await loadConfig();
+  if (!config.tmux.enabled) {
+    return;
+  }
+  try {
+    execSync3("tmux -V", { stdio: "ignore" });
+  } catch {
+    logger.warn("tmux is enabled in config, but 'tmux' command was not found. tmux watcher is disabled.", "aar");
+    return;
+  }
+  logger.info("Starting tmux watcher (experimental)...", "aar");
+  const poll = async () => {
+    if (abortSignal?.aborted) return;
+    try {
+      await checkTmuxPanes();
+    } catch (err) {
+      logger.debug(`Error checking tmux panes: ${err.message}`, "aar");
+    }
+    tmuxTimer = setTimeout(poll, config.tmux.pollIntervalMs || 5e3);
+  };
+  poll();
+  abortSignal?.addEventListener("abort", () => {
+    if (tmuxTimer) clearTimeout(tmuxTimer);
+    logger.info("Tmux watcher stopped.", "aar");
+  });
+}
+async function checkTmuxPanes() {
+  let listOutput = "";
+  try {
+    listOutput = execSync3("tmux list-panes -a -F '#{pane_id}|#{pane_pid}|#{pane_current_path}|#{pane_current_command}'", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return;
+  }
+  const panes = listOutput.split("\n").filter(Boolean).map((line) => {
+    const [paneId, panePid, paneCwd, paneCmd] = line.split("|");
+    return { paneId, panePid, paneCwd, paneCmd };
+  });
+  const providers = [
+    { name: "claude", cmdKeywords: ["claude", "claude-code"] },
+    { name: "codex", cmdKeywords: ["codex"] },
+    { name: "antigravity", cmdKeywords: ["agy", "antigravity"] }
+  ];
+  for (const pane of panes) {
+    const matchedProvider = providers.find(
+      (p) => p.cmdKeywords.some((keyword) => pane.paneCmd.toLowerCase().includes(keyword))
+    );
+    if (!matchedProvider) {
+      continue;
+    }
+    let paneOutput = "";
+    try {
+      paneOutput = execSync3(`tmux capture-pane -p -t ${pane.paneId}`, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+    } catch {
+      continue;
+    }
+    const detection = detectLimit(paneOutput, matchedProvider.name);
+    if (detection.matched) {
+      const sessions = await listSessions();
+      let matchedSession = sessions.find((s) => s.tmuxPaneId === pane.paneId && s.status === "waiting_limit_reset");
+      const resetAtStr = detection.resetAt ? detection.resetAt.toISOString() : void 0;
+      if (!matchedSession) {
+        matchedSession = sessions.find((s) => s.tmuxPaneId === pane.paneId && s.status === "running");
+        if (matchedSession) {
+          await updateSession(matchedSession.id, {
+            status: "waiting_limit_reset",
+            lastLimitDetectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            resetAt: resetAtStr,
+            lastOutputSnippet: paneOutput.slice(-1e3)
+          });
+          logger.info(`Updated tmux session ${matchedSession.id} to waiting_limit_reset`, "aar");
+        } else {
+          const config = await loadConfig();
+          const provider = getProvider(matchedProvider.name);
+          const newSession = await createSession({
+            provider: matchedProvider.name,
+            cwd: pane.paneCwd || process.cwd(),
+            originalCommand: provider.defaultCommand,
+            resumeStrategy: "pty-input",
+            status: "waiting_limit_reset",
+            lastLimitDetectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            resetAt: resetAtStr,
+            attempts: 0,
+            maxAttempts: config.maxAttempts,
+            bufferSeconds: config.bufferSeconds,
+            lastOutputSnippet: paneOutput.slice(-1e3),
+            managedByAar: false,
+            source: "tmux-watcher",
+            tmuxPaneId: pane.paneId
+          });
+          logger.info(`Created new session ${newSession.id} via tmux-watcher (pane: ${pane.paneId})`, "aar");
+        }
+      }
+    }
+  }
+}
+function sendKeysToTmux(paneId, keys) {
+  try {
+    execSync3(`tmux send-keys -t ${paneId} "${keys.replace(/"/g, '\\"')}"`, { stdio: "ignore" });
+    return true;
+  } catch (err) {
+    logger.error(`Failed to send keys to tmux pane ${paneId}: ${err.message}`, "aar");
+    return false;
+  }
+}
+
+// src/core/scheduler.ts
+function getWaitMs(state) {
+  if (!state.resetAt) {
+    return 0;
+  }
+  const resetTime = new Date(state.resetAt).getTime();
+  const bufferMs = (state.bufferSeconds ?? 120) * 1e3;
+  const targetTime = resetTime + bufferMs;
+  const now = Date.now();
+  return targetTime - now;
+}
+
+// src/core/process-manager.ts
+import pty from "node-pty";
+async function resumeSessionInBackground(state) {
+  const provider = getProvider(state.provider);
+  const resumeCommand = await provider.getResumeCommand(state);
+  const resumeInput = provider.getResumeInput ? await provider.getResumeInput(state) : void 0;
+  logger.info(`Resuming session ${state.id} with command: ${resumeCommand.join(" ")}`, "aar");
+  await updateSession(state.id, {
+    status: "resuming",
+    resumeCommand,
+    resumeInput,
+    attempts: state.attempts + 1
+  });
+  const cmd = resumeCommand[0];
+  const args = resumeCommand.slice(1);
+  let ptyProcess;
+  try {
+    ptyProcess = pty.spawn(cmd, args, {
+      name: "xterm-color",
+      cols: 80,
+      rows: 24,
+      cwd: state.cwd,
+      env: {
+        ...process.env,
+        AAR_SESSION_ID: state.id
+      }
+    });
+  } catch (err) {
+    logger.error(`Failed to spawn resume command: ${err.message}`, "aar");
+    await updateSession(state.id, { status: "failed" });
+    return false;
+  }
+  return new Promise((resolve) => {
+    let limitDetected = false;
+    let accumulatedOutput = "";
+    if (resumeInput) {
+      setTimeout(() => {
+        try {
+          ptyProcess.write(resumeInput);
+          logger.info(`Sent resume input to session ${state.id}: ${JSON.stringify(resumeInput)}`, "aar");
+        } catch (err) {
+          logger.error(`Failed to write resume input to PTY: ${err.message}`, "aar");
+        }
+      }, 2e3);
+    }
+    ptyProcess.onData(async (data) => {
+      accumulatedOutput += data;
+      if (accumulatedOutput.length > 8192) {
+        accumulatedOutput = accumulatedOutput.slice(-4096);
+      }
+      logger.debug(`[PTY Output ${state.id}] ${data.trim()}`, "aar");
+      if (!limitDetected) {
+        const detection = detectLimit(accumulatedOutput, state.provider);
+        if (detection.matched) {
+          limitDetected = true;
+          logger.warn(`Limit re-detected during resume for session ${state.id}`, "aar");
+          const resetAtStr = detection.resetAt ? detection.resetAt.toISOString() : void 0;
+          await updateSession(state.id, {
+            status: "waiting_limit_reset",
+            lastLimitDetectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            resetAt: resetAtStr,
+            lastOutputSnippet: accumulatedOutput.slice(-1e3)
+          });
+          try {
+            ptyProcess.kill();
+          } catch {
+          }
+        }
+      }
+    });
+    ptyProcess.onExit(async (res) => {
+      const current = await getSession(state.id);
+      if (!current) {
+        return resolve(false);
+      }
+      if (current.status === "resuming") {
+        if (res.exitCode === 0) {
+          logger.info(`Session ${state.id} completed successfully.`, "aar");
+          await updateSession(state.id, { status: "completed" });
+          resolve(true);
+        } else {
+          logger.info(`Session ${state.id} exited with code ${res.exitCode}.`, "aar");
+          await updateSession(state.id, { status: "failed" });
+          resolve(false);
+        }
+      } else if (current.status === "waiting_limit_reset") {
+        resolve(false);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+
+// src/core/daemon.ts
+var AarDaemon = class {
+  abortController = null;
+  timer = null;
+  isProcessing = false;
+  async start(options = {}) {
+    if (await isDaemonRunning()) {
+      logger.error("Daemon is already running.", "aar");
+      process.exit(1);
+    }
+    await ensureDirs();
+    await writePid(process.pid);
+    logger.info(`Daemon started with PID ${process.pid}`, "aar");
+    this.abortController = new AbortController();
+    const config = await loadConfig();
+    if (options.tmux !== void 0) {
+      config.tmux.enabled = options.tmux;
+    }
+    await startTranscriptWatcher(this.abortController.signal);
+    if (config.tmux.enabled) {
+      await startTmuxWatcher(this.abortController.signal);
+    }
+    const shutdown = async () => {
+      logger.info("Daemon shutting down...", "aar");
+      if (this.timer) {
+        clearTimeout(this.timer);
+      }
+      this.abortController?.abort();
+      await clearPid();
+      logger.info("Daemon stopped.", "aar");
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    const loop = async () => {
+      if (this.abortController?.signal.aborted) {
+        return;
+      }
+      if (!this.isProcessing) {
+        this.isProcessing = true;
+        try {
+          await this.processWaitingSessions();
+        } catch (err) {
+          logger.error(`Error in daemon loop: ${err.message}`, "aar");
+        } finally {
+          this.isProcessing = false;
+        }
+      }
+      this.timer = setTimeout(loop, config.daemon.pollIntervalMs || 5e3);
+    };
+    loop();
+  }
+  async processWaitingSessions() {
+    const waiting = await getWaitingSessions();
+    for (const session of waiting) {
+      if (!session.resetAt) {
+        logger.warn(`Session ${session.id} reset time is unknown. Mark as failed.`, "aar");
+        await updateSession(session.id, {
+          status: "failed"
+        });
+        continue;
+      }
+      const waitMsLeft = getWaitMs(session);
+      if (waitMsLeft <= 0) {
+        logger.info(`Session ${session.id} is ready to resume (Wait completed).`, "aar");
+        await updateSession(session.id, {
+          status: "ready_to_resume"
+        });
+        if (session.attempts >= session.maxAttempts) {
+          logger.warn(`Session ${session.id} exceeded max resume attempts (${session.maxAttempts}). Mark as failed.`, "aar");
+          await updateSession(session.id, {
+            status: "failed"
+          });
+          continue;
+        }
+        if (session.source === "tmux-watcher" && session.tmuxPaneId) {
+          const provider = getProvider(session.provider);
+          const resumeInput = provider.getResumeInput ? await provider.getResumeInput(session) : void 0;
+          if (resumeInput) {
+            logger.info(`Resuming tmux session ${session.id} in pane ${session.tmuxPaneId}`, "aar");
+            await updateSession(session.id, {
+              status: "resuming",
+              attempts: session.attempts + 1
+            });
+            const sent = sendKeysToTmux(session.tmuxPaneId, resumeInput);
+            if (sent) {
+              await updateSession(session.id, {
+                status: "running"
+              });
+              logger.info(`Sent resume input to tmux pane successfully.`, "aar");
+            } else {
+              await updateSession(session.id, {
+                status: "failed"
+              });
+            }
+          } else {
+            await updateSession(session.id, {
+              status: "failed"
+            });
+          }
+        } else {
+          try {
+            const success = await resumeSessionInBackground(session);
+            if (success) {
+              logger.info(`Session ${session.id} resumed and completed successfully.`, "aar");
+            } else {
+              logger.warn(`Session ${session.id} resume failed or hit limit again.`, "aar");
+            }
+          } catch (err) {
+            logger.error(`Failed to resume session ${session.id}: ${err.message}`, "aar");
+            await updateSession(session.id, {
+              status: "failed"
+            });
+          }
+        }
+      } else {
+        const secondsLeft = Math.ceil(waitMsLeft / 1e3);
+        logger.debug(`Session ${session.id} waiting... ${secondsLeft}s left`, "aar");
+      }
+    }
+  }
+};
+
+// src/commands/daemon.ts
+import fs7 from "fs-extra";
+import chalk3 from "chalk";
+async function handleDaemon(action, options) {
+  const cleanAction = action.toLowerCase();
+  if (cleanAction === "start") {
+    await startDaemonProcess(options);
+  } else if (cleanAction === "stop") {
+    await stopDaemonProcess();
+  } else if (cleanAction === "restart") {
+    console.log("Restarting daemon...");
+    await stopDaemonProcess();
+    await startDaemonProcess(options);
+  } else if (cleanAction === "status") {
+    const running = await isDaemonRunning();
+    if (running) {
+      const pid = await readPid();
+      console.log(chalk3.green(`Daemon is RUNNING (PID: ${pid})`));
+    } else {
+      console.log(chalk3.red("Daemon is STOPPED"));
+    }
+  } else if (cleanAction === "logs") {
+    if (await fs7.pathExists(LOG_FILE)) {
+      const content = await fs7.readFile(LOG_FILE, "utf-8");
+      console.log(content);
+    } else {
+      console.log("No log file found.");
+    }
+  } else if (cleanAction === "run") {
+    const daemon = new AarDaemon();
+    await daemon.start(options);
+  } else {
+    console.error(`Unknown daemon action: ${action}`);
+    process.exit(1);
+  }
+}
+
+// src/core/pty-runner.ts
+import pty2 from "node-pty";
+async function runInPty(options) {
+  const { providerName, command, args, cwd = process.cwd(), sessionId } = options;
+  const config = await loadConfig();
+  const provider = getProvider(providerName);
+  let session;
+  if (sessionId) {
+    const existing = await getSession(sessionId);
+    if (existing) {
+      session = existing;
+    } else {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+  } else {
+    session = await createSession({
+      provider: providerName,
+      cwd,
+      originalCommand: [command, ...args],
+      resumeStrategy: providerName === "claude" ? "pty-input" : "command",
+      status: "running",
+      attempts: 0,
+      maxAttempts: config.maxAttempts,
+      bufferSeconds: config.bufferSeconds,
+      managedByAar: true,
+      source: "managed-pty"
+    });
+  }
+  logger.info(`Managed session started: ${session.id}`, "aar");
+  const ptyProcess = pty2.spawn(command, args, {
+    name: "xterm-color",
+    cols: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24,
+    cwd,
+    env: {
+      ...process.env,
+      AAR_SESSION_ID: session.id
+    }
+  });
+  await updateSession(session.id, { pid: ptyProcess.pid, status: "running" });
+  let limitDetected = false;
+  let accumulatedOutput = "";
+  const resizeHandler = () => {
+    try {
+      ptyProcess.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+    } catch {
+    }
+  };
+  process.stdout.on("resize", resizeHandler);
+  const stdinHandler = (data) => {
+    ptyProcess.write(data.toString());
+  };
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  process.stdin.on("data", stdinHandler);
+  ptyProcess.onData(async (data) => {
+    process.stdout.write(data);
+    accumulatedOutput += data;
+    if (accumulatedOutput.length > 8192) {
+      accumulatedOutput = accumulatedOutput.slice(-4096);
+    }
+    if (!limitDetected) {
+      const detection = detectLimit(accumulatedOutput, providerName);
+      if (detection.matched) {
+        limitDetected = true;
+        const resetAtStr = detection.resetAt ? detection.resetAt.toISOString() : void 0;
+        logger.warn(`Usage limit detected for ${provider.displayName}!`, "aar");
+        if (resetAtStr) {
+          logger.warn(`Resets at: ${detection.resetAt?.toLocaleString()}`, "aar");
+        } else {
+          logger.warn("Reset time not specified. Auto-resume will fail without manual intervention or retry-now.", "aar");
+        }
+        await updateSession(session.id, {
+          status: "waiting_limit_reset",
+          lastLimitDetectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          resetAt: resetAtStr,
+          lastOutputSnippet: accumulatedOutput.slice(-1e3)
+        });
+        console.log(`
+
+\x1B[33m[aar] Usage limit detected. Setting session to waiting state...\x1B[0m`);
+        console.log(`\x1B[33m[aar] Session ID: ${session.id}\x1B[0m`);
+        if (resetAtStr) {
+          console.log(`\x1B[33m[aar] Scheduled to resume after reset time + buffer seconds.\x1B[0m`);
+        } else {
+          console.log(`\x1B[31m[aar] Warning: Reset time unknown. Run 'aar retry-now --id ${session.id}' manually if needed.\x1B[0m`);
+        }
+        try {
+          ptyProcess.kill();
+        } catch {
+        }
+      }
+    }
+  });
+  ptyProcess.onExit(async (res) => {
+    process.stdout.off("resize", resizeHandler);
+    process.stdin.off("data", stdinHandler);
+    try {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+    } catch {
+    }
+    const currentSession = await getSession(session.id);
+    if (currentSession) {
+      if (currentSession.status === "running") {
+        await updateSession(session.id, {
+          status: res.exitCode === 0 ? "completed" : "failed",
+          pid: void 0
+        });
+      } else if (currentSession.status === "waiting_limit_reset") {
+        await updateSession(session.id, {
+          pid: void 0
+        });
+      }
+    }
+    process.exit(res.exitCode);
+  });
+}
+
+// src/commands/managed.ts
+async function runManaged(providerNameStr, args) {
+  let providerName;
+  try {
+    const prov = getProvider(providerNameStr);
+    providerName = prov.name;
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+  if (args.length === 0) {
+    console.error("No command specified. Usage: aar managed <provider> -- <command...>");
+    process.exit(1);
+  }
+  const command = args[0];
+  const cmdArgs = args.slice(1);
+  await runInPty({
+    providerName,
+    command,
+    args: cmdArgs,
+    cwd: process.cwd()
+  });
+}
+
+// src/commands/run.ts
+async function runGeneric(options, args) {
+  if (!options.provider) {
+    console.error("Provider must be specified via --provider <provider>");
+    process.exit(1);
+  }
+  await runManaged(options.provider, args);
+}
+
+// src/commands/status.ts
+import chalk4 from "chalk";
+async function runStatus(options) {
+  const daemonRunning = await isDaemonRunning();
+  const daemonPid = await readPid();
+  const waitingSessions = await getWaitingSessions();
+  const statusData = {
+    daemon: {
+      running: daemonRunning,
+      pid: daemonPid
+    },
+    waitingSessions: waitingSessions.map((s) => {
+      const waitMs = getWaitMs(s);
+      const nextResume = s.resetAt ? new Date(new Date(s.resetAt).getTime() + (s.bufferSeconds ?? 120) * 1e3) : null;
+      return {
+        id: s.id,
+        provider: s.provider,
+        cwd: s.cwd,
+        attempts: s.attempts,
+        resetAt: s.resetAt,
+        nextResumeAt: nextResume ? nextResume.toISOString() : null,
+        secondsLeft: waitMs > 0 ? Math.ceil(waitMs / 1e3) : 0
+      };
+    })
+  };
+  if (options.json) {
+    console.log(JSON.stringify(statusData, null, 2));
+    return;
+  }
+  console.log(chalk4.bold("--- agent-auto-resume status ---"));
+  if (daemonRunning) {
+    console.log(`Daemon Status: ${chalk4.green("RUNNING")} (PID: ${daemonPid})`);
+  } else {
+    console.log(`Daemon Status: ${chalk4.red("STOPPED")}`);
+  }
+  console.log(`
+Waiting Sessions (${waitingSessions.length}):`);
+  if (waitingSessions.length === 0) {
+    console.log("  No waiting sessions.");
+  } else {
+    for (const s of statusData.waitingSessions) {
+      console.log(`
+  Session ID: ${chalk4.cyan(s.id)} [${s.provider}]`);
+      console.log(`    CWD: ${s.cwd}`);
+      console.log(`    Attempts: ${s.attempts}`);
+      if (s.resetAt) {
+        console.log(`    Limit reset time: ${new Date(s.resetAt).toLocaleString()}`);
+        console.log(`    Auto-resume scheduled: ${s.nextResumeAt ? new Date(s.nextResumeAt).toLocaleString() : "Unknown"}`);
+        console.log(`    Time remaining: ${s.secondsLeft > 0 ? `${s.secondsLeft}s` : "Ready to resume"}`);
+      } else {
+        console.log(`    ${chalk4.yellow("Warning: Reset time unknown. Auto-resume will not happen automatically.")}`);
+      }
+    }
+  }
+}
+
+// src/commands/sessions.ts
+import chalk5 from "chalk";
+async function runSessions(options) {
+  const sessions = await listSessions();
+  if (options.json) {
+    console.log(JSON.stringify(sessions, null, 2));
+    return;
+  }
+  console.log(chalk5.bold(`--- agent-auto-resume sessions (${sessions.length}) ---`));
+  if (sessions.length === 0) {
+    console.log("No sessions found.");
+    return;
+  }
+  for (const s of sessions) {
+    const statusColor = s.status === "completed" ? chalk5.green : s.status === "waiting_limit_reset" ? chalk5.yellow : s.status === "failed" ? chalk5.red : s.status === "running" ? chalk5.blue : chalk5.gray;
+    console.log(`
+Session ID: ${chalk5.cyan(s.id)} [${s.provider}]`);
+    console.log(`  Status: ${statusColor(s.status)}`);
+    console.log(`  CWD: ${s.cwd}`);
+    console.log(`  Created: ${new Date(s.createdAt).toLocaleString()}`);
+    console.log(`  Command: ${s.originalCommand.join(" ")}`);
+    if (s.resetAt) {
+      console.log(`  Reset time: ${new Date(s.resetAt).toLocaleString()}`);
+    }
+  }
+}
+
+// src/commands/recover.ts
+import chalk6 from "chalk";
+async function runRecover(options) {
+  let session;
+  if (options.id) {
+    session = await getSession(options.id);
+    if (!session) {
+      console.error(chalk6.red(`Error: Session with ID ${options.id} not found.`));
+      process.exit(1);
+    }
+  } else if (options.last) {
+    session = await getLastSession();
+    if (!session) {
+      console.error(chalk6.red("Error: No sessions found."));
+      process.exit(1);
+    }
+  } else {
+    const recoverable = await getRecoverableSessions();
+    if (recoverable.length === 0) {
+      console.log("No recoverable sessions found.");
+      return;
+    }
+    console.log(chalk6.bold("Recoverable sessions:"));
+    for (const r of recoverable) {
+      console.log(`  - ID: ${chalk6.cyan(r.id)} [${r.provider}] Status: ${r.status} (${r.originalCommand.join(" ")})`);
+    }
+    console.log("\nUse 'aar recover --id <session-id>' or 'aar recover --last' to recover.");
+    return;
+  }
+  const recoverableStatuses = ["waiting_limit_reset", "ready_to_resume", "failed", "resuming", "cancelled"];
+  if (!recoverableStatuses.includes(session.status)) {
+    console.warn(chalk6.yellow(`Warning: Session ${session.id} status is '${session.status}', which might not need recovery.`));
+  }
+  console.log(`Attempting to recover session ${chalk6.cyan(session.id)}...`);
+  await updateSession(session.id, {
+    source: "manual-recover"
+  });
+  const success = await resumeSessionInBackground(session);
+  if (success) {
+    console.log(chalk6.green(`\u2713 Session ${session.id} recovered and completed successfully.`));
+  } else {
+    console.log(chalk6.red(`\u2717 Recovery failed or session hit limit again. Status is currently saved.`));
+  }
+}
+
+// src/commands/retry-now.ts
+import chalk7 from "chalk";
+async function runRetryNow(options) {
+  let session;
+  if (options.id) {
+    session = await getSession(options.id);
+    if (!session) {
+      console.error(chalk7.red(`Error: Session with ID ${options.id} not found.`));
+      process.exit(1);
+    }
+  } else if (options.last) {
+    session = await getLastSession();
+    if (!session) {
+      console.error(chalk7.red("Error: No sessions found."));
+      process.exit(1);
+    }
+  } else {
+    console.error(chalk7.red("Error: Must specify either --id <session-id> or --last."));
+    process.exit(1);
+  }
+  const waitMs = getWaitMs(session);
+  if (waitMs > 0 && !options.force) {
+    const secondsLeft = Math.ceil(waitMs / 1e3);
+    console.log(chalk7.yellow(`Warning: Limit reset time has not yet passed for session ${session.id}.`));
+    console.log(`Time remaining: ${secondsLeft} seconds.`);
+    console.log("Run with '--force' to retry immediately (not recommended).");
+    return;
+  }
+  console.log(`Starting immediate retry for session ${chalk7.cyan(session.id)}...`);
+  await updateSession(session.id, {
+    status: "ready_to_resume"
+  });
+  const success = await resumeSessionInBackground(session);
+  if (success) {
+    console.log(chalk7.green(`\u2713 Session ${session.id} resumed and completed successfully.`));
+  } else {
+    console.log(chalk7.red(`\u2717 Retry failed or hit limit again.`));
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("aar").description("Daemon-based auto-resume CLI tool for Claude Code, Codex, and Antigravity").version("0.1.0");
+program.command("setup").description("Setup state directories, configuration, and shell integration").option("--shell <type>", "Specify shell type (zsh, bash, fish)").option("--no-shell-modify", "Do not modify shell configuration files automatically").option("--print-shell-snippet", "Only print the shell snippet to stdout").action(runSetup);
+program.command("daemon <action>").description("Manage the agent-auto-resume daemon (actions: start, stop, restart, status, logs, run)").option("--tmux", "Enable experimental tmux watcher").action((action, options) => handleDaemon(action, options));
+program.command("managed <provider>").description("Run a CLI tool in managed mode under PTY").argument("[command...]", "Command to execute (e.g. claude, codex, agy)").action((provider, args) => runManaged(provider, args));
+program.command("run").description("Generic run command to wrap any agent CLI under a provider").option("--provider <provider>", "Specify provider (claude, codex, antigravity)").argument("[command...]", "Command to execute").action((args, options) => {
+  runGeneric(options, args);
+});
+program.command("status").description("Show daemon status, waiting sessions, and next resume schedules").option("--json", "Format output as JSON").action(runStatus);
+program.command("sessions").description("List all saved sessions and their statuses").option("--json", "Format output as JSON").action(runSessions);
+program.command("recover").description("Manually recover waiting, failed, or cancelled sessions").option("--last", "Recover the most recent session").option("--id <session-id>", "Recover session by ID").action(runRecover);
+program.command("retry-now").description("Retry waiting sessions immediately").option("--id <session-id>", "Session ID to retry").option("--last", "Retry the most recent waiting session").option("--force", "Force retry even if reset time has not passed").action(runRetryNow);
+program.command("claude").description("One-shot wrapper to run Claude Code in managed mode").allowUnknownOption().action(() => {
+  const idx = process.argv.indexOf("claude");
+  const forwardedArgs = process.argv.slice(idx + 1);
+  runManaged("claude", ["claude", ...forwardedArgs]);
+});
+program.command("codex").description("One-shot wrapper to run Codex CLI in managed mode").allowUnknownOption().action(() => {
+  const idx = process.argv.indexOf("codex");
+  const forwardedArgs = process.argv.slice(idx + 1);
+  runManaged("codex", ["codex", ...forwardedArgs]);
+});
+program.command("antigravity").description("One-shot wrapper to run Antigravity CLI in managed mode").allowUnknownOption().action(() => {
+  const idx = process.argv.indexOf("antigravity");
+  const forwardedArgs = process.argv.slice(idx + 1);
+  runManaged("antigravity", ["agy", ...forwardedArgs]);
+});
+program.command("agy").description("Alias for antigravity command").allowUnknownOption().action(() => {
+  const idx = process.argv.indexOf("agy");
+  const forwardedArgs = process.argv.slice(idx + 1);
+  runManaged("antigravity", ["agy", ...forwardedArgs]);
+});
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map