@open330/oac 2026.2.5

package/dist/chunk-OTPXGXO7.js

@@ -0,0 +1,2368 @@
+import {
+  createMemoryMonitor,
+  truncate
+} from "./chunk-6A37SKAJ.js";
+
+// src/discovery/scanners/todo-scanner.ts
+import { spawn } from "child_process";
+import { createHash } from "crypto";
+import { readFile, readdir } from "fs/promises";
+import { resolve, sep } from "path";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var TODO_GROUPING_WINDOW = 10;
+var TODO_RG_PATTERN = "\\b(TODO|FIXME|HACK|XXX)\\b";
+var TODO_KEYWORD_PATTERN = /\b(TODO|FIXME|HACK|XXX)\b/i;
+var TODO_TEXT_PATTERN = /\b(TODO|FIXME|HACK|XXX)\b[:\s-]?(.*)$/i;
+var COMMENT_CONTINUATION_PATTERN = /^\s*(?:\/\/|\/\*+|\*|#|--)/;
+var MAX_FUNCTION_LOOKBACK_LINES = 80;
+var DEFAULT_EXCLUDES = [".git", "node_modules", "dist", "build", "coverage"];
+var FUNCTION_PATTERNS = [
+  /^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/,
+  /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/,
+  /^\s*(?:public|private|protected|static|readonly|\s)*(?:async\s+)?([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*[:{]/,
+  /^\s*def\s+([A-Za-z_]\w*)\s*\(/
+];
+var TodoScanner = class {
+  id = "todo";
+  name = "TODO Scanner";
+  async scan(repoPath, options = {}) {
+    const matches = await this.findTodoMatches(repoPath, options);
+    if (matches.length === 0) {
+      return [];
+    }
+    const grouped = groupTodoMatches(matches, TODO_GROUPING_WINDOW);
+    const fileCache = /* @__PURE__ */ new Map();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const tasks = [];
+    for (const cluster of grouped) {
+      const fileLines = await getFileLines(repoPath, cluster.filePath, fileCache);
+      const task = buildTodoTask(cluster, fileLines, now);
+      tasks.push(task);
+    }
+    if (typeof options.maxTasks === "number" && options.maxTasks >= 0) {
+      return tasks.slice(0, options.maxTasks);
+    }
+    return tasks;
+  }
+  async findTodoMatches(repoPath, options) {
+    try {
+      return await findTodoMatchesWithRipgrep(repoPath, options);
+    } catch (error) {
+      if (isCommandNotFound(error)) {
+        return findTodoMatchesWithFsFallback(repoPath, options);
+      }
+      throw error;
+    }
+  }
+};
+async function findTodoMatchesWithRipgrep(repoPath, options) {
+  const args = ["--json", "--line-number", "--column"];
+  if (options.includeHidden) {
+    args.push("--hidden");
+  }
+  const excludes = mergeExcludes(options.exclude);
+  for (const pattern of excludes) {
+    args.push("--glob", toRgExclude(pattern));
+  }
+  args.push("-e", TODO_RG_PATTERN, ".");
+  const result = await runCommand("rg", args, {
+    cwd: repoPath,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    signal: options.signal
+  });
+  if (result.timedOut) {
+    throw new Error(`TODO scanner timed out after ${options.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`);
+  }
+  if (result.exitCode === 1 && result.stdout.trim().length === 0) {
+    return [];
+  }
+  if (result.exitCode !== 0 && result.exitCode !== 1) {
+    throw new Error(`ripgrep failed: ${result.stderr || result.stdout}`);
+  }
+  return parseRipgrepJson(result.stdout);
+}
+function parseRipgrepJson(output) {
+  const matches = [];
+  for (const line of output.split(/\r?\n/)) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const record = toRecord(parsed);
+    if (record.type !== "match") {
+      continue;
+    }
+    const data = toRecord(record.data);
+    const pathRecord = toRecord(data.path);
+    const linesRecord = toRecord(data.lines);
+    const rawFilePath = asString(pathRecord.text);
+    const rawText = asString(linesRecord.text);
+    const filePath = rawFilePath ? normalizeRelativePath(rawFilePath) : void 0;
+    const lineNumber = asNumber(data.line_number);
+    const text = rawText ? sanitizeLine(rawText) : void 0;
+    const submatches = asArray(data.submatches);
+    const firstSubmatch = toRecord(submatches.at(0));
+    const column = (asNumber(firstSubmatch.start) ?? 0) + 1;
+    if (!filePath || !lineNumber || !text) {
+      continue;
+    }
+    const keyword = extractTodoKeyword(text) ?? "TODO";
+    matches.push({
+      filePath,
+      line: lineNumber,
+      column,
+      keyword,
+      text
+    });
+  }
+  return matches;
+}
+async function findTodoMatchesWithFsFallback(repoPath, options) {
+  const excludes = mergeExcludes(options.exclude);
+  const files = await collectFiles(repoPath, excludes);
+  const matches = [];
+  for (const filePath of files) {
+    const absolutePath = resolve(repoPath, filePath);
+    let content = "";
+    try {
+      content = await readFile(absolutePath, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+      const lineText = lines[index] ?? "";
+      if (!TODO_KEYWORD_PATTERN.test(lineText)) {
+        continue;
+      }
+      const keyword = extractTodoKeyword(lineText) ?? "TODO";
+      const columnIndex = lineText.search(TODO_KEYWORD_PATTERN);
+      matches.push({
+        filePath,
+        line: index + 1,
+        column: columnIndex >= 0 ? columnIndex + 1 : 1,
+        keyword,
+        text: sanitizeLine(lineText)
+      });
+    }
+  }
+  return matches;
+}
+function groupTodoMatches(matches, lineWindow) {
+  const sorted = [...matches].sort((left, right) => {
+    const byFile = left.filePath.localeCompare(right.filePath);
+    if (byFile !== 0) {
+      return byFile;
+    }
+    return left.line - right.line;
+  });
+  const groups = [];
+  let active;
+  for (const match of sorted) {
+    if (!active) {
+      active = { filePath: match.filePath, matches: [match] };
+      groups.push(active);
+      continue;
+    }
+    const last = active.matches[active.matches.length - 1];
+    const sameFile = active.filePath === match.filePath;
+    if (sameFile && last && match.line - last.line <= lineWindow) {
+      active.matches.push(match);
+      continue;
+    }
+    active = { filePath: match.filePath, matches: [match] };
+    groups.push(active);
+  }
+  return groups;
+}
+async function getFileLines(repoPath, filePath, cache) {
+  const cached = cache.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const text = await readFile(resolve(repoPath, filePath), "utf8");
+    const lines = text.split(/\r?\n/);
+    cache.set(filePath, lines);
+    return lines;
+  } catch {
+    const empty = [];
+    cache.set(filePath, empty);
+    return empty;
+  }
+}
+function buildTodoTask(cluster, fileLines, discoveredAt) {
+  const first = cluster.matches[0];
+  const last = cluster.matches[cluster.matches.length - 1];
+  const functionName = first ? findNearestFunctionName(fileLines, first.line) : void 0;
+  const isMultiLine = cluster.matches.some((match) => isMultiLineTodo(match, fileLines));
+  const complexity = cluster.matches.length > 1 || isMultiLine ? "simple" : "trivial";
+  const title = first ? `Address TODO comments in ${cluster.filePath}:${first.line}` : `Address TODO comments in ${cluster.filePath}`;
+  const todoSummary = cluster.matches.map((match) => `- ${match.keyword} at line ${match.line}: ${truncate(match.text, 140)}`).join("\n");
+  const descriptionParts = [
+    `Resolve TODO-style markers in \`${cluster.filePath}\`.`,
+    functionName ? `Nearest function context: \`${functionName}\`.` : void 0,
+    "Markers discovered:",
+    todoSummary
+  ].filter((part) => Boolean(part));
+  const description = descriptionParts.join("\n\n");
+  const uniqueKeywords = Array.from(
+    new Set(cluster.matches.map((match) => match.keyword.toUpperCase()))
+  );
+  const stableHashInput = [
+    cluster.filePath,
+    String(first?.line ?? 0),
+    String(last?.line ?? 0),
+    uniqueKeywords.join(","),
+    cluster.matches.map((match) => match.text).join("\n")
+  ].join("::");
+  const task = {
+    id: createTaskId("todo", [cluster.filePath], title, stableHashInput),
+    source: "todo",
+    title,
+    description,
+    targetFiles: [cluster.filePath],
+    priority: 0,
+    complexity,
+    executionMode: "new-pr",
+    metadata: {
+      scannerId: "todo",
+      filePath: cluster.filePath,
+      startLine: first?.line ?? null,
+      endLine: last?.line ?? null,
+      functionName: functionName ?? null,
+      keywordSet: uniqueKeywords,
+      matchCount: cluster.matches.length,
+      matches: cluster.matches.map((match) => ({
+        line: match.line,
+        column: match.column,
+        keyword: match.keyword,
+        text: match.text
+      }))
+    },
+    discoveredAt
+  };
+  return task;
+}
+function findNearestFunctionName(fileLines, lineNumber) {
+  if (lineNumber <= 0 || fileLines.length === 0) {
+    return void 0;
+  }
+  const startIndex = Math.max(0, lineNumber - 1 - MAX_FUNCTION_LOOKBACK_LINES);
+  for (let index = lineNumber - 1; index >= startIndex; index -= 1) {
+    const candidate = fileLines[index]?.trim();
+    if (!candidate || candidate.startsWith("//")) {
+      continue;
+    }
+    for (const pattern of FUNCTION_PATTERNS) {
+      const match = candidate.match(pattern);
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+  }
+  return void 0;
+}
+function isMultiLineTodo(match, fileLines) {
+  const baseIndex = match.line - 1;
+  const line = fileLines[baseIndex + 1];
+  if (line === void 0) {
+    return false;
+  }
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || TODO_KEYWORD_PATTERN.test(trimmed)) {
+    return false;
+  }
+  if (COMMENT_CONTINUATION_PATTERN.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+function extractTodoKeyword(lineText) {
+  const match = lineText.match(TODO_TEXT_PATTERN);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  return match[1].toUpperCase();
+}
+function createTaskId(source, targetFiles, title, suffix) {
+  const base = [source, [...targetFiles].sort().join(","), title, suffix].join("::");
+  return createHash("sha256").update(base).digest("hex").slice(0, 16);
+}
+function mergeExcludes(exclude) {
+  return Array.from(new Set([...DEFAULT_EXCLUDES, ...exclude ?? []].filter(Boolean)));
+}
+function toRgExclude(pattern) {
+  const trimmed = pattern.trim();
+  if (trimmed.startsWith("!")) {
+    return trimmed;
+  }
+  return `!${trimmed}`;
+}
+async function collectFiles(rootDir, excludes) {
+  const files = [];
+  const compiledExcludes = excludes.map(compileGlobMatcher);
+  async function walk(relativeDir) {
+    const absoluteDir = resolve(rootDir, relativeDir);
+    let entries;
+    try {
+      entries = await readdir(absoluteDir, { withFileTypes: true, encoding: "utf8" });
+    } catch {
+      return;
+    }
+    const subdirs = [];
+    for (const entry of entries) {
+      const entryName = String(entry.name);
+      const relPath = normalizeRelativePath(
+        relativeDir ? `${relativeDir}/${entryName}` : entryName
+      );
+      if (compiledExcludes.some((matches) => matches(relPath))) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        subdirs.push(walk(relPath));
+        continue;
+      }
+      if (entry.isFile()) {
+        files.push(relPath);
+      }
+    }
+    await Promise.all(subdirs);
+  }
+  await walk("");
+  return files;
+}
+function compileGlobMatcher(pattern) {
+  const normalized = normalizeRelativePath(pattern.replace(/^!+/, "").trim());
+  if (!normalized) {
+    return () => false;
+  }
+  if (!normalized.includes("*")) {
+    const prefix = normalized.endsWith("/") ? normalized : `${normalized}/`;
+    return (filePath) => filePath === normalized || filePath.startsWith(prefix) || filePath.endsWith(`/${normalized}`);
+  }
+  const escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*");
+  const regex = new RegExp(`^${escaped}$`);
+  return (filePath) => regex.test(filePath);
+}
+function normalizeRelativePath(filePath) {
+  return filePath.split(sep).join("/");
+}
+function sanitizeLine(line) {
+  return line.replace(/\r?\n/g, "").trim();
+}
+function toRecord(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function isCommandNotFound(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const maybeNodeError = error;
+  return maybeNodeError.code === "ENOENT";
+}
+function runCommand(command, args, options) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      signal: options.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let killHandle;
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      killHandle = setTimeout(() => child.kill("SIGKILL"), 2e3);
+    }, options.timeoutMs);
+    child.on("error", (error) => {
+      clearTimeout(timeoutHandle);
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
+      rejectPromise(error);
+    });
+    child.on("close", (exitCode, signal) => {
+      clearTimeout(timeoutHandle);
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
+      resolvePromise({
+        stdout,
+        stderr,
+        exitCode,
+        signal,
+        timedOut
+      });
+    });
+  });
+}
+
+// src/discovery/scanners/lint-scanner.ts
+import { spawn as spawn2 } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { access, readFile as readFile2 } from "fs/promises";
+import { relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+var DEFAULT_TIMEOUT_MS2 = 6e4;
+var LintScanner = class {
+  id = "lint";
+  name = "Lint Scanner";
+  async scan(repoPath, options = {}) {
+    const detection = await detectLinter(repoPath);
+    if (detection.kind === "none") {
+      return [];
+    }
+    const result = await runLinter(repoPath, detection, options);
+    const findings = detection.kind === "eslint" ? parseEslintFindings(result.stdout, repoPath) : parseBiomeFindings(result.stdout, repoPath);
+    if (findings.length === 0) {
+      return [];
+    }
+    const tasks = buildLintTasks(findings, detection.kind);
+    if (typeof options.maxTasks === "number" && options.maxTasks >= 0) {
+      return tasks.slice(0, options.maxTasks);
+    }
+    return tasks;
+  }
+};
+async function detectLinter(repoPath) {
+  const packageManager = await detectPackageManager(repoPath);
+  const packageJson = await readPackageJson(repoPath);
+  const scriptLint = asString2(toRecord2(packageJson.scripts).lint)?.toLowerCase() ?? "";
+  const dependencies = collectDependencyNames(packageJson);
+  if (scriptLint.includes("biome")) {
+    return { kind: "biome", packageManager };
+  }
+  if (scriptLint.includes("eslint")) {
+    return { kind: "eslint", packageManager };
+  }
+  if (dependencies.has("eslint") || await hasAnyFile(repoPath, ESLINT_CONFIG_FILES)) {
+    return { kind: "eslint", packageManager };
+  }
+  if (dependencies.has("@biomejs/biome") || await hasAnyFile(repoPath, BIOME_CONFIG_FILES)) {
+    return { kind: "biome", packageManager };
+  }
+  return { kind: "none", packageManager };
+}
+var ESLINT_CONFIG_FILES = [
+  ".eslintrc",
+  ".eslintrc.json",
+  ".eslintrc.cjs",
+  ".eslintrc.js",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs"
+];
+var BIOME_CONFIG_FILES = ["biome.json", "biome.jsonc"];
+async function detectPackageManager(repoPath) {
+  const checks = [
+    { file: "pnpm-lock.yaml", manager: "pnpm" },
+    { file: "bun.lockb", manager: "bun" },
+    { file: "bun.lock", manager: "bun" },
+    { file: "yarn.lock", manager: "yarn" },
+    { file: "package-lock.json", manager: "npm" }
+  ];
+  for (const check of checks) {
+    if (await fileExists(resolve2(repoPath, check.file))) {
+      return check.manager;
+    }
+  }
+  return "npm";
+}
+async function runLinter(repoPath, detection, options) {
+  const command = buildLintCommand(detection, options);
+  const result = await runCommand2(command.command, command.args, {
+    cwd: repoPath,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
+    signal: options.signal
+  });
+  if (result.timedOut) {
+    throw new Error(`Lint scanner timed out after ${options.timeoutMs ?? DEFAULT_TIMEOUT_MS2}ms`);
+  }
+  const output = result.stdout.trim();
+  if (result.exitCode !== 0 && output.length === 0) {
+    return {
+      ...result,
+      stdout: normalizeJsonText(result.stderr)
+    };
+  }
+  return {
+    ...result,
+    stdout: normalizeJsonText(result.stdout)
+  };
+}
+function buildLintCommand(detection, options) {
+  const excludes = options.exclude ?? [];
+  if (detection.kind === "eslint") {
+    const eslintArgs = ["eslint", ".", "--format", "json", "--no-error-on-unmatched-pattern"];
+    for (const pattern of excludes) {
+      eslintArgs.push("--ignore-pattern", pattern);
+    }
+    return withPackageManagerRunner(detection.packageManager, eslintArgs);
+  }
+  const biomeArgs = ["biome", "check", ".", "--reporter=json"];
+  return withPackageManagerRunner(detection.packageManager, biomeArgs);
+}
+function withPackageManagerRunner(packageManager, commandArgs) {
+  if (packageManager === "pnpm") {
+    return { command: "pnpm", args: ["exec", ...commandArgs] };
+  }
+  if (packageManager === "yarn") {
+    return { command: "yarn", args: commandArgs };
+  }
+  if (packageManager === "bun") {
+    return { command: "bunx", args: commandArgs };
+  }
+  return { command: "npx", args: ["--no-install", ...commandArgs] };
+}
+function parseEslintFindings(output, repoPath) {
+  const parsed = parseJson(output);
+  if (!Array.isArray(parsed)) {
+    return [];
+  }
+  const findings = [];
+  for (const result of parsed) {
+    const resultRecord = toRecord2(result);
+    const filePathValue = asString2(resultRecord.filePath);
+    const filePath = normalizeFilePath(filePathValue, repoPath);
+    if (!filePath) {
+      continue;
+    }
+    const messages = asArray2(resultRecord.messages);
+    for (const message of messages) {
+      const messageRecord = toRecord2(message);
+      const ruleId = asString2(messageRecord.ruleId) ?? "unknown";
+      const text = asString2(messageRecord.message);
+      if (!text) {
+        continue;
+      }
+      findings.push({
+        filePath,
+        line: asNumber2(messageRecord.line),
+        column: asNumber2(messageRecord.column),
+        ruleId,
+        message: text,
+        fixable: messageRecord.fix !== void 0,
+        severity: asNumber2(messageRecord.severity)
+      });
+    }
+  }
+  return findings;
+}
+function parseBiomeFindings(output, repoPath) {
+  const parsed = parseJson(output);
+  if (parsed === void 0) {
+    return [];
+  }
+  const diagnostics = collectBiomeDiagnostics(parsed);
+  const findings = [];
+  for (const diagnostic of diagnostics) {
+    const path = extractBiomePath(diagnostic);
+    const filePath = normalizeFilePath(path, repoPath);
+    if (!filePath) {
+      continue;
+    }
+    const message = asString2(diagnostic.description) ?? asString2(diagnostic.message) ?? asString2(diagnostic.reason);
+    if (!message) {
+      continue;
+    }
+    const category = asString2(diagnostic.category) ?? "unknown";
+    const position = extractBiomePosition(diagnostic);
+    const tags = asArray2(diagnostic.tags).map((value) => String(value).toLowerCase());
+    findings.push({
+      filePath,
+      line: position?.line,
+      column: position?.column,
+      ruleId: category,
+      message,
+      fixable: tags.includes("fixable") || tags.includes("quickfix") || diagnostic.suggestedFixes !== void 0,
+      severity: normalizeBiomeSeverity(asString2(diagnostic.severity))
+    });
+  }
+  return findings;
+}
+function collectBiomeDiagnostics(value) {
+  const diagnostics = [];
+  const queue = [value];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0 || current === null) {
+      continue;
+    }
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        queue.push(item);
+      }
+      continue;
+    }
+    if (typeof current !== "object") {
+      continue;
+    }
+    const record = current;
+    if (looksLikeBiomeDiagnostic(record)) {
+      diagnostics.push(record);
+    }
+    for (const value2 of Object.values(record)) {
+      if (Array.isArray(value2) || value2 && typeof value2 === "object") {
+        queue.push(value2);
+      }
+    }
+  }
+  return diagnostics;
+}
+function looksLikeBiomeDiagnostic(record) {
+  if (record.location !== void 0 && record.category !== void 0) {
+    return true;
+  }
+  if (record.path !== void 0 && (record.description !== void 0 || record.message !== void 0)) {
+    return true;
+  }
+  return false;
+}
+function extractBiomePath(diagnostic) {
+  const location = toRecord2(diagnostic.location);
+  const pathValue = location.path;
+  if (typeof pathValue === "string") {
+    return pathValue;
+  }
+  const pathRecord = toRecord2(pathValue);
+  const file = asString2(pathRecord.file);
+  if (file) {
+    return file;
+  }
+  return asString2(diagnostic.filePath);
+}
+function extractBiomePosition(diagnostic) {
+  const location = toRecord2(diagnostic.location);
+  const span = toRecord2(location.span);
+  const start = toRecord2(span.start);
+  const line = asNumber2(start.line);
+  const column = asNumber2(start.column);
+  if (line !== void 0 || column !== void 0) {
+    return { line, column };
+  }
+  const lineFallback = asNumber2(location.line) ?? asNumber2(diagnostic.line);
+  const columnFallback = asNumber2(location.column) ?? asNumber2(diagnostic.column);
+  if (lineFallback !== void 0 || columnFallback !== void 0) {
+    return { line: lineFallback, column: columnFallback };
+  }
+  return void 0;
+}
+function normalizeBiomeSeverity(severity) {
+  if (!severity) {
+    return void 0;
+  }
+  const normalized = severity.toLowerCase();
+  if (normalized === "error") {
+    return 2;
+  }
+  if (normalized === "warning" || normalized === "warn") {
+    return 1;
+  }
+  return void 0;
+}
+function buildLintTasks(findings, linter) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const existing = grouped.get(finding.filePath);
+    if (existing) {
+      existing.push(finding);
+    } else {
+      grouped.set(finding.filePath, [finding]);
+    }
+  }
+  const discoveredAt = (/* @__PURE__ */ new Date()).toISOString();
+  const tasks = [];
+  for (const [filePath, fileFindings] of grouped.entries()) {
+    const uniqueRules = Array.from(new Set(fileFindings.map((finding) => finding.ruleId)));
+    const fixableCount = fileFindings.filter((finding) => finding.fixable).length;
+    const complexity = fileFindings.length === 1 && fixableCount === 1 ? "trivial" : "simple";
+    const headlineRules = uniqueRules.slice(0, 5).join(", ") || "unknown";
+    const title = `Fix lint findings in ${filePath}`;
+    const description = [
+      `Resolve ${fileFindings.length} lint finding(s) reported by ${linter} in \`${filePath}\`.`,
+      `Primary rules: ${headlineRules}.`,
+      fixableCount > 0 ? `${fixableCount} finding(s) appear auto-fixable.` : "No auto-fixable findings were detected."
+    ].join("\n\n");
+    const task = {
+      id: createTaskId2("lint", [filePath], title, `${linter}:${headlineRules}`),
+      source: "lint",
+      title,
+      description,
+      targetFiles: [filePath],
+      priority: 0,
+      complexity,
+      executionMode: "new-pr",
+      metadata: {
+        scannerId: "lint",
+        linter,
+        filePath,
+        issueCount: fileFindings.length,
+        ruleIds: uniqueRules,
+        fixableCount,
+        findings: fileFindings.map((finding) => ({
+          line: finding.line ?? null,
+          column: finding.column ?? null,
+          ruleId: finding.ruleId,
+          message: finding.message,
+          fixable: finding.fixable,
+          severity: finding.severity ?? null
+        }))
+      },
+      discoveredAt
+    };
+    tasks.push(task);
+  }
+  return tasks;
+}
+function createTaskId2(source, targetFiles, title, suffix) {
+  const content = [source, [...targetFiles].sort().join(","), title, suffix].join("::");
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
+}
+async function readPackageJson(repoPath) {
+  const packageJsonPath = resolve2(repoPath, "package.json");
+  try {
+    const raw = await readFile2(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return toRecord2(parsed);
+  } catch {
+    return {};
+  }
+}
+function collectDependencyNames(packageJson) {
+  const sections = [
+    toRecord2(packageJson.dependencies),
+    toRecord2(packageJson.devDependencies),
+    toRecord2(packageJson.peerDependencies),
+    toRecord2(packageJson.optionalDependencies)
+  ];
+  const names = /* @__PURE__ */ new Set();
+  for (const section of sections) {
+    for (const key of Object.keys(section)) {
+      names.add(key);
+    }
+  }
+  return names;
+}
+async function hasAnyFile(repoPath, candidates) {
+  for (const candidate of candidates) {
+    if (await fileExists(resolve2(repoPath, candidate))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeFilePath(filePath, repoPath) {
+  if (!filePath) {
+    return void 0;
+  }
+  if (filePath.startsWith("<")) {
+    return void 0;
+  }
+  const absoluteCandidate = resolve2(repoPath, filePath);
+  const rel = relative2(repoPath, absoluteCandidate);
+  if (!rel.startsWith("..")) {
+    return rel.split(sep2).join("/");
+  }
+  const direct = filePath.split(sep2).join("/");
+  return direct;
+}
+function normalizeJsonText(text) {
+  return text.trim();
+}
+function parseJson(text) {
+  if (text.trim().length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    const jsonStart = text.indexOf("[");
+    const objectStart = text.indexOf("{");
+    const start = jsonStart === -1 ? objectStart : objectStart === -1 ? jsonStart : Math.min(jsonStart, objectStart);
+    if (start < 0) {
+      return void 0;
+    }
+    const trimmed = text.slice(start).trim();
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function toRecord2(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function asString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asArray2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function runCommand2(command, args, options) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn2(command, args, {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      signal: options.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let killHandle;
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      killHandle = setTimeout(() => child.kill("SIGKILL"), 2e3);
+    }, options.timeoutMs);
+    child.on("error", (error) => {
+      clearTimeout(timeoutHandle);
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
+      rejectPromise(error);
+    });
+    child.on("close", (exitCode, signal) => {
+      clearTimeout(timeoutHandle);
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
+      resolvePromise({
+        stdout,
+        stderr,
+        exitCode,
+        signal,
+        timedOut
+      });
+    });
+  });
+}
+
+// src/discovery/scanners/test-gap-scanner.ts
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile3, readdir as readdir2, stat } from "fs/promises";
+import { basename, resolve as resolve3, sep as sep3 } from "path";
+var DEFAULT_EXCLUDES2 = [".git", "node_modules", "dist", "build", "coverage"];
+var TestGapScanner = class {
+  id = "test-gap";
+  name = "Test Gap Scanner";
+  async scan(repoPath, options = {}) {
+    const maxTasks = options.maxTasks;
+    if (typeof maxTasks === "number" && maxTasks === 0) {
+      return [];
+    }
+    const excludes = mergeExcludes2(options.exclude);
+    const { sourceFiles, testFiles } = await collectCandidateFiles(repoPath, excludes);
+    if (sourceFiles.length === 0) {
+      return [];
+    }
+    const coveredSourceKeys = buildCoveredSourceKeySet(testFiles);
+    const untestedSourceFiles = sourceFiles.filter(
+      (sourceFilePath) => !coveredSourceKeys.has(toSourceKey(sourceFilePath))
+    );
+    if (untestedSourceFiles.length === 0) {
+      return [];
+    }
+    const cappedSourceFiles = typeof maxTasks === "number" && maxTasks > 0 ? untestedSourceFiles.slice(0, maxTasks) : untestedSourceFiles;
+    const discoveredAt = (/* @__PURE__ */ new Date()).toISOString();
+    const tasks = [];
+    for (const sourceFilePath of cappedSourceFiles) {
+      const absolutePath = resolve3(repoPath, sourceFilePath);
+      let fileContent = "";
+      let fileSizeBytes = 0;
+      try {
+        const [content, fileStats] = await Promise.all([
+          readFile3(absolutePath, "utf8"),
+          stat(absolutePath)
+        ]);
+        fileContent = content;
+        fileSizeBytes = fileStats.size;
+      } catch {
+        continue;
+      }
+      const lineCount = countLines(fileContent);
+      const complexityBucket = toComplexityBucket(lineCount);
+      const complexity = toTaskComplexity(complexityBucket);
+      const estimatedTokens = estimateTokens(complexityBucket);
+      const symbols = extractSymbols(fileContent);
+      const task = {
+        id: createTaskId3(sourceFilePath),
+        source: "test-gap",
+        title: `Add tests for ${basename(sourceFilePath)}`,
+        description: buildDescription(sourceFilePath, symbols),
+        targetFiles: [sourceFilePath],
+        priority: 0,
+        complexity,
+        executionMode: "new-pr",
+        metadata: {
+          scannerId: "test-gap",
+          filePath: sourceFilePath,
+          lineCount,
+          fileSizeBytes,
+          complexityBucket,
+          estimatedTokens,
+          symbols
+        },
+        discoveredAt
+      };
+      tasks.push(task);
+    }
+    return tasks;
+  }
+};
+async function collectCandidateFiles(repoPath, excludePatterns) {
+  const sourceFiles = [];
+  const testFiles = [];
+  const excludeMatchers = excludePatterns.map(compileGlobMatcher2);
+  async function walk(relativeDir) {
+    const absoluteDir = resolve3(repoPath, relativeDir);
+    let entries;
+    try {
+      entries = await readdir2(absoluteDir, { withFileTypes: true, encoding: "utf8" });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryName = String(entry.name);
+      const relativePath = normalizeRelativePath2(
+        relativeDir ? `${relativeDir}/${entryName}` : entryName
+      );
+      if (excludeMatchers.some((matches) => matches(relativePath))) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await walk(relativePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      if (isSourceFile(relativePath)) {
+        sourceFiles.push(relativePath);
+      }
+      if (isTestFile(relativePath)) {
+        testFiles.push(relativePath);
+      }
+    }
+  }
+  await walk("");
+  sourceFiles.sort((left, right) => left.localeCompare(right));
+  testFiles.sort((left, right) => left.localeCompare(right));
+  return { sourceFiles, testFiles };
+}
+function isSourceFile(filePath) {
+  if (!filePath.endsWith(".ts")) {
+    return false;
+  }
+  if (filePath.endsWith(".d.ts") || filePath.endsWith(".test.ts")) {
+    return false;
+  }
+  if (basename(filePath) === "index.ts") {
+    return false;
+  }
+  const parts = filePath.split("/");
+  return parts.includes("src");
+}
+function isTestFile(filePath) {
+  if (!filePath.endsWith(".test.ts")) {
+    return false;
+  }
+  const parts = filePath.split("/");
+  return parts.includes("tests") || parts.includes("__tests__");
+}
+function buildCoveredSourceKeySet(testFiles) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const testFilePath of testFiles) {
+    const candidateSourceKeys = deriveCandidateSourceKeysFromTest(testFilePath);
+    for (const sourceKey of candidateSourceKeys) {
+      covered.add(sourceKey);
+    }
+  }
+  return covered;
+}
+function deriveCandidateSourceKeysFromTest(testFilePath) {
+  const normalized = normalizeRelativePath2(testFilePath);
+  if (!normalized.endsWith(".test.ts")) {
+    return [];
+  }
+  const withoutSuffix = normalized.slice(0, -".test.ts".length);
+  const parts = withoutSuffix.split("/");
+  const markerIndex = parts.findIndex((part) => part === "tests" || part === "__tests__");
+  if (markerIndex < 0) {
+    return [];
+  }
+  const prefix = parts.slice(0, markerIndex);
+  const suffix = parts.slice(markerIndex + 1);
+  const candidates = /* @__PURE__ */ new Set();
+  candidates.add(normalizeRelativePath2([...prefix, "src", ...suffix].join("/")));
+  if (prefix[prefix.length - 1] === "src") {
+    candidates.add(normalizeRelativePath2([...prefix, ...suffix].join("/")));
+  }
+  return [...candidates];
+}
+function toSourceKey(sourceFilePath) {
+  const normalized = normalizeRelativePath2(sourceFilePath);
+  return normalized.endsWith(".ts") ? normalized.slice(0, -".ts".length) : normalized;
+}
+function buildDescription(sourceFilePath, symbols) {
+  if (symbols.length === 0) {
+    return `Add initial test coverage for \`${sourceFilePath}\`. No named functions or classes were detected.`;
+  }
+  const symbolList = symbols.map((symbol) => `\`${symbol}\``).join(", ");
+  return `Add test coverage for \`${sourceFilePath}\`, including: ${symbolList}.`;
+}
+function extractSymbols(fileContent) {
+  const symbols = /* @__PURE__ */ new Set();
+  const patterns = [
+    /\b(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/g,
+    /\b(?:export\s+)?class\s+([A-Za-z_$][\w$]*)\b/g,
+    /\b(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    match = pattern.exec(fileContent);
+    while (match) {
+      const symbolName = match[1];
+      if (symbolName) {
+        symbols.add(symbolName);
+      }
+      match = pattern.exec(fileContent);
+    }
+  }
+  return [...symbols].sort((left, right) => left.localeCompare(right));
+}
+function countLines(fileContent) {
+  if (fileContent.length === 0) {
+    return 0;
+  }
+  return fileContent.split(/\r?\n/).length;
+}
+function toComplexityBucket(lineCount) {
+  if (lineCount < 50) {
+    return "small";
+  }
+  if (lineCount < 200) {
+    return "medium";
+  }
+  return "large";
+}
+function toTaskComplexity(bucket) {
+  if (bucket === "small") {
+    return "simple";
+  }
+  if (bucket === "medium") {
+    return "moderate";
+  }
+  return "complex";
+}
+function estimateTokens(bucket) {
+  if (bucket === "small") {
+    return 1500;
+  }
+  if (bucket === "medium") {
+    return 4e3;
+  }
+  return 8e3;
+}
+function createTaskId3(sourceFilePath) {
+  return createHash3("sha256").update(sourceFilePath).digest("hex").slice(0, 16);
+}
+function mergeExcludes2(exclude) {
+  return Array.from(new Set([...DEFAULT_EXCLUDES2, ...exclude ?? []].filter(Boolean)));
+}
+function compileGlobMatcher2(pattern) {
+  const normalized = normalizeRelativePath2(pattern.replace(/^!+/, "").trim());
+  if (!normalized) {
+    return () => false;
+  }
+  if (!normalized.includes("*")) {
+    const prefix = normalized.endsWith("/") ? normalized : `${normalized}/`;
+    return (filePath) => filePath === normalized || filePath.startsWith(prefix) || filePath.endsWith(`/${normalized}`);
+  }
+  const escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*");
+  const regex = new RegExp(`^${escaped}$`);
+  return (filePath) => regex.test(filePath);
+}
+function normalizeRelativePath2(filePath) {
+  return filePath.split(sep3).join("/");
+}
+
+// src/discovery/scanners/github-issues-scanner.ts
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+var GITHUB_API_BASE_URL = "https://api.github.com";
+var ISSUES_PER_PAGE = 30;
+var TITLE_LIMIT = 120;
+var DESCRIPTION_LIMIT = 500;
+var ESTIMATED_TOKENS_BY_COMPLEXITY = {
+  trivial: 1500,
+  simple: 4e3,
+  moderate: 9e3,
+  complex: 18e3
+};
+var GitHubIssuesScanner = class {
+  constructor(token) {
+    this.token = token;
+  }
+  id = "github-issue";
+  name = "GitHub Issues Scanner";
+  async scan(repoPath, options = {}) {
+    const token = this.token ?? process.env.GITHUB_TOKEN;
+    if (!token) {
+      return [];
+    }
+    const repo = await resolveRepoCoordinates(repoPath, options);
+    if (!repo) {
+      return [];
+    }
+    const issues = await fetchOpenIssues(repo, token);
+    if (issues.length === 0) {
+      return [];
+    }
+    const discoveredAt = (/* @__PURE__ */ new Date()).toISOString();
+    const tasks = issues.filter((issue) => issue.pull_request === void 0).map((issue) => mapIssueToTask(issue, discoveredAt)).filter((task) => task !== void 0);
+    if (typeof options.maxTasks === "number" && options.maxTasks >= 0) {
+      return tasks.slice(0, options.maxTasks);
+    }
+    return tasks;
+  }
+};
+async function resolveRepoCoordinates(repoPath, options) {
+  if (options.repo?.owner && options.repo.name) {
+    return {
+      owner: options.repo.owner,
+      name: options.repo.name
+    };
+  }
+  return parseRepoFromGitConfig(repoPath);
+}
+async function fetchOpenIssues(repo, token) {
+  const url = `${GITHUB_API_BASE_URL}/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}/issues?state=open&per_page=${ISSUES_PER_PAGE}&sort=updated`;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json"
+      },
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      return [];
+    }
+    const payload = await response.json();
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+    return payload.map((item) => toIssueResponse(item));
+  } catch {
+    return [];
+  }
+}
+async function parseRepoFromGitConfig(repoPath) {
+  const config = await readGitConfig(repoPath);
+  if (!config) {
+    return void 0;
+  }
+  const remoteUrl = extractRemoteUrl(config);
+  if (!remoteUrl) {
+    return void 0;
+  }
+  return parseGitHubRemoteUrl(remoteUrl);
+}
+async function readGitConfig(repoPath) {
+  try {
+    return await readFile4(resolve4(repoPath, ".git", "config"), "utf8");
+  } catch {
+  }
+  try {
+    const gitFile = await readFile4(resolve4(repoPath, ".git"), "utf8");
+    const gitDir = parseGitDirPointer(gitFile);
+    if (!gitDir) {
+      return void 0;
+    }
+    return await readFile4(resolve4(repoPath, gitDir, "config"), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function parseGitDirPointer(content) {
+  const match = content.match(/^\s*gitdir:\s*(.+)\s*$/im);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  return match[1].trim();
+}
+function extractRemoteUrl(configText) {
+  const lines = configText.split(/\r?\n/);
+  let activeRemote;
+  let firstRemoteUrl;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith(";")) {
+      continue;
+    }
+    const sectionMatch = line.match(/^\[\s*remote\s+"([^"]+)"\s*\]$/i);
+    if (sectionMatch?.[1]) {
+      activeRemote = sectionMatch[1];
+      continue;
+    }
+    if (!activeRemote) {
+      continue;
+    }
+    const urlMatch = line.match(/^url\s*=\s*(.+)$/i);
+    if (!urlMatch?.[1]) {
+      continue;
+    }
+    const url = urlMatch[1].trim();
+    if (activeRemote === "origin") {
+      return url;
+    }
+    if (!firstRemoteUrl) {
+      firstRemoteUrl = url;
+    }
+  }
+  return firstRemoteUrl;
+}
+var GITHUB_SSH_PATTERN = /^git@github\.com:(?<owner>[A-Za-z0-9_.-]+)\/(?<repo>[A-Za-z0-9_.-]+?)(?:\.git)?$/i;
+function parseGitHubRemoteUrl(remoteUrl) {
+  const normalized = remoteUrl.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  const sshMatch = normalized.match(GITHUB_SSH_PATTERN);
+  if (sshMatch?.groups?.owner && sshMatch.groups.repo) {
+    return {
+      owner: sshMatch.groups.owner,
+      name: stripGitSuffix(sshMatch.groups.repo)
+    };
+  }
+  const normalizedUrlInput = normalized.startsWith("github.com/") ? `https://${normalized}` : normalized;
+  try {
+    const url = new URL(normalizedUrlInput);
+    if (!isGitHubHost(url.hostname)) {
+      return void 0;
+    }
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    if (pathParts.length < 2) {
+      return void 0;
+    }
+    const owner = pathParts[0];
+    const name = stripGitSuffix(pathParts[1]);
+    if (!owner || !name) {
+      return void 0;
+    }
+    return { owner, name };
+  } catch {
+    return void 0;
+  }
+}
+function isGitHubHost(hostname) {
+  const normalized = hostname.toLowerCase();
+  return normalized === "github.com" || normalized === "www.github.com";
+}
+function stripGitSuffix(value) {
+  return value.replace(/\.git$/i, "");
+}
+function mapIssueToTask(issue, discoveredAt) {
+  const issueNumber = asNumber3(issue.number);
+  const rawTitle = asString3(issue.title)?.trim();
+  if (issueNumber === void 0 || !rawTitle) {
+    return void 0;
+  }
+  const labels = normalizeLabels(issue.labels);
+  const complexity = mapComplexityFromLabels(labels);
+  const estimatedTokens = ESTIMATED_TOKENS_BY_COMPLEXITY[complexity];
+  const bodyText = asString3(issue.body)?.trim() || "No description provided.";
+  const labelSummary = labels.length > 0 ? `Labels: ${labels.join(", ")}` : "Labels: none";
+  const title = truncate(rawTitle, TITLE_LIMIT);
+  const description = truncate(`${bodyText}
+
+${labelSummary}`, DESCRIPTION_LIMIT);
+  const url = asString3(issue.html_url) ?? "";
+  const author = readAuthor(issue.user);
+  const createdAt = asString3(issue.created_at) ?? discoveredAt;
+  return {
+    id: `github-issue-${issueNumber}`,
+    source: "github-issue",
+    title,
+    description,
+    targetFiles: [],
+    priority: 0,
+    complexity,
+    executionMode: "new-pr",
+    linkedIssue: {
+      number: issueNumber,
+      url,
+      labels
+    },
+    metadata: {
+      issueNumber,
+      labels,
+      url,
+      author,
+      createdAt,
+      estimatedTokens
+    },
+    discoveredAt
+  };
+}
+function mapComplexityFromLabels(labels) {
+  const normalized = labels.map((label) => label.toLowerCase());
+  if (normalized.some(
+    (label) => label.includes("good first issue") || label.includes("good-first-issue")
+  )) {
+    return "simple";
+  }
+  if (normalized.some((label) => label.includes("feature"))) {
+    return "complex";
+  }
+  if (normalized.some((label) => label.includes("enhancement"))) {
+    return "moderate";
+  }
+  if (normalized.some((label) => label.includes("bug"))) {
+    return "simple";
+  }
+  return "moderate";
+}
+function normalizeLabels(rawLabels) {
+  if (!Array.isArray(rawLabels)) {
+    return [];
+  }
+  const labels = [];
+  for (const rawLabel of rawLabels) {
+    if (typeof rawLabel === "string") {
+      const trimmed = rawLabel.trim();
+      if (trimmed.length > 0) {
+        labels.push(trimmed);
+      }
+      continue;
+    }
+    if (rawLabel && typeof rawLabel === "object") {
+      const name = asString3(rawLabel.name)?.trim();
+      if (name) {
+        labels.push(name);
+      }
+    }
+  }
+  return Array.from(new Set(labels));
+}
+function readAuthor(user) {
+  if (!user || typeof user !== "object") {
+    return "unknown";
+  }
+  const login = asString3(user.login);
+  if (!login) {
+    return "unknown";
+  }
+  return login;
+}
+function toIssueResponse(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function asString3(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/discovery/scanner.ts
+import { createHash as createHash4 } from "crypto";
+var CompositeScanner = class {
+  id = "composite";
+  name = "Composite Scanner";
+  scanners;
+  constructor(scanners = [new LintScanner(), new TodoScanner()]) {
+    this.scanners = scanners;
+  }
+  async scan(repoPath, options = {}) {
+    const settled = await Promise.allSettled(
+      this.scanners.map(async (scanner) => ({
+        scannerId: scanner.id,
+        tasks: await scanner.scan(repoPath, options)
+      }))
+    );
+    const collected = [];
+    for (const result of settled) {
+      if (result.status !== "fulfilled") {
+        continue;
+      }
+      const scannerId = result.value.scannerId;
+      for (const task of result.value.tasks) {
+        collected.push({ scannerId, task });
+      }
+    }
+    const deduplicated = deduplicateTasks(collected);
+    if (typeof options.maxTasks === "number" && options.maxTasks >= 0) {
+      return deduplicated.slice(0, options.maxTasks);
+    }
+    return deduplicated;
+  }
+};
+function createDefaultCompositeScanner() {
+  return new CompositeScanner([new LintScanner(), new TodoScanner()]);
+}
+function deduplicateTasks(candidates) {
+  const deduplicatedByHash = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const hash = taskContentHash(candidate.task);
+    const existing = deduplicatedByHash.get(hash);
+    if (!existing) {
+      deduplicatedByHash.set(hash, {
+        task: candidate.task,
+        mergedSources: [candidate.scannerId],
+        duplicateTaskIds: [candidate.task.id]
+      });
+      continue;
+    }
+    const preferIncoming = candidate.task.priority > existing.task.priority;
+    const winner = preferIncoming ? candidate.task : existing.task;
+    const loser = preferIncoming ? existing.task : candidate.task;
+    const mergedSources = unique([
+      ...existing.mergedSources,
+      candidate.scannerId,
+      String(loser.source)
+    ]);
+    const duplicateTaskIds = unique([...existing.duplicateTaskIds, loser.id, winner.id]);
+    const winnerMetadata = toRecord3(winner.metadata);
+    const loserMetadata = toRecord3(loser.metadata);
+    deduplicatedByHash.set(hash, {
+      task: {
+        ...winner,
+        metadata: {
+          ...loserMetadata,
+          ...winnerMetadata,
+          mergedSources,
+          duplicateTaskIds,
+          dedupeHash: hash
+        }
+      },
+      mergedSources,
+      duplicateTaskIds
+    });
+  }
+  const deduplicated = [...deduplicatedByHash.values()].map((entry) => entry.task);
+  deduplicated.sort((left, right) => {
+    const byPriority = right.priority - left.priority;
+    if (byPriority !== 0) {
+      return byPriority;
+    }
+    return left.title.localeCompare(right.title);
+  });
+  return deduplicated;
+}
+function taskContentHash(task) {
+  const content = [task.source, [...task.targetFiles].sort().join(","), task.title].join("::");
+  return createHash4("sha256").update(content).digest("hex").slice(0, 16);
+}
+function toRecord3(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function unique(values) {
+  return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}
+
+// src/discovery/scanner-factory.ts
+function buildScanners(config, hasGitHubAuth) {
+  const names = [];
+  if (config?.discovery.scanners.lint !== false) {
+    names.push("lint");
+  }
+  if (config?.discovery.scanners.todo !== false) {
+    names.push("todo");
+  }
+  if (config?.discovery.scanners.testGap !== false) {
+    names.push("test-gap");
+  }
+  if (hasGitHubAuth) {
+    names.push("github-issues");
+  }
+  if (names.length === 0) {
+    names.push("lint", "todo", "test-gap");
+  }
+  const unique2 = [...new Set(names)];
+  const instances = unique2.map(instantiateScanner);
+  return { names: unique2, instances, composite: new CompositeScanner(instances) };
+}
+function instantiateScanner(name) {
+  switch (name) {
+    case "lint":
+      return new LintScanner();
+    case "todo":
+      return new TodoScanner();
+    case "test-gap":
+      return new TestGapScanner();
+    case "github-issues":
+      return new GitHubIssuesScanner();
+  }
+}
+
+// src/discovery/ranker.ts
+var IMPACT_BY_SOURCE = {
+  lint: 22,
+  todo: 10,
+  "test-gap": 24,
+  "dead-code": 14,
+  "github-issue": 20,
+  custom: 12
+};
+var FEASIBILITY_BY_COMPLEXITY = {
+  trivial: 25,
+  simple: 20,
+  moderate: 12,
+  complex: 6
+};
+var TOKEN_EFFICIENCY_BY_COMPLEXITY = {
+  trivial: 18,
+  simple: 14,
+  moderate: 8,
+  complex: 4
+};
+function rankTasks(tasks) {
+  const ranked = tasks.map((task) => {
+    const scores = scoreTask(task);
+    const priority = clamp(
+      Math.round(
+        scores.impactScore + scores.feasibilityScore + scores.freshnessScore + scores.issueSignals + scores.tokenEfficiency
+      ),
+      0,
+      100
+    );
+    const metadata = toRecord4(task.metadata);
+    return {
+      ...task,
+      priority,
+      metadata: {
+        ...metadata,
+        priorityBreakdown: scores
+      }
+    };
+  });
+  ranked.sort((left, right) => {
+    const byPriority = right.priority - left.priority;
+    if (byPriority !== 0) {
+      return byPriority;
+    }
+    return left.title.localeCompare(right.title);
+  });
+  return ranked;
+}
+function scoreTask(task) {
+  const metadata = toRecord4(task.metadata);
+  const impactScore = scoreImpact(task, metadata);
+  const feasibilityScore = scoreFeasibility(task, metadata);
+  const freshnessScore = scoreFreshness(task, metadata);
+  const issueSignals = scoreIssueSignals(task, metadata);
+  const tokenEfficiency = scoreTokenEfficiency(task, metadata, impactScore);
+  return {
+    impactScore,
+    feasibilityScore,
+    freshnessScore,
+    issueSignals,
+    tokenEfficiency
+  };
+}
+function scoreImpact(task, metadata) {
+  let score = IMPACT_BY_SOURCE[task.source] ?? 12;
+  const matchCount = readNumber(metadata, "matchCount");
+  if (task.source === "todo" && matchCount !== void 0) {
+    if (matchCount >= 4) {
+      score += 4;
+    } else if (matchCount >= 2) {
+      score += 2;
+    }
+  }
+  const issueCount = readNumber(metadata, "issueCount");
+  if (task.source === "lint" && issueCount !== void 0 && issueCount >= 5) {
+    score += 2;
+  }
+  if (task.linkedIssue) {
+    score += 2;
+  }
+  return clamp(score, 0, 25);
+}
+function scoreFeasibility(task, metadata) {
+  let score = FEASIBILITY_BY_COMPLEXITY[task.complexity];
+  const fileCount = Math.max(task.targetFiles.length, readNumber(metadata, "targetFileCount") ?? 0);
+  if (fileCount >= 6) {
+    score -= 8;
+  } else if (fileCount >= 3) {
+    score -= 4;
+  }
+  if (task.executionMode === "direct-commit") {
+    score -= 2;
+  }
+  return clamp(score, 0, 25);
+}
+function scoreFreshness(task, metadata) {
+  const daysSinceChange = readNumber(metadata, "daysSinceLastChange") ?? readNumber(metadata, "freshnessDays") ?? getAgeInDays(readString(metadata, "lastModifiedAt"));
+  if (daysSinceChange === void 0) {
+    const discoveredAge = getAgeInDays(task.discoveredAt);
+    if (discoveredAge === void 0) {
+      return 7;
+    }
+    return clamp(15 - Math.floor(discoveredAge / 3), 4, 15);
+  }
+  if (daysSinceChange <= 3) {
+    return 15;
+  }
+  if (daysSinceChange <= 14) {
+    return 12;
+  }
+  if (daysSinceChange <= 30) {
+    return 9;
+  }
+  if (daysSinceChange <= 90) {
+    return 6;
+  }
+  if (daysSinceChange <= 180) {
+    return 4;
+  }
+  return 2;
+}
+function scoreIssueSignals(task, metadata) {
+  let score = 0;
+  if (task.linkedIssue) {
+    score += 5;
+    score += Math.min(task.linkedIssue.labels.length, 4);
+  }
+  const labels = task.linkedIssue?.labels.map((label) => label.toLowerCase()) ?? [];
+  if (labels.includes("good-first-issue")) {
+    score += 2;
+  }
+  if (labels.includes("help-wanted")) {
+    score += 1;
+  }
+  const upvotes = readNumber(metadata, "upvotes") ?? readNumber(metadata, "thumbsUp") ?? 0;
+  const reactions = readNumber(metadata, "reactions") ?? 0;
+  const maintainerComments = readNumber(metadata, "maintainerComments") ?? (readBoolean(metadata, "hasMaintainerComment") ? 1 : 0);
+  score += Math.min(4, Math.floor(upvotes / 2) + Math.floor(reactions / 3));
+  score += Math.min(3, maintainerComments);
+  return clamp(score, 0, 15);
+}
+function scoreTokenEfficiency(task, metadata, impactScore) {
+  const estimatedTokens = readNumber(metadata, "estimatedTokens") ?? readNumber(metadata, "totalEstimatedTokens") ?? readNestedNumber(metadata, "tokenEstimate", "totalEstimatedTokens");
+  let score = TOKEN_EFFICIENCY_BY_COMPLEXITY[task.complexity];
+  if (estimatedTokens !== void 0) {
+    if (estimatedTokens <= 1500) {
+      score = 20;
+    } else if (estimatedTokens <= 5e3) {
+      score = 16;
+    } else if (estimatedTokens <= 12e3) {
+      score = 12;
+    } else if (estimatedTokens <= 25e3) {
+      score = 8;
+    } else {
+      score = 4;
+    }
+  }
+  if (task.targetFiles.length >= 4) {
+    score -= 2;
+  }
+  if (impactScore >= 20) {
+    score += 1;
+  }
+  return clamp(score, 0, 20);
+}
+function getAgeInDays(value) {
+  if (!value) {
+    return void 0;
+  }
+  const time = Date.parse(value);
+  if (Number.isNaN(time)) {
+    return void 0;
+  }
+  const now = Date.now();
+  const diffMs = Math.max(now - time, 0);
+  return Math.floor(diffMs / (24 * 60 * 60 * 1e3));
+}
+function readNestedNumber(metadata, parentKey, childKey) {
+  const parent = toRecord4(metadata[parentKey]);
+  return readNumber(parent, childKey);
+}
+function readNumber(metadata, key) {
+  const value = metadata[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readString(metadata, key) {
+  const value = metadata[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readBoolean(metadata, key) {
+  return metadata[key] === true;
+}
+function toRecord4(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+// src/discovery/analyzer.ts
+import { createReadStream } from "fs";
+import { mkdir, readFile as readFile5, readdir as readdir3, rename, stat as stat2, unlink, writeFile } from "fs/promises";
+import { createInterface } from "readline";
+import { dirname, extname, join, relative as relative3, resolve as resolve5 } from "path";
+import PQueue from "p-queue";
+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 LARGE_FILE_THRESHOLD_BYTES = 1048576;
+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 MAX_CONCURRENCY = 50;
+  const MIN_CONCURRENCY = 4;
+  const analysisQueue = new PQueue({ concurrency: MAX_CONCURRENCY });
+  const memoryMonitor = createMemoryMonitor({
+    intervalMs: 3e3,
+    pressureRatio: 0.85,
+    onPressure: () => {
+      const current = analysisQueue.concurrency;
+      const reduced = Math.max(MIN_CONCURRENCY, Math.floor(current / 2));
+      if (reduced < current) analysisQueue.concurrency = reduced;
+    },
+    onRelief: () => {
+      const current = analysisQueue.concurrency;
+      const restored = Math.min(MAX_CONCURRENCY, current * 2);
+      if (restored > current) analysisQueue.concurrency = restored;
+    }
+  });
+  const fileInfos = await Promise.all(
+    allFiles.map(
+      (absPath) => analysisQueue.add(async () => {
+        const relPath = relative3(resolvedRepoPath, absPath);
+        const info = await analyzeFile(absPath, relPath);
+        return { ...info, _absolutePath: absPath };
+      })
+    )
+  );
+  memoryMonitor.stop();
+  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;
+    }
+    const subdirs = [];
+    for (const entry of entries) {
+      if (entry.isDirectory() && !isExcludedDir(entry.name)) {
+        subdirs.push(walk(join(dir, entry.name)));
+      } else if (entry.isFile() && !isExcludedFile(entry.name)) {
+        results.push(join(dir, entry.name));
+      }
+    }
+    await Promise.all(subdirs);
+  }
+  await walk(dirPath);
+  results.sort();
+  return results;
+}
+async function analyzeFile(absolutePath, relativePath) {
+  const fileStat = await stat2(absolutePath);
+  if (fileStat.size > LARGE_FILE_THRESHOLD_BYTES) {
+    const loc2 = await countLinesStreaming(absolutePath);
+    return { path: relativePath, loc: loc2, sizeBytes: fileStat.size, exports: [], imports: [] };
+  }
+  const content = await readFile5(absolutePath, "utf-8");
+  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
+  };
+}
+async function countLinesStreaming(absolutePath) {
+  return new Promise((resolve6, reject) => {
+    let loc = 0;
+    const rl = createInterface({
+      input: createReadStream(absolutePath, { encoding: "utf-8" }),
+      crlfDelay: Number.POSITIVE_INFINITY
+    });
+    rl.on("line", (line) => {
+      if (line.trim().length > 0) loc += 1;
+    });
+    rl.on("close", () => resolve6(loc));
+    rl.on("error", reject);
+  });
+}
+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,
+  TestGapScanner,
+  GitHubIssuesScanner,
+  CompositeScanner,
+  createDefaultCompositeScanner,
+  buildScanners,
+  rankTasks,
+  analyzeCodebase,
+  persistContext,
+  loadContext,
+  isContextStale,
+  deriveModuleFromPath,
+  groupFindingsIntoEpics,
+  findingToTask,
+  computeEpicPriority,
+  computeEpicComplexity,
+  persistBacklog,
+  loadBacklog,
+  createBacklog,
+  updateBacklog,
+  getPendingEpics
+};
+//# sourceMappingURL=chunk-OTPXGXO7.js.map