fifony 0.1.30 → 0.1.32

package/dist/{chunk-3FCJI2GK.js → chunk-FAFGDK62.js}

@@ -21,7 +21,7 @@ import {
   snapshotAndClearDirtyEventIds,
   snapshotAndClearDirtyIssueIds,
   snapshotAndClearDirtyIssuePlanIds
-} from "./chunk-2G6SRDOC.js";
+} from "./chunk-H2QRC6UQ.js";
 import {
   ADAPTERS,
   assertIssueHasGitWorktree,
@@ -31,6 +31,9 @@ import {
   buildRetryContext,
   buildTurnPrompt,
   cleanWorkspace,
+  collectClaudeUsageFromCli,
+  collectCodexUsageFromCli,
+  collectGeminiUsageFromCli,
   computeDiffStats,
   detectAvailableProviders,
   discoverModels,
@@ -49,7 +52,7 @@ import {
   resolveAgentCommand,
   runCommandWithTimeout,
   runHook
-} from "./chunk-XVF6GOVS.js";
+} from "./chunk-2D5P75F6.js";
 import {
   appendFileTail,
   clamp,
@@ -74,7 +77,7 @@ import {
 } from "./chunk-O5AEQXUV.js";
 import {
   enqueue
-} from "./chunk-VOQT7RVT.js";
+} from "./chunk-FPUTP743.js";
 import {
   logger
 } from "./chunk-DVU3CXWA.js";
@@ -949,7 +952,34 @@ function loadAgentCatalog() {
   return entries;
 }
 function loadSkillCatalog() {
-  return [];
+  const entries = [];
+  try {
+    const repos = listReferenceRepositories();
+    for (const repo of repos) {
+      if (!repo.present || !repo.synced) continue;
+      const artifacts = collectArtifacts(repo.path, repo.id).filter((a) => a.kind === "skill");
+      for (const artifact of artifacts) {
+        try {
+          const content = readFileSync3(artifact.sourcePath, "utf8");
+          const fm = parseFrontmatter(content);
+          entries.push({
+            name: artifact.targetName,
+            displayName: fm.name || artifact.targetName,
+            description: fm.description || "",
+            domains: fm.domains ? fm.domains.split(",").map((d) => d.trim()).filter(Boolean) : [],
+            source: repo.id,
+            installType: "bundled",
+            content
+          });
+        } catch (err) {
+          logger.warn({ err, path: artifact.sourcePath }, "Failed to read skill file");
+        }
+      }
+    }
+  } catch (error) {
+    logger.error({ err: error }, "Failed to load skill catalog from repositories");
+  }
+  return entries;
 }
 function filterByDomains(catalog, domains) {
   const domainSet = new Set(domains.map((d) => d.toLowerCase().trim()));
@@ -2337,6 +2367,11 @@ async function whichExists(cmd) {
     return false;
   }
 }
+var PROVIDER_USAGE_ORDER = ["claude", "codex", "gemini"];
+function normalizeProviderName(name) {
+  const normalized = (name || "").trim().toLowerCase();
+  return PROVIDER_USAGE_ORDER.includes(normalized) ? normalized : null;
+}
 function resolveCodexHomeCandidates() {
   const homePaths = /* @__PURE__ */ new Set([
     homedir2(),
@@ -2393,9 +2428,25 @@ function computeTodayStart() {
   d.setUTCHours(0, 0, 0, 0);
   return d;
 }
+function computeLastHoursStart(hours) {
+  return new Date(Date.now() - hours * 60 * 60 * 1e3);
+}
 function makePeriod(input, output, sessions, since) {
   return { inputTokens: input, outputTokens: output, tokensUsed: input + output, sessions, since };
 }
+function toNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : 0;
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+function parseTimestamp(value) {
+  if (typeof value !== "string") return 0;
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? 0 : timestamp;
+}
 var CLAUDE_PLAN_LIMITS = {
   pro: 45e6,
   // ~45M tokens/week (Pro plan estimate)
@@ -2404,6 +2455,14 @@ var CLAUDE_PLAN_LIMITS = {
   max5x: 675e6
   // ~675M tokens/week (Max 5x plan)
 };
+function resolveClaudePlanKey(displayName) {
+  const lower = displayName.toLowerCase().trim();
+  if (/max\s*5x/i.test(lower)) return "max5x";
+  if (/max/i.test(lower)) return "max";
+  if (/pro/i.test(lower)) return "pro";
+  if (/free/i.test(lower)) return null;
+  return null;
+}
 async function collectClaudeUsage() {
   const home = homedir2();
   const claudeDir = join8(home, ".claude");
@@ -2419,10 +2478,15 @@ async function collectClaudeUsage() {
   let weekInputTokens = 0;
   let weekOutputTokens = 0;
   let weekSessions = 0;
+  let last5hInputTokens = 0;
+  let last5hOutputTokens = 0;
+  let last5hSessions = 0;
   const todayStart = computeTodayStart();
   const todayMs = todayStart.getTime();
   const weekStart = computeWeekStart();
   const weekMs = weekStart.getTime();
+  const last5hStart = computeLastHoursStart(5);
+  const last5hMs = last5hStart.getTime();
   if (existsSync6(projectsDir)) {
     try {
       const projectDirs = readdirSync2(projectsDir, { withFileTypes: true });
@@ -2446,6 +2510,7 @@ async function collectClaudeUsage() {
           let sessionCounted = false;
           let sessionTodayCounted = false;
           let sessionWeekCounted = false;
+          let sessionLast5hCounted = false;
           for (const line of content.split("\n")) {
             if (!line.trim()) continue;
             try {
@@ -2477,6 +2542,14 @@ async function collectClaudeUsage() {
                   sessionWeekCounted = true;
                 }
               }
+              if (timestamp >= last5hMs) {
+                last5hInputTokens += inputTokens;
+                last5hOutputTokens += outputTokens;
+                if (!sessionLast5hCounted) {
+                  last5hSessions++;
+                  sessionLast5hCounted = true;
+                }
+              }
             } catch {
             }
           }
@@ -2487,9 +2560,9 @@ async function collectClaudeUsage() {
     }
   }
   const models = [
-    { slug: "claude-opus-4-6", displayName: "Claude Opus 4.6", description: "Most capable model for complex tasks" },
-    { slug: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6", description: "Balanced performance and speed" },
-    { slug: "claude-haiku-4-5", displayName: "Claude Haiku 4.5", description: "Fast and efficient model" }
+    { slug: "claude-opus-4-6", displayName: "claude opus 4.6", description: "Most capable model for complex tasks" },
+    { slug: "claude-sonnet-4-6", displayName: "claude sonnet 4.6", description: "Balanced performance and speed" },
+    { slug: "claude-haiku-4-5", displayName: "claude haiku 4.5", description: "Fast and efficient model" }
   ];
   let plan = "pro";
   let resetInfo = "Weekly reset (every Monday 00:00 UTC)";
@@ -2508,10 +2581,53 @@ async function collectClaudeUsage() {
     } catch {
     }
   }
-  const nextResetAt = computeNextMonday().toISOString();
-  const weeklyLimit = CLAUDE_PLAN_LIMITS[plan] ?? null;
+  let nextResetAt = computeNextMonday().toISOString();
+  let weeklyLimit = CLAUDE_PLAN_LIMITS[plan] ?? null;
   const weeklyUsed = weekInputTokens + weekOutputTokens;
   const percentUsed = weeklyLimit ? Math.min(100, Math.round(weeklyUsed / weeklyLimit * 100)) : null;
+  const statusUsage = await collectClaudeUsageFromCli();
+  if (statusUsage) {
+    if (statusUsage.currentModel) {
+      currentModel = statusUsage.currentModel;
+    }
+    if (statusUsage.plan) {
+      const planKey = resolveClaudePlanKey(statusUsage.plan);
+      if (planKey && CLAUDE_PLAN_LIMITS[planKey]) {
+        plan = planKey;
+        weeklyLimit = CLAUDE_PLAN_LIMITS[planKey];
+      }
+    }
+    if (statusUsage.weeklyLimitEstimate !== null) {
+      weeklyLimit = statusUsage.weeklyLimitEstimate;
+    }
+    if (statusUsage.thisWeekInputTokens !== null || statusUsage.thisWeekOutputTokens !== null) {
+      weekInputTokens = statusUsage.thisWeekInputTokens ?? weekInputTokens;
+      weekOutputTokens = statusUsage.thisWeekOutputTokens ?? weekOutputTokens;
+      if (statusUsage.thisWeekSessions !== null) weekSessions = statusUsage.thisWeekSessions;
+    }
+    if (statusUsage.todayInputTokens !== null || statusUsage.todayOutputTokens !== null) {
+      todayInputTokens = statusUsage.todayInputTokens ?? todayInputTokens;
+      todayOutputTokens = statusUsage.todayOutputTokens ?? todayOutputTokens;
+      if (statusUsage.todaySessions !== null) todaySessions = statusUsage.todaySessions;
+    }
+    if (statusUsage.last5HoursInputTokens !== null || statusUsage.last5HoursOutputTokens !== null) {
+      last5hInputTokens = statusUsage.last5HoursInputTokens ?? last5hInputTokens;
+      last5hOutputTokens = statusUsage.last5HoursOutputTokens ?? last5hOutputTokens;
+      if (statusUsage.last5HoursSessions !== null) last5hSessions = statusUsage.last5HoursSessions;
+    }
+    if (statusUsage.allTimeInputTokens !== null || statusUsage.allTimeOutputTokens !== null) {
+      totalInputTokens = statusUsage.allTimeInputTokens ?? totalInputTokens;
+      totalOutputTokens = statusUsage.allTimeOutputTokens ?? totalOutputTokens;
+      if (statusUsage.allTimeSessions !== null) totalSessions = statusUsage.allTimeSessions;
+    }
+    if (statusUsage.resetInfo) {
+      resetInfo = statusUsage.resetInfo;
+    }
+    if (statusUsage.nextResetAt) {
+      nextResetAt = statusUsage.nextResetAt;
+    }
+  }
+  const finalPercentUsed = weeklyLimit ? Math.min(100, Math.round((weekInputTokens + weekOutputTokens) / weeklyLimit * 100)) : percentUsed;
   return {
     name: "claude",
     available,
@@ -2520,14 +2636,95 @@ async function collectClaudeUsage() {
     usage: {
       today: makePeriod(todayInputTokens, todayOutputTokens, todaySessions, todayStart.toISOString()),
       thisWeek: makePeriod(weekInputTokens, weekOutputTokens, weekSessions, weekStart.toISOString()),
+      last5Hours: makePeriod(last5hInputTokens, last5hOutputTokens, last5hSessions, last5hStart.toISOString()),
       allTime: makePeriod(totalInputTokens, totalOutputTokens, totalSessions, "")
     },
     resetInfo,
     nextResetAt,
     weeklyLimitEstimate: weeklyLimit,
-    percentUsed
+    percentUsed: finalPercentUsed,
+    version: statusUsage?.version ?? null,
+    plan: statusUsage?.plan ?? (plan !== "pro" ? plan.toUpperCase() : "Pro"),
+    account: statusUsage?.account ?? null,
+    effort: statusUsage?.effort ?? null,
+    rateLimits: statusUsage?.rateLimits ?? []
+  };
+}
+function aggregateCodexSessionUsageFromJsonl(lines) {
+  let maxInput = 0;
+  let maxOutput = 0;
+  let maxTotal = 0;
+  let sessionTs = 0;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const lineTs = parseTimestamp(entry?.timestamp);
+    const payloadTs = parseTimestamp(entry?.payload?.timestamp);
+    const candidateTs = Math.max(lineTs, payloadTs);
+    if (candidateTs > sessionTs) sessionTs = candidateTs;
+    if (entry.type !== "event_msg") continue;
+    if (entry.payload?.type !== "token_count") continue;
+    const info = entry.payload?.info || {};
+    const usage = info.total_token_usage || info.last_token_usage;
+    if (!usage || typeof usage !== "object") continue;
+    const input = toNumber(usage.input_tokens);
+    const output = toNumber(usage.output_tokens);
+    const total = toNumber(usage.total_tokens);
+    if (total <= 0) continue;
+    if (total > maxTotal) {
+      maxTotal = total;
+      maxInput = input;
+      maxOutput = output;
+    }
+  }
+  if (maxTotal <= 0) return { inputTokens: 0, outputTokens: 0, totalTokens: 0, timestampMs: sessionTs };
+  return {
+    inputTokens: maxInput,
+    outputTokens: maxOutput,
+    totalTokens: maxTotal,
+    timestampMs: sessionTs
   };
 }
+function collectCodexSessionUsagesFromJsonl(codexDir) {
+  const sessionsDir = join8(codexDir, "sessions");
+  if (!existsSync6(sessionsDir)) return [];
+  const stack = [sessionsDir];
+  const usageByFile = [];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    let entries = [];
+    try {
+      entries = readdirSync2(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const next = join8(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(next);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+      try {
+        const content = readFileSync5(next, "utf8");
+        const usage = aggregateCodexSessionUsageFromJsonl(content.split("\n"));
+        if (usage.totalTokens > 0) {
+          usageByFile.push(usage);
+        }
+      } catch {
+      }
+    }
+  }
+  return usageByFile;
+}
 async function collectCodexUsage() {
   const codexDir = resolveCodexDir();
   if (!codexDir) return null;
@@ -2541,7 +2738,7 @@ async function collectCodexUsage() {
       for (const m of cache.models || []) {
         models.push({
           slug: m.slug,
-          displayName: m.display_name || m.slug,
+          displayName: (m.display_name || m.slug).toLowerCase(),
           description: (m.description || "").slice(0, 80)
         });
       }
@@ -2559,60 +2756,199 @@ async function collectCodexUsage() {
   }
   const todayStart = computeTodayStart();
   const weekStart = computeWeekStart();
-  const nextResetAt = computeNextMonday().toISOString();
+  let nextResetAt = computeNextMonday().toISOString();
+  let resetInfo = "Weekly rate limit resets every Monday";
+  const last5hStart = computeLastHoursStart(5);
+  const last5hMs = last5hStart.getTime();
+  const todayMs = todayStart.getTime();
+  const weekMs = weekStart.getTime();
   const dbPath = findLatestCodexDb(codexDir);
-  if (!dbPath) {
-    return {
-      name: "codex",
-      available,
-      models,
-      currentModel,
-      usage: {
-        today: makePeriod(0, 0, 0, todayStart.toISOString()),
-        thisWeek: makePeriod(0, 0, 0, weekStart.toISOString()),
-        allTime: makePeriod(0, 0, 0, "")
-      },
-      resetInfo: "Weekly rate limit resets every Monday",
-      nextResetAt,
-      weeklyLimitEstimate: null,
-      percentUsed: null
-    };
-  }
   let allTimeTokens = 0;
   let allTimeSessions = 0;
   let todayTokens = 0;
   let todaySessions = 0;
   let weekTokens = 0;
   let weekSessions = 0;
+  let last5hTokens = 0;
+  let last5hSessions = 0;
+  let allTimeInputTokens = 0;
+  let allTimeOutputTokens = 0;
+  let todayInputTokens = 0;
+  let todayOutputTokens = 0;
+  let weekInputTokens = 0;
+  let weekOutputTokens = 0;
+  let last5hInputTokens = 0;
+  let last5hOutputTokens = 0;
   const todayUnix = Math.floor(todayStart.getTime() / 1e3);
   const weekUnix = Math.floor(weekStart.getTime() / 1e3);
-  try {
-    const query = `
-      SELECT
-        SUM(tokens_used) as total_tokens,
-        COUNT(*) as total_sessions,
-        SUM(CASE WHEN created_at >= ${todayUnix} THEN tokens_used ELSE 0 END) as today_tokens,
-        SUM(CASE WHEN created_at >= ${todayUnix} THEN 1 ELSE 0 END) as today_sessions,
-        SUM(CASE WHEN created_at >= ${weekUnix} THEN tokens_used ELSE 0 END) as week_tokens,
-        SUM(CASE WHEN created_at >= ${weekUnix} THEN 1 ELSE 0 END) as week_sessions
-      FROM threads;
-    `;
-    const { stdout } = await execFileAsync("sqlite3", [dbPath, query], {
-      encoding: "utf8",
-      timeout: 5e3
-    });
-    const result = stdout.trim();
-    if (result) {
-      const parts = result.split("|");
-      allTimeTokens = parseInt(parts[0], 10) || 0;
-      allTimeSessions = parseInt(parts[1], 10) || 0;
-      todayTokens = parseInt(parts[2], 10) || 0;
-      todaySessions = parseInt(parts[3], 10) || 0;
-      weekTokens = parseInt(parts[4], 10) || 0;
-      weekSessions = parseInt(parts[5], 10) || 0;
+  const last5hUnix = Math.floor(last5hStart.getTime() / 1e3);
+  if (dbPath) {
+    try {
+      const query = `
+        SELECT
+          SUM(tokens_used) as total_tokens,
+          COUNT(*) as total_sessions,
+          SUM(CASE WHEN created_at >= ${todayUnix} THEN tokens_used ELSE 0 END) as today_tokens,
+          SUM(CASE WHEN created_at >= ${todayUnix} THEN 1 ELSE 0 END) as today_sessions,
+          SUM(CASE WHEN created_at >= ${weekUnix} THEN tokens_used ELSE 0 END) as week_tokens,
+          SUM(CASE WHEN created_at >= ${weekUnix} THEN 1 ELSE 0 END) as week_sessions,
+          SUM(CASE WHEN created_at >= ${last5hUnix} THEN tokens_used ELSE 0 END) as last5h_tokens,
+          SUM(CASE WHEN created_at >= ${last5hUnix} THEN 1 ELSE 0 END) as last5h_sessions
+        FROM threads;
+      `;
+      const { stdout } = await execFileAsync("sqlite3", [dbPath, query], {
+        encoding: "utf8",
+        timeout: 5e3
+      });
+      const result = stdout.trim();
+      if (result) {
+        const parts = result.split("|");
+        allTimeTokens = parseInt(parts[0], 10) || 0;
+        allTimeSessions = parseInt(parts[1], 10) || 0;
+        todayTokens = parseInt(parts[2], 10) || 0;
+        todaySessions = parseInt(parts[3], 10) || 0;
+        weekTokens = parseInt(parts[4], 10) || 0;
+        weekSessions = parseInt(parts[5], 10) || 0;
+        last5hTokens = parseInt(parts[6], 10) || 0;
+        last5hSessions = parseInt(parts[7], 10) || 0;
+      }
+    } catch (err) {
+      logger.debug(`Failed to query Codex SQLite: ${String(err)}`);
+    }
+  }
+  const sessionUsages = collectCodexSessionUsagesFromJsonl(codexDir);
+  if (sessionUsages.length > 0) {
+    let jsonlAllTimeInput = 0;
+    let jsonlAllTimeOutput = 0;
+    let jsonlAllTimeTokens = 0;
+    let jsonlAllTimeSessions = 0;
+    let jsonlTodayInput = 0;
+    let jsonlTodayOutput = 0;
+    let jsonlTodaySessions = 0;
+    let jsonlWeekInput = 0;
+    let jsonlWeekOutput = 0;
+    let jsonlWeekSessions = 0;
+    let jsonlLast5hInput = 0;
+    let jsonlLast5hOutput = 0;
+    let jsonlLast5hSessions = 0;
+    for (const usage of sessionUsages) {
+      if (usage.totalTokens <= 0) continue;
+      jsonlAllTimeInput += usage.inputTokens;
+      jsonlAllTimeOutput += usage.outputTokens;
+      jsonlAllTimeTokens += usage.totalTokens;
+      jsonlAllTimeSessions++;
+      if (usage.timestampMs >= todayMs) {
+        jsonlTodayInput += usage.inputTokens;
+        jsonlTodayOutput += usage.outputTokens;
+        jsonlTodaySessions++;
+      }
+      if (usage.timestampMs >= weekMs) {
+        jsonlWeekInput += usage.inputTokens;
+        jsonlWeekOutput += usage.outputTokens;
+        jsonlWeekSessions++;
+      }
+      if (usage.timestampMs >= last5hMs) {
+        jsonlLast5hInput += usage.inputTokens;
+        jsonlLast5hOutput += usage.outputTokens;
+        jsonlLast5hSessions++;
+      }
+    }
+    if (allTimeTokens === 0 && allTimeSessions === 0) {
+      allTimeTokens = jsonlAllTimeTokens;
+      allTimeSessions = jsonlAllTimeSessions;
+      todayTokens = jsonlTodayInput + jsonlTodayOutput;
+      todaySessions = jsonlTodaySessions;
+      weekTokens = jsonlWeekInput + jsonlWeekOutput;
+      weekSessions = jsonlWeekSessions;
+      last5hTokens = jsonlLast5hInput + jsonlLast5hOutput;
+      last5hSessions = jsonlLast5hSessions;
+    } else {
+      allTimeInputTokens = jsonlAllTimeInput;
+      allTimeOutputTokens = jsonlAllTimeOutput;
+      todayInputTokens = jsonlTodayInput;
+      todayOutputTokens = jsonlTodayOutput;
+      weekInputTokens = jsonlWeekInput;
+      weekOutputTokens = jsonlWeekOutput;
+      last5hInputTokens = jsonlLast5hInput;
+      last5hOutputTokens = jsonlLast5hOutput;
+    }
+    if (allTimeSessions === 0) allTimeSessions = jsonlAllTimeSessions;
+    if (todaySessions === 0) todaySessions = jsonlTodaySessions;
+    if (weekSessions === 0) weekSessions = jsonlWeekSessions;
+    if (last5hSessions === 0) last5hSessions = jsonlLast5hSessions;
+  }
+  if (allTimeInputTokens === 0 && allTimeOutputTokens === 0 && sessionUsages.length > 0) {
+    for (const usage of sessionUsages) {
+      if (usage.totalTokens <= 0) continue;
+      allTimeInputTokens += usage.inputTokens;
+      allTimeOutputTokens += usage.outputTokens;
+    }
+    if (allTimeInputTokens > 0 || allTimeOutputTokens > 0) {
+      todayInputTokens = 0;
+      todayOutputTokens = 0;
+      weekInputTokens = 0;
+      weekOutputTokens = 0;
+      last5hInputTokens = 0;
+      last5hOutputTokens = 0;
+      for (const usage of sessionUsages) {
+        if (usage.timestampMs >= todayMs) {
+          todayInputTokens += usage.inputTokens;
+          todayOutputTokens += usage.outputTokens;
+        }
+        if (usage.timestampMs >= weekMs) {
+          weekInputTokens += usage.inputTokens;
+          weekOutputTokens += usage.outputTokens;
+        }
+        if (usage.timestampMs >= last5hMs) {
+          last5hInputTokens += usage.inputTokens;
+          last5hOutputTokens += usage.outputTokens;
+        }
+      }
+    }
+  }
+  if (allTimeInputTokens === 0 && allTimeOutputTokens === 0) {
+    allTimeInputTokens = allTimeTokens;
+  }
+  if (todayInputTokens === 0 && todayOutputTokens === 0) {
+    todayInputTokens = todayTokens;
+  }
+  if (weekInputTokens === 0 && weekOutputTokens === 0) {
+    weekInputTokens = weekTokens;
+  }
+  if (last5hInputTokens === 0 && last5hOutputTokens === 0) {
+    last5hInputTokens = last5hTokens;
+  }
+  const statusUsage = await collectCodexUsageFromCli();
+  if (statusUsage) {
+    if (statusUsage.currentModel) {
+      currentModel = statusUsage.currentModel;
+    }
+    if (statusUsage.allTimeInputTokens !== null || statusUsage.allTimeOutputTokens !== null) {
+      allTimeInputTokens = statusUsage.allTimeInputTokens ?? allTimeInputTokens;
+      allTimeOutputTokens = statusUsage.allTimeOutputTokens ?? allTimeOutputTokens;
+      if (statusUsage.allTimeSessions !== null) allTimeSessions = statusUsage.allTimeSessions;
+    }
+    if (statusUsage.todayInputTokens !== null || statusUsage.todayOutputTokens !== null) {
+      todayInputTokens = statusUsage.todayInputTokens ?? todayInputTokens;
+      todayOutputTokens = statusUsage.todayOutputTokens ?? todayOutputTokens;
+      if (statusUsage.todaySessions !== null) todaySessions = statusUsage.todaySessions;
+    }
+    if (statusUsage.thisWeekInputTokens !== null || statusUsage.thisWeekOutputTokens !== null) {
+      weekInputTokens = statusUsage.thisWeekInputTokens ?? weekInputTokens;
+      weekOutputTokens = statusUsage.thisWeekOutputTokens ?? weekOutputTokens;
+      if (statusUsage.thisWeekSessions !== null) weekSessions = statusUsage.thisWeekSessions;
+    }
+    if (statusUsage.last5HoursInputTokens !== null || statusUsage.last5HoursOutputTokens !== null) {
+      last5hInputTokens = statusUsage.last5HoursInputTokens ?? last5hInputTokens;
+      last5hOutputTokens = statusUsage.last5HoursOutputTokens ?? last5hOutputTokens;
+      if (statusUsage.last5HoursSessions !== null) last5hSessions = statusUsage.last5HoursSessions;
+    }
+    if (statusUsage.resetInfo) {
+      resetInfo = statusUsage.resetInfo;
+    }
+    if (statusUsage.nextResetAt) {
+      nextResetAt = statusUsage.nextResetAt;
     }
-  } catch (err) {
-    logger.debug(`Failed to query Codex SQLite: ${String(err)}`);
   }
   return {
     name: "codex",
@@ -2620,22 +2956,113 @@ async function collectCodexUsage() {
     models,
     currentModel,
     usage: {
-      today: makePeriod(todayTokens, 0, todaySessions, todayStart.toISOString()),
-      thisWeek: makePeriod(weekTokens, 0, weekSessions, weekStart.toISOString()),
-      allTime: makePeriod(allTimeTokens, 0, allTimeSessions, "")
+      today: makePeriod(todayInputTokens, todayOutputTokens, todaySessions, todayStart.toISOString()),
+      thisWeek: makePeriod(weekInputTokens, weekOutputTokens, weekSessions, weekStart.toISOString()),
+      last5Hours: makePeriod(last5hInputTokens, last5hOutputTokens, last5hSessions, last5hStart.toISOString()),
+      allTime: makePeriod(allTimeInputTokens, allTimeOutputTokens, allTimeSessions, "")
     },
-    resetInfo: "Weekly rate limit resets every Monday",
+    resetInfo,
     nextResetAt,
     weeklyLimitEstimate: null,
-    percentUsed: null
+    percentUsed: statusUsage?.weeklyPercentUsed ?? null,
+    version: statusUsage?.version ?? null,
+    plan: statusUsage?.plan ?? null,
+    account: statusUsage?.account ?? null,
+    effort: statusUsage?.effort ?? null,
+    rateLimits: statusUsage?.rateLimits ?? []
   };
 }
+function aggregateGeminiSessionUsageFromJson(content) {
+  let sessionInput = 0;
+  let sessionOutput = 0;
+  let sessionTotal = 0;
+  let sessionTs = 0;
+  let session;
+  try {
+    session = JSON.parse(content);
+  } catch {
+    return { inputTokens: 0, outputTokens: 0, totalTokens: 0, timestampMs: 0 };
+  }
+  const fallbackTs = parseTimestamp(session.startTime) || parseTimestamp(session.lastUpdated);
+  if (fallbackTs > sessionTs) sessionTs = fallbackTs;
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  for (const message of messages) {
+    if (!message || message.type !== "gemini" || !message.tokens) continue;
+    const tokens = message.tokens;
+    const input = toNumber(tokens.input);
+    const output = toNumber(tokens.output);
+    const total = toNumber(tokens.total);
+    if (input === 0 && output === 0 && total === 0) continue;
+    sessionInput += input;
+    sessionOutput += output;
+    sessionTotal += total > 0 ? total : input + output;
+    const messageTs = parseTimestamp(message.timestamp);
+    if (messageTs > sessionTs) sessionTs = messageTs;
+  }
+  if (sessionTotal <= 0) return { inputTokens: 0, outputTokens: 0, totalTokens: 0, timestampMs: sessionTs };
+  return {
+    inputTokens: sessionInput,
+    outputTokens: sessionOutput,
+    totalTokens: sessionTotal,
+    timestampMs: sessionTs
+  };
+}
+function collectGeminiSessionUsages() {
+  const geminiTmp = join8(homedir2(), ".gemini", "tmp");
+  if (!existsSync6(geminiTmp)) return [];
+  const usages = [];
+  let entries = [];
+  try {
+    entries = readdirSync2(geminiTmp, { withFileTypes: true });
+  } catch {
+    return usages;
+  }
+  for (const profile of entries) {
+    if (!profile.isDirectory()) continue;
+    const chatsDir = join8(geminiTmp, profile.name, "chats");
+    if (!existsSync6(chatsDir)) continue;
+    let sessions = [];
+    try {
+      sessions = readdirSync2(chatsDir).filter((name) => name.startsWith("session-") && (name.endsWith(".json") || name.endsWith(".jsonl")));
+    } catch {
+      continue;
+    }
+    for (const sessionFile of sessions) {
+      const sessionPath = join8(chatsDir, sessionFile);
+      try {
+        const usage = aggregateGeminiSessionUsageFromJson(readFileSync5(sessionPath, "utf8"));
+        if (usage.totalTokens > 0) usages.push(usage);
+      } catch {
+      }
+    }
+  }
+  return usages;
+}
 async function collectGeminiUsage() {
   const available = await whichExists("gemini");
   if (!available) return null;
+  let version = null;
+  try {
+    const { stdout } = await execFileAsync("gemini", ["--version"], { encoding: "utf8", timeout: 5e3 });
+    const trimmed = stdout.trim();
+    if (/^\d+\.\d+/.test(trimmed)) version = trimmed;
+  } catch {
+  }
+  let account = null;
+  const accountsPath = join8(homedir2(), ".gemini", "google_accounts.json");
+  if (existsSync6(accountsPath)) {
+    try {
+      const data = JSON.parse(readFileSync5(accountsPath, "utf8"));
+      if (typeof data.active === "string" && data.active.includes("@")) {
+        account = data.active;
+      }
+    } catch {
+    }
+  }
   const todayStart = computeTodayStart();
   const weekStart = computeWeekStart();
-  const nextResetAt = computeNextMonday().toISOString();
+  let nextResetAt = computeNextMonday().toISOString();
+  const last5hStart = computeLastHoursStart(5);
   const models = [];
   try {
     const { stdout: binPath } = await execFileAsync("which", ["gemini"], { encoding: "utf8", timeout: 3e3 });
@@ -2670,20 +3097,99 @@ async function collectGeminiUsage() {
     } catch {
     }
   }
+  const todayMs = todayStart.getTime();
+  const weekMs = weekStart.getTime();
+  const last5hMs = last5hStart.getTime();
+  let resetInfo = "Usage from local Gemini session logs";
+  let todayInputTokens = 0;
+  let todayOutputTokens = 0;
+  let todaySessions = 0;
+  let weekInputTokens = 0;
+  let weekOutputTokens = 0;
+  let weekSessions = 0;
+  let last5hInputTokens = 0;
+  let last5hOutputTokens = 0;
+  let last5hSessions = 0;
+  let allTimeInputTokens = 0;
+  let allTimeOutputTokens = 0;
+  let allTimeSessions = 0;
+  const sessionUsages = collectGeminiSessionUsages();
+  for (const usage of sessionUsages) {
+    allTimeInputTokens += usage.inputTokens;
+    allTimeOutputTokens += usage.outputTokens;
+    allTimeSessions++;
+    if (usage.timestampMs >= todayMs) {
+      todayInputTokens += usage.inputTokens;
+      todayOutputTokens += usage.outputTokens;
+      todaySessions++;
+    }
+    if (usage.timestampMs >= weekMs) {
+      weekInputTokens += usage.inputTokens;
+      weekOutputTokens += usage.outputTokens;
+      weekSessions++;
+    }
+    if (usage.timestampMs >= last5hMs) {
+      last5hInputTokens += usage.inputTokens;
+      last5hOutputTokens += usage.outputTokens;
+      last5hSessions++;
+    }
+  }
+  const statusUsage = await collectGeminiUsageFromCli();
+  if (statusUsage) {
+    if (statusUsage.currentModel) {
+      currentModel = statusUsage.currentModel;
+    }
+    if (statusUsage.allTimeInputTokens !== null || statusUsage.allTimeOutputTokens !== null) {
+      allTimeInputTokens = statusUsage.allTimeInputTokens ?? allTimeInputTokens;
+      allTimeOutputTokens = statusUsage.allTimeOutputTokens ?? allTimeOutputTokens;
+      if (statusUsage.allTimeSessions !== null) allTimeSessions = statusUsage.allTimeSessions;
+    }
+    if (statusUsage.todayInputTokens !== null || statusUsage.todayOutputTokens !== null) {
+      todayInputTokens = statusUsage.todayInputTokens ?? todayInputTokens;
+      todayOutputTokens = statusUsage.todayOutputTokens ?? todayOutputTokens;
+      if (statusUsage.todaySessions !== null) todaySessions = statusUsage.todaySessions;
+    }
+    if (statusUsage.thisWeekInputTokens !== null || statusUsage.thisWeekOutputTokens !== null) {
+      weekInputTokens = statusUsage.thisWeekInputTokens ?? weekInputTokens;
+      weekOutputTokens = statusUsage.thisWeekOutputTokens ?? weekOutputTokens;
+      if (statusUsage.thisWeekSessions !== null) weekSessions = statusUsage.thisWeekSessions;
+    }
+    if (statusUsage.last5HoursInputTokens !== null || statusUsage.last5HoursOutputTokens !== null) {
+      last5hInputTokens = statusUsage.last5HoursInputTokens ?? last5hInputTokens;
+      last5hOutputTokens = statusUsage.last5HoursOutputTokens ?? last5hOutputTokens;
+      if (statusUsage.last5HoursSessions !== null) last5hSessions = statusUsage.last5HoursSessions;
+    }
+    if (statusUsage.resetInfo) {
+      resetInfo = statusUsage.resetInfo;
+    }
+    if (statusUsage.nextResetAt) {
+      nextResetAt = statusUsage.nextResetAt;
+    }
+    if (statusUsage.weeklyLimitEstimate !== null && statusUsage.weeklyPercentUsed !== null) {
+      resetInfo = `Estimated weekly used: ${statusUsage.weeklyPercentUsed}%`;
+    }
+  }
   return {
     name: "gemini",
     available,
     models,
     currentModel,
     usage: {
-      today: makePeriod(0, 0, 0, todayStart.toISOString()),
-      thisWeek: makePeriod(0, 0, 0, weekStart.toISOString()),
-      allTime: makePeriod(0, 0, 0, "")
+      today: makePeriod(todayInputTokens, todayOutputTokens, todaySessions, todayStart.toISOString()),
+      thisWeek: makePeriod(weekInputTokens, weekOutputTokens, weekSessions, weekStart.toISOString()),
+      last5Hours: makePeriod(last5hInputTokens, last5hOutputTokens, last5hSessions, last5hStart.toISOString()),
+      allTime: makePeriod(allTimeInputTokens, allTimeOutputTokens, allTimeSessions, "")
     },
-    resetInfo: "Usage data not available for Gemini CLI",
+    resetInfo,
     nextResetAt,
     weeklyLimitEstimate: null,
-    percentUsed: null
+    percentUsed: statusUsage?.weeklyPercentUsed ?? null,
+    version: statusUsage?.version ?? version,
+    plan: statusUsage?.plan ?? null,
+    account: statusUsage?.account ?? account,
+    effort: null,
+    // Gemini has no effort/reasoning concept
+    rateLimits: statusUsage?.rateLimits ?? []
   };
 }
 var usageCache = null;
@@ -2705,6 +3211,13 @@ async function collectProvidersUsage() {
   usageCacheAt = Date.now();
   return usageCache;
 }
+async function collectProviderUsage(providerName) {
+  const normalized = normalizeProviderName(providerName);
+  if (!normalized) return null;
+  if (normalized === "claude") return collectClaudeUsage();
+  if (normalized === "codex") return collectCodexUsage();
+  return collectGeminiUsage();
+}
 
 // src/routes/state.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
@@ -2774,6 +3287,34 @@ async function replanIssueCommand(input, deps) {
   deps.eventStore.addEvent(issue.id, "manual", `Replan requested for ${issue.identifier} \u2014 now at plan v${issue.planVersion}.`);
 }
 
+// src/commands/request-rework.command.ts
+async function requestReworkCommand(input, deps) {
+  const { issue, reviewerFeedback, note } = input;
+  if (issue.state !== "Reviewing" && issue.state !== "PendingDecision") {
+    throw new Error(
+      `requestReworkCommand requires Reviewing or PendingDecision state, got ${issue.state}.`
+    );
+  }
+  issue.lastError = reviewerFeedback;
+  issue.lastFailedPhase = "review";
+  issue.attempts += 1;
+  if (issue.state === "Reviewing") {
+    await transitionIssueCommand(
+      { issue, target: "PendingDecision", note: `Reviewer completed for ${issue.identifier}.` },
+      deps
+    );
+  }
+  await transitionIssueCommand(
+    { issue, target: "Queued", note: note ?? `Reviewer requested rework for ${issue.identifier}.` },
+    deps
+  );
+  deps.eventStore.addEvent(
+    issue.id,
+    "runner",
+    `Issue ${issue.identifier} sent back for rework by reviewer.`
+  );
+}
+
 // src/commands/merge-workspace.command.ts
 import { existsSync as existsSync7 } from "fs";
 import { execSync } from "child_process";
@@ -3014,8 +3555,9 @@ async function retryExecutionCommand(input, deps) {
       `retryExecutionCommand requires Blocked state, got ${issue.state}. Use replanIssueCommand for re-planning or the generic /retry endpoint for other states.`
     );
   }
+  issue.attempts += 1;
   await transitionIssueCommand(
-    { issue, target: "Queued", note: note ?? `Retry execution for ${issue.identifier} (attempt ${issue.attempts + 1}).` },
+    { issue, target: "Queued", note: note ?? `Retry execution for ${issue.identifier} (attempt ${issue.attempts}).` },
     deps
   );
   deps.eventStore.addEvent(
@@ -3075,6 +3617,19 @@ function registerStateRoutes(app, state) {
   app.get("/api/parallelism", async (c) => {
     return c.json(analyzeParallelizability(state.issues));
   });
+  app.get("/api/providers/:slug/usage", async (c) => {
+    const provider = c.req.param("slug") || "";
+    try {
+      const usage = await collectProviderUsage(provider);
+      return c.json({
+        providers: usage ? [usage] : [],
+        collectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (error) {
+      logger.error({ err: error, provider }, "Failed to collect provider usage");
+      return c.json({ providers: [] }, 500);
+    }
+  });
   app.get("/api/providers/usage", async (c) => {
     try {
       const usage = await collectProvidersUsage();
@@ -3111,8 +3666,14 @@ function registerStateRoutes(app, state) {
       if (!nextState) {
         throw new Error(`Unsupported state: ${String(payload.state)}`);
       }
+      if (nextState === "Running" && issue.state !== "Queued") {
+        return c.json({ ok: false, error: "Manual transition to Running is only supported from Queued." }, 400);
+      }
       const container = getContainer();
       await transitionIssueCommand({ issue, target: nextState, note: `Manual state update: ${nextState}` }, container);
+      if (nextState === "Running") {
+        await enqueue(issue, "execute");
+      }
       if (nextState === "Cancelled" && payload.reason) {
         issue.lastError = toStringValue(payload.reason);
       }
@@ -3147,6 +3708,7 @@ function registerStateRoutes(app, state) {
           container
         );
       } else if (issue.state === "Approved") {
+        issue.attempts += 1;
         await transitionIssueCommand(
           { issue, target: "Planning", note: "Requeued for rework after merge conflicts." },
           container
@@ -3161,6 +3723,15 @@ function registerStateRoutes(app, state) {
             container
           );
         }
+      } else if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
+        await requestReworkCommand(
+          {
+            issue,
+            reviewerFeedback: issue.lastError || "Manual rework request.",
+            note: `Manual rework requested for ${issue.identifier}.`
+          },
+          container
+        );
       } else if (issue.state === "PendingApproval") {
         await transitionIssueCommand(
           { issue, target: "Queued", note: "Manual retry \u2014 queued for execution." },
@@ -3229,7 +3800,7 @@ function registerStateRoutes(app, state) {
       if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
       const issue = findIssue(state, issueId);
       if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
-      const { dryMerge } = await import("./workspace-KEHFITYR.js");
+      const { dryMerge } = await import("./workspace-5XOCMZ57.js");
       const result = dryMerge(issue);
       return c.json({ ok: true, ...result });
     } catch (error) {
@@ -3244,7 +3815,7 @@ function registerStateRoutes(app, state) {
       if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
       const issue = findIssue(state, issueId);
       if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
-      const { rebaseWorktree } = await import("./workspace-KEHFITYR.js");
+      const { rebaseWorktree } = await import("./workspace-5XOCMZ57.js");
       const result = rebaseWorktree(issue);
       if (result.success) {
         addEvent(state, issue.id, "info", `Branch ${issue.branchName} rebased onto ${issue.baseBranch}.`);
@@ -3376,7 +3947,7 @@ function registerStateRoutes(app, state) {
     const issue = findIssue(state, issueId);
     if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
     try {
-      const { getIssueTransitionHistory } = await import("./issue-state-machine-V2KPUYPW.js");
+      const { getIssueTransitionHistory } = await import("./issue-state-machine-NBSYRDZW.js");
       const limit = parseInt(c.req.query("limit") ?? "50", 10);
       const offset = parseInt(c.req.query("offset") ?? "0", 10);
       const transitions = await getIssueTransitionHistory(issue.id, { limit, offset });
@@ -3387,7 +3958,7 @@ function registerStateRoutes(app, state) {
   });
   app.get("/api/state-machine/transitions", async (c) => {
     try {
-      const { getStateMachineTransitions } = await import("./issue-state-machine-V2KPUYPW.js");
+      const { getStateMachineTransitions } = await import("./issue-state-machine-NBSYRDZW.js");
       return c.json({ ok: true, transitions: getStateMachineTransitions() });
     } catch (error) {
       return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
@@ -3395,7 +3966,7 @@ function registerStateRoutes(app, state) {
   });
   app.get("/api/state-machine/visualize", async (c) => {
     try {
-      const { visualizeStateMachine } = await import("./issue-state-machine-V2KPUYPW.js");
+      const { visualizeStateMachine } = await import("./issue-state-machine-NBSYRDZW.js");
       const dot = visualizeStateMachine();
       if (!dot) return c.json({ ok: false, error: "Visualization not available." }, 404);
       return c.json({ ok: true, dot });
@@ -3717,6 +4288,7 @@ var SETTING_ID_WORKFLOW_CONFIG = "runtime.workflowConfig";
 var SETTING_ID_TEST_COMMAND = "runtime.testCommand";
 var SETTING_ID_MERGE_MODE = "runtime.mergeMode";
 var SETTING_ID_PR_BASE_BRANCH = "runtime.prBaseBranch";
+var SETTING_ID_AUTO_REVIEW_APPROVAL = "runtime.autoReviewApproval";
 async function loadRuntimeSettings() {
   return loadPersistedSettings();
 }
@@ -3735,7 +4307,8 @@ var RUNTIME_CONFIG_SETTING_IDS = /* @__PURE__ */ new Set([
   SETTING_ID_DEFAULT_EFFORT,
   SETTING_ID_TEST_COMMAND,
   SETTING_ID_MERGE_MODE,
-  SETTING_ID_PR_BASE_BRANCH
+  SETTING_ID_PR_BASE_BRANCH,
+  SETTING_ID_AUTO_REVIEW_APPROVAL
 ]);
 var VALID_REASONING_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "extra-high"]);
 function parseIntegerSetting(value) {
@@ -3797,7 +4370,8 @@ function buildRuntimeConfigSettings(config, source) {
     { id: SETTING_ID_DEFAULT_EFFORT, scope: "runtime", value: config.defaultEffort, source, updatedAt },
     { id: SETTING_ID_TEST_COMMAND, scope: "runtime", value: config.testCommand ?? "", source, updatedAt },
     { id: SETTING_ID_MERGE_MODE, scope: "runtime", value: config.mergeMode ?? "local", source, updatedAt },
-    { id: SETTING_ID_PR_BASE_BRANCH, scope: "runtime", value: config.prBaseBranch ?? "", source, updatedAt }
+    { id: SETTING_ID_PR_BASE_BRANCH, scope: "runtime", value: config.prBaseBranch ?? "", source, updatedAt },
+    { id: SETTING_ID_AUTO_REVIEW_APPROVAL, scope: "runtime", value: config.autoReviewApproval, source, updatedAt }
   ];
 }
 function applyPersistedSettings(config, settings) {
@@ -3906,6 +4480,10 @@ function applyPersistedSettings(config, settings) {
         }
         break;
       }
+      case SETTING_ID_AUTO_REVIEW_APPROVAL: {
+        nextConfig.autoReviewApproval = toBooleanValue(setting.value, true);
+        break;
+      }
       default:
         break;
     }
@@ -5674,8 +6252,11 @@ async function startApiServer(state, port) {
       "GET /analytics": () => serveAppShell(),
       "GET /agents": () => serveAppShell(),
       "GET /settings": () => serveAppShell(),
+      "GET /settings/project": () => serveAppShell(),
       "GET /settings/general": () => serveAppShell(),
+      "GET /settings/agents": () => serveAppShell(),
       "GET /settings/notifications": () => serveAppShell(),
+      "GET /settings/preferences": () => serveAppShell(),
       "GET /settings/workflow": () => serveAppShell(),
       "GET /settings/providers": () => serveAppShell(),
       "GET /api/health": (c) => c.json({ status: state.booting ? "booting" : "ready" })
@@ -6583,7 +7164,8 @@ var AGENCY_AGENTS_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
 var REFERENCE_REPOSITORY_PARSERS = {
   ring: collectStandardArtifacts,
   "agency-agents": collectAgencyArtifacts,
-  impeccable: collectImpeccableArtifacts
+  impeccable: collectImpeccableArtifacts,
+  "everything-claude-code": collectStandardArtifacts
 };
 function runGit(args, cwd) {
   return execFileSync2("git", args, {
@@ -7046,6 +7628,7 @@ function deriveConfig(args) {
     },
     maxConcurrentByState: {},
     runMode: "filesystem",
+    autoReviewApproval: true,
     afterCreateHook: env4.FIFONY_AFTER_CREATE_HOOK ?? "",
     beforeRunHook: env4.FIFONY_BEFORE_RUN_HOOK ?? "",
     afterRunHook: env4.FIFONY_AFTER_RUN_HOOK ?? "",
@@ -7276,6 +7859,7 @@ async function handleStatePatch(state, issue, payload) {
   if (!nextState || !ALLOWED_STATES.includes(nextState)) {
     throw new Error(`Unsupported state: ${String(payload.state)}`);
   }
+  const sourceState = issue.state;
   const path = findIssueStateMachineTransitionPath(null, issue.state, nextState);
   if (!path || path.length === 0) {
     throw new Error(`No valid transition from '${issue.state}' to '${nextState}' for issue ${issue.id}.`);
@@ -7283,6 +7867,14 @@ async function handleStatePatch(state, issue, payload) {
   for (const event of path) {
     await transitionIssue(issue, event, { note: `Manual state update: ${nextState}`, reason: toStringValue(payload.reason) });
   }
+  if (nextState === "Running" && sourceState === "Queued") {
+    try {
+      const { enqueue: enqueue2 } = await import("./queue-workers-OHPJKAPM.js");
+      await enqueue2(issue, "execute");
+    } catch (error) {
+      logger.warn({ issueId: issue.id, err: error }, "[Issues] Failed to enqueue after manual Running transition");
+    }
+  }
   if (nextState === "PendingApproval") {
     issue.nextRetryAt = void 0;
     issue.lastError = void 0;
@@ -7293,34 +7885,6 @@ async function handleStatePatch(state, issue, payload) {
   addEvent(state, issue.id, "manual", `Manual state transition to ${nextState}`);
 }
 
-// src/commands/request-rework.command.ts
-async function requestReworkCommand(input, deps) {
-  const { issue, reviewerFeedback, note } = input;
-  if (issue.state !== "Reviewing" && issue.state !== "PendingDecision") {
-    throw new Error(
-      `requestReworkCommand requires Reviewing or PendingDecision state, got ${issue.state}.`
-    );
-  }
-  issue.lastError = reviewerFeedback;
-  issue.lastFailedPhase = "review";
-  issue.attempts += 1;
-  if (issue.state === "Reviewing") {
-    await transitionIssueCommand(
-      { issue, target: "PendingDecision", note: `Reviewer completed for ${issue.identifier}.` },
-      deps
-    );
-  }
-  await transitionIssueCommand(
-    { issue, target: "Queued", note: note ?? `Reviewer requested rework for ${issue.identifier}.` },
-    deps
-  );
-  deps.eventStore.addEvent(
-    issue.id,
-    "runner",
-    `Issue ${issue.identifier} sent back for rework by reviewer.`
-  );
-}
-
 // src/agents/issue-runner.ts
 async function runPlanningJob(state, issue) {
   issue.planningStatus = "planning";
@@ -7383,9 +7947,15 @@ async function handleReviewStage(state, issue, workspacePath, startTs, routedPro
   markIssueDirty(issue.id);
   const container = getContainer();
   const reviewer = routedProviders.find((p) => p.role === "reviewer");
+  const autoReviewApproval = state.config.autoReviewApproval !== false;
   if (!reviewer) {
-    issue.mergedReason = "Auto-approved: no reviewer configured.";
-    await transitionIssueCommand({ issue, target: "Approved", note: `No reviewer configured; auto-approved for ${issue.identifier}.` }, container);
+    if (autoReviewApproval) {
+      issue.mergedReason = "Auto-approved: no reviewer configured.";
+      await transitionIssueCommand({ issue, target: "Approved", note: `No reviewer configured; auto-approved for ${issue.identifier}.` }, container);
+      return;
+    }
+    issue.mergedReason = "Reviewer not configured; manual approval required.";
+    await transitionIssueCommand({ issue, target: "PendingDecision", note: `No reviewer configured; manual approval required for ${issue.identifier}.` }, container);
     return;
   }
   addEvent(state, issue.id, "info", `Review provider: ${reviewer.role}:${reviewer.provider}${reviewer.model ? `/${reviewer.model}` : ""}${reviewer.profile ? `:${reviewer.profile}` : ""}.`);
@@ -7434,8 +8004,9 @@ async function handleReviewStage(state, issue, workspacePath, startTs, routedPro
     logger.warn({ err: String(vErr) }, "[Agent] Failed to write versioned review artifacts");
   }
   if (reviewResult.success) {
-    issue.mergedReason = `Auto-approved by reviewer in ${reviewResult.turns} turn(s).`;
+    issue.mergedReason = autoReviewApproval ? `Auto-approved by reviewer in ${reviewResult.turns} turn(s).` : `Reviewer completed for ${issue.identifier}; waiting for manual approval.`;
     await transitionIssueCommand({ issue, target: "PendingDecision", note: `Reviewer completed for ${issue.identifier}.` }, container);
+    if (!autoReviewApproval) return;
     const validation = await runValidationGate(issue, state.config);
     if (validation) {
       issue.validationResult = validation;
@@ -7566,7 +8137,7 @@ async function runIssueOnce(state, issue, running) {
     const { workspacePath, promptText, promptFile } = await prepareWorkspace(issue, state, state.config.defaultBranch);
     container.issueRepository.markDirty(issue.id);
     try {
-      const { getIssueStateResource: getIssueStateResource2 } = await import("./store-RVKQ6UEY.js");
+      const { getIssueStateResource: getIssueStateResource2 } = await import("./store-FFHHRNVI.js");
       const res = getIssueStateResource2();
       if (res) {
         await res.patch(issue.id, {
@@ -7678,4 +8249,4 @@ export {
   syncReferenceRepositories,
   importReferenceArtifacts
 };
-//# sourceMappingURL=chunk-3FCJI2GK.js.map
+//# sourceMappingURL=chunk-FAFGDK62.js.map