@pratik7368patil/anchor-core 0.1.7 → 0.1.8

package/dist/index.js

@@ -252,8 +252,8 @@ function redactedHistoricalText(text) {
 }
 
 // src/db/database.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import Database from "better-sqlite3";
 
 // src/db/migrations.ts
@@ -380,6 +380,9 @@ CREATE TABLE IF NOT EXISTS sync_state (
   repo TEXT PRIMARY KEY,
   last_sync_at TEXT,
   last_indexed_pr INTEGER,
+  history_coverage TEXT,
+  history_limit INTEGER,
+  history_since TEXT,
   updated_at TEXT NOT NULL
 );
 
@@ -392,12 +395,378 @@ CREATE INDEX IF NOT EXISTS idx_code_files_path ON code_files(path);
 CREATE INDEX IF NOT EXISTS idx_code_chunks_file_path ON code_chunks(file_path);
 `;
 
+// src/rules/team-rules.ts
+import fs2 from "fs";
+import path2 from "path";
+import { z } from "zod";
+
+// src/retrieval/evidence.ts
+function claimKeyFor(category, sanitizedText) {
+  return `${category}:${canonicalizeText(sanitizedText).slice(0, 180)}`;
+}
+function confidenceLevelFor(confidence) {
+  if (confidence >= 0.75) return "strong";
+  if (confidence >= 0.55) return "moderate";
+  return "weak";
+}
+function confidenceRank(level) {
+  const ranks = {
+    weak: 1,
+    moderate: 2,
+    strong: 3
+  };
+  return ranks[level];
+}
+function confidenceAtLeast(level, minimum) {
+  return confidenceRank(level) >= confidenceRank(minimum);
+}
+function evidenceForWisdom(unit) {
+  return {
+    prNumber: unit.prNumber,
+    prUrl: unit.prUrl,
+    sourceType: unit.sourceType,
+    author: unit.authors[0],
+    filePath: unit.filePaths[0]
+  };
+}
+function confidenceReasonsFor(unit, repeatedEvidenceCount) {
+  const reasons = [];
+  if (unit.sourceType === "review_comment" || unit.sourceType === "review_summary") {
+    reasons.push("reviewer evidence");
+  } else if (unit.sourceType === "pr_body") {
+    reasons.push("PR description evidence");
+  } else if (unit.sourceType === "commit_message") {
+    reasons.push("commit message evidence");
+  } else {
+    reasons.push(sourceTypeLabel(unit.sourceType));
+  }
+  if (unit.filePaths.length > 0) reasons.push("file-associated");
+  if (unit.symbols.length > 0) reasons.push("symbol-associated");
+  if (/\b(regression|this broke|broke|root cause)\b/i.test(unit.sanitizedText)) {
+    reasons.push("regression language");
+  }
+  if (/\b(do not|don't|must|should not|avoid|invariant|contract)\b/i.test(unit.sanitizedText)) {
+    reasons.push("constraint language");
+  }
+  if (repeatedEvidenceCount > 1) {
+    reasons.push(`repeated across ${repeatedEvidenceCount} PRs`);
+  }
+  return reasons;
+}
+function sourceTypeLabel(sourceType) {
+  return sourceType.replace(/_/g, " ");
+}
+function parseJsonArray(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function loadCurrentCodeSnapshot(db) {
+  const fileRows = db.prepare("SELECT path FROM code_files").all();
+  const chunkRows = db.prepare("SELECT file_path, symbols_json FROM code_chunks").all();
+  const filePaths = new Set(fileRows.map((row) => row.path));
+  const symbolsByFile = /* @__PURE__ */ new Map();
+  const allSymbols = /* @__PURE__ */ new Set();
+  for (const row of chunkRows) {
+    const symbols = parseJsonArray(row.symbols_json).map((symbol) => symbol.toLowerCase());
+    const fileSymbols = symbolsByFile.get(row.file_path) ?? /* @__PURE__ */ new Set();
+    for (const symbol of symbols) {
+      fileSymbols.add(symbol);
+      allSymbols.add(symbol);
+    }
+    symbolsByFile.set(row.file_path, fileSymbols);
+  }
+  return {
+    hasCodeIndex: fileRows.length > 0 || chunkRows.length > 0,
+    filePaths,
+    symbolsByFile,
+    allSymbols
+  };
+}
+function evaluateFreshness(subject, snapshot) {
+  if (!snapshot.hasCodeIndex) {
+    return {
+      status: "possibly_stale",
+      reason: "No current code index is available to verify this evidence."
+    };
+  }
+  const filePaths = subject.filePaths.filter(Boolean);
+  const symbols = subject.symbols.map((symbol) => symbol.toLowerCase()).filter(Boolean);
+  if (filePaths.length > 0) {
+    const existingFiles = filePaths.filter((filePath) => snapshot.filePaths.has(filePath));
+    if (existingFiles.length === 0) {
+      return {
+        status: "stale",
+        reason: "None of the historical file paths exist in the current code index."
+      };
+    }
+    if (symbols.length === 0) {
+      return {
+        status: "current",
+        reason: "At least one historical file path exists in the current code index."
+      };
+    }
+    for (const filePath of existingFiles) {
+      const fileSymbols = snapshot.symbolsByFile.get(filePath) ?? /* @__PURE__ */ new Set();
+      if (symbols.some((symbol) => fileSymbols.has(symbol))) {
+        return {
+          status: "current",
+          reason: "Historical file and symbol are present in the current code index."
+        };
+      }
+    }
+    if (symbols.some((symbol) => snapshot.allSymbols.has(symbol))) {
+      return {
+        status: "possibly_stale",
+        reason: "The historical file exists, but the referenced symbol appears elsewhere or moved."
+      };
+    }
+    return {
+      status: "possibly_stale",
+      reason: "The historical file exists, but referenced symbols were not found there."
+    };
+  }
+  if (symbols.length > 0 && symbols.some((symbol) => snapshot.allSymbols.has(symbol))) {
+    return {
+      status: "current",
+      reason: "Referenced symbol exists in the current code index."
+    };
+  }
+  return {
+    status: "possibly_stale",
+    reason: "Evidence has no exact current file path to verify."
+  };
+}
+
+// src/rules/team-rules.ts
+var TEAM_RULES_FILE = "anchor.rules.json";
+var SourceTypeSchema = z.enum([
+  "pr_body",
+  "review_comment",
+  "issue_comment",
+  "review_summary",
+  "commit_message",
+  "diff_context"
+]);
+var WisdomCategorySchema = z.enum([
+  "architecture_decision",
+  "constraint",
+  "rejected_approach",
+  "bug_regression",
+  "testing_rule",
+  "api_contract",
+  "performance_note",
+  "security_note",
+  "style_convention",
+  "unknown"
+]);
+var ConfidenceLevelSchema = z.enum(["strong", "moderate", "weak"]);
+var EvidenceRefSchema = z.object({
+  prNumber: z.number().int().positive(),
+  prUrl: z.string().url(),
+  sourceType: SourceTypeSchema,
+  author: z.string().min(1).optional(),
+  filePath: z.string().min(1).optional(),
+  note: z.string().min(1).max(500).optional()
+});
+var TeamRuleSchema = z.object({
+  id: z.string().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/i),
+  category: WisdomCategorySchema,
+  text: z.string().min(1).max(1e3),
+  filePaths: z.array(z.string().min(1)).max(50).default([]),
+  symbols: z.array(z.string().min(1)).max(100).default([]),
+  evidence: z.array(EvidenceRefSchema).min(1),
+  confidenceLevel: ConfidenceLevelSchema.default("strong")
+});
+var TeamRulesFileSchema = z.object({
+  version: z.literal(1),
+  rules: z.array(TeamRuleSchema).default([])
+});
+function rulesPath(cwd) {
+  return path2.join(detectGitRoot(cwd) ?? cwd, TEAM_RULES_FILE);
+}
+function defaultRulesFile() {
+  return `${JSON.stringify({ version: 1, rules: [] }, null, 2)}
+`;
+}
+function ensureTeamRulesFile(cwd) {
+  const filePath = rulesPath(cwd);
+  if (fs2.existsSync(filePath)) return { path: filePath, created: false };
+  fs2.writeFileSync(filePath, defaultRulesFile());
+  return { path: filePath, created: true };
+}
+function sanitizeEvidence(evidence) {
+  return evidence.map((item) => ({
+    ...item,
+    note: item.note ? sanitizeHistoricalText(item.note) : void 0
+  }));
+}
+function loadTeamRulesFile(cwd) {
+  const filePath = rulesPath(cwd);
+  if (!fs2.existsSync(filePath)) {
+    return { ok: true, exists: false, path: filePath, errors: [], rules: [] };
+  }
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    return {
+      ok: false,
+      exists: true,
+      path: filePath,
+      errors: [`Invalid JSON: ${error instanceof Error ? error.message : String(error)}`],
+      rules: []
+    };
+  }
+  const parsed = TeamRulesFileSchema.safeParse(parsedJson);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      exists: true,
+      path: filePath,
+      errors: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`),
+      rules: []
+    };
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  const duplicateIds = parsed.data.rules.map((rule) => rule.id).filter((id) => {
+    if (seenIds.has(id)) return true;
+    seenIds.add(id);
+    return false;
+  });
+  if (duplicateIds.length > 0) {
+    return {
+      ok: false,
+      exists: true,
+      path: filePath,
+      errors: [`Duplicate rule ids: ${uniqueStrings(duplicateIds).join(", ")}`],
+      rules: []
+    };
+  }
+  const rules = parsed.data.rules.map((rule) => {
+    const sanitizedText = sanitizeHistoricalText(rule.text);
+    return {
+      id: rule.id,
+      category: rule.category,
+      text: sanitizedText,
+      sanitizedText,
+      filePaths: uniqueStrings(rule.filePaths),
+      symbols: uniqueStrings(rule.symbols),
+      evidence: sanitizeEvidence(rule.evidence),
+      confidenceLevel: rule.confidenceLevel
+    };
+  });
+  return { ok: true, exists: true, path: filePath, errors: [], rules };
+}
+function validateTeamRulesFile(cwd) {
+  const loaded = loadTeamRulesFile(cwd);
+  if (!loaded.exists) {
+    return {
+      ok: false,
+      path: loaded.path,
+      errors: [`${TEAM_RULES_FILE} does not exist. Run anchor rules init.`],
+      rules: []
+    };
+  }
+  return {
+    ok: loaded.ok,
+    path: loaded.path,
+    errors: loaded.errors,
+    rules: loaded.rules
+  };
+}
+function pathMatch(rulePaths, queryFiles) {
+  if (rulePaths.length === 0 || queryFiles.length === 0) return 0;
+  let best = 0;
+  for (const rulePath of rulePaths) {
+    const ruleBase = path2.basename(rulePath).toLowerCase();
+    const ruleDir = path2.dirname(rulePath).toLowerCase();
+    for (const queryFile of queryFiles) {
+      const queryBase = path2.basename(queryFile).toLowerCase();
+      const queryDir = path2.dirname(queryFile).toLowerCase();
+      if (rulePath.toLowerCase() === queryFile.toLowerCase()) best = Math.max(best, 1);
+      else if (ruleBase === queryBase) best = Math.max(best, 0.72);
+      else if (ruleDir === queryDir) best = Math.max(best, 0.6);
+      else if (ruleDir.startsWith(queryDir) || queryDir.startsWith(ruleDir)) {
+        best = Math.max(best, 0.35);
+      }
+    }
+  }
+  return best;
+}
+function symbolMatch(rule, querySymbols) {
+  if (rule.symbols.length === 0 || querySymbols.length === 0) return 0;
+  const ruleSymbols = rule.symbols.map((symbol) => symbol.toLowerCase());
+  let best = 0;
+  for (const symbol of querySymbols) {
+    const lower = symbol.toLowerCase();
+    if (ruleSymbols.includes(lower)) best = Math.max(best, 1);
+    else if (ruleSymbols.some((candidate) => candidate.includes(lower) || lower.includes(candidate))) {
+      best = Math.max(best, 0.45);
+    }
+  }
+  return best;
+}
+function textMatch(rule, input) {
+  const tokens = tokenizeSearchText(
+    `${input.task} ${input.diff ?? ""} ${input.currentCode ?? ""}`,
+    32
+  );
+  if (tokens.length === 0) return 0;
+  const haystack = `${rule.sanitizedText} ${rule.filePaths.join(" ")} ${rule.symbols.join(" ")}`.toLowerCase();
+  return tokens.filter((token) => haystack.includes(token.toLowerCase())).length / tokens.length;
+}
+function confidenceScore(level) {
+  if (level === "strong") return 1;
+  if (level === "moderate") return 0.7;
+  return 0.4;
+}
+function confidenceReasons(rule) {
+  const firstEvidence = rule.evidence[0];
+  return [
+    "team-approved rule",
+    firstEvidence ? `${sourceTypeLabel(firstEvidence.sourceType)} evidence` : "source evidence",
+    ...rule.filePaths.length > 0 ? ["file-associated"] : [],
+    ...rule.symbols.length > 0 ? ["symbol-associated"] : []
+  ];
+}
+function passesStrictMode(rule, input) {
+  if (!input.strict) return true;
+  if (rule.freshnessStatus === "stale") return false;
+  return confidenceAtLeast(rule.confidenceLevel, input.minConfidence ?? "strong");
+}
+function rankTeamRules(db, cwd, input) {
+  const loaded = loadTeamRulesFile(cwd);
+  if (!loaded.ok || loaded.rules.length === 0) return [];
+  const codeSnapshot = loadCurrentCodeSnapshot(db);
+  return loaded.rules.map((rule) => {
+    const freshness = evaluateFreshness(rule, codeSnapshot);
+    const score = 1 + 0.35 * pathMatch(rule.filePaths, input.files ?? []) + 0.25 * symbolMatch(rule, input.symbols ?? []) + 0.25 * textMatch(rule, input) + 0.15 * confidenceScore(rule.confidenceLevel);
+    return {
+      ...rule,
+      score: Number(score.toFixed(4)),
+      freshnessStatus: freshness.status,
+      freshnessReason: freshness.reason,
+      confidenceReasons: confidenceReasons(rule)
+    };
+  }).filter((rule) => passesStrictMode(rule, input)).sort((a, b) => b.score - a.score).slice(0, 4);
+}
+function countValidTeamRules(cwd) {
+  const loaded = loadTeamRulesFile(cwd);
+  if (!loaded.exists || !loaded.ok) return { count: 0 };
+  const stat = fs2.statSync(loaded.path);
+  return { count: loaded.rules.length, lastRuleIndexTime: stat.mtime.toISOString() };
+}
+
 // src/db/database.ts
 function defaultDatabasePath(cwd) {
-  return path2.join(cwd, ".anchor", "index.sqlite");
+  return path3.join(cwd, ".anchor", "index.sqlite");
 }
 function openAnchorDatabase(cwd, databasePath = defaultDatabasePath(cwd)) {
-  fs2.mkdirSync(path2.dirname(databasePath), { recursive: true });
+  fs3.mkdirSync(path3.dirname(databasePath), { recursive: true });
   const db = new Database(databasePath);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
@@ -405,6 +774,15 @@ function openAnchorDatabase(cwd, databasePath = defaultDatabasePath(cwd)) {
 }
 function initializeSchema(db) {
   db.exec(SCHEMA_SQL);
+  ensureColumn(db, "sync_state", "history_coverage", "TEXT");
+  ensureColumn(db, "sync_state", "history_limit", "INTEGER");
+  ensureColumn(db, "sync_state", "history_since", "TEXT");
+}
+function ensureColumn(db, tableName, columnName, definition) {
+  const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
+  if (!columns.some((column) => column.name === columnName)) {
+    db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${definition}`);
+  }
 }
 function checkSchema(db) {
   try {
@@ -432,16 +810,28 @@ function getLastSyncTime(db, repo) {
   const row = db.prepare("SELECT last_sync_at FROM sync_state WHERE repo = ?").get(repo);
   return row?.last_sync_at ?? void 0;
 }
-function updateSyncState(db, repo, lastIndexedPr) {
+function updateSyncState(db, repo, lastIndexedPr, metadata = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.prepare(
-    `INSERT INTO sync_state (repo, last_sync_at, last_indexed_pr, updated_at)
-     VALUES (?, ?, ?, ?)
+    `INSERT INTO sync_state
+     (repo, last_sync_at, last_indexed_pr, history_coverage, history_limit, history_since, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(repo) DO UPDATE SET
        last_sync_at = excluded.last_sync_at,
        last_indexed_pr = excluded.last_indexed_pr,
+       history_coverage = excluded.history_coverage,
+       history_limit = excluded.history_limit,
+       history_since = excluded.history_since,
        updated_at = excluded.updated_at`
-  ).run(repo, now, lastIndexedPr ?? null, now);
+  ).run(
+    repo,
+    now,
+    lastIndexedPr ?? null,
+    metadata.historyCoverage ?? "unknown",
+    metadata.historyLimit ?? null,
+    metadata.historySince ?? null,
+    now
+  );
 }
 function deleteExistingPrData(db, prId) {
   const unitRows = db.prepare("SELECT id FROM wisdom_units WHERE pr_id = ?").all(prId);
@@ -671,7 +1061,8 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd) {
   };
 }
 function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken({ cwd }).token), databasePath = defaultDatabasePath(cwd)) {
-  if (!fs2.existsSync(databasePath)) {
+  if (!fs3.existsSync(databasePath)) {
+    const rules = countValidTeamRules(cwd);
     return {
       databasePath,
       prCount: 0,
@@ -680,6 +1071,10 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
       wisdomUnitCount: 0,
       codeFileCount: 0,
       codeChunkCount: 0,
+      historyCoverage: "unknown",
+      staleEvidenceCount: 0,
+      teamRuleCount: rules.count,
+      lastRuleIndexTime: rules.lastRuleIndexTime,
       githubTokenConfigured,
       health: "missing_database"
     };
@@ -688,6 +1083,7 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
   try {
     initializeSchema(db);
     if (!checkSchema(db)) {
+      const rules2 = countValidTeamRules(cwd);
       return {
         databasePath,
         prCount: 0,
@@ -696,16 +1092,23 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
         wisdomUnitCount: 0,
         codeFileCount: 0,
         codeChunkCount: 0,
+        historyCoverage: "unknown",
+        staleEvidenceCount: 0,
+        teamRuleCount: rules2.count,
+        lastRuleIndexTime: rules2.lastRuleIndexTime,
         githubTokenConfigured,
         health: "schema_invalid"
       };
     }
     const count = (table) => db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get().count;
     const repoRow = db.prepare("SELECT full_name FROM repositories ORDER BY id LIMIT 1").get();
-    const syncRow = db.prepare("SELECT last_sync_at FROM sync_state ORDER BY updated_at DESC LIMIT 1").get();
+    const syncRow = db.prepare(
+      "SELECT last_sync_at, history_coverage, history_limit FROM sync_state ORDER BY updated_at DESC LIMIT 1"
+    ).get();
     const codeIndexRow = db.prepare("SELECT last_indexed_at FROM code_index_state ORDER BY last_indexed_at DESC LIMIT 1").get();
     const wisdomUnitCount = count("wisdom_units");
     const codeChunkCount = count("code_chunks");
+    const rules = countValidTeamRules(cwd);
     return {
       repo: repoRow?.full_name,
       databasePath,
@@ -715,8 +1118,13 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
       wisdomUnitCount,
       codeFileCount: count("code_files"),
       codeChunkCount,
+      historyCoverage: syncRow?.history_coverage ?? "unknown",
+      historyLimit: syncRow?.history_limit ?? void 0,
+      staleEvidenceCount: countStaleEvidence(db),
+      teamRuleCount: rules.count,
       lastSyncTime: syncRow?.last_sync_at ?? void 0,
       lastCodeIndexTime: codeIndexRow?.last_indexed_at ?? void 0,
+      lastRuleIndexTime: rules.lastRuleIndexTime,
       githubTokenConfigured,
       health: wisdomUnitCount > 0 || codeChunkCount > 0 ? "ok" : "empty_index"
     };
@@ -724,6 +1132,27 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
     db.close();
   }
 }
+function countStaleEvidence(db) {
+  const codeFiles = new Set(
+    db.prepare("SELECT path FROM code_files").all().map(
+      (row) => row.path
+    )
+  );
+  if (codeFiles.size === 0) return 0;
+  const rows = db.prepare("SELECT file_paths_json FROM wisdom_units").all();
+  let stale = 0;
+  for (const row of rows) {
+    let paths = [];
+    try {
+      const parsed = JSON.parse(row.file_paths_json);
+      paths = Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+    } catch {
+      paths = [];
+    }
+    if (paths.length > 0 && !paths.some((filePath) => codeFiles.has(filePath))) stale += 1;
+  }
+  return stale;
+}
 
 // src/indexer/chunker.ts
 var HIGH_SIGNAL_PATTERN = /\b(because|we intentionally|do not|don't|must|should not|avoid|rejected|regression|breaking|contract|invariant|performance|security|secret|token|migration|compatibility|lazy|eager|thread-safe|race|deadlock|deprecated|backward compatible|do not change|this broke|root cause|architecture decision)\b/i;
@@ -757,7 +1186,7 @@ function chunkHistoricalText(text, maxChunkLength = 700) {
 
 // src/indexer/code-chunker.ts
 import crypto from "crypto";
-import path3 from "path";
+import path4 from "path";
 var DEFAULT_CHUNK_LINES = 80;
 var DEFAULT_OVERLAP_LINES = 8;
 var FUNCTION_CALL_STOP_WORDS = /* @__PURE__ */ new Set([
@@ -790,7 +1219,7 @@ function extractCodeSymbols(text, filePath) {
     const candidate = match[1] ?? "";
     if (!FUNCTION_CALL_STOP_WORDS.has(candidate)) symbols.push(candidate);
   }
-  const basename = path3.basename(filePath).replace(/\.[^.]+$/, "");
+  const basename = path4.basename(filePath).replace(/\.[^.]+$/, "");
   if (/^[A-Za-z_$][\w$-]*$/.test(basename)) symbols.push(basename);
   return uniqueStrings(symbols).slice(0, 40);
 }
@@ -829,8 +1258,8 @@ function chunkCodeFile(file, options = {}) {
 // src/indexer/code-file-discovery.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import crypto2 from "crypto";
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 var DEFAULT_MAX_CODE_FILE_BYTES = 512 * 1024;
 var HARD_EXCLUDED_SEGMENTS = /* @__PURE__ */ new Set([
   ".git",
@@ -878,7 +1307,7 @@ function isHardExcludedCodePath(filePath) {
   const normalized = normalizeGitPath(filePath);
   const segments = normalized.split("/");
   if (segments.some((segment) => HARD_EXCLUDED_SEGMENTS.has(segment))) return true;
-  const basename = path4.posix.basename(normalized).toLowerCase();
+  const basename = path5.posix.basename(normalized).toLowerCase();
   if ([".netrc", ".npmrc", ".pypirc", ".yarnrc"].includes(basename)) return true;
   if (basename === ".env" || basename.startsWith(".env.")) return true;
   if (basename === "id_rsa" || basename === "id_rsa.pub" || basename === "id_dsa" || basename === "id_ecdsa" || basename === "id_ed25519") {
@@ -888,7 +1317,7 @@ function isHardExcludedCodePath(filePath) {
   return false;
 }
 function languageForPath(filePath) {
-  const extension = path4.extname(filePath).toLowerCase();
+  const extension = path5.extname(filePath).toLowerCase();
   return LANGUAGE_BY_EXTENSION[extension];
 }
 function isProbablyBinary(buffer) {
@@ -911,7 +1340,7 @@ function discoverGitFiles(cwd) {
 }
 function discoverCodeFiles(cwd, repo, options = {}) {
   const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_CODE_FILE_BYTES;
-  const rootPath = path4.resolve(cwd);
+  const rootPath = path5.resolve(cwd);
   const files = [];
   let skippedFiles = 0;
   for (const filePath of discoverGitFiles(cwd)) {
@@ -919,15 +1348,15 @@ function discoverCodeFiles(cwd, repo, options = {}) {
       skippedFiles += 1;
       continue;
     }
-    const absolutePath = path4.resolve(cwd, filePath);
-    const relativeToRoot = path4.relative(rootPath, absolutePath);
-    if (relativeToRoot.startsWith("..") || path4.isAbsolute(relativeToRoot)) {
+    const absolutePath = path5.resolve(cwd, filePath);
+    const relativeToRoot = path5.relative(rootPath, absolutePath);
+    if (relativeToRoot.startsWith("..") || path5.isAbsolute(relativeToRoot)) {
       skippedFiles += 1;
       continue;
     }
     let stat;
     try {
-      stat = fs3.statSync(absolutePath);
+      stat = fs4.statSync(absolutePath);
     } catch {
       skippedFiles += 1;
       continue;
@@ -936,7 +1365,7 @@ function discoverCodeFiles(cwd, repo, options = {}) {
       skippedFiles += 1;
       continue;
     }
-    const buffer = fs3.readFileSync(absolutePath);
+    const buffer = fs4.readFileSync(absolutePath);
     if (isProbablyBinary(buffer)) {
       skippedFiles += 1;
       continue;
@@ -1008,7 +1437,7 @@ function emptyCodeIndexSummary(cwd) {
 
 // src/indexer/wisdom-extractor.ts
 import crypto3 from "crypto";
-import path5 from "path";
+import path6 from "path";
 var CATEGORY_KEYWORDS = [
   ["security_note", /\b(security|secret|token|bearer|oauth|credential|xss|csrf|injection|sanitize|redact)\b/i],
   ["architecture_decision", /\b(architecture decision|architectural|we intentionally|design decision)\b/i],
@@ -1040,7 +1469,7 @@ function extractSymbols(text, filePaths) {
     }
   }
   for (const filePath of filePaths) {
-    const basename = path5.basename(filePath).replace(/\.[^.]+$/, "");
+    const basename = path6.basename(filePath).replace(/\.[^.]+$/, "");
     if (/^[A-Za-z_$][\w$]*$/.test(basename)) symbols.push(basename);
   }
   return uniqueStrings(symbols).slice(0, 30);
@@ -1242,7 +1671,11 @@ function indexPullRequests(db, pullRequests, options) {
     });
   }
   if (options.updateSyncStateAfter !== false) {
-    updateSyncState(db, options.repo, lastPr);
+    updateSyncState(db, options.repo, lastPr, {
+      historyCoverage: options.historyCoverage,
+      historyLimit: options.historyLimit,
+      historySince: options.historySince
+    });
   }
   return {
     indexedPrs: pullRequests.length - skippedItems,
@@ -1260,7 +1693,7 @@ function shouldSyncSince(db, repo, fallbackSince) {
 }
 
 // src/retrieval/query-builder.ts
-import path6 from "path";
+import path7 from "path";
 var CATEGORY_HINTS = [
   "security",
   "regression",
@@ -1285,8 +1718,8 @@ function buildFtsQuery(input) {
   const baseText = "task" in input ? input.task : input.query;
   const fileTerms = files.flatMap((file) => [
     file,
-    path6.basename(file),
-    ...path6.dirname(file).split(/[\\/]/).filter(Boolean)
+    path7.basename(file),
+    ...path7.dirname(file).split(/[\\/]/).filter(Boolean)
   ]);
   const tokens = uniqueStrings([
     ...tokenizeSearchText(baseText, 24),
@@ -1305,8 +1738,8 @@ function clampMaxResults(value, defaultValue) {
 }
 
 // src/retrieval/ranker.ts
-import path7 from "path";
-function parseJsonArray(value) {
+import path8 from "path";
+function parseJsonArray2(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -1324,9 +1757,9 @@ function rowToWisdomUnit(row) {
     category: row.category,
     text: row.text,
     sanitizedText: row.sanitized_text,
-    filePaths: parseJsonArray(row.file_paths_json),
-    symbols: parseJsonArray(row.symbols_json),
-    authors: parseJsonArray(row.authors_json),
+    filePaths: parseJsonArray2(row.file_paths_json),
+    symbols: parseJsonArray2(row.symbols_json),
+    authors: parseJsonArray2(row.authors_json),
     createdAt: row.created_at,
     mergedAt: row.merged_at ?? void 0,
     confidence: row.confidence,
@@ -1352,17 +1785,18 @@ function filePathMatch(unitPaths, queryFiles) {
   if (queryFiles.length === 0 || unitPaths.length === 0) return 0;
   let best = 0;
   for (const queryFile of queryFiles) {
-    const queryBase = path7.basename(queryFile).toLowerCase();
-    const queryDir = path7.dirname(queryFile).toLowerCase();
+    const queryBase = path8.basename(queryFile).toLowerCase();
+    const queryDir = path8.dirname(queryFile).toLowerCase();
     for (const unitPath of unitPaths) {
-      const unitBase = path7.basename(unitPath).toLowerCase();
-      const unitDir = path7.dirname(unitPath).toLowerCase();
+      const unitBase = path8.basename(unitPath).toLowerCase();
+      const unitDir = path8.dirname(unitPath).toLowerCase();
       const q = queryFile.toLowerCase();
       const u = unitPath.toLowerCase();
       if (q === u) best = Math.max(best, 1);
       else if (queryBase === unitBase) best = Math.max(best, 0.68);
       else if (queryDir === unitDir) best = Math.max(best, 0.62);
-      else if (unitDir.startsWith(queryDir) || queryDir.startsWith(unitDir)) best = Math.max(best, 0.38);
+      else if (unitDir.startsWith(queryDir) || queryDir.startsWith(unitDir))
+        best = Math.max(best, 0.38);
       else if (queryBase && unitBase && queryBase.split(".")[0] === unitBase.split(".")[0]) {
         best = Math.max(best, 0.48);
       }
@@ -1370,7 +1804,7 @@ function filePathMatch(unitPaths, queryFiles) {
   }
   return best;
 }
-function symbolMatch(unit, querySymbols) {
+function symbolMatch2(unit, querySymbols) {
   if (querySymbols.length === 0) return 0;
   const unitSymbols = unit.symbols.map((symbol) => symbol.toLowerCase());
   const text = unit.sanitizedText.toLowerCase();
@@ -1379,14 +1813,15 @@ function symbolMatch(unit, querySymbols) {
     const lower = symbol.toLowerCase();
     if (unitSymbols.includes(lower)) best = Math.max(best, 1);
     else if (text.includes(`\`${lower}\``)) best = Math.max(best, 1);
-    else if (new RegExp(`\\b${escapeRegExp(lower)}\\b`, "i").test(text)) best = Math.max(best, 0.66);
+    else if (new RegExp(`\\b${escapeRegExp(lower)}\\b`, "i").test(text))
+      best = Math.max(best, 0.66);
     else if (unitSymbols.some((candidate) => candidate.includes(lower) || lower.includes(candidate))) {
       best = Math.max(best, 0.35);
     }
   }
   return best;
 }
-function textMatch(unit, inputText) {
+function textMatch2(unit, inputText) {
   const queryTokens = tokenizeSearchText(inputText, 32);
   if (queryTokens.length === 0) return unit.bm25 === void 0 ? 0 : 0.45;
   const haystack = `${unit.sanitizedText} ${unit.filePaths.join(" ")} ${unit.symbols.join(" ")}`.toLowerCase();
@@ -1410,25 +1845,38 @@ function recencyScore(unit) {
   if (ageDays < 1460) return 0.45;
   return 0.25;
 }
-function scoreUnit(unit, input, duplicateCount) {
+function freshnessMultiplier(status) {
+  if (status === "current") return 1;
+  if (status === "possibly_stale") return 0.85;
+  return 0.55;
+}
+function scoreUnit(unit, input, duplicateCount, repeatedEvidenceCount, freshness) {
   const queryFiles = input.files ?? [];
   const querySymbols = "symbols" in input ? input.symbols ?? [] : [];
   const inputText = "task" in input ? `${input.task} ${input.diff ?? ""} ${input.currentCode ?? ""}` : input.query;
-  const repetition = Math.min(1, duplicateCount / 3);
+  const repetition = Math.min(1, Math.max(duplicateCount, repeatedEvidenceCount) / 3);
+  const claimKey = claimKeyFor(unit.category, unit.sanitizedText);
   const parts = {
     filePathMatch: filePathMatch(unit.filePaths, queryFiles),
-    symbolMatch: symbolMatch(unit, querySymbols),
-    textMatch: textMatch(unit, inputText),
+    symbolMatch: symbolMatch2(unit, querySymbols),
+    textMatch: textMatch2(unit, inputText),
     reviewerOrAuthorSignal: reviewerOrAuthorSignal(unit),
     recencyOrRepetition: Math.max(recencyScore(unit), repetition),
     categoryPriority: categoryPriority(unit.category)
   };
-  const score = 0.35 * parts.filePathMatch + 0.2 * parts.symbolMatch + 0.2 * parts.textMatch + 0.1 * parts.reviewerOrAuthorSignal + 0.1 * parts.recencyOrRepetition + 0.05 * parts.categoryPriority;
+  const score = (0.35 * parts.filePathMatch + 0.2 * parts.symbolMatch + 0.2 * parts.textMatch + 0.1 * parts.reviewerOrAuthorSignal + 0.1 * parts.recencyOrRepetition + 0.05 * parts.categoryPriority) * freshnessMultiplier(freshness.status);
   return {
     ...unit,
     score: Number(score.toFixed(4)),
     scoreParts: parts,
-    duplicateCount
+    duplicateCount,
+    claimKey,
+    repeatedEvidenceCount,
+    confidenceLevel: confidenceLevelFor(unit.confidence),
+    confidenceReasons: confidenceReasonsFor(unit, repeatedEvidenceCount),
+    freshnessStatus: freshness.status,
+    freshnessReason: freshness.reason,
+    evidence: evidenceForWisdom(unit)
   };
 }
 function escapeRegExp(value) {
@@ -1458,20 +1906,48 @@ function loadCandidates(db, input) {
   ).all(...categories);
   return rows.map(rowToWisdomUnit);
 }
+function loadClaimRepetitionCounts(db) {
+  const rows = db.prepare("SELECT category, sanitized_text, pr_number FROM wisdom_units").all();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = claimKeyFor(row.category, row.sanitized_text);
+    const prs = grouped.get(key) ?? /* @__PURE__ */ new Set();
+    prs.add(row.pr_number);
+    grouped.set(key, prs);
+  }
+  return new Map([...grouped.entries()].map(([key, prs]) => [key, prs.size]));
+}
+function minConfidence(input) {
+  if ("minConfidence" in input && input.minConfidence) return input.minConfidence;
+  return "strong";
+}
+function passesStrictMode2(unit, input) {
+  if (!("strict" in input) || !input.strict) return true;
+  if (unit.freshnessStatus === "stale") return false;
+  return confidenceAtLeast(unit.confidenceLevel, minConfidence(input));
+}
 function rankWisdomUnits(db, input) {
   const candidates = loadCandidates(db, input);
+  const codeSnapshot = loadCurrentCodeSnapshot(db);
+  const repetitionCounts = loadClaimRepetitionCounts(db);
   const duplicates = /* @__PURE__ */ new Map();
   for (const unit of candidates) {
-    const key = `${unit.category}:${canonicalizeText(unit.sanitizedText).slice(0, 180)}`;
+    const key = claimKeyFor(unit.category, unit.sanitizedText);
     duplicates.set(key, (duplicates.get(key) ?? 0) + 1);
   }
   const ranked = candidates.map((unit) => {
-    const key = `${unit.category}:${canonicalizeText(unit.sanitizedText).slice(0, 180)}`;
-    return scoreUnit(unit, input, duplicates.get(key) ?? 1);
-  }).sort((a, b) => b.score - a.score || b.confidence - a.confidence);
+    const key = claimKeyFor(unit.category, unit.sanitizedText);
+    return scoreUnit(
+      unit,
+      input,
+      duplicates.get(key) ?? 1,
+      repetitionCounts.get(key) ?? 1,
+      evaluateFreshness(unit, codeSnapshot)
+    );
+  }).filter((unit) => passesStrictMode2(unit, input)).sort((a, b) => b.score - a.score || b.confidence - a.confidence);
   const grouped = /* @__PURE__ */ new Map();
   for (const unit of ranked) {
-    const key = `${unit.category}:${canonicalizeText(unit.sanitizedText).slice(0, 180)}`;
+    const key = unit.claimKey;
     const existing = grouped.get(key);
     if (!existing || unit.score > existing.score) {
       grouped.set(key, {
@@ -1479,7 +1955,11 @@ function rankWisdomUnits(db, input) {
         filePaths: uniqueStrings([...existing?.filePaths ?? [], ...unit.filePaths]),
         symbols: uniqueStrings([...existing?.symbols ?? [], ...unit.symbols]),
         authors: uniqueStrings([...existing?.authors ?? [], ...unit.authors]),
-        duplicateCount: Math.max(unit.duplicateCount, existing?.duplicateCount ?? 1)
+        duplicateCount: Math.max(unit.duplicateCount, existing?.duplicateCount ?? 1),
+        repeatedEvidenceCount: Math.max(
+          unit.repeatedEvidenceCount,
+          existing?.repeatedEvidenceCount ?? 1
+        )
       });
     }
   }
@@ -1488,8 +1968,8 @@ function rankWisdomUnits(db, input) {
 }
 
 // src/retrieval/code-ranker.ts
-import path8 from "path";
-function parseJsonArray2(value) {
+import path9 from "path";
+function parseJsonArray3(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -1506,7 +1986,7 @@ function rowToCodeChunk(row) {
     startLine: row.start_line,
     endLine: row.end_line,
     sanitizedText: row.sanitized_text,
-    symbols: parseJsonArray2(row.symbols_json),
+    symbols: parseJsonArray3(row.symbols_json),
     contentHash: row.content_hash,
     updatedAt: row.updated_at,
     bm25: row.bm25 ?? void 0
@@ -1515,13 +1995,13 @@ function rowToCodeChunk(row) {
 function filePathMatch2(filePath, queryFiles) {
   if (queryFiles.length === 0) return 0;
   let best = 0;
-  const unitBase = path8.basename(filePath).toLowerCase();
-  const unitDir = path8.dirname(filePath).toLowerCase();
+  const unitBase = path9.basename(filePath).toLowerCase();
+  const unitDir = path9.dirname(filePath).toLowerCase();
   const unit = filePath.toLowerCase();
   for (const queryFile of queryFiles) {
     const query = queryFile.toLowerCase();
-    const queryBase = path8.basename(queryFile).toLowerCase();
-    const queryDir = path8.dirname(queryFile).toLowerCase();
+    const queryBase = path9.basename(queryFile).toLowerCase();
+    const queryDir = path9.dirname(queryFile).toLowerCase();
     if (query === unit) best = Math.max(best, 1);
     else if (queryBase === unitBase) best = Math.max(best, 0.72);
     else if (queryDir === unitDir) best = Math.max(best, 0.62);
@@ -1533,7 +2013,7 @@ function filePathMatch2(filePath, queryFiles) {
   }
   return best;
 }
-function symbolMatch2(chunk, querySymbols) {
+function symbolMatch3(chunk, querySymbols) {
   if (querySymbols.length === 0) return 0;
   const chunkSymbols = chunk.symbols.map((symbol) => symbol.toLowerCase());
   const text = chunk.sanitizedText.toLowerCase();
@@ -1548,7 +2028,7 @@ function symbolMatch2(chunk, querySymbols) {
   }
   return best;
 }
-function textMatch2(chunk, input) {
+function textMatch3(chunk, input) {
   const tokens = tokenizeSearchText(
     `${input.task} ${input.diff ?? ""} ${input.currentCode ?? ""}`,
     40
@@ -1591,7 +2071,7 @@ function loadCodeCandidates(db, input) {
     }
   }
   for (const file of input.files ?? []) {
-    const basename = path8.basename(file);
+    const basename = path9.basename(file);
     const rows = db.prepare(
       `SELECT cc.*, NULL AS bm25
          FROM code_chunks cc
@@ -1624,8 +2104,8 @@ function rankCodeChunks(db, input) {
   const ranked = loadCodeCandidates(db, input).map((chunk) => {
     const parts = {
       filePathMatch: filePathMatch2(chunk.filePath, queryFiles),
-      symbolMatch: symbolMatch2(chunk, querySymbols),
-      textMatch: textMatch2(chunk, input),
+      symbolMatch: symbolMatch3(chunk, querySymbols),
+      textMatch: textMatch3(chunk, input),
       recency: recencyScore2(chunk)
     };
     const score = 0.4 * parts.filePathMatch + 0.25 * parts.symbolMatch + 0.25 * parts.textMatch + 0.1 * parts.recency;
@@ -1646,8 +2126,15 @@ function evidenceLine(unit) {
   const file = unit.filePaths[0] ? `, ${unit.filePaths[0]}` : "";
   return `PR #${unit.prNumber}${author}, ${unit.sourceType}${file}`;
 }
+function confidenceLine(unit) {
+  const reasons = unit.confidenceReasons.length ? ` (${unit.confidenceReasons.join(", ")})` : "";
+  return `${unit.confidenceLevel}${reasons}`;
+}
+function currentCodeCheckLine(unit) {
+  return `${unit.freshnessStatus.replace(/_/g, " ")} - ${unit.freshnessReason}`;
+}
 function whyItMatters(unit, input) {
-  const prefix = unit.confidence < 0.7 ? "Historical evidence suggests " : "";
+  const prefix = unit.confidenceLevel === "weak" ? "Historical evidence suggests " : "";
   const target = input.files?.[0] ? ` when editing ${input.files[0]}` : " for this change";
   const categoryReasons = {
     security_note: `${prefix}there is a security-sensitive constraint to preserve${target}.`,
@@ -1679,15 +2166,39 @@ function riskLines(units) {
   }
   return [...risks].slice(0, 4);
 }
-function formatAnchorContext(units, input, codeChunks = []) {
-  const lines = ["# Anchor Context", "", "## Must know", ""];
+function formatAnchorContext(units, input, codeChunks = [], teamRules = [], warnings = []) {
+  const lines = ["# Anchor Context", ""];
+  if (warnings.length > 0) {
+    lines.push("## Warnings", "");
+    for (const warning of warnings) lines.push(`- ${warning}`);
+    lines.push("");
+  }
+  if (teamRules.length > 0) {
+    lines.push("## Team-approved rules", "");
+    teamRules.forEach((rule, index) => {
+      const evidence = rule.evidence[0];
+      const evidenceText = evidence ? `PR #${evidence.prNumber}, ${evidence.sourceType}${evidence.filePath ? `, ${evidence.filePath}` : ""}` : "No evidence";
+      lines.push(`${index + 1}. [${rule.category}] ${clipSentence(rule.sanitizedText)}`);
+      lines.push(`   Evidence: ${evidenceText}`);
+      lines.push(`   Confidence: ${confidenceLine(rule)}`);
+      lines.push(`   Current code check: ${currentCodeCheckLine(rule)}`);
+      if (evidence?.prUrl) lines.push(`   Link: ${evidence.prUrl}`);
+      lines.push("");
+    });
+  }
+  lines.push("## Must know", "");
   if (units.length === 0) {
-    lines.push("No directly relevant indexed PR history found.", "");
+    lines.push(
+      input.strict ? "No reliable historical evidence found." : "No directly relevant indexed PR history found.",
+      ""
+    );
   } else {
     units.forEach((unit, index) => {
-      const statement = unit.confidence < 0.7 ? `Historical evidence suggests ${clipSentence(unit.sanitizedText)}` : clipSentence(unit.sanitizedText);
+      const statement = unit.confidenceLevel === "weak" ? `Historical evidence suggests ${clipSentence(unit.sanitizedText)}` : clipSentence(unit.sanitizedText);
       lines.push(`${index + 1}. [${unit.category}] ${statement}`);
       lines.push(`   Evidence: ${evidenceLine(unit)}`);
+      lines.push(`   Confidence: ${confidenceLine(unit)}`);
+      lines.push(`   Current code check: ${currentCodeCheckLine(unit)}`);
       lines.push(`   Why it matters: ${whyItMatters(unit, input)}`);
       lines.push(`   Link: ${unit.prUrl}`);
       lines.push("");
@@ -1724,6 +2235,13 @@ function formatAnchorContext(units, input, codeChunks = []) {
         id: unit.id,
         score: unit.score,
         confidence: unit.confidence,
+        confidenceLevel: unit.confidenceLevel,
+        confidenceReasons: unit.confidenceReasons,
+        freshnessStatus: unit.freshnessStatus,
+        freshnessReason: unit.freshnessReason,
+        evidence: unit.evidence,
+        claimKey: unit.claimKey,
+        repeatedEvidenceCount: unit.repeatedEvidenceCount,
         category: unit.category,
         prNumber: unit.prNumber,
         prUrl: unit.prUrl,
@@ -1732,6 +2250,18 @@ function formatAnchorContext(units, input, codeChunks = []) {
         symbols: unit.symbols,
         duplicateCount: unit.duplicateCount
       })),
+      teamRules: teamRules.map((rule) => ({
+        id: rule.id,
+        score: rule.score,
+        confidenceLevel: rule.confidenceLevel,
+        confidenceReasons: rule.confidenceReasons,
+        freshnessStatus: rule.freshnessStatus,
+        freshnessReason: rule.freshnessReason,
+        category: rule.category,
+        filePaths: rule.filePaths,
+        symbols: rule.symbols,
+        evidence: rule.evidence
+      })),
       codeEvidence: codeChunks.map((chunk) => ({
         id: chunk.id,
         score: chunk.score,
@@ -1790,8 +2320,13 @@ function formatIndexStatus(status) {
     `- Wisdom units: ${status.wisdomUnitCount}`,
     `- Code files: ${status.codeFileCount}`,
     `- Code chunks: ${status.codeChunkCount}`,
+    `- History coverage: ${status.historyCoverage ?? "unknown"}`,
+    `- History limit: ${status.historyLimit ?? "n/a"}`,
+    `- Stale evidence: ${status.staleEvidenceCount}`,
+    `- Team rules: ${status.teamRuleCount}`,
     `- Last sync: ${status.lastSyncTime ?? "never"}`,
     `- Last code index: ${status.lastCodeIndexTime ?? "never"}`,
+    `- Last rule index: ${status.lastRuleIndexTime ?? "never"}`,
     `- GitHub token configured: ${status.githubTokenConfigured ? "yes" : "no"}`,
     `- Health: ${status.health}`
   ];
@@ -1987,8 +2522,8 @@ async function fetchMergedPullRequests(options) {
 }
 
 // src/doctor.ts
-import fs4 from "fs";
-import path9 from "path";
+import fs5 from "fs";
+import path10 from "path";
 function check(name, ok, message, fix) {
   return { name, ok, message, fix: ok ? void 0 : fix };
 }
@@ -2049,12 +2584,12 @@ async function runDoctor(options) {
       )
     );
   }
-  const cursorConfigPath = path9.join(gitRoot ?? cwd, ".cursor", "mcp.json");
+  const cursorConfigPath = path10.join(gitRoot ?? cwd, ".cursor", "mcp.json");
   let cursorConfig;
   let cursorConfigValid = false;
-  if (fs4.existsSync(cursorConfigPath)) {
+  if (fs5.existsSync(cursorConfigPath)) {
     try {
-      cursorConfig = JSON.parse(fs4.readFileSync(cursorConfigPath, "utf8"));
+      cursorConfig = JSON.parse(fs5.readFileSync(cursorConfigPath, "utf8"));
       cursorConfigValid = true;
     } catch {
       cursorConfigValid = false;
@@ -2063,7 +2598,7 @@ async function runDoctor(options) {
   checks.push(
     check(
       ".cursor/mcp.json valid",
-      fs4.existsSync(cursorConfigPath) && cursorConfigValid,
+      fs5.existsSync(cursorConfigPath) && cursorConfigValid,
       cursorConfigValid ? ".cursor/mcp.json exists and is valid JSON." : ".cursor/mcp.json is missing or invalid.",
       "Run anchor init. If the file is malformed, fix the JSON and rerun anchor init."
     )
@@ -2080,7 +2615,7 @@ async function runDoctor(options) {
     )
   );
   const dbPath = defaultDatabasePath(gitRoot ?? cwd);
-  const dbExists = fs4.existsSync(dbPath);
+  const dbExists = fs5.existsSync(dbPath);
   checks.push(
     check(
       ".anchor/index.sqlite exists",
@@ -2124,12 +2659,12 @@ async function runDoctor(options) {
       "Run pnpm build, then try anchor serve from the repository."
     )
   );
-  const rulePath = path9.join(gitRoot ?? cwd, ".cursor", "rules", "anchor.mdc");
+  const rulePath = path10.join(gitRoot ?? cwd, ".cursor", "rules", "anchor.mdc");
   checks.push(
     check(
       "Cursor rule file exists",
-      fs4.existsSync(rulePath),
-      fs4.existsSync(rulePath) ? "Cursor rule file exists." : "Cursor rule file is missing.",
+      fs5.existsSync(rulePath),
+      fs5.existsSync(rulePath) ? "Cursor rule file exists." : "Cursor rule file is missing.",
       "Run anchor init to create .cursor/rules/anchor.mdc."
     )
   );
@@ -2139,6 +2674,7 @@ export {
   ANCHOR_CURSOR_RULE,
   DEFAULT_MAX_CODE_FILE_BYTES,
   SCHEMA_SQL,
+  TEAM_RULES_FILE,
   anchorMcpEntry,
   buildFtsQuery,
   canonicalizeText,
@@ -2146,8 +2682,14 @@ export {
   checkSchema,
   chunkCodeFile,
   chunkHistoricalText,
+  claimKeyFor,
   clampMaxResults,
   clipSentence,
+  confidenceAtLeast,
+  confidenceLevelFor,
+  confidenceRank,
+  confidenceReasonsFor,
+  countValidTeamRules,
   createGitHubClient,
   defaultDatabasePath,
   detectGitHubRepo,
@@ -2158,6 +2700,9 @@ export {
   ensureCursorConfig,
   ensureCursorRule,
   ensureRepository,
+  ensureTeamRulesFile,
+  evaluateFreshness,
+  evidenceForWisdom,
   extractCodeSymbols,
   extractSymbols,
   extractWisdomUnits,
@@ -2174,11 +2719,14 @@ export {
   indexPullRequests,
   initializeSchema,
   isHardExcludedCodePath,
+  loadCurrentCodeSnapshot,
+  loadTeamRulesFile,
   mergeAnchorMcpConfig,
   normalizePullRequest,
   openAnchorDatabase,
   parseGitHubRemote,
   rankCodeChunks,
+  rankTeamRules,
   rankWisdomUnits,
   redactSecrets,
   redactedHistoricalText,
@@ -2189,11 +2737,13 @@ export {
   runDoctor,
   sanitizeHistoricalText,
   shouldSyncSince,
+  sourceTypeLabel,
   stripPromptInjection,
   tokenizeSearchText,
   truncateText,
   uniqueStrings,
   updateSyncState,
-  upsertPullRequest
+  upsertPullRequest,
+  validateTeamRulesFile
 };
 //# sourceMappingURL=index.js.map