opencode-swarm 6.67.1 → 6.68.1

package/dist/cli/index.js

@@ -18314,9 +18314,9 @@ var init_evidence_summary_service = __esm(() => {
 });
 
 // src/cli/index.ts
-import * as fs19 from "fs";
+import * as fs21 from "fs";
 import * as os6 from "os";
-import * as path29 from "path";
+import * as path31 from "path";
 
 // src/commands/acknowledge-spec-drift.ts
 init_utils2();
@@ -18461,6 +18461,7 @@ init_zod();
 // src/tools/tool-names.ts
 var TOOL_NAMES = [
   "diff",
+  "diff_summary",
   "syntax_check",
   "placeholder_scan",
   "imports",
@@ -18483,6 +18484,8 @@ var TOOL_NAMES = [
   "checkpoint",
   "pkg_audit",
   "test_runner",
+  "test_impact",
+  "mutation_test",
   "detect_domains",
   "gitingest",
   "retrieve_summary",
@@ -18507,7 +18510,9 @@ var TOOL_NAMES = [
   "suggest_patch",
   "req_coverage",
   "get_approved_plan",
-  "repo_map"
+  "repo_map",
+  "get_qa_gate_profile",
+  "set_qa_gates"
 ];
 var TOOL_NAME_SET = new Set(TOOL_NAMES);
 
@@ -18546,6 +18551,7 @@ var AGENT_TOOL_MAP = {
     "knowledge_query",
     "lint",
     "diff",
+    "diff_summary",
     "pkg_audit",
     "pre_check_batch",
     "quality_budget",
@@ -18557,6 +18563,8 @@ var AGENT_TOOL_MAP = {
     "secretscan",
     "symbols",
     "test_runner",
+    "test_impact",
+    "mutation_test",
     "todo_extract",
     "update_task_status",
     "lint_spec",
@@ -18577,7 +18585,9 @@ var AGENT_TOOL_MAP = {
     "knowledge_remove",
     "co_change_analyzer",
     "suggest_patch",
-    "repo_map"
+    "repo_map",
+    "get_qa_gate_profile",
+    "set_qa_gates"
   ],
   explorer: [
     "complexity_hotspots",
@@ -18611,6 +18621,8 @@ var AGENT_TOOL_MAP = {
   ],
   test_engineer: [
     "test_runner",
+    "test_impact",
+    "mutation_test",
     "diff",
     "symbols",
     "extract_code_blocks",
@@ -18634,6 +18646,7 @@ var AGENT_TOOL_MAP = {
   ],
   reviewer: [
     "diff",
+    "diff_summary",
     "imports",
     "lint",
     "pkg_audit",
@@ -18644,6 +18657,7 @@ var AGENT_TOOL_MAP = {
     "retrieve_summary",
     "extract_code_blocks",
     "test_runner",
+    "test_impact",
     "sast_scan",
     "placeholder_scan",
     "knowledge_recall",
@@ -19818,6 +19832,24 @@ async function handleBenchmarkCommand(directory, args) {
 `);
 }
 
+// src/commands/brainstorm.ts
+function sanitizeTopic(raw) {
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  const stripped = collapsed.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
+  const normalized = stripped.replace(/\s+/g, " ").trim();
+  const MAX_TOPIC_LEN = 2000;
+  if (normalized.length <= MAX_TOPIC_LEN)
+    return normalized;
+  return `${normalized.slice(0, MAX_TOPIC_LEN)}\u2026`;
+}
+async function handleBrainstormCommand(_directory, args) {
+  const description = sanitizeTopic(args.join(" "));
+  if (description) {
+    return `[MODE: BRAINSTORM] ${description}`;
+  }
+  return "[MODE: BRAINSTORM] Please enter MODE: BRAINSTORM and begin the structured brainstorm workflow (CONTEXT SCAN \u2192 DIALOGUE \u2192 APPROACHES \u2192 DESIGN SECTIONS \u2192 SPEC WRITE + SELF-REVIEW \u2192 QA GATE SELECTION \u2192 TRANSITION).";
+}
+
 // src/commands/checkpoint.ts
 init_zod();
 
@@ -38449,8 +38481,8 @@ async function handlePlanCommand(directory, args) {
 // src/services/preflight-service.ts
 init_manager2();
 init_manager();
-import * as fs14 from "fs";
-import * as path24 from "path";
+import * as fs16 from "fs";
+import * as path26 from "path";
 
 // src/tools/lint.ts
 import * as fs10 from "fs";
@@ -39585,12 +39617,577 @@ async function runSecretscan(directory) {
 }
 
 // src/tools/test-runner.ts
-import * as fs13 from "fs";
-import * as path23 from "path";
+import * as fs15 from "fs";
+import * as path25 from "path";
+
+// src/test-impact/analyzer.ts
+import fs12 from "fs";
+import path22 from "path";
+var IMPORT_REGEX_ES = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+var IMPORT_REGEX_REQUIRE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var IMPORT_REGEX_REEXPORT = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
+var EXTENSIONS_TO_TRY = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+function isCacheStale(impactMap, generatedAtMs) {
+  for (const sourcePath of Object.keys(impactMap)) {
+    try {
+      const stat2 = fs12.statSync(sourcePath);
+      if (stat2.mtimeMs > generatedAtMs) {
+        return true;
+      }
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveRelativeImport(fromDir, importPath) {
+  if (!importPath.startsWith(".")) {
+    return null;
+  }
+  const resolved = path22.resolve(fromDir, importPath);
+  if (path22.extname(resolved)) {
+    if (fs12.existsSync(resolved) && fs12.statSync(resolved).isFile()) {
+      return normalizePath(resolved);
+    }
+  } else {
+    for (const ext of EXTENSIONS_TO_TRY) {
+      const withExt = resolved + ext;
+      if (fs12.existsSync(withExt) && fs12.statSync(withExt).isFile()) {
+        return normalizePath(withExt);
+      }
+    }
+  }
+  return null;
+}
+function findTestFilesSync(cwd) {
+  const testFiles = [];
+  const skipDirs = new Set([
+    "node_modules",
+    "dist",
+    ".git",
+    ".swarm",
+    ".cache"
+  ]);
+  function walk(dir, visitedInodes) {
+    let entries;
+    try {
+      entries = fs12.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    let dirInode;
+    try {
+      dirInode = fs12.statSync(dir).ino;
+    } catch {
+      return;
+    }
+    if (dirInode !== 0) {
+      if (visitedInodes.has(dirInode)) {
+        return;
+      }
+      visitedInodes.add(dirInode);
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!skipDirs.has(entry.name)) {
+          walk(path22.join(dir, entry.name), visitedInodes);
+        }
+      } else if (entry.isFile()) {
+        const name = entry.name;
+        if (/\.(test|spec)\.(ts|tsx|js|jsx)$/.test(name) || dir.includes("__tests__") && /\.(ts|tsx|js|jsx)$/.test(name)) {
+          testFiles.push(normalizePath(path22.join(dir, entry.name)));
+        }
+      }
+    }
+  }
+  walk(cwd, new Set);
+  return [...new Set(testFiles)];
+}
+function extractImports(content) {
+  function execRegex(regex, content2) {
+    const results = [];
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(content2)) !== null) {
+      results.push(match[1]);
+    }
+    return results;
+  }
+  return [
+    ...execRegex(IMPORT_REGEX_ES, content),
+    ...execRegex(IMPORT_REGEX_REQUIRE, content),
+    ...execRegex(IMPORT_REGEX_REEXPORT, content)
+  ];
+}
+async function buildImpactMapInternal(cwd) {
+  const testFiles = findTestFilesSync(cwd);
+  const impactMap = {};
+  for (const testFile of testFiles) {
+    let content;
+    try {
+      content = fs12.readFileSync(testFile, "utf-8");
+    } catch {
+      continue;
+    }
+    if (content.substring(0, 8192).includes("\x00")) {
+      continue;
+    }
+    const imports = extractImports(content);
+    const testDir = path22.dirname(testFile);
+    for (const importPath of imports) {
+      const resolvedSource = resolveRelativeImport(testDir, importPath);
+      if (resolvedSource === null) {
+        continue;
+      }
+      if (!impactMap[resolvedSource]) {
+        impactMap[resolvedSource] = [];
+      }
+      if (!impactMap[resolvedSource].includes(testFile)) {
+        impactMap[resolvedSource].push(testFile);
+      }
+    }
+  }
+  return impactMap;
+}
+async function buildImpactMap(cwd) {
+  const impactMap = await buildImpactMapInternal(cwd);
+  await saveImpactMap(cwd, impactMap);
+  return impactMap;
+}
+async function loadImpactMap(cwd) {
+  const cachePath = path22.join(cwd, ".swarm", "cache", "impact-map.json");
+  if (fs12.existsSync(cachePath)) {
+    try {
+      const content = fs12.readFileSync(cachePath, "utf-8");
+      const data = JSON.parse(content);
+      const map3 = data.map;
+      const generatedAt = new Date(data.generatedAt).getTime();
+      if (!isCacheStale(map3, generatedAt)) {
+        return map3;
+      }
+    } catch {}
+  }
+  return buildImpactMap(cwd);
+}
+async function saveImpactMap(cwd, impactMap) {
+  const cacheDir = path22.join(cwd, ".swarm", "cache");
+  const cachePath = path22.join(cacheDir, "impact-map.json");
+  if (!fs12.existsSync(cacheDir)) {
+    fs12.mkdirSync(cacheDir, { recursive: true });
+  }
+  const data = {
+    generatedAt: new Date().toISOString(),
+    fileCount: Object.keys(impactMap).length,
+    map: impactMap
+  };
+  fs12.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+}
+async function analyzeImpact(changedFiles, cwd) {
+  if (!Array.isArray(changedFiles)) {
+    const emptyMap = {};
+    return {
+      impactedTests: [],
+      unrelatedTests: [],
+      untestedFiles: [],
+      impactMap: emptyMap
+    };
+  }
+  const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
+  const impactMap = await loadImpactMap(cwd);
+  const impactedTestsSet = new Set;
+  const untestedFiles = [];
+  for (const changedFile of validFiles) {
+    const normalizedChanged = normalizePath(path22.resolve(changedFile));
+    const tests = impactMap[normalizedChanged];
+    if (tests && tests.length > 0) {
+      for (const test of tests) {
+        impactedTestsSet.add(test);
+      }
+    } else {
+      let found = false;
+      for (const [sourcePath, tests2] of Object.entries(impactMap)) {
+        if (sourcePath.endsWith(changedFile) || changedFile.endsWith(sourcePath)) {
+          for (const test of tests2) {
+            impactedTestsSet.add(test);
+          }
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        untestedFiles.push(changedFile);
+      }
+    }
+  }
+  const impactedTests = [...impactedTestsSet];
+  const allTestFiles = new Set;
+  for (const tests of Object.values(impactMap)) {
+    for (const test of tests) {
+      allTestFiles.add(test);
+    }
+  }
+  const unrelatedTests = [...allTestFiles].filter((t) => !impactedTestsSet.has(t));
+  return {
+    impactedTests,
+    unrelatedTests,
+    untestedFiles,
+    impactMap
+  };
+}
+
+// src/test-impact/failure-classifier.ts
+function computeConfidence2(historyLength) {
+  if (historyLength >= 5) {
+    return 1;
+  }
+  if (historyLength >= 3) {
+    return 0.5;
+  }
+  if (historyLength >= 1) {
+    return 0.3;
+  }
+  return 0.1;
+}
+function countAlternations(results) {
+  if (results.length < 2) {
+    return 0;
+  }
+  let alternations = 0;
+  for (let i = 1;i < results.length; i++) {
+    if (results[i] !== results[i - 1]) {
+      alternations++;
+    }
+  }
+  return alternations;
+}
+function stringHash(str) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0;i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+  h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+  h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16);
+}
+function classifyFailure(currentResult, history) {
+  const normalizedFile = currentResult.testFile.toLowerCase();
+  const normalizedName = currentResult.testName.toLowerCase();
+  const testHistory = history.filter((r) => r.testFile.toLowerCase() === normalizedFile && r.testName.toLowerCase() === normalizedName).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  const lastThree = testHistory.slice(0, 3);
+  const lastTen = testHistory.slice(0, 10);
+  const normalizedTestFile = currentResult.testFile.toLowerCase();
+  const isInChangedFiles = currentResult.changedFiles.some((f) => f.toLowerCase() === normalizedTestFile);
+  const hasRecentPass = lastThree.every((r) => r.result === "pass");
+  const hasRecentFailure = lastThree.some((r) => r.result === "fail");
+  const alternationCount = countAlternations(lastTen.map((r) => r.result));
+  if (lastThree.length >= 3 && hasRecentPass && currentResult.result === "fail" && isInChangedFiles) {
+    return {
+      testFile: currentResult.testFile,
+      testName: currentResult.testName,
+      classification: "new_regression",
+      errorMessage: currentResult.errorMessage,
+      stackPrefix: currentResult.stackPrefix,
+      durationMs: currentResult.durationMs,
+      confidence: computeConfidence2(testHistory.length)
+    };
+  }
+  if (lastThree.length > 0 && hasRecentFailure && !isInChangedFiles) {
+    return {
+      testFile: currentResult.testFile,
+      testName: currentResult.testName,
+      classification: "pre_existing",
+      errorMessage: currentResult.errorMessage,
+      stackPrefix: currentResult.stackPrefix,
+      durationMs: currentResult.durationMs,
+      confidence: computeConfidence2(testHistory.length)
+    };
+  }
+  if (alternationCount >= 2) {
+    return {
+      testFile: currentResult.testFile,
+      testName: currentResult.testName,
+      classification: "flaky",
+      errorMessage: currentResult.errorMessage,
+      stackPrefix: currentResult.stackPrefix,
+      durationMs: currentResult.durationMs,
+      confidence: computeConfidence2(testHistory.length)
+    };
+  }
+  return {
+    testFile: currentResult.testFile,
+    testName: currentResult.testName,
+    classification: "unknown",
+    errorMessage: currentResult.errorMessage,
+    stackPrefix: currentResult.stackPrefix,
+    durationMs: currentResult.durationMs,
+    confidence: computeConfidence2(testHistory.length)
+  };
+}
+function clusterFailures(failures) {
+  const clusterMap = new Map;
+  for (const failure of failures) {
+    const key = (failure.stackPrefix || "") + (failure.errorMessage || "");
+    if (!clusterMap.has(key)) {
+      clusterMap.set(key, {
+        failures: [],
+        stackPrefix: failure.stackPrefix,
+        errorMessage: failure.errorMessage
+      });
+    }
+    clusterMap.get(key).failures.push(failure);
+  }
+  const clusters = [];
+  for (const [key, data] of clusterMap) {
+    const classificationCounts = new Map;
+    for (const f of data.failures) {
+      const count = classificationCounts.get(f.classification) || 0;
+      classificationCounts.set(f.classification, count + 1);
+    }
+    let dominantClassification = "unknown";
+    let maxCount = 0;
+    for (const [cls, count] of classificationCounts) {
+      if (count > maxCount) {
+        maxCount = count;
+        dominantClassification = cls;
+      }
+    }
+    const affectedTestFiles = [
+      ...new Set(data.failures.map((f) => f.testFile))
+    ];
+    clusters.push({
+      clusterId: stringHash(key),
+      rootCause: key,
+      stackPrefix: data.stackPrefix,
+      errorMessage: data.errorMessage,
+      failures: data.failures,
+      classification: dominantClassification,
+      affectedTestFiles
+    });
+  }
+  return clusters;
+}
+function classifyAndCluster(testResults, history) {
+  const failingResults = testResults.filter((r) => r.result === "fail");
+  const classified = failingResults.map((r) => classifyFailure(r, history));
+  const clusters = clusterFailures(classified);
+  return { classified, clusters };
+}
+
+// src/test-impact/flaky-detector.ts
+var FLAKY_THRESHOLD = 0.3;
+var MIN_RUNS_FOR_QUARANTINE = 5;
+var MAX_HISTORY_RUNS = 20;
+function detectFlakyTests(allHistory) {
+  const grouped = new Map;
+  for (const record3 of allHistory) {
+    const key = `${record3.testFile.toLowerCase()}|${record3.testName.toLowerCase()}`;
+    if (!grouped.has(key)) {
+      grouped.set(key, {
+        records: [],
+        originalFile: record3.testFile,
+        originalName: record3.testName
+      });
+    }
+    grouped.get(key).records.push(record3);
+  }
+  const results = [];
+  for (const [_key, entry] of grouped) {
+    const records = entry.records;
+    if (records.length === 0) {
+      continue;
+    }
+    const sorted = records.slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const recent = sorted.slice(-MAX_HISTORY_RUNS);
+    const totalRuns = recent.length;
+    if (totalRuns < 2) {
+      continue;
+    }
+    let alternationCount = 0;
+    for (let i = 1;i < recent.length; i++) {
+      if (recent[i].result !== recent[i - 1].result) {
+        alternationCount++;
+      }
+    }
+    const flakyScore = totalRuns >= 2 ? alternationCount / totalRuns : 0;
+    const isQuarantined = flakyScore > FLAKY_THRESHOLD && totalRuns >= MIN_RUNS_FOR_QUARANTINE;
+    const recentResults = recent.map((r) => r.result);
+    const testFile = entry.originalFile;
+    const testName = entry.originalName;
+    let recommendation;
+    if (isQuarantined) {
+      if (alternationCount === totalRuns - 1) {
+        recommendation = "Highly unstable \u2014 investigate test isolation issues, mock cleanup, or shared state";
+      } else if (flakyScore > 0.5) {
+        recommendation = "Severely flaky \u2014 consider quarantining and rewriting test with proper isolation";
+      } else if (flakyScore > FLAKY_THRESHOLD) {
+        recommendation = "Moderately flaky \u2014 review for timing dependencies, async issues, or environmental factors";
+      }
+    }
+    results.push({
+      testFile,
+      testName,
+      flakyScore,
+      totalRuns,
+      alternationCount,
+      isQuarantined,
+      recentResults,
+      recommendation
+    });
+  }
+  return results;
+}
+
+// src/test-impact/history-store.ts
+import fs13 from "fs";
+import path23 from "path";
+var MAX_HISTORY_PER_TEST = 20;
+var MAX_ERROR_LENGTH = 500;
+var MAX_STACK_LENGTH = 200;
+var MAX_CHANGED_FILES = 50;
+function getHistoryPath(workingDir) {
+  return path23.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
+}
+function sanitizeErrorMessage(errorMessage) {
+  if (errorMessage === undefined) {
+    return;
+  }
+  if (errorMessage.length > MAX_ERROR_LENGTH) {
+    return errorMessage.substring(0, MAX_ERROR_LENGTH);
+  }
+  return errorMessage;
+}
+function sanitizeStackPrefix(stackPrefix) {
+  if (stackPrefix === undefined) {
+    return;
+  }
+  if (stackPrefix.length > MAX_STACK_LENGTH) {
+    return stackPrefix.substring(0, MAX_STACK_LENGTH);
+  }
+  return stackPrefix;
+}
+var DANGEROUS_PROPERTY_NAMES = new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function sanitizeChangedFiles(changedFiles) {
+  const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !DANGEROUS_PROPERTY_NAMES.has(f));
+  return validFiles.slice(0, MAX_CHANGED_FILES);
+}
+function appendTestRun(record3, workingDir) {
+  if (typeof record3.testFile !== "string" || record3.testFile.length === 0) {
+    throw new TypeError("testFile must be a non-empty string");
+  }
+  if (typeof record3.testName !== "string" || record3.testName.length === 0) {
+    throw new TypeError("testName must be a non-empty string");
+  }
+  if (typeof record3.taskId !== "string" || record3.taskId.length === 0) {
+    throw new TypeError("taskId must be a non-empty string");
+  }
+  if (record3.result !== "pass" && record3.result !== "fail" && record3.result !== "skip") {
+    throw new TypeError('result must be "pass", "fail", or "skip"');
+  }
+  if (typeof record3.durationMs !== "number" || !Number.isFinite(record3.durationMs)) {
+    throw new TypeError("durationMs must be a finite number");
+  }
+  if (record3.timestamp !== undefined && Number.isNaN(Date.parse(record3.timestamp))) {
+    throw new TypeError("timestamp must be a valid ISO 8601 string");
+  }
+  if (record3.changedFiles !== undefined && !Array.isArray(record3.changedFiles)) {
+    throw new TypeError("changedFiles must be an array");
+  }
+  const sanitizedRecord = {
+    ...record3,
+    timestamp: record3.timestamp || new Date().toISOString(),
+    durationMs: Math.max(0, record3.durationMs),
+    errorMessage: sanitizeErrorMessage(record3.errorMessage),
+    stackPrefix: sanitizeStackPrefix(record3.stackPrefix),
+    changedFiles: sanitizeChangedFiles(record3.changedFiles || [])
+  };
+  const historyPath = getHistoryPath(workingDir);
+  const historyDir = path23.dirname(historyPath);
+  if (!fs13.existsSync(historyDir)) {
+    fs13.mkdirSync(historyDir, { recursive: true });
+  }
+  const existingRecords = readAllRecords(historyPath);
+  existingRecords.push(sanitizedRecord);
+  const recordsByFile = new Map;
+  for (const rec of existingRecords) {
+    const normalizedFile = rec.testFile.toLowerCase();
+    if (!recordsByFile.has(normalizedFile)) {
+      recordsByFile.set(normalizedFile, []);
+    }
+    recordsByFile.get(normalizedFile).push(rec);
+  }
+  const prunedRecords = [];
+  for (const [, records] of recordsByFile) {
+    records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const toKeep = records.slice(-MAX_HISTORY_PER_TEST);
+    prunedRecords.push(...toKeep);
+  }
+  prunedRecords.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  try {
+    const lines = prunedRecords.map((rec) => JSON.stringify(rec));
+    const content = lines.join(`
+`) + `
+`;
+    const tempPath = historyPath + ".tmp";
+    fs13.writeFileSync(tempPath, content, "utf-8");
+    fs13.renameSync(tempPath, historyPath);
+  } catch (err) {
+    try {
+      const tempPath = historyPath + ".tmp";
+      if (fs13.existsSync(tempPath)) {
+        fs13.unlinkSync(tempPath);
+      }
+    } catch {}
+    throw new Error(`Failed to write test history: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function readAllRecords(historyPath) {
+  if (!fs13.existsSync(historyPath)) {
+    return [];
+  }
+  try {
+    const content = fs13.readFileSync(historyPath, "utf-8");
+    const lines = content.split(`
+`);
+    const records = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "object" && parsed !== null && "testFile" in parsed && "testName" in parsed && "result" in parsed) {
+          records.push(parsed);
+        }
+      } catch {}
+    }
+    return records;
+  } catch (err) {
+    throw new Error(`Failed to read test history: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function getAllHistory(workingDir) {
+  const historyPath = getHistoryPath(workingDir);
+  const records = readAllRecords(historyPath);
+  records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  return records;
+}
 
 // src/tools/resolve-working-directory.ts
-import * as fs12 from "fs";
-import * as path22 from "path";
+import * as fs14 from "fs";
+import * as path24 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     return { success: true, directory: fallbackDirectory };
@@ -39610,17 +40207,17 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const normalizedDir = path22.normalize(workingDirectory);
-  const pathParts = normalizedDir.split(path22.sep);
+  const normalizedDir = path24.normalize(workingDirectory);
+  const pathParts = normalizedDir.split(path24.sep);
   if (pathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const resolvedDir = path22.resolve(normalizedDir);
+  const resolvedDir = path24.resolve(normalizedDir);
   try {
-    const realPath = fs12.realpathSync(resolvedDir);
+    const realPath = fs14.realpathSync(resolvedDir);
     return { success: true, directory: realPath };
   } catch {
     return {
@@ -39656,7 +40253,7 @@ function validateArgs2(args) {
     return false;
   const obj = args;
   if (obj.scope !== undefined) {
-    if (obj.scope !== "all" && obj.scope !== "convention" && obj.scope !== "graph") {
+    if (obj.scope !== "all" && obj.scope !== "convention" && obj.scope !== "graph" && obj.scope !== "impact") {
       return false;
     }
   }
@@ -39701,19 +40298,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs13.existsSync(path23.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs15.existsSync(path25.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs13.existsSync(path23.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs15.existsSync(path25.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs13.existsSync(path23.join(cwd, "build.gradle")) || fs13.existsSync(path23.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs13.existsSync(path23.join(cwd, "gradlew")) || fs13.existsSync(path23.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs15.existsSync(path25.join(cwd, "build.gradle")) || fs15.existsSync(path25.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs15.existsSync(path25.join(cwd, "gradlew")) || fs15.existsSync(path25.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs13.readdirSync(cwd);
+    const files = fs15.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -39721,32 +40318,32 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs13.existsSync(path23.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs13.existsSync(path23.join(cwd, "CMakeCache.txt")) || fs13.existsSync(path23.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs15.existsSync(path25.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs15.existsSync(path25.join(cwd, "CMakeCache.txt")) || fs15.existsSync(path25.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs13.existsSync(path23.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs15.existsSync(path25.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs13.existsSync(path23.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs15.existsSync(path25.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs13.existsSync(path23.join(cwd, ".rspec"));
-  const hasGemfile = fs13.existsSync(path23.join(cwd, "Gemfile"));
-  const hasSpecDir = fs13.existsSync(path23.join(cwd, "spec"));
+  const hasRSpecFile = fs15.existsSync(path25.join(cwd, ".rspec"));
+  const hasGemfile = fs15.existsSync(path25.join(cwd, "Gemfile"));
+  const hasSpecDir = fs15.existsSync(path25.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs13.existsSync(path23.join(cwd, "test")) && (fs13.existsSync(path23.join(cwd, "Gemfile")) || fs13.existsSync(path23.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs15.existsSync(path25.join(cwd, "test")) && (fs15.existsSync(path25.join(cwd, "Gemfile")) || fs15.existsSync(path25.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path23.join(baseDir, "package.json");
-    if (fs13.existsSync(packageJsonPath)) {
-      const content = fs13.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonPath = path25.join(baseDir, "package.json");
+    if (fs15.existsSync(packageJsonPath)) {
+      const content = fs15.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -39765,38 +40362,38 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs13.existsSync(path23.join(baseDir, "bun.lockb")) || fs13.existsSync(path23.join(baseDir, "bun.lock"))) {
+      if (fs15.existsSync(path25.join(baseDir, "bun.lockb")) || fs15.existsSync(path25.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path23.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path23.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path23.join(baseDir, "requirements.txt");
-    if (fs13.existsSync(pyprojectTomlPath)) {
-      const content = fs13.readFileSync(pyprojectTomlPath, "utf-8");
+    const pyprojectTomlPath = path25.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path25.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path25.join(baseDir, "requirements.txt");
+    if (fs15.existsSync(pyprojectTomlPath)) {
+      const content = fs15.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs13.existsSync(setupCfgPath)) {
-      const content = fs13.readFileSync(setupCfgPath, "utf-8");
+    if (fs15.existsSync(setupCfgPath)) {
+      const content = fs15.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs13.existsSync(requirementsTxtPath)) {
-      const content = fs13.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs15.existsSync(requirementsTxtPath)) {
+      const content = fs15.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
-    const cargoTomlPath = path23.join(baseDir, "Cargo.toml");
-    if (fs13.existsSync(cargoTomlPath)) {
-      const content = fs13.readFileSync(cargoTomlPath, "utf-8");
+    const cargoTomlPath = path25.join(baseDir, "Cargo.toml");
+    if (fs15.existsSync(cargoTomlPath)) {
+      const content = fs15.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -39805,10 +40402,10 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path23.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path23.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path23.join(baseDir, "tests.ps1");
-    if (fs13.existsSync(pesterConfigPath) || fs13.existsSync(pesterConfigJsonPath) || fs13.existsSync(pesterPs1Path)) {
+    const pesterConfigPath = path25.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path25.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path25.join(baseDir, "tests.ps1");
+    if (fs15.existsSync(pesterConfigPath) || fs15.existsSync(pesterConfigJsonPath) || fs15.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -39859,8 +40456,8 @@ function getTestFilesFromConvention(sourceFiles) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const normalizedPath = file3.replace(/\\/g, "/");
-    const basename4 = path23.basename(file3);
-    const dirname10 = path23.dirname(file3);
+    const basename4 = path25.basename(file3);
+    const dirname10 = path25.dirname(file3);
     if (hasCompoundTestExtension(basename4) || basename4.includes(".spec.") || basename4.includes(".test.") || normalizedPath.includes("/__tests__/") || normalizedPath.includes("/tests/") || normalizedPath.includes("/test/")) {
       if (!testFiles.includes(file3)) {
         testFiles.push(file3);
@@ -39869,16 +40466,16 @@ function getTestFilesFromConvention(sourceFiles) {
     }
     for (const _pattern of TEST_PATTERNS) {
       const nameWithoutExt = basename4.replace(/\.[^.]+$/, "");
-      const ext = path23.extname(basename4);
+      const ext = path25.extname(basename4);
       const possibleTestFiles = [
-        path23.join(dirname10, `${nameWithoutExt}.spec${ext}`),
-        path23.join(dirname10, `${nameWithoutExt}.test${ext}`),
-        path23.join(dirname10, "__tests__", `${nameWithoutExt}${ext}`),
-        path23.join(dirname10, "tests", `${nameWithoutExt}${ext}`),
-        path23.join(dirname10, "test", `${nameWithoutExt}${ext}`)
+        path25.join(dirname10, `${nameWithoutExt}.spec${ext}`),
+        path25.join(dirname10, `${nameWithoutExt}.test${ext}`),
+        path25.join(dirname10, "__tests__", `${nameWithoutExt}${ext}`),
+        path25.join(dirname10, "tests", `${nameWithoutExt}${ext}`),
+        path25.join(dirname10, "test", `${nameWithoutExt}${ext}`)
       ];
       for (const testFile of possibleTestFiles) {
-        if (fs13.existsSync(testFile) && !testFiles.includes(testFile)) {
+        if (fs15.existsSync(testFile) && !testFiles.includes(testFile)) {
           testFiles.push(testFile);
         }
       }
@@ -39894,8 +40491,8 @@ async function getTestFilesFromGraph(sourceFiles) {
   }
   for (const testFile of candidateTestFiles) {
     try {
-      const content = fs13.readFileSync(testFile, "utf-8");
-      const testDir = path23.dirname(testFile);
+      const content = fs15.readFileSync(testFile, "utf-8");
+      const testDir = path25.dirname(testFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -39903,8 +40500,8 @@ async function getTestFilesFromGraph(sourceFiles) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path23.resolve(testDir, importPath);
-          const existingExt = path23.extname(resolvedImport);
+          resolvedImport = path25.resolve(testDir, importPath);
+          const existingExt = path25.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -39915,7 +40512,7 @@ async function getTestFilesFromGraph(sourceFiles) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (sourceFiles.includes(withExt) || fs13.existsSync(withExt)) {
+              if (sourceFiles.includes(withExt) || fs15.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -39924,12 +40521,12 @@ async function getTestFilesFromGraph(sourceFiles) {
         } else {
           continue;
         }
-        const importBasename = path23.basename(resolvedImport, path23.extname(resolvedImport));
-        const importDir = path23.dirname(resolvedImport);
+        const importBasename = path25.basename(resolvedImport, path25.extname(resolvedImport));
+        const importDir = path25.dirname(resolvedImport);
         for (const sourceFile of sourceFiles) {
-          const sourceDir = path23.dirname(sourceFile);
-          const sourceBasename = path23.basename(sourceFile, path23.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path23.join(sourceDir, "__tests__") || importDir === path23.join(sourceDir, "tests") || importDir === path23.join(sourceDir, "test");
+          const sourceDir = path25.dirname(sourceFile);
+          const sourceBasename = path25.basename(sourceFile, path25.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path25.join(sourceDir, "__tests__") || importDir === path25.join(sourceDir, "tests") || importDir === path25.join(sourceDir, "test");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             if (!testFiles.includes(testFile)) {
               testFiles.push(testFile);
@@ -39944,8 +40541,8 @@ async function getTestFilesFromGraph(sourceFiles) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path23.resolve(testDir, importPath);
-          const existingExt = path23.extname(resolvedImport);
+          let resolvedImport = path25.resolve(testDir, importPath);
+          const existingExt = path25.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -39956,18 +40553,18 @@ async function getTestFilesFromGraph(sourceFiles) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (sourceFiles.includes(withExt) || fs13.existsSync(withExt)) {
+              if (sourceFiles.includes(withExt) || fs15.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
             }
           }
-          const importDir = path23.dirname(resolvedImport);
-          const importBasename = path23.basename(resolvedImport, path23.extname(resolvedImport));
+          const importDir = path25.dirname(resolvedImport);
+          const importBasename = path25.basename(resolvedImport, path25.extname(resolvedImport));
           for (const sourceFile of sourceFiles) {
-            const sourceDir = path23.dirname(sourceFile);
-            const sourceBasename = path23.basename(sourceFile, path23.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path23.join(sourceDir, "__tests__") || importDir === path23.join(sourceDir, "tests") || importDir === path23.join(sourceDir, "test");
+            const sourceDir = path25.dirname(sourceFile);
+            const sourceBasename = path25.basename(sourceFile, path25.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path25.join(sourceDir, "__tests__") || importDir === path25.join(sourceDir, "tests") || importDir === path25.join(sourceDir, "test");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               if (!testFiles.includes(testFile)) {
                 testFiles.push(testFile);
@@ -40052,8 +40649,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs13.existsSync(path23.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs13.existsSync(path23.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs15.existsSync(path25.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs15.existsSync(path25.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -40070,7 +40667,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs13.existsSync(path23.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs15.existsSync(path25.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -40496,10 +41093,57 @@ var SKIP_DIRECTORIES = new Set([
   ".bundle",
   ".tox"
 ]);
+function recordAndAnalyzeResults(result, testFiles, workingDir, sourceFiles) {
+  if (!result.totals || result.totals.total === 0)
+    return;
+  const now = new Date().toISOString();
+  const changedFiles = (sourceFiles && sourceFiles.length > 0 ? sourceFiles : testFiles).map((f) => f.replace(/\\/g, "/"));
+  for (const testFile of testFiles) {
+    try {
+      appendTestRun({
+        timestamp: now,
+        taskId: "auto",
+        testFile: testFile.replace(/\\/g, "/"),
+        testName: "(aggregate)",
+        result: result.success ? "pass" : "fail",
+        durationMs: result.duration_ms || 0,
+        changedFiles
+      }, workingDir);
+    } catch {}
+  }
+}
+function analyzeFailures(workingDir) {
+  const report = {
+    flakyTests: [],
+    failureClusters: [],
+    quarantinedFailures: []
+  };
+  try {
+    const history = getAllHistory(workingDir);
+    if (history.length === 0)
+      return report;
+    report.flakyTests = detectFlakyTests(history);
+    const failingResults = history.filter((r) => r.result === "fail");
+    if (failingResults.length > 0) {
+      const { clusters } = classifyAndCluster(failingResults, history);
+      report.failureClusters = clusters.map((c) => ({
+        rootCause: c.rootCause,
+        affectedFiles: c.affectedTestFiles,
+        classification: c.classification
+      }));
+    }
+    for (const entry of report.flakyTests) {
+      if (entry.isQuarantined) {
+        report.quarantinedFailures.push(`${entry.testFile}: ${entry.testName}`);
+      }
+    }
+  } catch {}
+  return report;
+}
 var test_runner = createSwarmTool({
-  description: 'Run project tests with framework detection. Supports bun, vitest, jest, mocha, pytest, cargo, pester, go-test, maven, gradle, dotnet-test, ctest, swift-test, dart-test, rspec, and minitest. Returns deterministic normalized JSON with framework, scope, command, totals, coverage, duration, success status, and failures. Use scope "all" for full suite, "convention" to map source files to test files, or "graph" to find related tests via imports.',
+  description: 'Run project tests with framework detection. Supports bun, vitest, jest, mocha, pytest, cargo, pester, go-test, maven, gradle, dotnet-test, ctest, swift-test, dart-test, rspec, and minitest. Returns deterministic normalized JSON with framework, scope, command, totals, coverage, duration, success status, and failures. Use scope "all" for full suite, "convention" to map source files to test files, "graph" to find related tests via imports, or "impact" to find tests covering changed files using test-impact analysis.',
   args: {
-    scope: tool.schema.enum(["all", "convention", "graph"]).optional().describe('Test scope: "all" runs full suite, "convention" maps source files to test files by naming, "graph" finds related tests via imports'),
+    scope: tool.schema.enum(["all", "convention", "graph", "impact"]).optional().describe('Test scope: "all" runs full suite, "convention" maps source files to test files by naming, "graph" finds related tests via imports, "impact" finds tests covering changed files via test-impact analysis'),
     files: tool.schema.array(tool.schema.string()).optional().describe("Specific files to test (used with convention or graph scope)"),
     coverage: tool.schema.boolean().optional().describe("Enable coverage reporting if supported"),
     timeout_ms: tool.schema.number().optional().describe("Timeout in milliseconds (default 60000, max 300000)"),
@@ -40570,7 +41214,7 @@ var test_runner = createSwarmTool({
         framework: "none",
         scope: "all",
         error: "Invalid arguments",
-        message: 'scope must be "all", "convention", or "graph"; files must be array of strings; coverage must be boolean; timeout_ms must be a positive number',
+        message: 'scope must be "all", "convention", "graph", or "impact"; files must be array of strings; coverage must be boolean; timeout_ms must be a positive number',
         outcome: "error"
       };
       return JSON.stringify(errorResult, null, 2);
@@ -40589,7 +41233,7 @@ var test_runner = createSwarmTool({
         return JSON.stringify(errorResult, null, 2);
       }
     }
-    if ((scope === "convention" || scope === "graph") && (!args.files || args.files.length === 0)) {
+    if ((scope === "convention" || scope === "graph" || scope === "impact") && (!args.files || args.files.length === 0)) {
       const errorResult = {
         success: false,
         framework: "none",
@@ -40626,7 +41270,7 @@ var test_runner = createSwarmTool({
     let effectiveScope = scope;
     if (scope === "all") {} else if (scope === "convention") {
       const sourceFiles = args.files.filter((f) => {
-        const ext = path23.extname(f).toLowerCase();
+        const ext = path25.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -40643,7 +41287,7 @@ var test_runner = createSwarmTool({
       testFiles = getTestFilesFromConvention(sourceFiles);
     } else if (scope === "graph") {
       const sourceFiles = args.files.filter((f) => {
-        const ext = path23.extname(f).toLowerCase();
+        const ext = path25.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -40665,6 +41309,53 @@ var test_runner = createSwarmTool({
         effectiveScope = "convention";
         testFiles = getTestFilesFromConvention(sourceFiles);
       }
+    } else if (scope === "impact") {
+      const sourceFiles = args.files.filter((f) => {
+        const ext = path25.extname(f).toLowerCase();
+        return SOURCE_EXTENSIONS.has(ext);
+      });
+      if (sourceFiles.length === 0) {
+        const errorResult = {
+          success: false,
+          framework,
+          scope,
+          error: "Provided files contain no source files with recognized extensions",
+          message: "The files array must contain at least one source file with a recognized extension (.ts, .tsx, .js, .jsx, .py, .rs, .ps1, etc.).",
+          outcome: "error"
+        };
+        return JSON.stringify(errorResult, null, 2);
+      }
+      try {
+        const impactResult = await analyzeImpact(sourceFiles, workingDir);
+        if (impactResult.impactedTests.length > 0) {
+          testFiles = impactResult.impactedTests.map((absPath) => {
+            const relativePath = path25.relative(workingDir, absPath);
+            return path25.isAbsolute(relativePath) ? absPath : relativePath;
+          });
+        } else {
+          graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
+          effectiveScope = "graph";
+          const graphTestFiles = await getTestFilesFromGraph(sourceFiles);
+          if (graphTestFiles.length > 0) {
+            testFiles = graphTestFiles;
+          } else {
+            graphFallbackReason = "imports resolution returned no results, falling back to convention";
+            effectiveScope = "convention";
+            testFiles = getTestFilesFromConvention(sourceFiles);
+          }
+        }
+      } catch {
+        graphFallbackReason = "impact analysis failed, falling back to graph";
+        effectiveScope = "graph";
+        const graphTestFiles = await getTestFilesFromGraph(sourceFiles);
+        if (graphTestFiles.length > 0) {
+          testFiles = graphTestFiles;
+        } else {
+          graphFallbackReason = "imports resolution returned no results, falling back to convention";
+          effectiveScope = "convention";
+          testFiles = getTestFilesFromConvention(sourceFiles);
+        }
+      }
     }
     if (scope !== "all" && testFiles.length === 0) {
       const baseMessage = "No matching test files found for the provided source files. Check that test files exist with matching naming conventions (.spec.*, .test.*, __tests__/, tests/, test/).";
@@ -40675,7 +41366,8 @@ var test_runner = createSwarmTool({
         error: "Provided source files resolved to zero test files",
         message: graphFallbackReason ? `${baseMessage} (${graphFallbackReason})` : baseMessage,
         outcome: "skip",
-        ...scope === "graph" && { attempted_scope: "graph" }
+        ...scope === "graph" && { attempted_scope: "graph" },
+        ...scope === "impact" && { attempted_scope: "graph" }
       };
       return JSON.stringify(errorResult, null, 2);
     }
@@ -40692,6 +41384,18 @@ var test_runner = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const result = await runTests(framework, effectiveScope, testFiles, coverage, timeout_ms, workingDir);
+    recordAndAnalyzeResults(result, testFiles, workingDir, _files.length > 0 ? _files : undefined);
+    let historyReport;
+    if (!result.success && result.totals && result.totals.failed > 0) {
+      historyReport = analyzeFailures(workingDir);
+      if (historyReport.quarantinedFailures.length > 0) {
+        result.message = (result.message || "") + ` | QUARANTINED (flaky): ${historyReport.quarantinedFailures.join(", ")}`;
+      }
+      if (historyReport.failureClusters.length > 0) {
+        const clusterSummary = historyReport.failureClusters.slice(0, 3).map((c) => `${c.classification}: ${c.rootCause.substring(0, 80)}`).join("; ");
+        result.message = `${result.message || ""} | FAILURE ANALYSIS: ${clusterSummary}`;
+      }
+    }
     if (graphFallbackReason && result.message) {
       result.message = `${result.message} (${graphFallbackReason})`;
     }
@@ -40719,8 +41423,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path24.normalize(dir);
-  const absolutePath = path24.isAbsolute(normalized) ? normalized : path24.resolve(normalized);
+  const normalized = path26.normalize(dir);
+  const absolutePath = path26.isAbsolute(normalized) ? normalized : path26.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -40743,9 +41447,9 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path24.join(dir, "package.json");
-    if (fs14.existsSync(packagePath)) {
-      const content = fs14.readFileSync(packagePath, "utf-8");
+    const packagePath = path26.join(dir, "package.json");
+    if (fs16.existsSync(packagePath)) {
+      const content = fs16.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -40754,9 +41458,9 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path24.join(dir, "CHANGELOG.md");
-    if (fs14.existsSync(changelogPath)) {
-      const content = fs14.readFileSync(changelogPath, "utf-8");
+    const changelogPath = path26.join(dir, "CHANGELOG.md");
+    if (fs16.existsSync(changelogPath)) {
+      const content = fs16.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -40768,10 +41472,10 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path24.join(dir, file3);
-    if (fs14.existsSync(filePath)) {
+    const filePath = path26.join(dir, file3);
+    if (fs16.existsSync(filePath)) {
       try {
-        const content = fs14.readFileSync(filePath, "utf-8").trim();
+        const content = fs16.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -41095,8 +41799,8 @@ async function runEvidenceCheck(dir) {
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
-    const specPath = path24.join(dir, ".swarm", "spec.md");
-    if (!fs14.existsSync(specPath)) {
+    const specPath = path26.join(dir, ".swarm", "spec.md");
+    if (!fs16.existsSync(specPath)) {
       return {
         type: "req_coverage",
         status: "skip",
@@ -41309,9 +42013,9 @@ async function handlePreflightCommand(directory, _args) {
   return formatPreflightMarkdown(report);
 }
 // src/knowledge/hive-promoter.ts
-import * as fs15 from "fs";
+import * as fs17 from "fs";
 import * as os5 from "os";
-import * as path25 from "path";
+import * as path27 from "path";
 var DANGEROUS_PATTERNS = [
   [/rm\s+-rf/, "rm\\s+-rf"],
   [/:\s*!\s*\|/, ":\\s*!\\s*\\|"],
@@ -41357,13 +42061,13 @@ function getHiveFilePath() {
   const home = os5.homedir();
   let dataDir;
   if (platform === "win32") {
-    dataDir = path25.join(process.env.LOCALAPPDATA || path25.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+    dataDir = path27.join(process.env.LOCALAPPDATA || path27.join(home, "AppData", "Local"), "opencode-swarm", "Data");
   } else if (platform === "darwin") {
-    dataDir = path25.join(home, "Library", "Application Support", "opencode-swarm");
+    dataDir = path27.join(home, "Library", "Application Support", "opencode-swarm");
   } else {
-    dataDir = path25.join(process.env.XDG_DATA_HOME || path25.join(home, ".local", "share"), "opencode-swarm");
+    dataDir = path27.join(process.env.XDG_DATA_HOME || path27.join(home, ".local", "share"), "opencode-swarm");
   }
-  return path25.join(dataDir, "hive-knowledge.jsonl");
+  return path27.join(dataDir, "hive-knowledge.jsonl");
 }
 async function promoteToHive(_directory, lesson, category) {
   const trimmed = (lesson ?? "").trim();
@@ -41375,9 +42079,9 @@ async function promoteToHive(_directory, lesson, category) {
     throw new Error(`Lesson rejected by validator: ${validation.reason}`);
   }
   const hivePath = getHiveFilePath();
-  const hiveDir = path25.dirname(hivePath);
-  if (!fs15.existsSync(hiveDir)) {
-    fs15.mkdirSync(hiveDir, { recursive: true });
+  const hiveDir = path27.dirname(hivePath);
+  if (!fs17.existsSync(hiveDir)) {
+    fs17.mkdirSync(hiveDir, { recursive: true });
   }
   const now = new Date;
   const entry = {
@@ -41391,16 +42095,16 @@ async function promoteToHive(_directory, lesson, category) {
     promotedAt: now.toISOString(),
     retrievalOutcomes: { applied: 0, succeededAfter: 0, failedAfter: 0 }
   };
-  fs15.appendFileSync(hivePath, `${JSON.stringify(entry)}
+  fs17.appendFileSync(hivePath, `${JSON.stringify(entry)}
 `, "utf-8");
   const preview = `${trimmed.slice(0, 50)}${trimmed.length > 50 ? "..." : ""}`;
   return `Promoted to hive: "${preview}" (confidence: 1.0, source: manual)`;
 }
 async function promoteFromSwarm(directory, lessonId) {
-  const knowledgePath = path25.join(directory, ".swarm", "knowledge.jsonl");
+  const knowledgePath = path27.join(directory, ".swarm", "knowledge.jsonl");
   const entries = [];
-  if (fs15.existsSync(knowledgePath)) {
-    const content = fs15.readFileSync(knowledgePath, "utf-8");
+  if (fs17.existsSync(knowledgePath)) {
+    const content = fs17.readFileSync(knowledgePath, "utf-8");
     for (const line of content.split(`
 `)) {
       const t = line.trim();
@@ -41424,9 +42128,9 @@ async function promoteFromSwarm(directory, lessonId) {
     throw new Error(`Lesson rejected by validator: ${validation.reason}`);
   }
   const hivePath = getHiveFilePath();
-  const hiveDir = path25.dirname(hivePath);
-  if (!fs15.existsSync(hiveDir)) {
-    fs15.mkdirSync(hiveDir, { recursive: true });
+  const hiveDir = path27.dirname(hivePath);
+  if (!fs17.existsSync(hiveDir)) {
+    fs17.mkdirSync(hiveDir, { recursive: true });
   }
   const now = new Date;
   const hiveEntry = {
@@ -41440,7 +42144,7 @@ async function promoteFromSwarm(directory, lessonId) {
     promotedAt: now.toISOString(),
     retrievalOutcomes: { applied: 0, succeededAfter: 0, failedAfter: 0 }
   };
-  fs15.appendFileSync(hivePath, `${JSON.stringify(hiveEntry)}
+  fs17.appendFileSync(hivePath, `${JSON.stringify(hiveEntry)}
 `, "utf-8");
   const preview = `${lessonText.slice(0, 50)}${lessonText.length > 50 ? "..." : ""}`;
   return `Promoted to hive: "${preview}" (confidence: 1.0, source: manual)`;
@@ -41493,8 +42197,326 @@ async function handlePromoteCommand(directory, args) {
   }
 }
 
+// src/db/qa-gate-profile.ts
+import { createHash as createHash4 } from "crypto";
+
+// src/db/project-db.ts
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync16, mkdirSync as mkdirSync7 } from "fs";
+import { join as join22, resolve as resolve11 } from "path";
+var MIGRATIONS = [
+  {
+    version: 1,
+    name: "create_project_constraints",
+    sql: `CREATE TABLE project_constraints (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			constraint_type TEXT NOT NULL,
+			content TEXT NOT NULL,
+			created_at TEXT NOT NULL DEFAULT (datetime('now'))
+		)`
+  },
+  {
+    version: 2,
+    name: "create_qa_gate_profile",
+    sql: `CREATE TABLE qa_gate_profile (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			plan_id TEXT NOT NULL UNIQUE,
+			created_at TEXT NOT NULL DEFAULT (datetime('now')),
+			project_type TEXT,
+			gates TEXT NOT NULL DEFAULT '{}',
+			locked_at TEXT,
+			locked_by_snapshot_seq INTEGER
+		)`
+  },
+  {
+    version: 3,
+    name: "create_qa_gate_profile_immutability_trigger",
+    sql: `CREATE TRIGGER IF NOT EXISTS trg_qa_gate_profile_no_update_after_lock
+			BEFORE UPDATE ON qa_gate_profile
+			WHEN OLD.locked_at IS NOT NULL
+			BEGIN
+				SELECT RAISE(ABORT, 'qa_gate_profile row is locked and cannot be modified after critic approval');
+			END`
+  }
+];
+var _projectDbs = new Map;
+function runProjectMigrations(db) {
+  db.run(`CREATE TABLE IF NOT EXISTS schema_migrations (
+		version INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+	)`);
+  const row = db.query("SELECT MAX(version) as version FROM schema_migrations").get();
+  const currentVersion = row?.version ?? 0;
+  for (const migration of MIGRATIONS) {
+    if (migration.version <= currentVersion)
+      continue;
+    const apply = db.transaction(() => {
+      db.run(migration.sql);
+      db.run("INSERT INTO schema_migrations (version, name) VALUES (?, ?)", [
+        migration.version,
+        migration.name
+      ]);
+    });
+    apply();
+  }
+}
+function projectDbPath(directory) {
+  return join22(resolve11(directory), ".swarm", "swarm.db");
+}
+function projectDbExists(directory) {
+  return existsSync16(projectDbPath(directory));
+}
+function getProjectDb(directory) {
+  const key = resolve11(directory);
+  const existing = _projectDbs.get(key);
+  if (existing)
+    return existing;
+  const swarmDir = join22(key, ".swarm");
+  mkdirSync7(swarmDir, { recursive: true });
+  const db = new Database(join22(swarmDir, "swarm.db"));
+  db.run("PRAGMA journal_mode = WAL;");
+  db.run("PRAGMA synchronous = NORMAL;");
+  db.run("PRAGMA busy_timeout = 5000;");
+  db.run("PRAGMA foreign_keys = ON;");
+  runProjectMigrations(db);
+  _projectDbs.set(key, db);
+  return db;
+}
+
+// src/db/qa-gate-profile.ts
+var DEFAULT_QA_GATES = {
+  reviewer: true,
+  test_engineer: true,
+  council_mode: false,
+  sme_enabled: true,
+  critic_pre_plan: true,
+  hallucination_guard: false,
+  sast_enabled: true
+};
+function rowToProfile(row) {
+  let parsed = {};
+  try {
+    parsed = JSON.parse(row.gates);
+  } catch {
+    parsed = {};
+  }
+  const gates = { ...DEFAULT_QA_GATES, ...parsed };
+  return {
+    id: row.id,
+    plan_id: row.plan_id,
+    created_at: row.created_at,
+    project_type: row.project_type,
+    gates,
+    locked_at: row.locked_at,
+    locked_by_snapshot_seq: row.locked_by_snapshot_seq
+  };
+}
+function getProfile(directory, planId) {
+  if (!projectDbExists(directory))
+    return null;
+  const db = getProjectDb(directory);
+  const row = db.query("SELECT * FROM qa_gate_profile WHERE plan_id = ?").get(planId);
+  return row ? rowToProfile(row) : null;
+}
+function getOrCreateProfile(directory, planId, projectType) {
+  const existing = getProfile(directory, planId);
+  if (existing)
+    return existing;
+  const db = getProjectDb(directory);
+  const gatesJson = JSON.stringify(DEFAULT_QA_GATES);
+  const insert = db.transaction(() => {
+    db.run("INSERT INTO qa_gate_profile (plan_id, project_type, gates) VALUES (?, ?, ?)", [planId, projectType ?? null, gatesJson]);
+  });
+  try {
+    insert();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!msg.toLowerCase().includes("unique")) {
+      throw err;
+    }
+  }
+  const after = getProfile(directory, planId);
+  if (!after) {
+    throw new Error(`Failed to create or load QA gate profile for plan_id=${planId}`);
+  }
+  return after;
+}
+function setGates(directory, planId, gates) {
+  const current = getProfile(directory, planId);
+  if (!current) {
+    throw new Error(`No QA gate profile found for plan_id=${planId} \u2014 call getOrCreateProfile first`);
+  }
+  if (current.locked_at !== null) {
+    throw new Error("Cannot modify gates: QA gate profile is locked after critic approval");
+  }
+  const merged = { ...current.gates };
+  for (const key of Object.keys(gates)) {
+    const incoming = gates[key];
+    if (incoming === undefined)
+      continue;
+    if (incoming === false && current.gates[key] === true) {
+      throw new Error(`Cannot disable gate '${key}': sessions can only ratchet tighter`);
+    }
+    if (incoming === true) {
+      merged[key] = true;
+    }
+  }
+  const db = getProjectDb(directory);
+  db.run("UPDATE qa_gate_profile SET gates = ? WHERE plan_id = ?", [
+    JSON.stringify(merged),
+    planId
+  ]);
+  const updated = getProfile(directory, planId);
+  if (!updated) {
+    throw new Error(`Failed to re-read QA gate profile after update for plan_id=${planId}`);
+  }
+  return updated;
+}
+function computeProfileHash(profile) {
+  const payload = JSON.stringify({
+    plan_id: profile.plan_id,
+    gates: profile.gates
+  });
+  return createHash4("sha256").update(payload).digest("hex");
+}
+function getEffectiveGates(profile, sessionOverrides) {
+  const merged = { ...profile.gates };
+  for (const key of Object.keys(sessionOverrides)) {
+    if (sessionOverrides[key] === true) {
+      merged[key] = true;
+    }
+  }
+  return merged;
+}
+
+// src/commands/qa-gates.ts
+init_manager();
+var ALL_GATE_NAMES = [
+  "reviewer",
+  "test_engineer",
+  "council_mode",
+  "sme_enabled",
+  "critic_pre_plan",
+  "hallucination_guard",
+  "sast_enabled"
+];
+function derivePlanId(plan) {
+  return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+function isGateName(name) {
+  return ALL_GATE_NAMES.includes(name);
+}
+function formatGates(gates) {
+  return ALL_GATE_NAMES.map((g) => `  - ${g}: ${gates[g] ? "on" : "off"}`).join(`
+`);
+}
+async function handleQaGatesCommand(directory, args, sessionID) {
+  const plan = await loadPlanJsonOnly(directory);
+  if (!plan) {
+    return "Error: plan.json not found or invalid. Create a plan first (e.g. /swarm specify or save_plan).";
+  }
+  const planId = derivePlanId(plan);
+  const subcommand = args[0]?.toLowerCase();
+  const gateArgs = args.slice(1);
+  if (!subcommand || subcommand === "show" || subcommand === "status") {
+    const profile = getProfile(directory, planId);
+    const spec = profile ? profile.gates : DEFAULT_QA_GATES;
+    const session = sessionID ? getAgentSession(sessionID) : null;
+    const overrides = session?.qaGateSessionOverrides ?? {};
+    const effective = profile ? getEffectiveGates(profile, overrides) : { ...DEFAULT_QA_GATES, ...overrides };
+    const lines = [];
+    lines.push(`QA Gate Profile for plan_id=${planId}`);
+    if (!profile) {
+      lines.push("  (no profile persisted yet \u2014 showing defaults)");
+    } else {
+      lines.push(`  locked: ${profile.locked_at ? `yes @ ${profile.locked_at} (seq ${profile.locked_by_snapshot_seq ?? "?"})` : "no"}`);
+      lines.push(`  profile_hash: ${computeProfileHash(profile)}`);
+    }
+    lines.push("Spec-level gates:");
+    lines.push(formatGates(spec));
+    lines.push("Session overrides (ratchet-tighter only):");
+    if (Object.keys(overrides).length === 0) {
+      lines.push("  (none)");
+    } else {
+      for (const k of ALL_GATE_NAMES) {
+        if (overrides[k] === true)
+          lines.push(`  - ${k}: on (override)`);
+      }
+    }
+    lines.push("Effective gates:");
+    lines.push(formatGates(effective));
+    return lines.join(`
+`);
+  }
+  if (subcommand === "enable") {
+    if (gateArgs.length === 0) {
+      return "Usage: /swarm qa-gates enable <gate> [<gate> ...]";
+    }
+    const invalid = gateArgs.filter((g) => !isGateName(g));
+    if (invalid.length > 0) {
+      return `Error: unknown gate(s): ${invalid.join(", ")}. Valid gates: ${ALL_GATE_NAMES.join(", ")}`;
+    }
+    getOrCreateProfile(directory, planId);
+    const patch = {};
+    for (const g of gateArgs) {
+      if (isGateName(g))
+        patch[g] = true;
+    }
+    try {
+      const updated = setGates(directory, planId, patch);
+      return [
+        `Enabled gates persisted for plan_id=${planId}:`,
+        formatGates(updated.gates),
+        `profile_hash: ${computeProfileHash(updated)}`
+      ].join(`
+`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return `Error: ${msg}`;
+    }
+  }
+  if (subcommand === "override") {
+    if (!sessionID) {
+      return "Error: session overrides require an active session context.";
+    }
+    if (gateArgs.length === 0) {
+      return "Usage: /swarm qa-gates override <gate> [<gate> ...]";
+    }
+    const invalid = gateArgs.filter((g) => !isGateName(g));
+    if (invalid.length > 0) {
+      return `Error: unknown gate(s): ${invalid.join(", ")}. Valid gates: ${ALL_GATE_NAMES.join(", ")}`;
+    }
+    const session = getAgentSession(sessionID);
+    if (!session) {
+      return "Error: no active session found for override.";
+    }
+    const current = session.qaGateSessionOverrides ?? {};
+    const next = { ...current };
+    for (const g of gateArgs) {
+      if (isGateName(g))
+        next[g] = true;
+    }
+    session.qaGateSessionOverrides = next;
+    return [
+      `Session overrides updated for plan_id=${planId}:`,
+      Object.keys(next).filter((k) => next[k] === true).map((k) => `  - ${k}: on`).join(`
+`) || "  (none)"
+    ].join(`
+`);
+  }
+  return [
+    "Usage:",
+    "  /swarm qa-gates                    show current profile + effective gates",
+    "  /swarm qa-gates enable <gate>...   persist-enable gate(s) (rejected if locked)",
+    "  /swarm qa-gates override <gate>... session-only enable (ratchet-tighter)",
+    `Valid gates: ${ALL_GATE_NAMES.join(", ")}`
+  ].join(`
+`);
+}
+
 // src/commands/reset.ts
-import * as fs16 from "fs";
+import * as fs18 from "fs";
 
 // src/background/manager.ts
 init_utils();
@@ -41549,13 +42571,13 @@ class CircuitBreaker {
     if (this.config.callTimeoutMs <= 0) {
       return fn();
     }
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const timeout = setTimeout(() => {
         reject(new Error(`Call timeout after ${this.config.callTimeoutMs}ms`));
       }, this.config.callTimeoutMs);
       fn().then((result) => {
         clearTimeout(timeout);
-        resolve11(result);
+        resolve12(result);
       }).catch((error93) => {
         clearTimeout(timeout);
         reject(error93);
@@ -41839,7 +42861,7 @@ class AutomationQueue {
 
 // src/background/worker.ts
 function sleep(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 
 class WorkerManager {
@@ -42195,8 +43217,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs16.existsSync(resolvedPath)) {
-        fs16.unlinkSync(resolvedPath);
+      if (fs18.existsSync(resolvedPath)) {
+        fs18.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -42213,8 +43235,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs16.existsSync(summariesPath)) {
-      fs16.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs18.existsSync(summariesPath)) {
+      fs18.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -42234,14 +43256,14 @@ async function handleResetCommand(directory, args) {
 
 // src/commands/reset-session.ts
 init_utils2();
-import * as fs17 from "fs";
-import * as path26 from "path";
+import * as fs19 from "fs";
+import * as path28 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs17.existsSync(statePath)) {
-      fs17.unlinkSync(statePath);
+    if (fs19.existsSync(statePath)) {
+      fs19.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -42250,15 +43272,15 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("\u274C Failed to delete state.json");
   }
   try {
-    const sessionDir = path26.dirname(validateSwarmPath(directory, "session/state.json"));
-    if (fs17.existsSync(sessionDir)) {
-      const files = fs17.readdirSync(sessionDir);
+    const sessionDir = path28.dirname(validateSwarmPath(directory, "session/state.json"));
+    if (fs19.existsSync(sessionDir)) {
+      const files = fs19.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path26.join(sessionDir, file3);
-        if (fs17.lstatSync(filePath).isFile()) {
-          fs17.unlinkSync(filePath);
+        const filePath = path28.join(sessionDir, file3);
+        if (fs19.lstatSync(filePath).isFile()) {
+          fs19.unlinkSync(filePath);
           deletedCount++;
         }
       }
@@ -42286,7 +43308,7 @@ async function handleResetSessionCommand(directory, _args) {
 // src/summaries/manager.ts
 init_utils2();
 init_utils();
-import * as path27 from "path";
+import * as path29 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -42310,7 +43332,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path27.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path29.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -42363,18 +43385,18 @@ ${error93 instanceof Error ? error93.message : String(error93)}`;
 
 // src/commands/rollback.ts
 init_utils2();
-import * as fs18 from "fs";
-import * as path28 from "path";
+import * as fs20 from "fs";
+import * as path30 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs18.existsSync(manifestPath2)) {
+    if (!fs20.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs18.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs20.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -42396,12 +43418,12 @@ async function handleRollbackCommand(directory, args) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs18.existsSync(manifestPath)) {
+  if (!fs20.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs18.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs20.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -42411,10 +43433,10 @@ async function handleRollbackCommand(directory, args) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs18.existsSync(checkpointDir)) {
+  if (!fs20.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs18.readdirSync(checkpointDir);
+  const checkpointFiles = fs20.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -42422,10 +43444,10 @@ async function handleRollbackCommand(directory, args) {
   const successes = [];
   const failures = [];
   for (const file3 of checkpointFiles) {
-    const src = path28.join(checkpointDir, file3);
-    const dest = path28.join(swarmDir, file3);
+    const src = path30.join(checkpointDir, file3);
+    const dest = path30.join(swarmDir, file3);
     try {
-      fs18.cpSync(src, dest, { recursive: true, force: true });
+      fs20.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
@@ -42442,7 +43464,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs18.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs20.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93 instanceof Error ? error93.message : String(error93));
@@ -42485,11 +43507,11 @@ async function handleSimulateCommand(directory, args) {
   ];
   const report = reportLines.filter(Boolean).join(`
 `);
-  const fs19 = await import("fs/promises");
-  const path29 = await import("path");
-  const reportPath = path29.join(directory, ".swarm", "simulate-report.md");
-  await fs19.mkdir(path29.dirname(reportPath), { recursive: true });
-  await fs19.writeFile(reportPath, report, "utf-8");
+  const fs21 = await import("fs/promises");
+  const path31 = await import("path");
+  const reportPath = path31.join(directory, ".swarm", "simulate-report.md");
+  await fs21.mkdir(path31.dirname(reportPath), { recursive: true });
+  await fs21.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
 
@@ -42930,6 +43952,18 @@ var COMMAND_REGISTRY = {
     description: "Generate or import a feature specification [description]",
     args: "[description-text]"
   },
+  brainstorm: {
+    handler: (ctx) => handleBrainstormCommand(ctx.directory, ctx.args),
+    description: "Enter architect MODE: BRAINSTORM \u2014 structured seven-phase planning workflow [topic]",
+    args: "[topic-text]",
+    details: "Triggers the architect to run the brainstorm workflow: CONTEXT SCAN, single-question DIALOGUE, APPROACHES, DESIGN SECTIONS, SPEC WRITE + SELF-REVIEW, QA GATE SELECTION, TRANSITION. Use for new plans where requirements need to be drawn out before writing spec.md / plan.md."
+  },
+  "qa-gates": {
+    handler: (ctx) => handleQaGatesCommand(ctx.directory, ctx.args, ctx.sessionID),
+    description: "View or modify QA gate profile for the current plan [enable|override <gate>...]",
+    args: "[show|enable|override] <gate>...",
+    details: "show: display spec-level, session-override, and effective QA gates for the current plan. enable: persist gate(s) into the locked-once profile (architect; rejected after critic approval lock). override: session-only ratchet-tighter enable. Valid gates: reviewer, test_engineer, council_mode, sme_enabled, critic_pre_plan, hallucination_guard, sast_enabled."
+  },
   promote: {
     handler: (ctx) => handlePromoteCommand(ctx.directory, ctx.args),
     description: "Manually promote lesson to hive knowledge",
@@ -43040,18 +44074,18 @@ function resolveCommand(tokens) {
 }
 
 // src/cli/index.ts
-var CONFIG_DIR = path29.join(process.env.XDG_CONFIG_HOME || path29.join(os6.homedir(), ".config"), "opencode");
-var OPENCODE_CONFIG_PATH = path29.join(CONFIG_DIR, "opencode.json");
-var PLUGIN_CONFIG_PATH = path29.join(CONFIG_DIR, "opencode-swarm.json");
-var PROMPTS_DIR = path29.join(CONFIG_DIR, "opencode-swarm");
+var CONFIG_DIR = path31.join(process.env.XDG_CONFIG_HOME || path31.join(os6.homedir(), ".config"), "opencode");
+var OPENCODE_CONFIG_PATH = path31.join(CONFIG_DIR, "opencode.json");
+var PLUGIN_CONFIG_PATH = path31.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path31.join(CONFIG_DIR, "opencode-swarm");
 function ensureDir(dir) {
-  if (!fs19.existsSync(dir)) {
-    fs19.mkdirSync(dir, { recursive: true });
+  if (!fs21.existsSync(dir)) {
+    fs21.mkdirSync(dir, { recursive: true });
   }
 }
 function loadJson(filepath) {
   try {
-    const content = fs19.readFileSync(filepath, "utf-8");
+    const content = fs21.readFileSync(filepath, "utf-8");
     const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(stripped);
   } catch {
@@ -43059,7 +44093,7 @@ function loadJson(filepath) {
   }
 }
 function saveJson(filepath, data) {
-  fs19.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
+  fs21.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 async function install() {
@@ -43067,7 +44101,7 @@ async function install() {
 `);
   ensureDir(CONFIG_DIR);
   ensureDir(PROMPTS_DIR);
-  const LEGACY_CONFIG_PATH = path29.join(CONFIG_DIR, "config.json");
+  const LEGACY_CONFIG_PATH = path31.join(CONFIG_DIR, "config.json");
   let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
   if (!opencodeConfig) {
     const legacyConfig = loadJson(LEGACY_CONFIG_PATH);
@@ -43092,7 +44126,7 @@ async function install() {
   saveJson(OPENCODE_CONFIG_PATH, opencodeConfig);
   console.log("\u2713 Added opencode-swarm to OpenCode plugins");
   console.log("\u2713 Disabled default OpenCode agents (explore, general)");
-  if (!fs19.existsSync(PLUGIN_CONFIG_PATH)) {
+  if (!fs21.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
       agents: {
         coder: { model: "opencode/minimax-m2.5-free" },
@@ -43135,7 +44169,7 @@ async function uninstall() {
 `);
     const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
     if (!opencodeConfig) {
-      if (fs19.existsSync(OPENCODE_CONFIG_PATH)) {
+      if (fs21.existsSync(OPENCODE_CONFIG_PATH)) {
         console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
         return 1;
       } else {
@@ -43167,13 +44201,13 @@ async function uninstall() {
     console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
     if (process.argv.includes("--clean")) {
       let cleaned = false;
-      if (fs19.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs19.unlinkSync(PLUGIN_CONFIG_PATH);
+      if (fs21.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs21.unlinkSync(PLUGIN_CONFIG_PATH);
         console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
         cleaned = true;
       }
-      if (fs19.existsSync(PROMPTS_DIR)) {
-        fs19.rmSync(PROMPTS_DIR, { recursive: true });
+      if (fs21.existsSync(PROMPTS_DIR)) {
+        fs21.rmSync(PROMPTS_DIR, { recursive: true });
         console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
         cleaned = true;
       }