@open330/oac 2026.4.1 → 2026.4.2

package/dist/budget/index.d.ts

@@ -1,3 +1,5 @@
+import { c as Epic } from '../types-DyP8GmxB.js';
+
 type AgentProviderId = "claude-code" | "codex" | "opencode" | string;
 type TaskSource = "lint" | "todo" | "test-gap" | "dead-code" | "github-issue" | "custom";
 type TaskComplexity = "trivial" | "simple" | "moderate" | "complex";
@@ -36,6 +38,11 @@ interface TokenCounter {
     readonly maxContextTokens: number;
 }
 declare function estimateTokens(task: Task, provider: AgentProviderId): Promise<TokenEstimate>;
+/**
+ * Estimate tokens for an entire epic by summing subtask estimates
+ * plus a 20% context overhead for shared module understanding.
+ */
+declare function estimateEpicTokens(epic: Epic, provider: AgentProviderId): Promise<number>;
 
 declare function estimateLocChanges(task: Task): number;
 declare function analyzeTaskComplexity(task: Task): TaskComplexity;
@@ -57,6 +64,27 @@ interface ExecutionPlan {
     remainingTokens: number;
 }
 declare function buildExecutionPlan(tasks: Task[], estimates: Map<string, TokenEstimate>, budget: number): ExecutionPlan;
+interface EpicExecutionPlan {
+    totalBudget: number;
+    selectedEpics: Array<{
+        epic: Epic;
+        estimatedTokens: number;
+        cumulativeBudgetUsed: number;
+    }>;
+    deferredEpics: Array<{
+        epic: Epic;
+        estimatedTokens: number;
+        reason: "budget_exceeded";
+    }>;
+    reserveTokens: number;
+    remainingTokens: number;
+}
+/**
+ * Build an execution plan for epics. Unlike task-level planning, epics are
+ * sorted purely by priority (not priority/tokens ratio) since they are
+ * already coherent units of work.
+ */
+declare function buildEpicExecutionPlan(epics: Epic[], budget: number): EpicExecutionPlan;
 
 declare class ClaudeTokenCounter {
     readonly invocationOverhead = 1500;
@@ -75,4 +103,4 @@ declare class CodexTokenCounter {
     countTokens(text: string): number;
 }
 
-export { type AgentProviderId, ClaudeTokenCounter, CodexTokenCounter, type ExecutionMode, type ExecutionPlan, type Task, type TaskComplexity, type TaskSource, type TokenCounter, type TokenEstimate, analyzeTaskComplexity, buildExecutionPlan, estimateLocChanges, estimateTokens };
+export { type AgentProviderId, ClaudeTokenCounter, CodexTokenCounter, type EpicExecutionPlan, type ExecutionMode, type ExecutionPlan, type Task, type TaskComplexity, type TaskSource, type TokenCounter, type TokenEstimate, analyzeTaskComplexity, buildEpicExecutionPlan, buildExecutionPlan, estimateEpicTokens, estimateLocChanges, estimateTokens };

package/dist/budget/index.js

@@ -2,15 +2,19 @@ import {
   ClaudeTokenCounter,
   CodexTokenCounter,
   analyzeTaskComplexity,
+  buildEpicExecutionPlan,
   buildExecutionPlan,
+  estimateEpicTokens,
   estimateLocChanges,
   estimateTokens
-} from "../chunk-UL66HWYF.js";
+} from "../chunk-3X6AFC3O.js";
 export {
   ClaudeTokenCounter,
   CodexTokenCounter,
   analyzeTaskComplexity,
+  buildEpicExecutionPlan,
   buildExecutionPlan,
+  estimateEpicTokens,
   estimateLocChanges,
   estimateTokens
 };

package/dist/{chunk-ZPI2VQ7U.js → chunk-2JOG3M5O.js}

@@ -1352,7 +1352,9 @@ ${labelSummary}`, DESCRIPTION_LIMIT);
 }
 function mapComplexityFromLabels(labels) {
   const normalized = labels.map((label) => label.toLowerCase());
-  if (normalized.some((label) => label.includes("good first issue") || label.includes("good-first-issue"))) {
+  if (normalized.some(
+    (label) => label.includes("good first issue") || label.includes("good-first-issue")
+  )) {
     return "simple";
   }
   if (normalized.some((label) => label.includes("feature"))) {
@@ -1720,6 +1722,551 @@ function clamp(value, min, max) {
   return Math.min(max, Math.max(min, value));
 }
 
+// src/discovery/analyzer.ts
+import { mkdir, readFile as readFile5, readdir as readdir3, rename, stat as stat2, unlink, writeFile } from "fs/promises";
+import { dirname, extname, join, relative as relative3, resolve as resolve5 } from "path";
+var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var DEFAULT_EXCLUDE_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage"]);
+var DEFAULT_EXCLUDE_SUFFIXES = [
+  ".d.ts",
+  ".test.ts",
+  ".spec.ts",
+  ".test.tsx",
+  ".spec.tsx",
+  ".test.js",
+  ".spec.js",
+  ".test.jsx",
+  ".spec.jsx"
+];
+var DEFAULT_MAX_AGE_MS = 864e5;
+var CONTEXT_DIR_NAME = ".oac/context";
+var CODEBASE_MAP_FILE = "codebase-map.json";
+var QUALITY_REPORT_FILE = "quality-report.json";
+async function analyzeCodebase(repoPath, options) {
+  const resolvedRepoPath = resolve5(repoPath);
+  const sourceDir = options?.sourceDir ?? "src";
+  const srcRoot = join(resolvedRepoPath, sourceDir);
+  const userExclude = options?.exclude ?? [];
+  const repoFullName = options?.repoFullName ?? "";
+  const headSha = options?.headSha ?? "";
+  const allFiles = await walkSourceFiles(srcRoot, userExclude);
+  const fileInfos = [];
+  for (const absPath of allFiles) {
+    const relPath = relative3(resolvedRepoPath, absPath);
+    const info = await analyzeFile(absPath, relPath);
+    fileInfos.push({ ...info, _absolutePath: absPath });
+  }
+  const moduleMap = buildModuleMap(fileInfos, sourceDir);
+  const moduleNames = new Set(Object.keys(moduleMap));
+  const modules = [];
+  for (const [moduleName, files] of Object.entries(moduleMap)) {
+    const moduleFiles = files.map(({ _absolutePath: _, ...fi }) => fi);
+    const totalLoc2 = moduleFiles.reduce((sum, f) => sum + f.loc, 0);
+    const allExports = moduleFiles.flatMap((f) => f.exports);
+    const dependencies = resolveModuleDependencies(files, moduleName, sourceDir, moduleNames);
+    modules.push({
+      name: moduleName,
+      path: moduleName === "root" ? sourceDir : `${sourceDir}/${moduleName}`,
+      files: moduleFiles,
+      totalLoc: totalLoc2,
+      exports: allExports,
+      dependencies
+    });
+  }
+  const totalFiles = fileInfos.length;
+  const totalLoc = fileInfos.reduce((sum, f) => sum + f.loc, 0);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const codebaseMap = {
+    version: 1,
+    generatedAt,
+    repoFullName,
+    headSha,
+    modules,
+    totalFiles,
+    totalLoc
+  };
+  const findings = await runScanners(resolvedRepoPath, sourceDir, options);
+  const qualityReport = buildQualityReport(findings, repoFullName, generatedAt);
+  return { codebaseMap, qualityReport };
+}
+async function persistContext(repoPath, codebaseMap, qualityReport, contextDir) {
+  const resolvedDir = contextDir ? resolve5(contextDir) : join(resolve5(repoPath), CONTEXT_DIR_NAME);
+  await mkdir(resolvedDir, { recursive: true });
+  await atomicWriteJson(join(resolvedDir, CODEBASE_MAP_FILE), codebaseMap);
+  await atomicWriteJson(join(resolvedDir, QUALITY_REPORT_FILE), qualityReport);
+  return resolvedDir;
+}
+async function loadContext(repoPath, contextDir) {
+  const resolvedDir = contextDir ? resolve5(contextDir) : join(resolve5(repoPath), CONTEXT_DIR_NAME);
+  try {
+    const [mapRaw, reportRaw] = await Promise.all([
+      readFile5(join(resolvedDir, CODEBASE_MAP_FILE), "utf-8"),
+      readFile5(join(resolvedDir, QUALITY_REPORT_FILE), "utf-8")
+    ]);
+    const codebaseMap = JSON.parse(mapRaw);
+    const qualityReport = JSON.parse(reportRaw);
+    return { codebaseMap, qualityReport };
+  } catch {
+    return null;
+  }
+}
+function isContextStale(codebaseMap, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  const generatedAt = new Date(codebaseMap.generatedAt).getTime();
+  if (Number.isNaN(generatedAt)) {
+    return true;
+  }
+  return Date.now() - generatedAt > maxAgeMs;
+}
+function deriveModuleFromPath(filePath, sourceDir = "src") {
+  const normalized = filePath.replace(/\\/g, "/");
+  const prefix = `${sourceDir.replace(/\\/g, "/")}/`;
+  if (!normalized.startsWith(prefix)) {
+    return "root";
+  }
+  const afterSrc = normalized.slice(prefix.length);
+  const firstSlash = afterSrc.indexOf("/");
+  if (firstSlash === -1) {
+    return "root";
+  }
+  return afterSrc.slice(0, firstSlash);
+}
+async function walkSourceFiles(dirPath, userExclude) {
+  const results = [];
+  const userExcludeDirs = /* @__PURE__ */ new Set();
+  const userExcludeSuffixes = [];
+  for (const pattern of userExclude) {
+    const cleaned = pattern.replace(/\/\*{1,2}$/, "");
+    if (cleaned.startsWith("*.")) {
+      userExcludeSuffixes.push(cleaned.slice(1));
+    } else {
+      userExcludeDirs.add(cleaned);
+    }
+  }
+  function isExcludedFile(name) {
+    if (!DEFAULT_EXTENSIONS.has(extname(name))) return true;
+    if (DEFAULT_EXCLUDE_SUFFIXES.some((suffix) => name.endsWith(suffix))) return true;
+    if (userExcludeSuffixes.some((suffix) => name.endsWith(suffix))) return true;
+    return false;
+  }
+  function isExcludedDir(name) {
+    return DEFAULT_EXCLUDE_DIRS.has(name) || userExcludeDirs.has(name);
+  }
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir3(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory() && !isExcludedDir(entry.name)) {
+        await walk(join(dir, entry.name));
+      } else if (entry.isFile() && !isExcludedFile(entry.name)) {
+        results.push(join(dir, entry.name));
+      }
+    }
+  }
+  await walk(dirPath);
+  results.sort();
+  return results;
+}
+async function analyzeFile(absolutePath, relativePath) {
+  const [content, fileStat] = await Promise.all([
+    readFile5(absolutePath, "utf-8"),
+    stat2(absolutePath)
+  ]);
+  const lines = content.split("\n");
+  const loc = lines.filter((line) => line.trim().length > 0).length;
+  const exports = extractExports(content);
+  const imports = extractImports(content);
+  return {
+    path: relativePath,
+    loc,
+    sizeBytes: fileStat.size,
+    exports,
+    imports
+  };
+}
+function extractExports(content) {
+  const exports = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    const trimmed = name.trim();
+    if (trimmed && !seen.has(trimmed)) {
+      seen.add(trimmed);
+      exports.push(trimmed);
+    }
+  };
+  const namedDeclRe = /\bexport\s+(?:async\s+)?(?:function\*?|class|const|let|var|type|interface|enum)\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+  for (const m of content.matchAll(namedDeclRe)) {
+    add(m[1]);
+  }
+  const bracedRe = /\bexport\s*\{([^}]+)\}/g;
+  for (const m of content.matchAll(bracedRe)) {
+    const inner = m[1];
+    for (const item of inner.split(",")) {
+      const parts = item.trim().split(/\s+as\s+/);
+      const exportedName = parts.length > 1 ? parts[1].trim() : parts[0].trim();
+      if (exportedName) {
+        add(exportedName);
+      }
+    }
+  }
+  const defaultRe = /\bexport\s+default\b/;
+  if (defaultRe.test(content)) {
+    add("default");
+  }
+  return exports;
+}
+function extractImports(content) {
+  const imports = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (path) => {
+    const trimmed = path.trim();
+    if (trimmed && !seen.has(trimmed)) {
+      seen.add(trimmed);
+      imports.push(trimmed);
+    }
+  };
+  const staticImportRe = /\bimport\s+(?:[\s\S]*?\s+from\s+)?["']([^"']+)["']/g;
+  for (const m of content.matchAll(staticImportRe)) {
+    add(m[1]);
+  }
+  const dynamicImportRe = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+  for (const m of content.matchAll(dynamicImportRe)) {
+    add(m[1]);
+  }
+  return imports;
+}
+function buildModuleMap(fileInfos, sourceDir) {
+  const moduleMap = {};
+  for (const fi of fileInfos) {
+    const moduleName = deriveModuleFromPath(fi.path, sourceDir);
+    if (!moduleMap[moduleName]) {
+      moduleMap[moduleName] = [];
+    }
+    moduleMap[moduleName].push(fi);
+  }
+  return moduleMap;
+}
+function resolveModuleDependencies(files, currentModule, sourceDir, allModuleNames) {
+  const deps = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    for (const importPath of file.imports) {
+      if (!importPath.startsWith(".")) continue;
+      const fileDir = dirname(file.path);
+      const resolvedImport = join(fileDir, importPath).replace(/\\/g, "/");
+      const importModule = deriveModuleFromPath(resolvedImport, sourceDir);
+      if (importModule !== currentModule && allModuleNames.has(importModule)) {
+        deps.add(importModule);
+      }
+    }
+  }
+  return [...deps].sort();
+}
+async function runScanners(repoPath, sourceDir, options) {
+  const scanners = options?.scanners;
+  const composite = scanners ? new CompositeScanner(scanners) : new CompositeScanner();
+  const scanOptions = {
+    exclude: options?.exclude
+  };
+  let tasks;
+  try {
+    tasks = await composite.scan(repoPath, scanOptions);
+  } catch {
+    tasks = [];
+  }
+  return tasks.map((task) => taskToRawFinding(task, sourceDir));
+}
+function taskToRawFinding(task, sourceDir) {
+  const filePath = task.targetFiles[0] ?? "";
+  const scannerId = typeof task.metadata?.scannerId === "string" ? task.metadata.scannerId : task.source;
+  return {
+    scannerId,
+    source: task.source,
+    filePath,
+    module: deriveModuleFromPath(filePath, sourceDir),
+    title: task.title,
+    description: task.description,
+    severity: deriveSeverity(task.source),
+    complexity: task.complexity,
+    line: typeof task.metadata?.startLine === "number" ? task.metadata.startLine : void 0,
+    metadata: task.metadata,
+    discoveredAt: task.discoveredAt
+  };
+}
+function deriveSeverity(source) {
+  switch (source) {
+    case "lint":
+      return "warning";
+    case "todo":
+      return "info";
+    case "test-gap":
+      return "info";
+    case "github-issue":
+      return "warning";
+    case "dead-code":
+      return "warning";
+    case "custom":
+      return "info";
+    default:
+      return "info";
+  }
+}
+function buildQualityReport(findings, repoFullName, generatedAt) {
+  const bySource = {};
+  const byModule = {};
+  const bySeverity = {};
+  for (const finding of findings) {
+    bySource[finding.source] = (bySource[finding.source] ?? 0) + 1;
+    const mod = finding.module ?? "root";
+    byModule[mod] = (byModule[mod] ?? 0) + 1;
+    bySeverity[finding.severity] = (bySeverity[finding.severity] ?? 0) + 1;
+  }
+  return {
+    version: 1,
+    generatedAt,
+    repoFullName,
+    findings,
+    summary: {
+      totalFindings: findings.length,
+      bySource,
+      byModule,
+      bySeverity
+    }
+  };
+}
+async function atomicWriteJson(filePath, data) {
+  const tmpPath = `${filePath}.tmp.${Date.now()}`;
+  const content = `${JSON.stringify(data, null, 2)}
+`;
+  try {
+    await writeFile(tmpPath, content, "utf-8");
+    await rename(tmpPath, filePath);
+  } catch (error) {
+    try {
+      await unlink(tmpPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// src/discovery/epic-grouper.ts
+import { randomUUID } from "crypto";
+var DEFAULT_MAX_SUBTASKS = 10;
+var DEFAULT_MIN_FINDINGS = 2;
+var MAX_CONTEXT_FILES = 20;
+function groupFindingsIntoEpics(findings, options) {
+  const maxSubtasks = options?.maxSubtasksPerEpic ?? DEFAULT_MAX_SUBTASKS;
+  const _minFindings = options?.minFindingsForEpic ?? DEFAULT_MIN_FINDINGS;
+  const codebaseMap = options?.codebaseMap;
+  const groups = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const module = finding.module ?? deriveModuleFromPath(finding.filePath);
+    const key = `${module}:${finding.source}`;
+    let group = groups.get(key);
+    if (!group) {
+      group = [];
+      groups.set(key, group);
+    }
+    group.push(finding);
+  }
+  const epics = [];
+  for (const [key, groupFindings] of groups) {
+    const [module, source] = key.split(":");
+    if (groupFindings.length <= maxSubtasks) {
+      epics.push(buildEpic(source, module, groupFindings, codebaseMap));
+    } else {
+      const chunks = chunkArray(groupFindings, maxSubtasks);
+      for (let i = 0; i < chunks.length; i++) {
+        epics.push(
+          buildEpic(source, module, chunks[i], codebaseMap, {
+            partIndex: i + 1,
+            totalParts: chunks.length
+          })
+        );
+      }
+    }
+  }
+  return epics;
+}
+function buildEpic(source, module, findings, codebaseMap, partInfo) {
+  const epicId = randomUUID().slice(0, 16);
+  const subtasks = findings.map((f) => findingToTask(f, epicId));
+  let title = buildEpicTitle(source, module, subtasks);
+  if (partInfo) {
+    title = `${title} (${partInfo.partIndex}/${partInfo.totalParts})`;
+  }
+  return {
+    id: epicId,
+    title,
+    description: buildEpicDescription(source, module, subtasks),
+    scope: module,
+    subtasks,
+    contextFiles: resolveContextFiles(module, codebaseMap),
+    status: "pending",
+    priority: computeEpicPriority(subtasks),
+    estimatedTokens: 0,
+    // filled later by estimator
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: {
+      groupingStrategy: "by-module",
+      source,
+      findingCount: findings.length
+    }
+  };
+}
+function buildEpicTitle(source, module, _subtasks) {
+  const moduleLabel = module === "root" ? "" : ` for ${module} module`;
+  switch (source) {
+    case "test-gap":
+      return `Improve test coverage${moduleLabel}`;
+    case "todo":
+      return `Address TODO comments${module === "root" ? "" : ` in ${module} module`}`;
+    case "lint":
+      return `Fix lint issues${module === "root" ? "" : ` in ${module} module`}`;
+    case "dead-code":
+      return `Remove dead code${module === "root" ? "" : ` in ${module} module`}`;
+    case "github-issue":
+      return `Resolve GitHub issues${module === "root" ? "" : ` in ${module} module`}`;
+    case "custom":
+      return `Address findings${module === "root" ? "" : ` in ${module} module`}`;
+    default:
+      return `Address ${source} findings${module === "root" ? "" : ` in ${module} module`}`;
+  }
+}
+function buildEpicDescription(source, module, subtasks) {
+  const lines = [
+    `Grouped ${subtasks.length} ${source} findings in the ${module} module:`,
+    ""
+  ];
+  for (const task of subtasks) {
+    const file = task.targetFiles.length > 0 ? `[${task.targetFiles[0]}] ` : "";
+    lines.push(`- ${file}${task.title}`);
+  }
+  return lines.join("\n");
+}
+function findingToTask(finding, epicId) {
+  return {
+    id: `${finding.source}-${randomUUID().slice(0, 8)}`,
+    source: finding.source,
+    title: finding.title,
+    description: finding.description,
+    targetFiles: [finding.filePath].filter(Boolean),
+    priority: derivePriorityFromSeverity(finding.severity),
+    complexity: finding.complexity,
+    executionMode: "new-pr",
+    metadata: finding.metadata,
+    discoveredAt: finding.discoveredAt,
+    parentEpicId: epicId
+  };
+}
+function derivePriorityFromSeverity(severity) {
+  switch (severity) {
+    case "error":
+      return 80;
+    case "warning":
+      return 50;
+    case "info":
+      return 30;
+  }
+}
+function resolveContextFiles(module, codebaseMap) {
+  if (!codebaseMap) return [];
+  const moduleInfo = codebaseMap.modules.find((m) => m.name === module);
+  if (!moduleInfo) return [];
+  return moduleInfo.files.map((f) => f.path).slice(0, MAX_CONTEXT_FILES);
+}
+function computeEpicPriority(subtasks) {
+  if (subtasks.length === 0) return 0;
+  const avg = subtasks.reduce((sum, t) => sum + t.priority, 0) / subtasks.length;
+  const sizeBoost = Math.min(10, subtasks.length * 2);
+  return Math.min(100, Math.round(avg + sizeBoost));
+}
+function computeEpicComplexity(subtasks) {
+  if (subtasks.length === 1) return subtasks[0].complexity;
+  if (subtasks.length <= 3) return "simple";
+  if (subtasks.length <= 6) return "moderate";
+  return "complex";
+}
+function chunkArray(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+
+// src/discovery/backlog.ts
+import { mkdir as mkdir2, readFile as readFile6, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+var DEFAULT_CONTEXT_DIR = ".oac/context";
+async function persistBacklog(repoPath, backlog, contextDir) {
+  const path = join2(repoPath, contextDir ?? DEFAULT_CONTEXT_DIR, "backlog.json");
+  await mkdir2(dirname2(path), { recursive: true });
+  const tempPath = `${path}.tmp`;
+  await writeFile2(tempPath, JSON.stringify(backlog, null, 2), "utf8");
+  await rename2(tempPath, path);
+  return path;
+}
+async function loadBacklog(repoPath, contextDir) {
+  const path = join2(repoPath, contextDir ?? DEFAULT_CONTEXT_DIR, "backlog.json");
+  try {
+    const content = await readFile6(path, "utf8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return null;
+    }
+    if (err instanceof SyntaxError) {
+      return null;
+    }
+    return null;
+  }
+}
+function createBacklog(repoFullName, headSha, epics) {
+  return {
+    version: 1,
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    repoFullName,
+    headSha,
+    epics
+  };
+}
+function updateBacklog(existing, newEpics, completedEpicIds, headSha) {
+  const epicMap = /* @__PURE__ */ new Map();
+  for (const epic of existing.epics) {
+    epicMap.set(epic.id, { ...epic });
+  }
+  for (const id of completedEpicIds) {
+    const epic = epicMap.get(id);
+    if (epic) {
+      epic.status = "completed";
+      epic.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  for (const epic of newEpics) {
+    const existing2 = epicMap.get(epic.id);
+    if (!existing2) {
+      epicMap.set(epic.id, { ...epic });
+    } else if (existing2.status === "pending") {
+      epicMap.set(epic.id, { ...epic });
+    }
+  }
+  const epics = Array.from(epicMap.values());
+  return {
+    version: 1,
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    repoFullName: existing.repoFullName,
+    headSha: headSha ?? existing.headSha,
+    epics
+  };
+}
+function getPendingEpics(backlog) {
+  return backlog.epics.filter((e) => e.status === "pending").sort((a, b) => b.priority - a.priority);
+}
+
 export {
   TodoScanner,
   LintScanner,
@@ -1727,6 +2274,20 @@ export {
   GitHubIssuesScanner,
   CompositeScanner,
   createDefaultCompositeScanner,
-  rankTasks
+  rankTasks,
+  analyzeCodebase,
+  persistContext,
+  loadContext,
+  isContextStale,
+  deriveModuleFromPath,
+  groupFindingsIntoEpics,
+  findingToTask,
+  computeEpicPriority,
+  computeEpicComplexity,
+  persistBacklog,
+  loadBacklog,
+  createBacklog,
+  updateBacklog,
+  getPendingEpics
 };
-//# sourceMappingURL=chunk-ZPI2VQ7U.js.map
+//# sourceMappingURL=chunk-2JOG3M5O.js.map