@pratik7368patil/anchor-core 0.1.11 → 0.1.13

package/dist/index.js

@@ -376,6 +376,61 @@ CREATE TABLE IF NOT EXISTS code_index_state (
   skipped_files INTEGER NOT NULL
 );
 
+CREATE TABLE IF NOT EXISTS code_imports (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  source_path TEXT NOT NULL,
+  specifier TEXT NOT NULL,
+  imported_path TEXT,
+  imported_symbols_json TEXT NOT NULL,
+  kind TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS architecture_components (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  path TEXT NOT NULL,
+  area TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  language TEXT,
+  symbols_json TEXT NOT NULL,
+  imports_json TEXT NOT NULL,
+  related_tests_json TEXT NOT NULL,
+  confidence REAL NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(repo_id, path)
+);
+
+CREATE TABLE IF NOT EXISTS architecture_patterns (
+  id TEXT PRIMARY KEY,
+  repo_id INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  repo TEXT NOT NULL,
+  area TEXT NOT NULL,
+  name TEXT NOT NULL,
+  summary_sanitized TEXT NOT NULL,
+  source_files_json TEXT NOT NULL,
+  symbols_json TEXT NOT NULL,
+  evidence_json TEXT NOT NULL,
+  confidence REAL NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS architecture_patterns_fts USING fts5(
+  patternId UNINDEXED,
+  summary,
+  area,
+  sourceFiles,
+  symbols
+);
+
+CREATE TABLE IF NOT EXISTS architecture_index_state (
+  repo TEXT PRIMARY KEY,
+  last_indexed_at TEXT NOT NULL,
+  components INTEGER NOT NULL,
+  patterns INTEGER NOT NULL,
+  imports INTEGER NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS test_files (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   repo_id INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
@@ -450,6 +505,11 @@ CREATE INDEX IF NOT EXISTS idx_wisdom_units_category ON wisdom_units(category);
 CREATE INDEX IF NOT EXISTS idx_wisdom_units_pr ON wisdom_units(pr_id);
 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);
+CREATE INDEX IF NOT EXISTS idx_code_imports_source ON code_imports(source_path);
+CREATE INDEX IF NOT EXISTS idx_code_imports_imported ON code_imports(imported_path);
+CREATE INDEX IF NOT EXISTS idx_architecture_components_path ON architecture_components(path);
+CREATE INDEX IF NOT EXISTS idx_architecture_components_area ON architecture_components(area);
+CREATE INDEX IF NOT EXISTS idx_architecture_patterns_area ON architecture_patterns(area);
 CREATE INDEX IF NOT EXISTS idx_test_files_path ON test_files(path);
 CREATE INDEX IF NOT EXISTS idx_test_links_source ON test_links(source_path);
 CREATE INDEX IF NOT EXISTS idx_test_links_test ON test_links(test_path);
@@ -1217,6 +1277,12 @@ function calculateCoverage(input) {
   } else {
     reasons.push("No regression memory indexed yet.");
   }
+  if (input.architecturePatternCount > 0) {
+    score += 10;
+    reasons.push(`${input.architecturePatternCount} architecture patterns indexed.`);
+  } else {
+    reasons.push("No architecture patterns indexed yet.");
+  }
   if (input.teamRuleCount > 0) {
     score += 5;
     reasons.push(`${input.teamRuleCount} team-approved rules available.`);
@@ -1267,7 +1333,9 @@ function checkSchema(db) {
     const code = db.prepare("SELECT name FROM sqlite_master WHERE name = ?").all("code_chunks");
     const tests = db.prepare("SELECT name FROM sqlite_master WHERE name = ?").all("test_files");
     const regressions = db.prepare("SELECT name FROM sqlite_master WHERE name = ?").all("regression_events");
-    return tables.length > 0 && wisdom.length > 0 && codeTables.length > 0 && code.length > 0 && tests.length > 0 && regressions.length > 0;
+    const architecture = db.prepare("SELECT name FROM sqlite_master WHERE name = ?").all("architecture_patterns");
+    const architectureFts = db.prepare("SELECT name FROM sqlite_master WHERE type IN ('table', 'virtual') AND name = ?").all("architecture_patterns_fts");
+    return tables.length > 0 && wisdom.length > 0 && codeTables.length > 0 && code.length > 0 && tests.length > 0 && regressions.length > 0 && architecture.length > 0 && architectureFts.length > 0;
   } catch {
     return false;
   }
@@ -1494,7 +1562,7 @@ function upsertPullRequest(db, pr, wisdomUnits, regressionEvents = []) {
     regressions: regressionEvents.length
   };
 }
-function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd) {
+function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, architecture = { components: [], patterns: [], imports: [] }) {
   initializeSchema(db);
   const repoId = ensureRepository(db, repo);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1507,6 +1575,7 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd) {
     db.prepare("DELETE FROM code_files WHERE repo_id = ?").run(repoId);
     db.prepare("DELETE FROM test_links WHERE repo_id = ? AND reason != 'PR co-change'").run(repoId);
     db.prepare("DELETE FROM test_files WHERE repo_id = ?").run(repoId);
+    deleteExistingArchitectureData(db, repoId);
     const insertFile = db.prepare(
       `INSERT INTO code_files
        (repo_id, path, language, size_bytes, content_hash, updated_at)
@@ -1561,6 +1630,7 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd) {
       );
     }
     insertTestAwareness(db, repoId, testAwareness.testFiles, testAwareness.testLinks);
+    insertArchitectureData(db, repoId, architecture);
     db.prepare(
       `INSERT INTO code_index_state (repo, last_indexed_at, indexed_files, code_chunks, skipped_files)
        VALUES (?, ?, ?, ?, ?)
@@ -1570,6 +1640,21 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd) {
          code_chunks = excluded.code_chunks,
          skipped_files = excluded.skipped_files`
     ).run(repo, now, codeFiles.length, codeChunks.length, skippedFiles);
+    db.prepare(
+      `INSERT INTO architecture_index_state (repo, last_indexed_at, components, patterns, imports)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(repo) DO UPDATE SET
+         last_indexed_at = excluded.last_indexed_at,
+         components = excluded.components,
+         patterns = excluded.patterns,
+         imports = excluded.imports`
+    ).run(
+      repo,
+      now,
+      architecture.components.length,
+      architecture.patterns.length,
+      architecture.imports.length
+    );
   });
   transaction();
   return {
@@ -1577,10 +1662,90 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd) {
     codeChunksCreated: codeChunks.length,
     testFilesIndexed: testAwareness.testFiles.length,
     testLinksCreated: testAwareness.testLinks.length,
+    architectureComponentsIndexed: architecture.components.length,
+    architecturePatternsIndexed: architecture.patterns.length,
+    architectureImportsIndexed: architecture.imports.length,
     skippedFiles,
     databasePath: defaultDatabasePath(cwd)
   };
 }
+function deleteExistingArchitectureData(db, repoId) {
+  const patternRows = db.prepare("SELECT id FROM architecture_patterns WHERE repo_id = ?").all(repoId);
+  const deleteFts = db.prepare("DELETE FROM architecture_patterns_fts WHERE patternId = ?");
+  for (const row of patternRows) deleteFts.run(row.id);
+  db.prepare("DELETE FROM architecture_patterns WHERE repo_id = ?").run(repoId);
+  db.prepare("DELETE FROM architecture_components WHERE repo_id = ?").run(repoId);
+  db.prepare("DELETE FROM code_imports WHERE repo_id = ?").run(repoId);
+}
+function insertArchitectureData(db, repoId, architecture) {
+  const insertImport = db.prepare(
+    `INSERT INTO code_imports
+     (repo_id, source_path, specifier, imported_path, imported_symbols_json, kind)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  );
+  for (const item of architecture.imports) {
+    insertImport.run(
+      repoId,
+      item.sourcePath,
+      item.specifier,
+      item.importedPath ?? null,
+      JSON.stringify(item.importedSymbols),
+      item.kind
+    );
+  }
+  const insertComponent = db.prepare(
+    `INSERT INTO architecture_components
+     (repo_id, path, area, kind, language, symbols_json, imports_json, related_tests_json,
+      confidence, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  for (const component of architecture.components) {
+    insertComponent.run(
+      repoId,
+      component.path,
+      component.area,
+      component.kind,
+      component.language ?? null,
+      JSON.stringify(component.symbols),
+      JSON.stringify(component.imports),
+      JSON.stringify(component.relatedTests),
+      component.confidence,
+      component.updatedAt
+    );
+  }
+  const insertPattern = db.prepare(
+    `INSERT INTO architecture_patterns
+     (id, repo_id, repo, area, name, summary_sanitized, source_files_json, symbols_json,
+      evidence_json, confidence, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const insertFts = db.prepare(
+    `INSERT INTO architecture_patterns_fts (patternId, summary, area, sourceFiles, symbols)
+     VALUES (?, ?, ?, ?, ?)`
+  );
+  for (const pattern of architecture.patterns) {
+    insertPattern.run(
+      pattern.id,
+      repoId,
+      pattern.repo,
+      pattern.area,
+      pattern.name,
+      pattern.sanitizedSummary,
+      JSON.stringify(pattern.sourceFiles),
+      JSON.stringify(pattern.symbols),
+      JSON.stringify(pattern.evidence),
+      pattern.confidence,
+      pattern.createdAt
+    );
+    insertFts.run(
+      pattern.id,
+      pattern.sanitizedSummary,
+      pattern.area,
+      pattern.sourceFiles.join(" "),
+      pattern.symbols.join(" ")
+    );
+  }
+}
 function insertPrCochangeTestLinks(db, repoId, filePaths) {
   const testPaths = filePaths.filter(isTestFilePath);
   const sourcePaths = filePaths.filter((filePath) => !isTestFilePath(filePath));
@@ -1649,6 +1814,7 @@ function withCoverage(status) {
     codeChunkCount: status.codeChunkCount,
     testLinkCount: status.testLinkCount,
     regressionEventCount: status.regressionEventCount,
+    architecturePatternCount: status.architecturePatternCount,
     teamRuleCount: status.teamRuleCount,
     historyCoverage: status.historyCoverage,
     staleEvidenceCount: status.staleEvidenceCount,
@@ -1670,6 +1836,9 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
       testFileCount: 0,
       testLinkCount: 0,
       regressionEventCount: 0,
+      architectureComponentCount: 0,
+      architecturePatternCount: 0,
+      architectureImportCount: 0,
       historyCoverage: "unknown",
       staleEvidenceCount: 0,
       teamRuleCount: rules.count,
@@ -1695,6 +1864,9 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
         testFileCount: 0,
         testLinkCount: 0,
         regressionEventCount: 0,
+        architectureComponentCount: 0,
+        architecturePatternCount: 0,
+        architectureImportCount: 0,
         historyCoverage: "unknown",
         staleEvidenceCount: 0,
         teamRuleCount: rules2.count,
@@ -1710,6 +1882,9 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
       "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 architectureIndexRow = db.prepare(
+      "SELECT last_indexed_at FROM architecture_index_state ORDER BY last_indexed_at DESC LIMIT 1"
+    ).get();
     const wisdomUnitCount = count("wisdom_units");
     const codeChunkCount = count("code_chunks");
     const lastSuccessfulRun = db.prepare(
@@ -1733,12 +1908,16 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
       testFileCount: count("test_files"),
       testLinkCount: count("test_links"),
       regressionEventCount: count("regression_events"),
+      architectureComponentCount: count("architecture_components"),
+      architecturePatternCount: count("architecture_patterns"),
+      architectureImportCount: count("code_imports"),
       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,
+      lastArchitectureIndexTime: architectureIndexRow?.last_indexed_at ?? void 0,
       lastRuleIndexTime: rules.lastRuleIndexTime,
       lastSuccessfulRun: lastSuccessfulRun?.finished_at ?? void 0,
       lastFailedRun: lastFailedRun?.finished_at ?? void 0,
@@ -1903,11 +2082,269 @@ function chunkCodeFile(file, options = {}) {
   return chunks;
 }
 
+// src/indexer/architecture-indexer.ts
+import crypto2 from "crypto";
+import path6 from "path";
+var KNOWN_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+function classifyArchitectureArea(filePath, language, content = "") {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  const basename = path6.basename(normalized);
+  if (isTestFilePath(normalized)) return "test";
+  if (/\b(route|routes|router|pages|app)\b/.test(normalized) || basename === "route.ts") {
+    return "route";
+  }
+  if (/\/(api|apis)\//.test(normalized) || /\b(api|client|request|graphql|rest)\b/.test(basename)) {
+    return "api";
+  }
+  if (/\/(services?|clients?|repositories?)\//.test(normalized)) return "service";
+  if (/\/(hooks?)\//.test(normalized) || /^use[A-Z]/.test(path6.basename(filePath))) return "hook";
+  if (/\/(components?|ui)\//.test(normalized) || language === "tsx" || /\bjsx?\b/.test(language ?? "")) {
+    return "component";
+  }
+  if (/\/(stores?|state|redux|zustand)\//.test(normalized)) return "store";
+  if (/\/(schemas?|validation|validators?)\//.test(normalized) || /\b(schema|zod)\b/.test(content)) {
+    return "schema";
+  }
+  if (/\/(types?|interfaces?|models?)\//.test(normalized) || normalized.endsWith(".d.ts")) {
+    return "type";
+  }
+  if (/\/(configs?|settings)\//.test(normalized) || /\b(config|rc)\b/.test(basename)) {
+    return "config";
+  }
+  if (/\/(utils?|helpers?|lib)\//.test(normalized)) return "util";
+  return "unknown";
+}
+function stablePatternId(repo, area, name, sourceFiles) {
+  const hash = crypto2.createHash("sha256").update([repo, area, name, ...sourceFiles].join("\0")).digest("hex").slice(0, 24);
+  return `ap_${hash}`;
+}
+function parseImportedSymbols(importClause) {
+  const symbols = [];
+  const named = importClause.match(/\{([^}]+)\}/)?.[1];
+  if (named) {
+    for (const item of named.split(",")) {
+      const symbol = item.trim().split(/\s+as\s+/i)[0]?.trim();
+      if (symbol) symbols.push(symbol);
+    }
+  }
+  const defaultImport = importClause.replace(/\{[^}]+\}/g, "").split(",")[0]?.trim().replace(/^type\s+/, "");
+  if (defaultImport && /^[A-Za-z_$][\w$]*$/.test(defaultImport)) symbols.push(defaultImport);
+  return uniqueStrings(symbols).slice(0, 20);
+}
+function resolveRelativeImport(sourcePath, specifier, codePaths) {
+  if (!specifier.startsWith(".")) return void 0;
+  const sourceDir = path6.posix.dirname(sourcePath.replace(/\\/g, "/"));
+  const base = path6.posix.normalize(path6.posix.join(sourceDir, specifier));
+  const candidates = [
+    base,
+    ...KNOWN_EXTENSIONS.map((extension) => `${base}${extension}`),
+    ...KNOWN_EXTENSIONS.map((extension) => path6.posix.join(base, `index${extension}`))
+  ];
+  return candidates.find((candidate) => codePaths.has(candidate));
+}
+function extractCodeImports(sourcePath, content, codePaths, repo = "") {
+  const imports = [];
+  const staticImports = content.matchAll(
+    /import\s+(?:type\s+)?([\s\S]*?)\s+from\s+["']([^"']+)["']/g
+  );
+  for (const match of staticImports) {
+    const importClause = match[1] ?? "";
+    const specifier = match[2] ?? "";
+    const sanitizedSpecifier = sanitizeHistoricalText(specifier);
+    imports.push({
+      repo,
+      sourcePath,
+      specifier: sanitizedSpecifier,
+      importedPath: resolveRelativeImport(sourcePath, specifier, codePaths),
+      importedSymbols: parseImportedSymbols(importClause),
+      kind: "static"
+    });
+  }
+  const dynamicImports = content.matchAll(/import\s*\(\s*["']([^"']+)["']\s*\)/g);
+  for (const match of dynamicImports) {
+    const specifier = match[1] ?? "";
+    const sanitizedSpecifier = sanitizeHistoricalText(specifier);
+    imports.push({
+      repo,
+      sourcePath,
+      specifier: sanitizedSpecifier,
+      importedPath: resolveRelativeImport(sourcePath, specifier, codePaths),
+      importedSymbols: [],
+      kind: "dynamic"
+    });
+  }
+  const requireImports = content.matchAll(/require\s*\(\s*["']([^"']+)["']\s*\)/g);
+  for (const match of requireImports) {
+    const specifier = match[1] ?? "";
+    const sanitizedSpecifier = sanitizeHistoricalText(specifier);
+    imports.push({
+      repo,
+      sourcePath,
+      specifier: sanitizedSpecifier,
+      importedPath: resolveRelativeImport(sourcePath, specifier, codePaths),
+      importedSymbols: [],
+      kind: "require"
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return imports.filter((item) => {
+    const key = `${item.sourcePath}:${item.specifier}:${item.kind}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function relatedTestsFor(filePath, allPaths) {
+  if (isTestFilePath(filePath)) return [];
+  const parsed = path6.posix.parse(filePath);
+  const basename = parsed.name.replace(/\.(test|spec)$/i, "");
+  return allPaths.filter((candidate) => isTestFilePath(candidate)).filter((candidate) => {
+    const candidateParsed = path6.posix.parse(candidate);
+    const candidateBase = candidateParsed.name.replace(/\.(test|spec)$/i, "");
+    return candidateBase === basename || candidate.startsWith(`${parsed.dir}/`) || candidate.includes(`/${basename}.`);
+  }).slice(0, 8);
+}
+function directoryLabel(filePath) {
+  const directory = path6.posix.dirname(filePath.replace(/\\/g, "/"));
+  return directory === "." ? "repo root" : directory;
+}
+function topDirectories(files) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const directory = directoryLabel(file);
+    counts.set(directory, (counts.get(directory) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 4).map(([directory]) => directory);
+}
+function createPattern(input) {
+  const sourceFiles = uniqueStrings(input.sourceFiles).slice(0, 12);
+  const sanitizedSummary = sanitizeHistoricalText(input.summary);
+  return {
+    id: stablePatternId(input.repo, input.area, input.name, sourceFiles),
+    repo: input.repo,
+    area: input.area,
+    name: input.name,
+    summary: sanitizedSummary,
+    sanitizedSummary,
+    sourceFiles,
+    symbols: uniqueStrings(input.symbols).slice(0, 30),
+    evidence: [],
+    confidence: Number(Math.min(0.95, Math.max(0.35, input.confidence)).toFixed(2)),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildArchitectureIndex(repo, files, chunks) {
+  const allPaths = files.map((file) => file.path);
+  const codePaths = new Set(allPaths);
+  const symbolsByPath = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    const existing = symbolsByPath.get(chunk.filePath) ?? [];
+    symbolsByPath.set(chunk.filePath, uniqueStrings([...existing, ...chunk.symbols]).slice(0, 40));
+  }
+  const imports = files.flatMap(
+    (file) => extractCodeImports(file.path, file.content, codePaths, repo)
+  );
+  const importsByPath = /* @__PURE__ */ new Map();
+  for (const item of imports) {
+    const existing = importsByPath.get(item.sourcePath) ?? [];
+    existing.push(item);
+    importsByPath.set(item.sourcePath, existing);
+  }
+  const components = files.map((file) => {
+    const area = classifyArchitectureArea(file.path, file.language, file.content);
+    const fileImports = importsByPath.get(file.path) ?? [];
+    const symbols = symbolsByPath.get(file.path) ?? [];
+    return {
+      repo,
+      path: file.path,
+      area,
+      kind: area,
+      language: file.language,
+      symbols,
+      imports: uniqueStrings(
+        fileImports.map((item) => item.importedPath ?? item.specifier).filter(Boolean)
+      ).slice(0, 20),
+      relatedTests: relatedTestsFor(file.path, allPaths),
+      confidence: area === "unknown" ? 0.45 : 0.82,
+      updatedAt: file.updatedAt
+    };
+  });
+  const componentByPath = new Map(components.map((component) => [component.path, component]));
+  const patterns = [];
+  const componentsByArea = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    const existing = componentsByArea.get(component.area) ?? [];
+    existing.push(component);
+    componentsByArea.set(component.area, existing);
+  }
+  for (const [area, areaComponents] of componentsByArea.entries()) {
+    const filesForArea = areaComponents.map((component) => component.path);
+    const directories = topDirectories(filesForArea);
+    const symbols = areaComponents.flatMap((component) => component.symbols);
+    patterns.push(
+      createPattern({
+        repo,
+        area,
+        name: `${area} area placement`,
+        summary: `${area} code is represented by ${filesForArea.length} file(s), commonly under ${directories.join(", ")}. Use these files as current architecture evidence before adding or changing similar code.`,
+        sourceFiles: filesForArea,
+        symbols,
+        confidence: 0.55 + Math.min(0.3, filesForArea.length * 0.04)
+      })
+    );
+  }
+  const importDirectionCounts = /* @__PURE__ */ new Map();
+  for (const item of imports) {
+    if (!item.importedPath) continue;
+    const source = componentByPath.get(item.sourcePath);
+    const target = componentByPath.get(item.importedPath);
+    if (!source || !target || source.area === target.area) continue;
+    const key = `${source.area}->${target.area}`;
+    const existing = importDirectionCounts.get(key) ?? { count: 0, files: [], symbols: [] };
+    existing.count += 1;
+    existing.files.push(source.path, target.path);
+    existing.symbols.push(...item.importedSymbols);
+    importDirectionCounts.set(key, existing);
+  }
+  for (const [key, value] of importDirectionCounts.entries()) {
+    const [sourceArea, targetArea] = key.split("->");
+    patterns.push(
+      createPattern({
+        repo,
+        area: sourceArea,
+        name: `${sourceArea} imports ${targetArea}`,
+        summary: `${sourceArea} files import ${targetArea} files in ${value.count} observed edge(s). Prefer this direction when adding similar code unless cited repo evidence says otherwise.`,
+        sourceFiles: value.files,
+        symbols: value.symbols,
+        confidence: 0.62 + Math.min(0.25, value.count * 0.05)
+      })
+    );
+  }
+  const testedComponents = components.filter((component) => component.relatedTests.length > 0);
+  if (testedComponents.length > 0) {
+    patterns.push(
+      createPattern({
+        repo,
+        area: "test",
+        name: "source files have nearby tests",
+        summary: `${testedComponents.length} source file(s) have nearby tests. When editing these areas, update or add sibling tests that match the existing placement.`,
+        sourceFiles: testedComponents.flatMap((component) => [
+          component.path,
+          ...component.relatedTests
+        ]),
+        symbols: testedComponents.flatMap((component) => component.symbols),
+        confidence: 0.72
+      })
+    );
+  }
+  return { components, patterns, imports };
+}
+
 // src/indexer/code-file-discovery.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 import fs4 from "fs";
-import path6 from "path";
+import path7 from "path";
 var DEFAULT_MAX_CODE_FILE_BYTES = 512 * 1024;
 var HARD_EXCLUDED_SEGMENTS = /* @__PURE__ */ new Set([
   ".git",
@@ -1955,7 +2392,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 = path6.posix.basename(normalized).toLowerCase();
+  const basename = path7.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") {
@@ -1965,7 +2402,7 @@ function isHardExcludedCodePath(filePath) {
   return false;
 }
 function languageForPath(filePath) {
-  const extension = path6.extname(filePath).toLowerCase();
+  const extension = path7.extname(filePath).toLowerCase();
   return LANGUAGE_BY_EXTENSION[extension];
 }
 function isProbablyBinary(buffer) {
@@ -1988,7 +2425,7 @@ function discoverGitFiles(cwd) {
 }
 function discoverCodeFiles(cwd, repo, options = {}) {
   const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_CODE_FILE_BYTES;
-  const rootPath = path6.resolve(cwd);
+  const rootPath = path7.resolve(cwd);
   const files = [];
   let skippedFiles = 0;
   for (const filePath of discoverGitFiles(cwd)) {
@@ -1996,9 +2433,9 @@ function discoverCodeFiles(cwd, repo, options = {}) {
       skippedFiles += 1;
       continue;
     }
-    const absolutePath = path6.resolve(cwd, filePath);
-    const relativeToRoot = path6.relative(rootPath, absolutePath);
-    if (relativeToRoot.startsWith("..") || path6.isAbsolute(relativeToRoot)) {
+    const absolutePath = path7.resolve(cwd, filePath);
+    const relativeToRoot = path7.relative(rootPath, absolutePath);
+    if (relativeToRoot.startsWith("..") || path7.isAbsolute(relativeToRoot)) {
       skippedFiles += 1;
       continue;
     }
@@ -2024,7 +2461,7 @@ function discoverCodeFiles(cwd, repo, options = {}) {
       path: filePath,
       language: languageForPath(filePath),
       sizeBytes: stat.size,
-      contentHash: crypto2.createHash("sha256").update(buffer).digest("hex"),
+      contentHash: crypto3.createHash("sha256").update(buffer).digest("hex"),
       updatedAt: stat.mtime.toISOString(),
       absolutePath,
       content
@@ -2065,13 +2502,22 @@ function indexCodebase(db, options) {
       chunks: fileChunks.length
     });
   }
+  const architecture = buildArchitectureIndex(options.repo, discovery.files, chunks);
+  options.onProgress?.({
+    stage: "indexed_architecture",
+    repo: options.repo,
+    components: architecture.components.length,
+    patterns: architecture.patterns.length,
+    imports: architecture.imports.length
+  });
   return replaceCodeIndex(
     db,
     options.repo,
     discovery.files.map(({ content: _content, absolutePath: _absolutePath, ...file }) => file),
     chunks,
     discovery.skippedFiles,
-    options.cwd
+    options.cwd,
+    architecture
   );
 }
 function emptyCodeIndexSummary(cwd) {
@@ -2080,17 +2526,20 @@ function emptyCodeIndexSummary(cwd) {
     codeChunksCreated: 0,
     testFilesIndexed: 0,
     testLinksCreated: 0,
+    architectureComponentsIndexed: 0,
+    architecturePatternsIndexed: 0,
+    architectureImportsIndexed: 0,
     skippedFiles: 0,
     databasePath: defaultDatabasePath(cwd)
   };
 }
 
 // src/indexer/regression-extractor.ts
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 
 // src/indexer/wisdom-extractor.ts
-import crypto3 from "crypto";
-import path7 from "path";
+import crypto4 from "crypto";
+import path8 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],
@@ -2122,7 +2571,7 @@ function extractSymbols(text, filePaths) {
     }
   }
   for (const filePath of filePaths) {
-    const basename = path7.basename(filePath).replace(/\.[^.]+$/, "");
+    const basename = path8.basename(filePath).replace(/\.[^.]+$/, "");
     if (/^[A-Za-z_$][\w$]*$/.test(basename)) symbols.push(basename);
   }
   return uniqueStrings(symbols).slice(0, 30);
@@ -2146,7 +2595,7 @@ function confidenceFor(entry, text, category, duplicateCount) {
   return Math.max(0, Math.min(1, Number(confidence.toFixed(2))));
 }
 function stableWisdomId(pr, sourceType, text, filePaths, createdAt, authors) {
-  const hash = crypto3.createHash("sha256").update(
+  const hash = crypto4.createHash("sha256").update(
     [pr.repo, pr.number, sourceType, canonicalizeText(text), filePaths.join("|"), createdAt, authors.join("|")].join(
       "\0"
     )
@@ -2297,7 +2746,7 @@ function sourceTexts(pr) {
   ].filter((text) => text.trim());
 }
 function stableRegressionId(pr, summary, signals) {
-  const hash = crypto4.createHash("sha256").update([pr.repo, pr.number, canonicalizeText(summary), signals.join("|")].join("\0")).digest("hex").slice(0, 24);
+  const hash = crypto5.createHash("sha256").update([pr.repo, pr.number, canonicalizeText(summary), signals.join("|")].join("\0")).digest("hex").slice(0, 24);
   return `re_${hash}`;
 }
 function extractRegressionEvents(pr) {
@@ -2420,7 +2869,7 @@ function shouldSyncSince(db, repo, fallbackSince) {
 }
 
 // src/retrieval/query-builder.ts
-import path8 from "path";
+import path9 from "path";
 var CATEGORY_HINTS = [
   "security",
   "regression",
@@ -2437,7 +2886,7 @@ function ftsToken(token) {
   return `${clean}*`;
 }
 function testFilenameHints(filePath) {
-  const parsed = path8.parse(filePath);
+  const parsed = path9.parse(filePath);
   const base = parsed.name.replace(/\.(test|spec)$/i, "");
   return [`${base}.test${parsed.ext}`, `${base}.spec${parsed.ext}`];
 }
@@ -2467,9 +2916,9 @@ function buildQueryTerms(input) {
   const baseText = "task" in input ? input.task : input.query;
   const fileTerms = files.flatMap((file) => [
     file,
-    path8.basename(file),
+    path9.basename(file),
     ...testFilenameHints(file),
-    ...path8.dirname(file).split(/[\\/]/).filter(Boolean)
+    ...path9.dirname(file).split(/[\\/]/).filter(Boolean)
   ]);
   return uniqueStrings([
     ...tokenizeSearchText(baseText, 24),
@@ -2493,7 +2942,7 @@ function clampMaxResults(value, defaultValue) {
 }
 
 // src/retrieval/ranker.ts
-import path9 from "path";
+import path10 from "path";
 function parseJsonArray3(value) {
   try {
     const parsed = JSON.parse(value);
@@ -2540,11 +2989,11 @@ function filePathMatch(unitPaths, queryFiles) {
   if (queryFiles.length === 0 || unitPaths.length === 0) return 0;
   let best = 0;
   for (const queryFile of queryFiles) {
-    const queryBase = path9.basename(queryFile).toLowerCase();
-    const queryDir = path9.dirname(queryFile).toLowerCase();
+    const queryBase = path10.basename(queryFile).toLowerCase();
+    const queryDir = path10.dirname(queryFile).toLowerCase();
     for (const unitPath of unitPaths) {
-      const unitBase = path9.basename(unitPath).toLowerCase();
-      const unitDir = path9.dirname(unitPath).toLowerCase();
+      const unitBase = path10.basename(unitPath).toLowerCase();
+      const unitDir = path10.dirname(unitPath).toLowerCase();
       const q = queryFile.toLowerCase();
       const u = unitPath.toLowerCase();
       if (q === u) best = Math.max(best, 1);
@@ -2738,7 +3187,7 @@ function rankWisdomUnits(db, input) {
 }
 
 // src/retrieval/code-ranker.ts
-import path10 from "path";
+import path11 from "path";
 function parseJsonArray4(value) {
   try {
     const parsed = JSON.parse(value);
@@ -2765,13 +3214,13 @@ function rowToCodeChunk(row) {
 function filePathMatch2(filePath, queryFiles) {
   if (queryFiles.length === 0) return 0;
   let best = 0;
-  const unitBase = path10.basename(filePath).toLowerCase();
-  const unitDir = path10.dirname(filePath).toLowerCase();
+  const unitBase = path11.basename(filePath).toLowerCase();
+  const unitDir = path11.dirname(filePath).toLowerCase();
   const unit = filePath.toLowerCase();
   for (const queryFile of queryFiles) {
     const query = queryFile.toLowerCase();
-    const queryBase = path10.basename(queryFile).toLowerCase();
-    const queryDir = path10.dirname(queryFile).toLowerCase();
+    const queryBase = path11.basename(queryFile).toLowerCase();
+    const queryDir = path11.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);
@@ -2851,7 +3300,7 @@ function loadCodeCandidates(db, input) {
     }
   }
   for (const file of input.files ?? []) {
-    const basename = path10.basename(file);
+    const basename = path11.basename(file);
     const rows = db.prepare(
       `SELECT cc.*, NULL AS bm25
          FROM code_chunks cc
@@ -2902,9 +3351,150 @@ function rankCodeChunks(db, input) {
   return ranked.slice(0, limit);
 }
 
-// src/retrieval/test-ranker.ts
-import path11 from "path";
+// src/retrieval/architecture-ranker.ts
+import path12 from "path";
 function parseJsonArray5(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function parseEvidence(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function rowToPattern(row) {
+  return {
+    id: row.id,
+    repo: row.repo,
+    area: row.area,
+    name: row.name,
+    summary: row.summary_sanitized,
+    sanitizedSummary: row.summary_sanitized,
+    sourceFiles: parseJsonArray5(row.source_files_json),
+    symbols: parseJsonArray5(row.symbols_json),
+    evidence: parseEvidence(row.evidence_json),
+    confidence: row.confidence,
+    createdAt: row.created_at,
+    bm25: row.bm25 ?? void 0
+  };
+}
+function filePathMatch3(pattern, files) {
+  if (files.length === 0) return 0;
+  let best = 0;
+  for (const sourceFile of pattern.sourceFiles) {
+    const sourceBase = path12.basename(sourceFile).toLowerCase();
+    const sourceDir = path12.dirname(sourceFile).toLowerCase();
+    for (const queryFile of files) {
+      const queryBase = path12.basename(queryFile).toLowerCase();
+      const queryDir = path12.dirname(queryFile).toLowerCase();
+      if (sourceFile.toLowerCase() === queryFile.toLowerCase()) best = Math.max(best, 1);
+      else if (sourceBase === queryBase) best = Math.max(best, 0.72);
+      else if (sourceDir === queryDir) best = Math.max(best, 0.62);
+      else if (sourceDir.startsWith(queryDir) || queryDir.startsWith(sourceDir)) {
+        best = Math.max(best, 0.38);
+      }
+    }
+  }
+  return best;
+}
+function symbolMatch4(pattern, symbols) {
+  if (symbols.length === 0) return 0;
+  const indexed = pattern.symbols.map((symbol) => symbol.toLowerCase());
+  let best = 0;
+  for (const symbol of symbols) {
+    const lower = symbol.toLowerCase();
+    if (indexed.includes(lower)) best = Math.max(best, 1);
+    else if (indexed.some((candidate) => candidate.includes(lower) || lower.includes(candidate))) {
+      best = Math.max(best, 0.45);
+    }
+  }
+  return best;
+}
+function textMatch4(pattern, input) {
+  const terms = buildQueryTerms(input).slice(0, 32);
+  const bm25Signal = pattern.bm25 === void 0 ? 0 : Math.max(0.25, Math.min(1, 1 / (1 + Math.abs(pattern.bm25))));
+  if (terms.length === 0) return bm25Signal;
+  const haystack = `${pattern.area} ${pattern.name} ${pattern.sanitizedSummary} ${pattern.sourceFiles.join(
+    " "
+  )} ${pattern.symbols.join(" ")}`.toLowerCase();
+  const overlap = terms.filter((term) => haystack.includes(term.toLowerCase())).length / terms.length;
+  return Math.max(overlap, bm25Signal);
+}
+function matchReasons4(parts, pattern) {
+  const reasons = [`${pattern.area} architecture pattern`];
+  if (parts.filePath >= 0.9) reasons.push("exact file architecture evidence");
+  else if (parts.filePath >= 0.45) reasons.push("nearby file architecture evidence");
+  if (parts.symbol >= 0.9) reasons.push("symbol match");
+  else if (parts.symbol >= 0.4) reasons.push("related symbol match");
+  if (parts.area >= 0.9) reasons.push("area match");
+  if (parts.text >= 0.25) reasons.push("query terms matched pattern");
+  return reasons.slice(0, 5);
+}
+function rankArchitecturePatterns(db, input) {
+  const fileAreas = /* @__PURE__ */ new Set();
+  for (const file of input.files ?? []) {
+    const row = db.prepare("SELECT area FROM architecture_components WHERE path = ? LIMIT 1").get(file);
+    if (row?.area) fileAreas.add(row.area);
+  }
+  const candidates = /* @__PURE__ */ new Map();
+  const ftsQuery = buildFtsQuery(input);
+  if (ftsQuery) {
+    const rows2 = db.prepare(
+      `SELECT ap.id, ap.repo, ap.area, ap.name, ap.summary_sanitized, ap.source_files_json,
+                ap.symbols_json, ap.evidence_json, ap.confidence, ap.created_at,
+                bm25(architecture_patterns_fts) AS bm25
+         FROM architecture_patterns_fts
+         JOIN architecture_patterns ap ON ap.id = architecture_patterns_fts.patternId
+         WHERE architecture_patterns_fts MATCH ?
+         ORDER BY bm25(architecture_patterns_fts)
+         LIMIT 150`
+    ).all(ftsQuery);
+    for (const row of rows2) {
+      const pattern = rowToPattern(row);
+      candidates.set(pattern.id, pattern);
+    }
+  }
+  const rows = db.prepare(
+    `SELECT id, repo, area, name, summary_sanitized, source_files_json, symbols_json,
+              evidence_json, confidence, created_at, NULL AS bm25
+       FROM architecture_patterns
+       ORDER BY confidence DESC, created_at DESC`
+  ).all();
+  for (const row of rows) {
+    const pattern = rowToPattern(row);
+    candidates.set(pattern.id, { ...pattern, bm25: candidates.get(pattern.id)?.bm25 });
+  }
+  return [...candidates.values()].filter((pattern) => !input.area || pattern.area === input.area).map((pattern) => {
+    const parts = {
+      filePath: filePathMatch3(pattern, input.files ?? []),
+      symbol: symbolMatch4(pattern, input.symbols ?? []),
+      text: textMatch4(pattern, input),
+      area: input.area && pattern.area === input.area ? 1 : fileAreas.has(pattern.area) ? 1 : 0,
+      confidence: pattern.confidence
+    };
+    const score = (0.34 * parts.filePath + 0.2 * parts.symbol + 0.18 * parts.text + 0.13 * parts.area + 0.15 * parts.confidence) * (fileAreas.size > 0 && !fileAreas.has(pattern.area) ? 0.75 : 1);
+    return {
+      ...pattern,
+      score: Number(score.toFixed(4)),
+      matchReasons: matchReasons4(parts, pattern),
+      rankSignals: parts
+    };
+  }).filter((pattern) => {
+    if (input.files?.length || input.symbols?.length || input.area) return pattern.score > 0.08;
+    return true;
+  }).sort((a, b) => b.score - a.score).slice(0, Math.min(input.maxResults ?? 6, 12));
+}
+
+// src/retrieval/test-ranker.ts
+import path13 from "path";
+function parseJsonArray6(value) {
   if (!value) return [];
   try {
     const parsed = JSON.parse(value);
@@ -2914,10 +3504,10 @@ function parseJsonArray5(value) {
   }
 }
 function baseStem(filePath) {
-  return path11.posix.basename(filePath).replace(/\.(test|spec)\.[^.]+$/i, "").replace(/\.[^.]+$/i, "").toLowerCase();
+  return path13.posix.basename(filePath).replace(/\.(test|spec)\.[^.]+$/i, "").replace(/\.[^.]+$/i, "").toLowerCase();
 }
 function rowToRanked(row, input) {
-  const symbols = parseJsonArray5(row.symbols_json);
+  const symbols = parseJsonArray6(row.symbols_json);
   const text = row.sanitized_text ?? "";
   const matchedSymbols = (input.symbols ?? []).filter((symbol) => {
     const lower = symbol.toLowerCase();
@@ -2986,8 +3576,8 @@ function rankRelevantTests(db, input) {
 }
 
 // src/retrieval/regression-ranker.ts
-import path12 from "path";
-function parseJsonArray6(value) {
+import path14 from "path";
+function parseJsonArray7(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -3002,25 +3592,25 @@ function rowToEvent(row) {
     prNumber: row.pr_number,
     prUrl: row.pr_url,
     summary: row.summary_sanitized,
-    filePaths: parseJsonArray6(row.file_paths_json),
-    symbols: parseJsonArray6(row.symbols_json),
-    testPaths: parseJsonArray6(row.test_paths_json),
-    authors: parseJsonArray6(row.authors_json),
-    labels: parseJsonArray6(row.labels_json),
-    signals: parseJsonArray6(row.signals_json),
+    filePaths: parseJsonArray7(row.file_paths_json),
+    symbols: parseJsonArray7(row.symbols_json),
+    testPaths: parseJsonArray7(row.test_paths_json),
+    authors: parseJsonArray7(row.authors_json),
+    labels: parseJsonArray7(row.labels_json),
+    signals: parseJsonArray7(row.signals_json),
     createdAt: row.created_at,
     mergedAt: row.merged_at ?? void 0,
     confidence: row.confidence
   };
 }
-function filePathMatch3(eventPaths, queryFiles) {
+function filePathMatch4(eventPaths, queryFiles) {
   let best = 0;
   for (const queryFile of queryFiles) {
-    const queryBase = path12.posix.basename(queryFile).toLowerCase();
-    const queryDir = path12.posix.dirname(queryFile).toLowerCase();
+    const queryBase = path14.posix.basename(queryFile).toLowerCase();
+    const queryDir = path14.posix.dirname(queryFile).toLowerCase();
     for (const eventPath of eventPaths) {
-      const eventBase = path12.posix.basename(eventPath).toLowerCase();
-      const eventDir = path12.posix.dirname(eventPath).toLowerCase();
+      const eventBase = path14.posix.basename(eventPath).toLowerCase();
+      const eventDir = path14.posix.dirname(eventPath).toLowerCase();
       if (queryFile.toLowerCase() === eventPath.toLowerCase()) best = Math.max(best, 1);
       else if (queryBase === eventBase) best = Math.max(best, 0.7);
       else if (queryDir === eventDir) best = Math.max(best, 0.55);
@@ -3028,7 +3618,7 @@ function filePathMatch3(eventPaths, queryFiles) {
   }
   return best;
 }
-function symbolMatch4(event, querySymbols) {
+function symbolMatch5(event, querySymbols) {
   const eventSymbols = event.symbols.map((symbol) => symbol.toLowerCase());
   let best = 0;
   for (const symbol of querySymbols) {
@@ -3038,7 +3628,7 @@ function symbolMatch4(event, querySymbols) {
   }
   return best;
 }
-function textMatch4(event, inputText) {
+function textMatch5(event, inputText) {
   const tokens = tokenizeSearchText(inputText, 32);
   if (tokens.length === 0) return 0;
   const haystack = `${event.summary} ${event.filePaths.join(" ")} ${event.symbols.join(" ")} ${event.signals.join(" ")}`.toLowerCase();
@@ -3052,7 +3642,7 @@ function recencyScore3(event) {
   if (ageDays < 730) return 0.7;
   return 0.35;
 }
-function matchReasons4(parts, event) {
+function matchReasons5(parts, event) {
   const reasons = [];
   if ((parts.filePathMatch ?? 0) >= 0.9) reasons.push("exact file path match");
   else if ((parts.filePathMatch ?? 0) >= 0.45) reasons.push("related file path match");
@@ -3074,9 +3664,9 @@ function rankRegressionEvents(db, input) {
   const inputText = "task" in input ? `${input.task} ${input.diff ?? ""} ${input.currentCode ?? ""}` : input.query;
   const ranked = loadRegressionEvents(db).map((event) => {
     const parts = {
-      filePathMatch: filePathMatch3(event.filePaths, queryFiles),
-      symbolMatch: symbolMatch4(event, querySymbols),
-      textMatch: textMatch4(event, inputText),
+      filePathMatch: filePathMatch4(event.filePaths, queryFiles),
+      symbolMatch: symbolMatch5(event, querySymbols),
+      textMatch: textMatch5(event, inputText),
       recency: recencyScore3(event),
       confidence: event.confidence
     };
@@ -3086,7 +3676,7 @@ function rankRegressionEvents(db, input) {
       filePaths: uniqueStrings(event.filePaths),
       symbols: uniqueStrings(event.symbols),
       score: Number(score.toFixed(4)),
-      matchReasons: matchReasons4(parts, event),
+      matchReasons: matchReasons5(parts, event),
       rankSignals: parts
     };
   }).filter((event) => event.score > 0 || "regressionsOnly" in input && input.regressionsOnly).sort((a, b) => b.score - a.score || b.confidence - a.confidence);
@@ -3139,7 +3729,7 @@ function riskLines(units) {
   }
   return [...risks].slice(0, 4);
 }
-function formatAnchorContext(units, input, codeChunks = [], teamRules = [], warnings = [], relevantTests = [], regressionEvents = [], extraMetadata = {}) {
+function formatAnchorContext(units, input, codeChunks = [], teamRules = [], warnings = [], relevantTests = [], regressionEvents = [], architecturePatterns = [], extraMetadata = {}) {
   const lines = ["# Anchor Context", ""];
   if (warnings.length > 0) {
     lines.push("## Warnings", "");
@@ -3189,6 +3779,20 @@ function formatAnchorContext(units, input, codeChunks = [], teamRules = [], warn
       lines.push("");
     });
   }
+  lines.push("## Architecture Guidance", "");
+  if (architecturePatterns.length === 0) {
+    lines.push("No directly relevant architecture patterns found in the local index.", "");
+  } else {
+    architecturePatterns.forEach((pattern, index) => {
+      lines.push(`${index + 1}. [${pattern.area}] ${clipSentence(pattern.sanitizedSummary, 240)}`);
+      lines.push(`   Evidence: ${pattern.sourceFiles.slice(0, 5).join(", ") || "indexed code"}`);
+      lines.push(`   Confidence: ${pattern.confidence.toFixed(2)}`);
+      lines.push(
+        `   Why it matters: Follow this current-code pattern unless stronger PR or team-rule evidence says otherwise.`
+      );
+      lines.push("");
+    });
+  }
   lines.push("## Relevant tests", "");
   if (relevantTests.length === 0) {
     lines.push("No directly related tests found in the local index.", "");
@@ -3280,6 +3884,19 @@ function formatAnchorContext(units, input, codeChunks = [], teamRules = [], warn
         matchReasons: chunk.matchReasons,
         rankSignals: chunk.rankSignals
       })),
+      architecturePatterns: architecturePatterns.map((pattern) => ({
+        id: pattern.id,
+        score: pattern.score,
+        area: pattern.area,
+        name: pattern.name,
+        sanitizedSummary: clipSentence(pattern.sanitizedSummary, 280),
+        sourceFiles: pattern.sourceFiles,
+        symbols: pattern.symbols,
+        confidence: pattern.confidence,
+        evidence: pattern.evidence,
+        matchReasons: pattern.matchReasons,
+        rankSignals: pattern.rankSignals
+      })),
       relevantTests: relevantTests.map((test) => ({
         path: test.path,
         sourcePath: test.sourcePath,
@@ -3356,6 +3973,9 @@ function formatIndexStatus(status) {
     `- Test files: ${status.testFileCount}`,
     `- Test links: ${status.testLinkCount}`,
     `- Regression events: ${status.regressionEventCount}`,
+    `- Architecture components: ${status.architectureComponentCount}`,
+    `- Architecture patterns: ${status.architecturePatternCount}`,
+    `- Architecture imports: ${status.architectureImportCount}`,
     `- Anchor coverage: ${status.coverageScore}% (${status.coverageGrade})`,
     `- History coverage: ${status.historyCoverage ?? "unknown"}`,
     `- History limit: ${status.historyLimit ?? "n/a"}`,
@@ -3363,6 +3983,7 @@ function formatIndexStatus(status) {
     `- Team rules: ${status.teamRuleCount}`,
     `- Last sync: ${status.lastSyncTime ?? "never"}`,
     `- Last code index: ${status.lastCodeIndexTime ?? "never"}`,
+    `- Last architecture index: ${status.lastArchitectureIndexTime ?? "never"}`,
     `- Last rule index: ${status.lastRuleIndexTime ?? "never"}`,
     `- Last successful index run: ${status.lastSuccessfulRun ?? "never"}`,
     `- Last failed index run: ${status.lastFailedRun ?? "never"}`,
@@ -3415,6 +4036,7 @@ function buildAnchorContextResult(db, cwd, input, warnings = []) {
   const rules = rankTeamRules(db, cwd, input);
   const tests = rankRelevantTests(db, input);
   const regressions = rankRegressionEvents(db, input);
+  const architecture = rankArchitecturePatterns(db, input);
   const indexStatus = getIndexStatus(cwd);
   const semanticStatus = getSemanticStatus();
   const strictWarnings = input.strict && indexStatus.historyCoverage !== "all" ? [
@@ -3428,12 +4050,14 @@ function buildAnchorContextResult(db, cwd, input, warnings = []) {
     [...warnings, ...strictWarnings],
     tests,
     regressions,
+    architecture,
     {
       indexHealth: {
         historyCoverage: indexStatus.historyCoverage ?? "unknown",
         staleCodeIndex: Boolean(indexStatus.staleCodeIndex),
         lastSuccessfulRun: indexStatus.lastSuccessfulRun,
-        lastFailedRun: indexStatus.lastFailedRun
+        lastFailedRun: indexStatus.lastFailedRun,
+        architecturePatternCount: indexStatus.architecturePatternCount
       },
       semanticStatus
     }
@@ -3521,6 +4145,116 @@ function explainFile(db, cwd, input) {
   };
 }
 
+// src/retrieval/architecture.ts
+function architectureFilesFromDiff(diff) {
+  const files = [];
+  for (const line of diff.split("\n")) {
+    const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (match?.[2] && match[2] !== "/dev/null") files.push(match[2]);
+    const plus = line.match(/^\+\+\+ b\/(.+)$/);
+    if (plus?.[1] && plus[1] !== "/dev/null") files.push(plus[1]);
+  }
+  return uniqueStrings(files);
+}
+function formatPatternList(patterns) {
+  if (patterns.length === 0) return ["No matching architecture patterns found."];
+  return patterns.flatMap((pattern, index) => [
+    `${index + 1}. [${pattern.area}] ${clipSentence(pattern.sanitizedSummary, 260)}`,
+    `   Evidence: ${pattern.sourceFiles.slice(0, 6).join(", ") || "indexed code"}`,
+    `   Confidence: ${pattern.confidence.toFixed(2)}`,
+    `   Match: ${pattern.matchReasons.join(", ")}`,
+    ""
+  ]);
+}
+function architectureMetadata(mode, patterns, extra = {}) {
+  return {
+    mode,
+    architecturePatterns: patterns.map((pattern) => ({
+      id: pattern.id,
+      score: pattern.score,
+      area: pattern.area,
+      name: pattern.name,
+      sanitizedSummary: clipSentence(pattern.sanitizedSummary, 280),
+      sourceFiles: pattern.sourceFiles,
+      symbols: pattern.symbols,
+      confidence: pattern.confidence,
+      evidence: pattern.evidence,
+      matchReasons: pattern.matchReasons,
+      rankSignals: pattern.rankSignals
+    })),
+    ...extra
+  };
+}
+function getArchitectureContext(db, _cwd, input = {}) {
+  const task = input.query ?? (input.file ? `Explain architecture patterns for ${input.file}` : input.area ? `Explain ${input.area} architecture patterns` : "Summarize repository architecture patterns");
+  const patterns = rankArchitecturePatterns(db, {
+    task,
+    files: input.file ? [input.file] : void 0,
+    area: input.area,
+    maxResults: input.maxResults ?? 8
+  });
+  const lines = ["# Anchor Architecture", ""];
+  if (input.file) lines.push(`File: ${input.file}`);
+  if (input.area) lines.push(`Area: ${input.area}`);
+  if (input.query) lines.push(`Query: ${input.query}`);
+  if (input.file || input.area || input.query) lines.push("");
+  lines.push("## Patterns", "", ...formatPatternList(patterns));
+  lines.push("## Recommended implementation path", "");
+  if (patterns.length === 0) {
+    lines.push("- Run `anchor index-code` to refresh current-code architecture evidence.");
+    lines.push("- Search nearby files manually before changing architecture-sensitive code.");
+  } else {
+    lines.push("- Follow the highest-ranked current-code pattern for placement and imports.");
+    lines.push("- Update related tests when the pattern evidence cites nearby tests.");
+    lines.push(
+      "- Use PR/team-rule evidence from `anchor_get_context` for stronger historical constraints."
+    );
+  }
+  return {
+    markdown: lines.join("\n"),
+    metadata: architectureMetadata("architecture", patterns, {
+      file: input.file,
+      area: input.area,
+      query: input.query
+    })
+  };
+}
+function checkArchitecture(db, _cwd, input) {
+  const files = input.files?.length ? input.files : architectureFilesFromDiff(input.diff);
+  const patterns = rankArchitecturePatterns(db, {
+    task: "Check this diff against current architecture patterns",
+    files,
+    diff: input.diff,
+    maxResults: input.maxResults ?? 8
+  });
+  const lines = [
+    "# Anchor Architecture Check",
+    "",
+    `Changed files: ${files.join(", ") || "n/a"}`,
+    "",
+    "## Matching patterns",
+    "",
+    ...formatPatternList(patterns),
+    "## Architecture risks",
+    ""
+  ];
+  if (patterns.length === 0) {
+    lines.push(
+      "- No matching architecture evidence found. Run `anchor index-code` or inspect nearby files."
+    );
+  } else {
+    lines.push("- Check that new files live in the same layer/area as matching examples.");
+    lines.push("- Check imports follow the observed direction between layers.");
+    lines.push("- Check related tests follow the cited test placement pattern.");
+  }
+  return {
+    markdown: lines.join("\n"),
+    metadata: architectureMetadata("architecture_check", patterns, {
+      changedFiles: files
+    })
+  };
+}
+
 // src/retrieval/review-diff.ts
 function filesFromDiff(diff) {
   const files = [];
@@ -3820,28 +4554,168 @@ function createGitHubClient(token) {
   });
 }
 
+// src/github/rate-limit.ts
+function isGitHubRateLimitError(error) {
+  const candidate = error;
+  if (candidate.status !== 403 && candidate.status !== 429) return false;
+  const message = candidate.message?.toLowerCase() ?? "";
+  const headers = candidate.response?.headers ?? {};
+  return candidate.status === 429 || headers["retry-after"] !== void 0 || headers["x-ratelimit-remaining"] === "0" || message.includes("rate limit") || message.includes("secondary limit");
+}
+function getGitHubRateLimitDelayMs(error, attempt, now = Date.now()) {
+  const headers = error.response?.headers ?? {};
+  const retryAfter = Number(headers["retry-after"]);
+  if (Number.isFinite(retryAfter) && retryAfter > 0) {
+    return {
+      delayMs: Math.ceil(retryAfter * 1e3),
+      reason: `retry-after header requested ${Math.ceil(retryAfter)} seconds`
+    };
+  }
+  const remaining = String(headers["x-ratelimit-remaining"] ?? "");
+  const reset = Number(headers["x-ratelimit-reset"]);
+  if (remaining === "0" && Number.isFinite(reset) && reset > 0) {
+    const resetDelayMs = Math.max(0, reset * 1e3 - now);
+    return {
+      delayMs: Math.ceil(resetDelayMs + 2e3),
+      reason: `primary rate limit resets at ${new Date(reset * 1e3).toISOString()}`
+    };
+  }
+  const backoffSeconds = Math.min(900, 60 * 2 ** Math.max(0, attempt - 1));
+  return {
+    delayMs: backoffSeconds * 1e3,
+    reason: `secondary rate limit backoff for ${backoffSeconds} seconds`
+  };
+}
+async function sleep(milliseconds) {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function waitForGlobalBlock(controller) {
+  const now = controller.now?.() ?? Date.now();
+  const waitMs = Math.max(0, (controller.blockedUntilMs ?? 0) - now);
+  if (waitMs > 0) {
+    await (controller.sleep ?? sleep)(waitMs);
+  }
+}
+async function requestWithGitHubRateLimit(request, options) {
+  const maxRetries = options.maxRetries ?? 8;
+  for (let attempt = 1; ; attempt += 1) {
+    await waitForGlobalBlock(options.controller);
+    try {
+      return await request();
+    } catch (error) {
+      if (!isGitHubRateLimitError(error) || attempt > maxRetries) throw error;
+      const now = options.controller.now?.() ?? Date.now();
+      const { delayMs, reason } = getGitHubRateLimitDelayMs(error, attempt, now);
+      const retryAtMs = now + delayMs;
+      options.controller.blockedUntilMs = Math.max(
+        options.controller.blockedUntilMs ?? 0,
+        retryAtMs
+      );
+      options.controller.onRateLimit?.({
+        waitSeconds: Math.ceil(delayMs / 1e3),
+        retryAt: new Date(retryAtMs).toISOString(),
+        reason,
+        request: options.requestName,
+        attempt
+      });
+      await (options.controller.sleep ?? sleep)(delayMs);
+    }
+  }
+}
+function hasNextPage(headers) {
+  return String(headers.link ?? "").includes('rel="next"');
+}
+async function paginateWithGitHubRateLimit(requestPage, options) {
+  const results = [];
+  for (let page = 1; ; page += 1) {
+    const response = await requestWithGitHubRateLimit(() => requestPage(page), {
+      controller: options.controller,
+      requestName: `${options.requestName} page ${page}`
+    });
+    results.push(...response.data);
+    if (!hasNextPage(response.headers) && response.data.length < 100) break;
+    if (!hasNextPage(response.headers) && response.data.length === 0) break;
+    if (!hasNextPage(response.headers)) break;
+  }
+  return results;
+}
+
 // src/github/fetch-pr-details.ts
-async function fetchPullRequestDetails(octokit, repoFullName, pullNumber) {
+async function fetchPullRequestDetails(octokit, repoFullName, pullNumber, controller = {}) {
   const [owner, repo] = repoFullName.split("/");
   if (!owner || !repo) throw new Error(`Invalid repo '${repoFullName}'. Expected owner/name.`);
-  const [{ data: pull }, files, reviews, reviewComments, issueComments, commits] = await Promise.all([
-    octokit.pulls.get({ owner, repo, pull_number: pullNumber }),
-    octokit.paginate(octokit.pulls.listFiles, { owner, repo, pull_number: pullNumber, per_page: 100 }),
-    octokit.paginate(octokit.pulls.listReviews, { owner, repo, pull_number: pullNumber, per_page: 100 }),
-    octokit.paginate(octokit.pulls.listReviewComments, {
+  const { data: pull } = await requestWithGitHubRateLimit(
+    () => octokit.pulls.get({ owner, repo, pull_number: pullNumber }),
+    {
+      controller,
+      requestName: `GET /repos/${repoFullName}/pulls/${pullNumber}`
+    }
+  );
+  const files = await paginateWithGitHubRateLimit(
+    (page) => octokit.pulls.listFiles({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      per_page: 100,
+      page
+    }),
+    {
+      controller,
+      requestName: `GET /repos/${repoFullName}/pulls/${pullNumber}/files`
+    }
+  );
+  const reviews = await paginateWithGitHubRateLimit(
+    (page) => octokit.pulls.listReviews({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      per_page: 100,
+      page
+    }),
+    {
+      controller,
+      requestName: `GET /repos/${repoFullName}/pulls/${pullNumber}/reviews`
+    }
+  );
+  const reviewComments = await paginateWithGitHubRateLimit(
+    (page) => octokit.pulls.listReviewComments({
       owner,
       repo,
       pull_number: pullNumber,
-      per_page: 100
+      per_page: 100,
+      page
     }),
-    octokit.paginate(octokit.issues.listComments, {
+    {
+      controller,
+      requestName: `GET /repos/${repoFullName}/pulls/${pullNumber}/comments`
+    }
+  );
+  const issueComments = await paginateWithGitHubRateLimit(
+    (page) => octokit.issues.listComments({
       owner,
       repo,
       issue_number: pullNumber,
-      per_page: 100
+      per_page: 100,
+      page
     }),
-    octokit.paginate(octokit.pulls.listCommits, { owner, repo, pull_number: pullNumber, per_page: 100 })
-  ]);
+    {
+      controller,
+      requestName: `GET /repos/${repoFullName}/issues/${pullNumber}/comments`
+    }
+  );
+  const commits = await paginateWithGitHubRateLimit(
+    (page) => octokit.pulls.listCommits({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      per_page: 100,
+      page
+    }),
+    {
+      controller,
+      requestName: `GET /repos/${repoFullName}/pulls/${pullNumber}/commits`
+    }
+  );
   return {
     repo: repoFullName,
     number: pull.number,
@@ -3914,7 +4788,12 @@ async function fetchPullRequestDetailsConcurrently(options) {
         prNumber: pullNumber,
         detailConcurrency: options.detailConcurrency
       });
-      results[index] = await fetchPullRequestDetails(options.octokit, options.repo, pullNumber);
+      results[index] = await fetchPullRequestDetails(
+        options.octokit,
+        options.repo,
+        pullNumber,
+        options.controller
+      );
       completed += 1;
       options.onProgress?.({
         stage: "fetched_pull_request_details",
@@ -3940,10 +4819,18 @@ async function fetchMergedPullRequests(options) {
   const octokit = createGitHubClient(options.token);
   const limit = resolvePullRequestFetchLimit(options);
   const detailConcurrency = resolvePullRequestDetailConcurrency(options);
+  const rateLimitController = {
+    onRateLimit: (progress) => options.onProgress?.({
+      stage: "github_rate_limited",
+      repo: options.repo,
+      ...progress
+    })
+  };
   const sinceTime = options.since ? Date.parse(options.since) : void 0;
   const pullNumbers = [];
   let scannedPullRequests = 0;
   let reachedSinceBoundary = false;
+  let page = 1;
   options.onProgress?.({
     stage: "discovering_pull_requests",
     repo: options.repo,
@@ -3951,14 +4838,22 @@ async function fetchMergedPullRequests(options) {
     limit,
     since: options.since
   });
-  for await (const response of octokit.paginate.iterator(octokit.pulls.list, {
-    owner,
-    repo,
-    state: "closed",
-    sort: "updated",
-    direction: "desc",
-    per_page: 100
-  })) {
+  while (true) {
+    const response = await requestWithGitHubRateLimit(
+      () => octokit.pulls.list({
+        owner,
+        repo,
+        state: "closed",
+        sort: "updated",
+        direction: "desc",
+        per_page: 100,
+        page
+      }),
+      {
+        controller: rateLimitController,
+        requestName: `GET /repos/${options.repo}/pulls page ${page}`
+      }
+    );
     scannedPullRequests += response.data.length;
     for (const pull of response.data) {
       if (sinceTime && Date.parse(pull.updated_at) < sinceTime) {
@@ -3977,7 +4872,11 @@ async function fetchMergedPullRequests(options) {
       scannedPullRequests,
       matchedMergedPullRequests: pullNumbers.length
     });
-    if (reachedSinceBoundary || limit !== void 0 && pullNumbers.length >= limit) break;
+    const hasNextPage2 = String(response.headers.link ?? "").includes('rel="next"');
+    if (reachedSinceBoundary || limit !== void 0 && pullNumbers.length >= limit || !hasNextPage2) {
+      break;
+    }
+    page += 1;
   }
   options.onProgress?.({
     stage: "discovered_pull_requests",
@@ -3992,13 +4891,14 @@ async function fetchMergedPullRequests(options) {
     repo: options.repo,
     pullNumbers,
     detailConcurrency,
+    controller: rateLimitController,
     onProgress: options.onProgress
   });
 }
 
 // src/doctor.ts
 import fs5 from "fs";
-import path13 from "path";
+import path15 from "path";
 function check(name, ok, message, fix) {
   return { name, ok, message, fix: ok ? void 0 : fix };
 }
@@ -4059,7 +4959,7 @@ async function runDoctor(options) {
       )
     );
   }
-  const cursorConfigPath = path13.join(gitRoot ?? cwd, ".cursor", "mcp.json");
+  const cursorConfigPath = path15.join(gitRoot ?? cwd, ".cursor", "mcp.json");
   let cursorConfig;
   let cursorConfigValid = false;
   if (fs5.existsSync(cursorConfigPath)) {
@@ -4134,7 +5034,7 @@ async function runDoctor(options) {
       "Run pnpm build, then try anchor serve from the repository."
     )
   );
-  const rulePath = path13.join(gitRoot ?? cwd, ".cursor", "rules", "anchor.mdc");
+  const rulePath = path15.join(gitRoot ?? cwd, ".cursor", "rules", "anchor.mdc");
   checks.push(
     check(
       "Cursor rule file exists",
@@ -4190,18 +5090,22 @@ export {
   TEAM_RULES_FILE,
   addTeamRule,
   anchorMcpEntry,
+  architectureFilesFromDiff,
   buildAnchorContextResult,
+  buildArchitectureIndex,
   buildFtsQuery,
   buildQueryTerms,
   calculateCoverage,
   canonicalizeText,
   categorizeWisdom,
+  checkArchitecture,
   checkSchema,
   checkTeamRuleEvidence,
   chunkCodeFile,
   chunkHistoricalText,
   claimKeyFor,
   clampMaxResults,
+  classifyArchitectureArea,
   clipSentence,
   confidenceAtLeast,
   confidenceLevelFor,
@@ -4223,6 +5127,7 @@ export {
   evaluateIndexHealth,
   evidenceForWisdom,
   explainFile,
+  extractCodeImports,
   extractCodeSymbols,
   extractRegressionEvents,
   extractSymbols,
@@ -4234,6 +5139,8 @@ export {
   formatIndexStatus,
   formatSearchHistory,
   getAnchorIndexHealth,
+  getArchitectureContext,
+  getGitHubRateLimitDelayMs,
   getIndexStatus,
   getLastSyncTime,
   getSemanticStatus,
@@ -4246,6 +5153,7 @@ export {
   indexPullRequests,
   inferTestAwareness,
   initializeSchema,
+  isGitHubRateLimitError,
   isHardExcludedCodePath,
   isTestFilePath,
   loadCurrentCodeSnapshot,
@@ -4253,7 +5161,9 @@ export {
   mergeAnchorMcpConfig,
   normalizePullRequest,
   openAnchorDatabase,
+  paginateWithGitHubRateLimit,
   parseGitHubRemote,
+  rankArchitecturePatterns,
   rankCodeChunks,
   rankRegressionEvents,
   rankRelevantTests,
@@ -4263,6 +5173,7 @@ export {
   redactSecrets,
   redactedHistoricalText,
   replaceCodeIndex,
+  requestWithGitHubRateLimit,
   resolveGitHubToken,
   resolvePullRequestDetailConcurrency,
   resolvePullRequestFetchLimit,