fifony 0.1.31 → 0.1.32

package/dist/{chunk-IYAF3SY6.js → chunk-2D5P75F6.js}

@@ -35,7 +35,7 @@ import {
   writeFileSync
 } from "fs";
 import { join as join6 } from "path";
-import { env } from "process";
+import { env as env2 } from "process";
 import { spawn } from "child_process";
 
 // src/agents/providers.ts
@@ -309,9 +309,531 @@ function extractPlanDirs(plan) {
   return [...dirs];
 }
 
+// src/agents/adapters/usage.ts
+import { cwd, env } from "process";
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function createPtyProcess(command, args) {
+  try {
+    const nodePty = await import("node-pty");
+    if (typeof nodePty.spawn !== "function") {
+      return null;
+    }
+    return nodePty.spawn(command, args, {
+      name: "xterm-color",
+      cols: 160,
+      rows: 48,
+      cwd: cwd(),
+      env
+    });
+  } catch (error) {
+    logger.debug(`Failed to initialize node-pty for ${command}: ${String(error)}`);
+    return null;
+  }
+}
+function stripTerminalEscapes(input) {
+  return input.replace(/\x1B\[[?>=!]?[0-9;]*[A-HJKSTdfG]/g, " ").replace(/\x1B\[[?>=!]?[0-9;]*[a-zI-Ri-z~]/g, "").replace(/\x1B\[[?>=!]?[0-9;]*[A-Za-z~]/g, "").replace(/\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[()#][A-Za-z0-9]/g, "").replace(/\x1B[A-Za-z]/g, "").replace(/[^\x20-\x7E\r\n\t]/g, "").replace(/[ \t]{2,}/g, " ");
+}
+function parseNumber(value) {
+  if (!value) return 0;
+  const clean = value.replace(/[^\d]/g, "");
+  if (!clean) return 0;
+  const parsed = Number.parseInt(clean, 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function parseTokenQuantity(value) {
+  if (!value) return 0;
+  const match = value.replace(/,/g, "").trim().match(/^([0-9]+(?:\.[0-9]+)?)([kKmMbBtT]?)$/);
+  if (!match) {
+    const fallback = parseNumber(value);
+    return fallback;
+  }
+  const number = Number.parseFloat(match[1]);
+  if (!Number.isFinite(number)) return 0;
+  const suffix = match[2].toLowerCase();
+  if (suffix === "t") return number * 1e12;
+  if (suffix === "b") return number * 1e9;
+  if (suffix === "m") return number * 1e6;
+  if (suffix === "k") return number * 1e3;
+  return number;
+}
+function parsePercent(value) {
+  if (!value) return null;
+  const parsed = Number.parseFloat(value.replace("%", ""));
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function keepLargest(current, incoming) {
+  if (!Number.isFinite(incoming)) return current ?? 0;
+  if (incoming <= 0) return current ?? 0;
+  return current === null ? incoming : Math.max(current, incoming);
+}
+var MONTH_MAP = {
+  jan: 0,
+  feb: 1,
+  mar: 2,
+  apr: 3,
+  may: 4,
+  jun: 5,
+  jul: 6,
+  aug: 7,
+  sep: 8,
+  oct: 9,
+  nov: 10,
+  dec: 11
+};
+function toMonthIndex(value) {
+  const index = MONTH_MAP[value.toLowerCase().slice(0, 3)];
+  return typeof index === "number" ? index : null;
+}
+function normalizeResetText(value) {
+  return value.replace(/\([^)]*\)/g, " ").replace(/\s+/g, " ").trim();
+}
+function parseResetTime(value) {
+  const match = value.trim().match(/^(\d{1,2})(?::(\d{2}))?\s*([AaPp][Mm])?$/);
+  if (!match) return null;
+  let hour = Number.parseInt(match[1], 10);
+  const minute = Number.parseInt(match[2] || "0", 10);
+  if (!Number.isFinite(hour) || !Number.isFinite(minute)) return null;
+  if (hour < 0 || hour > 23 || minute < 0 || minute > 59) return null;
+  const suffix = match[3]?.toLowerCase();
+  if (suffix === "pm" && hour !== 12) hour += 12;
+  if (suffix === "am" && hour === 12) hour = 0;
+  return { hour, minute };
+}
+function parseResetDateFromText(raw) {
+  const text = normalizeResetText(raw);
+  if (!text) return null;
+  const now2 = /* @__PURE__ */ new Date();
+  const explicitDateMatch = text.match(/([A-Za-z]{3,9})\s*(\d{1,2})(?:,?|\s+)(\d{1,2}:\d{2}(?:\s*[AaPp][Mm])?)/i) || text.match(/(\d{1,2})\s+([A-Za-z]{3,9})(?:,\s*)?(\d{1,2}:\d{2}(?:\s*[AaPp][Mm])?)/i);
+  if (explicitDateMatch) {
+    const [, monthRaw, dayRaw, timeRaw] = explicitDateMatch;
+    const day = Number.parseInt(dayRaw, 10);
+    const monthIndex = toMonthIndex(monthRaw);
+    const time2 = parseResetTime(timeRaw);
+    if (!Number.isNaN(day) && monthIndex !== null && time2) {
+      const candidate = new Date(now2);
+      candidate.setMonth(monthIndex);
+      candidate.setDate(day);
+      candidate.setHours(time2.hour, time2.minute, 0, 0);
+      if (candidate.getTime() <= now2.getTime()) {
+        candidate.setFullYear(now2.getFullYear() + 1);
+      }
+      return candidate.toISOString();
+    }
+  }
+  const timeMatch = text.match(/(\d{1,2}:\d{2}(?:\s*[AaPp][Mm])?)/i) || text.match(/(\d{1,2})(?:\s*([AaPp][Mm]))/i);
+  const time = timeMatch?.[1] ? parseResetTime(timeMatch[1]) : null;
+  if (time) {
+    const candidate = new Date(now2);
+    candidate.setHours(time.hour, time.minute, 0, 0);
+    if (candidate.getTime() <= now2.getTime()) {
+      candidate.setDate(candidate.getDate() + 1);
+    }
+    return candidate.toISOString();
+  }
+  return null;
+}
+function initSnapshot(raw) {
+  return {
+    currentModel: null,
+    allTimeInputTokens: null,
+    allTimeOutputTokens: null,
+    todayInputTokens: null,
+    todayOutputTokens: null,
+    thisWeekInputTokens: null,
+    thisWeekOutputTokens: null,
+    last5HoursInputTokens: null,
+    last5HoursOutputTokens: null,
+    allTimeSessions: null,
+    todaySessions: null,
+    thisWeekSessions: null,
+    last5HoursSessions: null,
+    weeklyLimitEstimate: null,
+    weeklyPercentUsed: null,
+    resetInfo: null,
+    nextResetAt: null,
+    version: null,
+    plan: null,
+    account: null,
+    effort: null,
+    sessionPercentUsed: null,
+    sessionResetInfo: null,
+    rateLimits: [],
+    raw
+  };
+}
+function waitForOutput(getOutput, pattern, timeoutMs, pollMs = 100) {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve2) => {
+    const check = () => {
+      if (pattern.test(getOutput())) return resolve2(true);
+      if (Date.now() >= deadline) return resolve2(false);
+      setTimeout(check, pollMs);
+    };
+    check();
+  });
+}
+var TRUST_PROMPT_RE = /trust this folder|trust this project|safety check|Do you trust/i;
+var CLI_READY_RE = /[❯›▶>]\s|Type your message|for shortcuts|\/model to change/;
+async function collectProviderStatusText(command, args, statusCommand) {
+  try {
+    const ptyProcess = await createPtyProcess(command, args);
+    if (!ptyProcess) return null;
+    let output = "";
+    ptyProcess.onData((data) => {
+      output += data;
+    });
+    const gotPrompt = await waitForOutput(
+      () => output,
+      new RegExp(`${TRUST_PROMPT_RE.source}|${CLI_READY_RE.source}`, "i"),
+      5e3,
+      100
+    );
+    if (gotPrompt && TRUST_PROMPT_RE.test(output)) {
+      logger.debug(`Trust prompt detected for ${command}, auto-accepting`);
+      ptyProcess.write("\r");
+      await waitForOutput(() => output, CLI_READY_RE, 5e3, 100);
+    } else if (!gotPrompt) {
+      logger.debug(`PTY prompt not detected for ${command}, sending command after fallback wait`);
+      await sleep(3e3);
+    }
+    let prevLen = output.length;
+    await sleep(800);
+    if (output.length !== prevLen) {
+      await sleep(1200);
+    }
+    ptyProcess.write(`${statusCommand}\r`);
+    await sleep(3e3);
+    ptyProcess.write("\x1B");
+    await sleep(200);
+    ptyProcess.write("");
+    await sleep(200);
+    try {
+      ptyProcess.kill();
+    } catch {
+    }
+    return stripTerminalEscapes(output).trim();
+  } catch (error) {
+    logger.debug(`Failed collecting status via pty for ${command}: ${String(error)}`);
+    return null;
+  }
+}
+function parseClaudeUsageHeading(line) {
+  if (/current week.*all models/i.test(line)) return { section: "current-week-all" };
+  const modelWeekMatch = line.match(/current week\s*\((\w+)\s+only\)/i);
+  if (modelWeekMatch) return { section: "current-week-model", modelScope: modelWeekMatch[1].toLowerCase() };
+  if (/current session/i.test(line)) return { section: "current-session" };
+  return null;
+}
+function formatClaudeModelFromLabel(label) {
+  const normalized = label.trim().toLowerCase();
+  const compact = normalized.replace(/\s+/g, "-");
+  if (compact.includes("opus")) return `claude-${compact}`;
+  if (compact.includes("sonnet")) return `claude-${compact}`;
+  if (compact.includes("haiku")) return `claude-${compact}`;
+  if (compact.startsWith("claude-")) return compact;
+  return label.trim();
+}
+function parseClaudeUsageFromStatus(raw) {
+  const base = initSnapshot(raw);
+  base.weeklyPercentUsed = null;
+  const lines = raw.split(/[\r\n]+/).map((line) => line.trim()).filter(Boolean);
+  let currentHeading = null;
+  let lastPercentSection = null;
+  let lastPercentUsed = null;
+  for (const line of lines) {
+    const normalized = line.toLowerCase();
+    if (/^esc to cancel/i.test(normalized)) continue;
+    if (/^loading/i.test(normalized)) continue;
+    if (/^status dialog/i.test(normalized)) continue;
+    const versionMatch = line.match(/Claude Code v(\d+\.\d+\.\d+)/i);
+    if (versionMatch?.[1]) {
+      base.version = versionMatch[1];
+      continue;
+    }
+    const effortMatch = line.match(/with\s+(high|medium|low|extra\s*high)\s+effort/i);
+    if (effortMatch?.[1]) {
+      base.effort = effortMatch[1].toLowerCase();
+      const afterEffort = line.slice(line.indexOf(effortMatch[0]) + effortMatch[0].length).trim();
+      if (afterEffort && /^[A-Z]/.test(afterEffort)) {
+        base.plan = afterEffort;
+      }
+    }
+    const heading = parseClaudeUsageHeading(line);
+    if (heading) {
+      currentHeading = heading;
+      continue;
+    }
+    const modelMatch = line.match(/\b(opus|sonnet|haiku)\s*\d+(?:\.\d+)?(?:\s*-\d+)?/i);
+    if (modelMatch?.[0]) {
+      base.currentModel = formatClaudeModelFromLabel(modelMatch[0]);
+    }
+    const percentMatch = normalized.match(/(\d+)%\s*used/i);
+    if (percentMatch?.[1] && currentHeading) {
+      const used = parseInt(percentMatch[1], 10);
+      lastPercentSection = currentHeading;
+      lastPercentUsed = used;
+      if (currentHeading.section === "current-week-all") {
+        base.weeklyPercentUsed = keepLargest(base.weeklyPercentUsed, used);
+      }
+      if (currentHeading.section === "current-session") {
+        base.sessionPercentUsed = used;
+        base.currentModel = base.currentModel || "claude";
+      }
+      const scope = currentHeading.section === "current-session" ? "session" : currentHeading.section === "current-week-model" ? currentHeading.modelScope || "unknown" : "global";
+      const period = currentHeading.section === "current-session" ? "session" : "weekly";
+      base.rateLimits.push({ scope, period, percentUsed: used, resetInfo: null, nextResetAt: null });
+    }
+    const resetMatch = line.match(/Rese\w*\s+(.+?)$/i);
+    if (resetMatch?.[1] && lastPercentSection) {
+      const resetText = resetMatch[1].trim();
+      const nextResetAt = parseResetDateFromText(resetText);
+      if (lastPercentSection.section === "current-week-all") {
+        base.resetInfo = `Current week resets ${resetText}`;
+        base.nextResetAt = nextResetAt || base.nextResetAt;
+      }
+      if (lastPercentSection.section === "current-session") {
+        base.sessionResetInfo = `Resets ${resetText}`;
+      }
+      const last = base.rateLimits[base.rateLimits.length - 1];
+      if (last) {
+        last.resetInfo = `Resets ${resetText}`;
+        last.nextResetAt = nextResetAt;
+      }
+      lastPercentSection = null;
+      lastPercentUsed = null;
+    }
+  }
+  const allModelsLine = lines.find((line) => parseClaudeUsageHeading(line)?.section === "current-week-all");
+  if (!base.currentModel && allModelsLine) {
+    const modelName = allModelsLine.match(/\b(opus|sonnet|haiku)\s*\d+(?:\.\d+)?(?:\s*-\d+)?/i)?.[0];
+    if (modelName) base.currentModel = formatClaudeModelFromLabel(modelName);
+  }
+  return base;
+}
+function parseCodexUsageFromStatus(raw) {
+  const base = initSnapshot(raw);
+  base.weeklyPercentUsed = null;
+  base.weeklyLimitEstimate = null;
+  const lines = raw.split(/[\r\n]+/).map((line) => line.trim()).filter(Boolean);
+  let limitScope = "global";
+  for (const line of lines) {
+    const normalizedLine = line.replace(/[│]/g, " ").trim();
+    if (!normalizedLine) continue;
+    if (/^[─╭╰]+$/.test(normalizedLine) || /^╮|^╯/.test(normalizedLine)) continue;
+    const versionMatch = normalizedLine.match(/(?:OpenAI\s+)?Codex\s+\(v([^)]+)\)/i);
+    if (versionMatch?.[1] && !base.version) {
+      base.version = versionMatch[1];
+      continue;
+    }
+    const modelDetailMatch = normalizedLine.match(
+      /^Model:\s+([a-z0-9][a-z0-9._\-\/]+)\s+\(([^)]+)\)/i
+    );
+    if (modelDetailMatch?.[1]) {
+      base.currentModel = modelDetailMatch[1];
+      const reasoningMatch = modelDetailMatch[2].match(/reasoning\s+(\w+)/i);
+      if (reasoningMatch?.[1]) {
+        base.effort = reasoningMatch[1].toLowerCase();
+      }
+      continue;
+    }
+    const modelLineMatch = normalizedLine.match(/^model:\s+([a-z0-9][a-z0-9._\-\/]+)(?:\s+(high|medium|low|extra\s*high))?/i);
+    if (modelLineMatch?.[1]) {
+      base.currentModel = modelLineMatch[1];
+      if (modelLineMatch[2]) {
+        base.effort = modelLineMatch[2].toLowerCase();
+      }
+      continue;
+    }
+    const accountMatch = normalizedLine.match(/^Account:\s+(\S+@\S+)\s+\((\w+)\)/i);
+    if (accountMatch) {
+      base.account = accountMatch[1];
+      base.plan = accountMatch[2];
+      continue;
+    }
+    if (/context window:/i.test(normalizedLine)) continue;
+    if (/weekly limit:/i.test(normalizedLine)) {
+      const leftMatch = normalizedLine.match(/(\d+(?:\.\d+)?)\s*%\s*left/i);
+      const leftPct = leftMatch?.[1] ? parsePercent(leftMatch[1]) : null;
+      const used = leftPct !== null ? Math.floor(100 - leftPct) : null;
+      const resetMatch = normalizedLine.match(/resets\s+([0-9]{1,2}:\d{2})(?:\s+on\s+(.+))?/i);
+      const resetTime = resetMatch?.[1] || "";
+      const resetDate = resetMatch?.[2]?.trim() || "";
+      const resetText = resetTime ? `${resetTime}${resetDate ? ` on ${resetDate}` : ""}` : null;
+      const nextResetAt = resetText ? parseResetDateFromText(resetText) : null;
+      if (used !== null) {
+        if (limitScope === "global") {
+          base.weeklyPercentUsed = keepLargest(base.weeklyPercentUsed, used);
+          if (resetText) {
+            base.resetInfo = `Weekly reset: ${resetText}`;
+            base.nextResetAt = nextResetAt || base.nextResetAt;
+          }
+        }
+        base.rateLimits.push({
+          scope: limitScope,
+          period: "weekly",
+          percentUsed: used,
+          resetInfo: resetText ? `Resets ${resetText}` : null,
+          nextResetAt
+        });
+      }
+      continue;
+    }
+    if (/5h limit:/i.test(normalizedLine)) {
+      const leftMatch = normalizedLine.match(/(\d+(?:\.\d+)?)\s*%\s*left/i);
+      const leftPct = leftMatch?.[1] ? parsePercent(leftMatch[1]) : null;
+      const used = leftPct !== null ? Math.floor(100 - leftPct) : null;
+      const resetMatch = normalizedLine.match(/resets\s+([0-9]{1,2}:\d{2})/i);
+      const resetText = resetMatch?.[1] || null;
+      const nextResetAt = resetText ? parseResetDateFromText(resetText) : null;
+      const usedTokenMatch = normalizedLine.match(/([0-9]+(?:\.[0-9]+)?[kKmMbBtT]?)\s+used/i);
+      if (usedTokenMatch?.[1]) {
+        const tokens = parseTokenQuantity(usedTokenMatch[1]);
+        base.last5HoursInputTokens = keepLargest(base.last5HoursInputTokens, tokens);
+      }
+      if (used !== null) {
+        base.rateLimits.push({
+          scope: limitScope,
+          period: "5h",
+          percentUsed: used,
+          resetInfo: resetText ? `Resets ${resetText}` : null,
+          nextResetAt
+        });
+      }
+      continue;
+    }
+    const modelLimitHeader = normalizedLine.match(/^([a-z0-9][a-z0-9._\-\/]+)\s+limit:/i);
+    if (modelLimitHeader?.[1] && !/^(5h|weekly)\b/i.test(normalizedLine)) {
+      limitScope = modelLimitHeader[1].toLowerCase();
+      if (!base.currentModel) base.currentModel = limitScope;
+      continue;
+    }
+    const usedMatch = normalizedLine.match(/([0-9]+(?:\.[0-9]+)?[kKmMbBtT]?)\s+used/i);
+    if (usedMatch?.[1] && /\b5h\b/i.test(normalizedLine)) {
+      const tokens = parseTokenQuantity(usedMatch[1]);
+      if (tokens > 0) {
+        base.last5HoursInputTokens = keepLargest(base.last5HoursInputTokens, tokens);
+        if (!base.currentModel && limitScope !== "global") {
+          base.currentModel = limitScope;
+        }
+      }
+    }
+    if (normalizedLine.length > 80) {
+      if (base.weeklyPercentUsed === null) {
+        const statusLeftMatch = normalizedLine.match(/(\d+)%\s*left/i);
+        if (statusLeftMatch?.[1]) {
+          const leftPct = parsePercent(statusLeftMatch[1]);
+          if (leftPct !== null) {
+            base.weeklyPercentUsed = Math.floor(100 - leftPct);
+          }
+        }
+      }
+      const fiveHMatch = normalizedLine.match(/5h\s+(\d+)%/i);
+      if (fiveHMatch?.[1] && base.rateLimits.length === 0) {
+        const leftPct = parsePercent(fiveHMatch[1]);
+        if (leftPct !== null) {
+          base.rateLimits.push({
+            scope: "global",
+            period: "5h",
+            percentUsed: Math.floor(100 - leftPct),
+            resetInfo: null,
+            nextResetAt: null
+          });
+        }
+      }
+    }
+  }
+  return base;
+}
+function parseGeminiModelUsageLine(line) {
+  const match = line.match(
+    /\b(gemini-[a-z0-9][a-z0-9._-]*)\b.*?(\d{1,3})\s*%\s+([0-9]{1,2}:\d{2}(?:\s*(?:AM|PM|am|pm))?)\s*(?:\(([^)]+)\))?/
+  );
+  if (!match) {
+    return { model: null, percentUsed: null, resetAt: null };
+  }
+  const model = match[1];
+  const percentUsed = parsePercent(match[2]);
+  if (percentUsed === null) return { model: null, percentUsed: null, resetAt: null };
+  const resetTime = match[3]?.trim() ?? "";
+  const resetIn = match[4]?.trim() ?? "";
+  const resetAt = resetIn ? `${resetTime} (${resetIn})` : resetTime;
+  return { model, percentUsed, resetAt: resetAt || null };
+}
+function parseGeminiUsageFromStatus(raw) {
+  const base = initSnapshot(raw);
+  base.weeklyPercentUsed = null;
+  base.weeklyLimitEstimate = null;
+  if (!raw) return base;
+  const lines = raw.split(/[\r\n]+/).map((line) => line.trim()).filter(Boolean);
+  for (const line of lines) {
+    const normalizedLine = line.replace(/[│]/g, " ").trim();
+    if (!normalizedLine) continue;
+    if (/^[─╭╰]+$/.test(normalizedLine) || /^╮|^╯/.test(normalizedLine)) {
+      continue;
+    }
+    const versionMatch = normalizedLine.match(/Gemini CLI v(\d+\.\d+\.\d+)/i);
+    if (versionMatch?.[1] && !base.version) {
+      base.version = versionMatch[1];
+      continue;
+    }
+    const accountMatch = normalizedLine.match(/Signed in with Google:\s+(\S+@\S+)/i);
+    if (accountMatch?.[1]) {
+      base.account = accountMatch[1].replace(/\s*\/auth$/, "");
+      continue;
+    }
+    const planMatch = normalizedLine.match(/^Plan:\s+(.+?)(?:\s+\/\w+)?$/i);
+    if (planMatch?.[1]) {
+      base.plan = planMatch[1].trim();
+      continue;
+    }
+    const tierMatch = normalizedLine.match(/^Tier:\s+(.+)/i);
+    if (tierMatch?.[1] && !base.plan) {
+      base.plan = tierMatch[1].trim();
+      continue;
+    }
+    if (normalizedLine.startsWith("Model")) continue;
+    const modelUsage = parseGeminiModelUsageLine(normalizedLine);
+    if (modelUsage.model && modelUsage.percentUsed !== null) {
+      if (!base.currentModel) {
+        base.currentModel = modelUsage.model;
+      }
+      base.weeklyPercentUsed = keepLargest(base.weeklyPercentUsed, modelUsage.percentUsed);
+      const nextResetAt = modelUsage.resetAt ? parseResetDateFromText(modelUsage.resetAt) : null;
+      if (modelUsage.resetAt) {
+        base.resetInfo = `Usage reset: ${modelUsage.resetAt}`;
+        base.nextResetAt = nextResetAt || base.nextResetAt;
+      }
+      base.rateLimits.push({
+        scope: modelUsage.model,
+        period: "daily",
+        percentUsed: modelUsage.percentUsed,
+        resetInfo: modelUsage.resetAt ? `Resets ${modelUsage.resetAt}` : null,
+        nextResetAt
+      });
+      continue;
+    }
+    if (/Session Stats/i.test(normalizedLine)) {
+      base.resetInfo = base.resetInfo || "Gemini session stats unavailable";
+    }
+  }
+  return base;
+}
+function collectProviderUsageSnapshotFromCli(command, usageCommand, parseSnapshot, args = []) {
+  return collectProviderStatusText(command, args, usageCommand).then((raw) => {
+    if (!raw) return null;
+    return parseSnapshot(raw);
+  });
+}
+
 // src/agents/adapters/claude.ts
+var CLAUDE_USAGE_COMMAND = "/usage";
+var collectClaudeUsageFromCli = () => collectProviderUsageSnapshotFromCli("claude", CLAUDE_USAGE_COMMAND, parseClaudeUsageFromStatus, [
+  "--dangerously-skip-permissions"
+]);
 function buildClaudeCommand(options) {
-  const parts = ["claude", "--print"];
+  const parts = ["claude", "--print", "--bare"];
   if (options.readOnly) {
     parts.push("--permission-mode plan");
   } else if (!options.noToolAccess) {
@@ -372,20 +894,20 @@ async function compile(issue, provider, plan, config, workspacePath, skillContex
     readOnly: isReadOnlyRole,
     maxBudgetUsd: config.maxBudgetUsd
   });
-  const env2 = {
+  const env3 = {
     FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
     FIFONY_PLAN_STEPS: String(plan.steps.length),
     FIFONY_EXECUTION_PAYLOAD_FILE: "fifony-execution-payload.json"
   };
-  if (plan.suggestedPaths?.length) env2.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
+  if (plan.suggestedPaths?.length) env3.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
   if (plan.suggestedSkills?.length) {
-    env2.FIFONY_PLAN_SKILLS = plan.suggestedSkills.join(",");
+    env3.FIFONY_PLAN_SKILLS = plan.suggestedSkills.join(",");
   }
   const { pre, post } = extractValidationCommands(plan);
   return {
     prompt,
     command,
-    env: env2,
+    env: env3,
     preHooks: pre,
     postHooks: post,
     outputSchema: CLAUDE_RESULT_SCHEMA,
@@ -415,6 +937,10 @@ var claudeAdapter = {
 // src/agents/adapters/codex.ts
 import { existsSync as existsSync3 } from "fs";
 import { join as join2 } from "path";
+var CODEX_USAGE_COMMAND = "/status";
+var collectCodexUsageFromCli = () => collectProviderUsageSnapshotFromCli("codex", CODEX_USAGE_COMMAND, parseCodexUsageFromStatus, [
+  "--dangerously-bypass-approvals-and-sandbox"
+]);
 var CODEX_RESULT_CONTRACT = `
 Return a JSON object with this exact schema when finished:
 {
@@ -429,7 +955,13 @@ Return a JSON object with this exact schema when finished:
 }
 `.trim();
 function buildCodexCommand(options) {
-  const parts = ["codex", "exec", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox"];
+  const parts = [
+    "codex",
+    "exec",
+    "--skip-git-repo-check",
+    "--dangerously-bypass-approvals-and-sandbox",
+    "--no-alt-screen"
+  ];
   if (options.model && options.model !== "codex") {
     parts.push(`--model ${options.model}`);
   }
@@ -484,18 +1016,18 @@ async function compile2(issue, provider, plan, config, workspacePath, skillConte
     effort,
     imagePaths: issue.images?.filter((p) => existsSync3(p))
   });
-  const env2 = {
+  const env3 = {
     FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
     FIFONY_PLAN_STEPS: String(plan.steps.length),
     FIFONY_PLAN_PHASES: String(plan.phases?.length || 0),
     FIFONY_EXECUTION_PAYLOAD_FILE: "execution-payload.json"
   };
-  if (plan.suggestedPaths?.length) env2.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
+  if (plan.suggestedPaths?.length) env3.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
   const { pre, post } = extractValidationCommands(plan);
   return {
     prompt,
     command,
-    env: env2,
+    env: env3,
     preHooks: pre,
     postHooks: post,
     outputSchema: "",
@@ -523,6 +1055,8 @@ var codexAdapter = {
 // src/agents/adapters/gemini.ts
 import { existsSync as existsSync4 } from "fs";
 import { join as join3 } from "path";
+var GEMINI_USAGE_COMMAND = "/stats session";
+var collectGeminiUsageFromCli = () => collectProviderUsageSnapshotFromCli("gemini", GEMINI_USAGE_COMMAND, parseGeminiUsageFromStatus);
 var GEMINI_RESULT_CONTRACT = `
 Return a JSON object with this exact schema when finished:
 {
@@ -546,6 +1080,7 @@ function buildGeminiCommand(options) {
   if (options.model) {
     parts.push(`--model ${options.model}`);
   }
+  parts.push("--screen-reader");
   parts.push("--output-format json");
   if (options.addDirs?.length) {
     parts.push(`--include-directories ${options.addDirs.map((d) => `"${d}"`).join(",")}`);
@@ -589,18 +1124,18 @@ async function compile3(issue, provider, plan, config, workspacePath, skillConte
     addDirs: absoluteDirs,
     readOnly: isReadOnlyRole
   });
-  const env2 = {
+  const env3 = {
     FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
     FIFONY_PLAN_STEPS: String(plan.steps.length),
     FIFONY_PLAN_PHASES: String(plan.phases?.length || 0),
     FIFONY_EXECUTION_PAYLOAD_FILE: "execution-payload.json"
   };
-  if (plan.suggestedPaths?.length) env2.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
+  if (plan.suggestedPaths?.length) env3.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
   const { pre, post } = extractValidationCommands(plan);
   return {
     prompt,
     command,
-    env: env2,
+    env: env3,
     preHooks: pre,
     postHooks: post,
     outputSchema: "",
@@ -1107,10 +1642,11 @@ async function runHook(command, workspacePath, issue, hookName, extraEnv = {}) {
     retryDelayMs: 0,
     staleInProgressTimeoutMs: 0,
     logLinesTail: 12e3,
-    agentProvider: normalizeAgentProvider(env.FIFONY_AGENT_PROVIDER ?? "codex"),
+    agentProvider: normalizeAgentProvider(env2.FIFONY_AGENT_PROVIDER ?? "codex"),
     agentCommand: command,
     maxTurns: 1,
-    runMode: "filesystem"
+    runMode: "filesystem",
+    autoReviewApproval: true
   }, "", "", { FIFONY_HOOK_NAME: hookName, ...extraEnv });
   if (!result.success) {
     throw new Error(`${hookName} hook failed: ${result.output}`);
@@ -1550,7 +2086,7 @@ function parseDiffStats(issue, raw) {
 }
 async function syncIssueDiffStatsToStore(issue) {
   if (!issue?.id) return;
-  const { getIssueStateResource } = await import("./store-MTE6H7WQ.js");
+  const { getIssueStateResource } = await import("./store-FFHHRNVI.js");
   const issueResource = getIssueStateResource();
   if (!issueResource) return;
   const toNumber = (value) => {
@@ -1773,6 +2309,9 @@ function writeVersionedArtifacts(workspacePath, prefix, planVersion, attempt, so
 export {
   buildFullPlanPrompt,
   buildExecutionPayload,
+  collectClaudeUsageFromCli,
+  collectCodexUsageFromCli,
+  collectGeminiUsageFromCli,
   ADAPTERS,
   discoverModels,
   normalizeAgentProvider,
@@ -1811,4 +2350,4 @@ export {
   hydrateIssuePathsFromWorkspace,
   writeVersionedArtifacts
 };
-//# sourceMappingURL=chunk-IYAF3SY6.js.map
+//# sourceMappingURL=chunk-2D5P75F6.js.map