septum 0.1.5 → 0.1.7

package/src/core/database/repositories/file.repository.ts

@@ -44,25 +44,22 @@ export class FileRepository {
     mtimeMs: number = 0,
     sizeBytes: number = 0
   ): number {
-    const existing = this.getFileByPath(path);
-    if (existing) {
-      this.db
-        .query(
-          `UPDATE files 
-           SET domain_id = ?, archetype = ?, content_hash = ?, line_count = ?, mtime_ms = ?, size_bytes = ?, last_scanned_at = CURRENT_TIMESTAMP 
-           WHERE id = ?`
-        )
-        .run(domainId, archetype, contentHash, lineCount, mtimeMs, sizeBytes, existing.id);
-      return existing.id;
-    } else {
-      const result = this.db
-        .query(
-          `INSERT INTO files (domain_id, path, archetype, content_hash, line_count, mtime_ms, size_bytes) 
-           VALUES (?, ?, ?, ?, ?, ?, ?)`
-        )
-        .run(domainId, path, archetype, contentHash, lineCount, mtimeMs, sizeBytes);
-      return Number(result.lastInsertRowid);
-    }
+    const row = this.db
+      .query<{ id: number }, [number, string, string, string, number, number, number]>(
+        `INSERT INTO files (domain_id, path, archetype, content_hash, line_count, mtime_ms, size_bytes)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+           domain_id = excluded.domain_id,
+           archetype = excluded.archetype,
+           content_hash = excluded.content_hash,
+           line_count = excluded.line_count,
+           mtime_ms = excluded.mtime_ms,
+           size_bytes = excluded.size_bytes,
+           last_scanned_at = CURRENT_TIMESTAMP
+         RETURNING id`
+      )
+      .get(domainId, path, archetype, contentHash, lineCount, mtimeMs, sizeBytes);
+    return row ? Number(row.id) : 0;
   }
 
   public updateFileMetadataOnly(id: number, mtimeMs: number, sizeBytes: number): void {
@@ -100,6 +97,10 @@ export class FileRepository {
     this.db.query("DELETE FROM files WHERE path = ?").run(path);
   }
 
+  public deleteFileByPath(path: string): void {
+    this.deleteFile(path);
+  }
+
   public getFileWithDomain(
     filePath: string
   ): { file: FileRecord; domain: DomainRecord } | null {

package/src/core/database/repositories/symbol.repository.ts

@@ -5,9 +5,31 @@ import type {
   ExtractedSymbol,
   FileRecord,
   GetSymbolDetailsResponse,
+  ResolvedOutboundCall,
+  SymbolComplexitySmell,
   SymbolKind,
   SymbolRecord,
 } from "../../../types/index.ts";
+import { DependencyRepository } from "./dependency.repository.ts";
+
+const SQL_KEYWORD_BLACKLIST = new Set([
+  "VALUES",
+  "WHERE",
+  "SELECT",
+  "FROM",
+  "JOIN",
+  "LIKE",
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+]);
+
+function stripCommentsAndStrings(source: string): string {
+  return source
+    .replace(/\/\*[\s\S]*?\*\//g, " ")
+    .replace(/\/\/.*$/gm, " ")
+    .replace(/'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|`(?:\\.|[^`\\])*`/g, '""');
+}
 
 export class SymbolRepository {
   constructor(private db: Database) {}
@@ -354,6 +376,10 @@ export class SymbolRepository {
       siblingMethods = classMethods.map((s) => s.name.replace(`${row.name}::`, ""));
     }
 
+    siblingMethods = Array.from(new Set(siblingMethods)).filter(
+      (m) => !SQL_KEYWORD_BLACKLIST.has(m.toUpperCase())
+    );
+
     // 2. Dependencies Injected (from signature type-hints and constructor)
     const dependenciesInjected = new Set<string>();
     const extractTypeHints = (sig: string) => {
@@ -398,30 +424,111 @@ export class SymbolRepository {
         const lines = fileContent.split(/\r?\n/);
         const start = Math.max(0, row.line_start - 1);
         const end = Math.min(lines.length, row.line_end);
-        const sliceLines = lines.slice(start, end).join("\n");
+        const rawSlice = lines.slice(start, end).join("\n");
+        const sanitizedSlice = stripCommentsAndStrings(rawSlice);
 
         // Match Static invocations: ClassName::methodName(
-        const staticCalls = sliceLines.matchAll(/([A-Z][a-zA-Z0-9_]+)::([a-zA-Z0-9_]+)\s*\(/g);
+        const staticCalls = sanitizedSlice.matchAll(/([A-Z][a-zA-Z0-9_]+)::([a-zA-Z0-9_]+)\s*\(/g);
         for (const m of staticCalls) {
           if (m[1] !== "self" && m[1] !== "parent" && m[1] !== "static") {
             outboundCalls.add(`${m[1]}::${m[2]}`);
           }
         }
 
-        // Match property calls: $this->property->method(
-        const propCalls = sliceLines.matchAll(/\$this->([a-zA-Z0-9_]+)->([a-zA-Z0-9_]+)\s*\(/g);
+        // Match PHP property calls: $this->property->method(
+        const propCalls = sanitizedSlice.matchAll(/\$this->([a-zA-Z0-9_]+)->([a-zA-Z0-9_]+)\s*\(/g);
         for (const m of propCalls) {
-          // Capitalize property name for clean domain inference (e.g. orderService -> OrderService::cancelOrder)
           const propName = m[1];
           const methodName = m[2];
           const inferredClass = propName.charAt(0).toUpperCase() + propName.slice(1);
           outboundCalls.add(`${inferredClass}::${methodName}`);
         }
+
+        // Match TS/JS property calls: this.property.method(
+        const tsPropCalls = sanitizedSlice.matchAll(/\bthis\.([a-zA-Z0-9_]+)\.([a-zA-Z0-9_]+)\s*\(/g);
+        for (const m of tsPropCalls) {
+          const propName = m[1];
+          const methodName = m[2];
+          if (propName !== "db") {
+            const inferredClass = propName.charAt(0).toUpperCase() + propName.slice(1);
+            outboundCalls.add(`${inferredClass}::${methodName}`);
+          }
+        }
       }
     } catch {
       // Graceful fallback if file not physically accessible
     }
 
+    const depRepo = new DependencyRepository(this.db);
+    const connectedFiles = depRepo.getFileConnections(row.file_path);
+
+    // 4. Resolve Outbound Calls to target symbol line ranges
+    const resolvedOutboundCalls: ResolvedOutboundCall[] = [];
+    const lookupStmt = this.db.query<
+      {
+        name: string;
+        line_start: number;
+        line_end: number;
+        line_count: number;
+        file_path: string;
+        domain_name: string;
+      },
+      [string, string, string, string]
+    >(`
+      SELECT 
+        s.name, 
+        s.line_start, 
+        s.line_end, 
+        s.line_count, 
+        f.path AS file_path, 
+        d.name AS domain_name
+      FROM symbols s
+      JOIN files f ON s.file_id = f.id
+      JOIN domains d ON f.domain_id = d.id
+      WHERE (s.name = ? OR s.name LIKE ? OR s.name LIKE ?)
+      ORDER BY CASE WHEN s.name = ? THEN 1 ELSE 2 END, s.line_start ASC
+      LIMIT 1
+    `);
+
+    for (const call of outboundCalls) {
+      try {
+        const target = lookupStmt.get(call, `%::${call}`, `${call}::%`, call);
+        if (target) {
+          resolvedOutboundCalls.push({
+            symbol: call,
+            target_file: target.file_path,
+            target_range: {
+              start_line: target.line_start,
+              end_line: target.line_end,
+              total_lines: target.line_count,
+            },
+            domain: target.domain_name,
+            is_resolved: true,
+          });
+        } else {
+          resolvedOutboundCalls.push({
+            symbol: call,
+            is_resolved: false,
+          });
+        }
+      } catch {
+        resolvedOutboundCalls.push({
+          symbol: call,
+          is_resolved: false,
+        });
+      }
+    }
+
+    const complexitySmell: SymbolComplexitySmell | undefined =
+      row.line_count > 300
+        ? {
+            is_high_complexity: true,
+            threshold: 300,
+            total_lines: row.line_count,
+            warning: `Symbol '${row.name}' spans ${row.line_count} lines (exceeds 300-line threshold). Candidate for decomposition/refactoring.`,
+          }
+        : undefined;
+
     return {
       symbol: row.name,
       kind: row.kind,
@@ -436,7 +543,10 @@ export class SymbolRepository {
       visibility: row.visibility,
       dependencies_injected: Array.from(dependenciesInjected),
       outbound_calls: Array.from(outboundCalls),
+      resolved_outbound_calls: resolvedOutboundCalls.length > 0 ? resolvedOutboundCalls : undefined,
+      complexity_smell: complexitySmell,
       sibling_methods: siblingMethods.length > 0 ? siblingMethods : undefined,
+      connected_files: connectedFiles,
     };
   }
 

package/src/core/database/repository.ts

@@ -122,11 +122,16 @@ export class SeptumRepository {
     this.files.deleteFile(path);
   }
 
+  public deleteFileByPath(path: string): void {
+    this.files.deleteFileByPath(path);
+  }
+
   public getDomainCatalog(
     domainName: string,
-    archetypeFilter?: string
+    archetypeFilter?: string,
+    options?: { detailLevel?: "compact" | "full"; fileFilter?: string }
   ): DomainCatalogResponse | null {
-    return this.domains.getDomainCatalog(domainName, archetypeFilter);
+    return this.domains.getDomainCatalog(domainName, archetypeFilter, options);
   }
 
   // --- Symbol Methods ---
@@ -171,10 +176,22 @@ export class SeptumRepository {
     return this.dependencies.getAllVerticalSlices();
   }
 
+  public countVerticalSlices(): number {
+    return this.dependencies.countVerticalSlices();
+  }
+
   public clearVerticalSlices(domainId?: number): void {
     this.dependencies.clearVerticalSlices(domainId);
   }
 
+  public getDomainFileConnections(domainId?: number) {
+    return this.dependencies.getDomainFileConnections(domainId);
+  }
+
+  public getFileConnections(filePath: string) {
+    return this.dependencies.getFileConnections(filePath);
+  }
+
   public getAllDependenciesWithDomains(): Array<{
     source_file: string;
     source_domain: string;

package/src/core/database/schema.ts

@@ -104,9 +104,10 @@ export const TABLE_STATEMENTS = [
 
 export const INDEX_STATEMENTS = [
   "CREATE INDEX IF NOT EXISTS idx_domains_name ON domains(name);",
-  "CREATE INDEX IF NOT EXISTS idx_files_domain_id ON files(domain_id);",
+  "CREATE INDEX IF NOT EXISTS idx_files_domain_id ON files(domain_id, id);",
   "CREATE INDEX IF NOT EXISTS idx_files_path ON files(path);",
   "CREATE INDEX IF NOT EXISTS idx_symbols_file_id ON symbols(file_id);",
+  "CREATE INDEX IF NOT EXISTS idx_symbols_file_lines ON symbols(file_id, line_start, line_end);",
   "CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);",
   "CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind);",
   "CREATE INDEX IF NOT EXISTS idx_symbols_line_count ON symbols(kind, line_count DESC);",
@@ -117,7 +118,7 @@ export const INDEX_STATEMENTS = [
   "CREATE INDEX IF NOT EXISTS idx_slices_route_name ON vertical_slices(route_name);",
   "CREATE INDEX IF NOT EXISTS idx_slices_controller ON vertical_slices(controller_class, action_name);",
   "CREATE INDEX IF NOT EXISTS idx_env_topology_status ON environment_topology(status);",
-  "CREATE INDEX IF NOT EXISTS idx_env_nodes_layer ON environment_nodes(layer);",
+  "CREATE INDEX IF NOT EXISTS idx_env_nodes_layer ON environment_nodes(layer, id);",
   "CREATE INDEX IF NOT EXISTS idx_env_nodes_status ON environment_nodes(status);",
 ];
 

package/src/core/ingestion/pipeline.ts

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import type { ParsedFileAST } from "../../types/index.ts";
 import type { ValidatedSeptumConfig } from "../config/schema.ts";
 import type { SeptumRepository } from "../database/repository.ts";
@@ -8,6 +8,7 @@ import { SemanticSliceExtractorRegistry } from "../parser/extractors/registry.ts
 import { TopologyDetector } from "../discovery/topology-detector.ts";
 import { ASTParserEngine } from "../parser/tree-sitter.ts";
 import { CallGraphTracer } from "../resolver/call-graph-tracer.ts";
+import { ModuleResolver } from "../resolver/module-resolver.ts";
 import { computeContentHash } from "./hasher.ts";
 
 export interface IngestionMetrics {
@@ -33,13 +34,15 @@ export class IngestionPipeline {
     }
   }
 
-  public async run(config: ValidatedSeptumConfig): Promise<IngestionMetrics> {
+  public async run(config: ValidatedSeptumConfig, options: { verifyContent?: boolean } = {}): Promise<IngestionMetrics> {
+    this.ensureParserRevision();
     const startTime = performance.now();
     let filesScanned = 0;
     let filesUpdated = 0;
     let filesSkipped = 0;
     let symbolsIndexed = 0;
     let dependenciesIndexed = 0;
+    const unsupportedFiles: string[] = [];
 
     let domainNames = Object.keys(config.domains);
     const projectRoot = this.customWorkspaceRoot || process.cwd();
@@ -59,6 +62,11 @@ export class IngestionPipeline {
       domainNames = Object.keys(config.domains);
     }
 
+    const existingFilesMap = new Map<string, import("../../types/index.ts").FileRecord>();
+    for (const f of this.repo.getAllFiles()) {
+      existingFilesMap.set(f.path, f);
+    }
+
     for (const domainName of domainNames) {
       const domainCfg = config.domains[domainName];
       const domainId = this.repo.upsertDomain(domainName, domainCfg);
@@ -66,17 +74,16 @@ export class IngestionPipeline {
       const absDomainRoot = resolve(workspaceRoot, domainCfg.root);
 
       if (!existsSync(absDomainRoot)) {
+        this.repo.files.deleteFilesNotInPaths(domainId, []);
         continue;
       }
 
-      const normCurrentRoot = domainCfg.root.replace(/\\/g, "/").replace(/^\.\/?/, "");
       const childDomainRoots = domainNames
-        .filter((d) => d !== domainName)
-        .map((d) => config.domains[d].root.replace(/\\/g, "/").replace(/^\.\/?/, ""))
-        .filter((r) => {
-          if (!r) return false;
-          if (!normCurrentRoot) return true;
-          return r.startsWith(normCurrentRoot + "/");
+        .filter(name => name !== domainName)
+        .map(name => relative(workspaceRoot, resolve(workspaceRoot, config.domains[name].root)).replace(/\\/g, "/"))
+        .filter(child => {
+          const fromParent = relative(absDomainRoot, resolve(workspaceRoot, child)).replace(/\\/g, "/");
+          return fromParent !== "" && fromParent !== ".." && !fromParent.startsWith("../") && !isAbsolute(fromParent);
         });
 
       const collectedFiles = this.collectFiles(
@@ -85,7 +92,13 @@ export class IngestionPipeline {
         config.settings.ignore_patterns,
         childDomainRoots
       );
-      const activeRelPaths: string[] = [];
+      const activeRelPaths = new Set<string>();
+
+      const pendingMetadataUpdates: Array<{
+        id: number;
+        mtimeMs: number;
+        sizeBytes: number;
+      }> = [];
 
       const pendingUpdates: Array<{
         fullPath: string;
@@ -100,7 +113,7 @@ export class IngestionPipeline {
 
       for (const { fullPath, relPath } of collectedFiles) {
         filesScanned++;
-        activeRelPaths.push(relPath);
+        activeRelPaths.add(relPath);
 
         let stat;
         try {
@@ -109,12 +122,13 @@ export class IngestionPipeline {
           continue;
         }
 
-        const mtimeMs = Math.round(stat.mtimeMs);
+        const mtimeMs = stat.mtimeMs;
         const sizeBytes = stat.size;
-        const existingFile = this.repo.getFileByPath(relPath);
+        const existingFile = existingFilesMap.get(relPath);
 
         // Tier 1: Fast OS metadata check (inode mtime + size + domain match)
         if (
+          !options.verifyContent &&
           existingFile &&
           existingFile.domain_id === domainId &&
           existingFile.mtime_ms === mtimeMs &&
@@ -133,17 +147,23 @@ export class IngestionPipeline {
           existingFile.domain_id === domainId &&
           existingFile.content_hash === currentHash
         ) {
-          // Content identical despite mtime bump (e.g. touch) - update metadata without re-parsing AST
-          this.repo.updateFileMetadataOnly(existingFile.id, mtimeMs, sizeBytes);
+          // Content identical despite mtime bump (e.g. touch) - queue metadata update for batch transaction
+          pendingMetadataUpdates.push({ id: existingFile.id, mtimeMs, sizeBytes });
           filesSkipped++;
           continue;
         }
 
-        filesUpdated++;
         const lineCount = content.split("\n").length;
         const archetype = detectArchetype(relPath, domainCfg.archetypes ?? {});
         const ast = await this.parserEngine.parseFile(fullPath, content);
+        if (ast.status === "unsupported") {
+          unsupportedFiles.push(relPath);
+          this.repo.deleteFileByPath(relPath);
+          continue;
+        }
+        if (ast.status === "degraded") throw new Error(`Cannot reliably index '${relPath}': parser is degraded.`);
 
+        filesUpdated++;
         pendingUpdates.push({
           fullPath,
           relPath,
@@ -158,6 +178,10 @@ export class IngestionPipeline {
 
       // Batch ACID Transaction per domain
       this.repo.runInTransaction(() => {
+        for (const meta of pendingMetadataUpdates) {
+          this.repo.updateFileMetadataOnly(meta.id, meta.mtimeMs, meta.sizeBytes);
+        }
+
         for (const item of pendingUpdates) {
           const fileId = this.repo.upsertFile(
             domainId,
@@ -176,8 +200,13 @@ export class IngestionPipeline {
           dependenciesIndexed += item.ast.dependencies.length;
         }
 
-        // State Reconciliation: Prune deleted files from DB
-        this.repo.deleteFilesNotInPaths(domainId, activeRelPaths);
+        // State Reconciliation: Prune deleted files from DB using pre-loaded existingFilesMap
+        for (const [existingPath, existingRecord] of existingFilesMap.entries()) {
+          if (existingRecord.domain_id === domainId && !activeRelPaths.has(existingPath)) {
+            this.repo.deleteFileByPath(existingPath);
+            existingFilesMap.delete(existingPath);
+          }
+        }
       });
     }
 
@@ -188,29 +217,29 @@ export class IngestionPipeline {
       detectedTopology.framework
     );
 
-    this.repo.clearVerticalSlices();
+    const slicesToPersist =
+      semanticSlices.length > 0
+        ? semanticSlices
+        : new CallGraphTracer(this.repo, projectRoot).traceAllSlices();
 
-    if (semanticSlices.length > 0) {
-      for (const slice of semanticSlices) {
-        this.repo.upsertVerticalSlice(slice);
-      }
-    } else {
-      // Heuristic Call-Graph Tracer fallback for Clean/Hexagonal or generic architectures
-      const callGraphTracer = new CallGraphTracer(this.repo, projectRoot);
-      const graphSlices = callGraphTracer.traceAllSlices();
-      for (const slice of graphSlices) {
+    this.repo.runInTransaction(() => {
+      this.repo.clearVerticalSlices();
+      for (const slice of slicesToPersist) {
         this.repo.upsertVerticalSlice(slice);
       }
-    }
+    });
 
     const durationMs = Math.round(performance.now() - startTime);
 
     // Update SSOT repo_meta watermark
-    this.repo.setMeta("last_sync", new Date().toISOString());
-    this.repo.setMeta("files_scanned", String(filesScanned));
-    this.repo.setMeta("files_updated", String(filesUpdated));
-    this.repo.setMeta("symbols_indexed", String(symbolsIndexed));
-    this.repo.setMeta("dependencies_indexed", String(dependenciesIndexed));
+    this.repo.runInTransaction(() => {
+      this.repo.setMeta("last_sync", new Date().toISOString());
+      this.repo.setMeta("files_scanned", String(filesScanned));
+      this.repo.setMeta("files_updated", String(filesUpdated));
+      this.repo.setMeta("symbols_indexed", String(symbolsIndexed));
+      this.repo.setMeta("dependencies_indexed", String(dependenciesIndexed));
+      this.repo.setMeta("unsupported_files", JSON.stringify(unsupportedFiles));
+    });
 
     return {
       domains_processed: domainNames.length,
@@ -495,15 +524,27 @@ export class IngestionPipeline {
   }
 
   private isSourceFile(path: string): boolean {
-    return /\.(ts|tsx|js|jsx|mjs|cjs|php|py|go|rs|vue|astro|svelte)$/i.test(path);
+    return ASTParserEngine.isSourceFile(path);
+  }
+
+  private ensureParserRevision(): void {
+    const revision = "2";
+    if (this.repo.getMeta("parser_revision") === revision) return;
+    this.repo.runInTransaction(() => {
+      for (const file of this.repo.getAllFiles()) {
+        this.repo.upsertFile(file.domain_id, file.path, file.archetype, "", file.line_count, -1, -1);
+      }
+      this.repo.clearVerticalSlices();
+      this.repo.setMeta("parser_revision", revision);
+    });
   }
 
   /**
    * JIT single-file ingestion: quickly verifies and updates a single file's AST,
    * symbols, and dependencies in SQLite if its mtime or content hash has changed.
-   * Runs in < 5ms for rapid delta sync without full project scans.
    */
   public async ingestFile(targetFilePath: string, config: ValidatedSeptumConfig): Promise<boolean> {
+    this.ensureParserRevision();
     const fullPath = resolve(targetFilePath);
     if (!existsSync(fullPath)) return false;
 
@@ -515,47 +556,31 @@ export class IngestionPipeline {
       return false;
     }
 
-    const mtimeMs = Math.round(stat.mtimeMs);
+    const mtimeMs = stat.mtimeMs;
     const sizeBytes = stat.size;
 
     const projectRoot = this.customWorkspaceRoot || process.cwd();
     const relPath = relative(projectRoot, fullPath).replace(/\\/g, "/");
 
-    let targetDomainName: string | null = null;
-    let targetDomainCfg = null;
-
-    for (const [dName, dCfg] of Object.entries(config.domains)) {
-      const absRoot = resolve(projectRoot, dCfg.root).replace(/\\/g, "/");
-      const normFullPath = fullPath.replace(/\\/g, "/");
-      if (normFullPath === absRoot || normFullPath.startsWith(absRoot + "/")) {
-        targetDomainName = dName;
-        targetDomainCfg = dCfg;
-        break;
-      }
+    if (this.shouldIgnore(relPath, config.settings.ignore_patterns ?? [])) {
+      return false;
     }
 
+    const targetDomainName = new ModuleResolver(projectRoot, this.repo).resolveSourceDomain(fullPath, config);
+    const targetDomainCfg = targetDomainName ? config.domains[targetDomainName] : null;
+
     if (!targetDomainName || !targetDomainCfg) {
-      targetDomainName = "core";
-      targetDomainCfg = { root: ".", allowed_dependencies: [], forbidden_dependencies: [], archetypes: {} };
+      return false;
     }
 
     const domainId = this.repo.upsertDomain(targetDomainName, targetDomainCfg);
     const existingFile = this.repo.getFileByPath(relPath);
 
-    // Tier 1: Fast OS metadata check
-    if (
-      existingFile &&
-      existingFile.mtime_ms === mtimeMs &&
-      existingFile.size_bytes === sizeBytes
-    ) {
-      return false; // Completely up to date
-    }
-
     const content = readFileSync(fullPath, "utf-8");
     const currentHash = computeContentHash(content);
 
     // Tier 2: Hash verification
-    if (existingFile && existingFile.content_hash === currentHash) {
+    if (existingFile && existingFile.domain_id === domainId && existingFile.content_hash === currentHash) {
       this.repo.updateFileMetadataOnly(existingFile.id, mtimeMs, sizeBytes);
       return false;
     }
@@ -563,6 +588,14 @@ export class IngestionPipeline {
     const lineCount = content.split("\n").length;
     const archetype = detectArchetype(relPath, targetDomainCfg.archetypes ?? {});
     const ast = await this.parserEngine.parseFile(fullPath, content);
+    if (ast.status === "unsupported") {
+      this.repo.deleteFileByPath(relPath);
+      const unsupported = new Set<string>(JSON.parse(this.repo.getMeta("unsupported_files") || "[]"));
+      unsupported.add(relPath);
+      this.repo.setMeta("unsupported_files", JSON.stringify([...unsupported]));
+      return false;
+    }
+    if (ast.status === "degraded") throw new Error(`Cannot reliably index '${relPath}': parser is degraded.`);
 
     this.repo.runInTransaction(() => {
       const fileId = this.repo.upsertFile(
@@ -576,6 +609,9 @@ export class IngestionPipeline {
       );
       this.repo.replaceFileSymbols(fileId, ast.symbols);
       this.repo.replaceFileDependencies(fileId, ast.dependencies);
+      this.repo.clearVerticalSlices();
+      const unsupported = JSON.parse(this.repo.getMeta("unsupported_files") || "[]") as string[];
+      this.repo.setMeta("unsupported_files", JSON.stringify(unsupported.filter(path => path !== relPath)));
     });
 
     return true;