@swarmvaultai/engine 0.1.30 → 0.1.32

package/README.md

@@ -184,6 +184,7 @@ This matters because many "OpenAI-compatible" backends only implement part of th
 
 - `compileVault(rootDir, { approve })` writes wiki pages, graph data, and search state using the vault schema as guidance, or stages a review bundle
 - compile also writes graph orientation pages such as `wiki/graph/report.md`, `wiki/graph/report.json`, and `wiki/graph/communities/<community>.md`
+- compile propagates semantic tags onto page frontmatter and source-backed graph nodes, and records deterministic `contradicts` edges plus a Contradictions section in the graph report when conflicting claims are found
 - `benchmarkVault(rootDir, { questions })` writes `state/benchmark.json` and folds the latest benchmark summary into `wiki/graph/report.md` and `wiki/graph/report.json`
 - semantic graph query and embedding-backed similarity enrichment cache vectors under `state/embeddings.json` so graph-semantic refresh stays incremental
 - `queryVault(rootDir, { question, save, format, review })` answers against the compiled vault using the same schema layer and saves by default
@@ -207,7 +208,7 @@ This matters because many "OpenAI-compatible" backends only implement part of th
 - `syncTrackedReposForWatch(rootDir)` is the repo-watch sync path that defers non-code semantic refresh into `state/watch/`
 - `installGitHooks(rootDir)`, `uninstallGitHooks(rootDir)`, and `getGitHookStatus(rootDir)` manage local `post-commit` and `post-checkout` hook blocks for the nearest git repository
 - `installAgent(rootDir, agent, { hook })` writes agent instructions and returns the primary `target`, all touched `targets`, and optional merge warnings for agents such as Aider
-- `lintVault(rootDir, options)` runs structural lint, optional deep lint, and optional web-augmented evidence gathering
+- `lintVault(rootDir, options)` runs structural lint, optional deep lint, optional contradiction-only filtering through `{ conflicts: true }`, and optional web-augmented evidence gathering
 - `listSchedules(rootDir)`, `runSchedule(rootDir, jobId)`, and `serveSchedules(rootDir)` manage recurring local jobs from config
 - compile, query, explore, lint, and watch also write canonical markdown session artifacts to `state/sessions/`
 - scheduled `query` and `explore` jobs stage saved outputs through approvals when they write artifacts

package/dist/index.d.ts

@@ -386,6 +386,7 @@ interface SourceAnalysis {
     entities: AnalyzedTerm[];
     claims: SourceClaim[];
     questions: string[];
+    tags: string[];
     rationales: SourceRationale[];
     code?: CodeAnalysis;
     producedAt: string;
@@ -407,6 +408,7 @@ interface GraphNode {
     degree?: number;
     bridgeScore?: number;
     isGodNode?: boolean;
+    tags?: string[];
 }
 interface GraphEdge {
     id: string;
@@ -549,6 +551,8 @@ interface ApprovalSummary {
 interface ApprovalEntryDetail extends ApprovalEntry {
     currentContent?: string;
     stagedContent?: string;
+    changeSummary?: string;
+    diff?: string;
 }
 interface ApprovalDetail extends ApprovalSummary {
     entries: ApprovalEntryDetail[];
@@ -731,6 +735,7 @@ interface CompileState {
 interface LintOptions {
     deep?: boolean;
     web?: boolean;
+    conflicts?: boolean;
 }
 interface ExploreOptions {
     question: string;
@@ -992,6 +997,13 @@ interface GraphReportArtifact {
         sourceType: SourceCaptureType;
         updatedAt: string;
     }>;
+    contradictions: Array<{
+        sourceIdA: string;
+        sourceIdB: string;
+        claimA: string;
+        claimB: string;
+        confidenceDelta: number;
+    }>;
 }
 interface ScheduledCompileTask {
     type: "compile";
@@ -1166,7 +1178,9 @@ declare function loadVaultSchemas(rootDir: string): Promise<LoadedVaultSchemas>;
 declare function loadVaultSchema(rootDir: string): Promise<VaultSchema>;
 
 declare function listApprovals(rootDir: string): Promise<ApprovalSummary[]>;
-declare function readApproval(rootDir: string, approvalId: string): Promise<ApprovalDetail>;
+declare function readApproval(rootDir: string, approvalId: string, options?: {
+    diff?: boolean;
+}): Promise<ApprovalDetail>;
 declare function acceptApproval(rootDir: string, approvalId: string, targets?: string[]): Promise<ReviewActionResult>;
 declare function rejectApproval(rootDir: string, approvalId: string, targets?: string[]): Promise<ReviewActionResult>;
 declare function listCandidates(rootDir: string): Promise<CandidateRecord[]>;

package/dist/index.js

@@ -3910,7 +3910,7 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
   const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType) ?? "typescript";
   const { code, rationales } = language === "javascript" || language === "jsx" || language === "typescript" || language === "tsx" ? analyzeTypeScriptLikeCode(manifest, extractedText) : await analyzeTreeSitterCode(manifest, extractedText, language);
   return {
-    analysisVersion: 5,
+    analysisVersion: 6,
     sourceId: manifest.sourceId,
     sourceHash: manifest.contentHash,
     extractionHash: manifest.extractionHash,
@@ -3921,6 +3921,7 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
     entities: [],
     claims: codeClaims(manifest, code),
     questions: codeQuestions(manifest, code),
+    tags: [],
     rationales,
     code,
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -6323,7 +6324,7 @@ import { z as z7 } from "zod";
 // src/analysis.ts
 import path13 from "path";
 import { z as z2 } from "zod";
-var ANALYSIS_FORMAT_VERSION = 5;
+var ANALYSIS_FORMAT_VERSION = 6;
 var sourceAnalysisSchema = z2.object({
   title: z2.string().min(1),
   summary: z2.string().min(1),
@@ -6338,7 +6339,8 @@ var sourceAnalysisSchema = z2.object({
       citation: z2.string().min(1)
     })
   ).max(8).default([]),
-  questions: z2.array(z2.string()).max(6).default([])
+  questions: z2.array(z2.string()).max(6).default([]),
+  tags: z2.array(z2.string()).max(5).default([])
 });
 var STOPWORDS = /* @__PURE__ */ new Set([
   "about",
@@ -6442,6 +6444,7 @@ function heuristicAnalysis(manifest, text, schemaHash) {
       citation: manifest.sourceId
     })),
     questions: concepts.slice(0, 3).map((term) => `How does ${term.name} relate to ${manifest.title}?`),
+    tags: [],
     rationales: [],
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -6454,6 +6457,8 @@ async function providerAnalysis(manifest, text, provider, schema) {
         "",
         "Follow the vault schema when choosing titles, categories, relationships, and summaries.",
         "",
+        "Return up to 5 broad domain tags that categorize this source. Tags should be lowercase kebab-case (e.g., cryptography, distributed-systems, machine-learning). These are broader categories, not specific concepts or entity names.",
+        "",
         `Vault schema path: ${schema.path}`,
         "",
         "Vault schema instructions:",
@@ -6497,6 +6502,7 @@ ${truncate(text, 18e3)}`
       citation: claim.citation
     })),
     questions: parsed.questions,
+    tags: parsed.tags,
     rationales: [],
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -6532,6 +6538,7 @@ function analysisFromVisionExtraction(manifest, extraction, schemaHash) {
       citation: manifest.sourceId
     })),
     questions: extraction.vision.questions,
+    tags: [],
     rationales: [],
     producedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -6571,6 +6578,7 @@ async function analyzeSource(manifest, extractedText, provider, paths, schema) {
         entities: [],
         claims: [],
         questions: [],
+        tags: [],
         rationales: [],
         producedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
@@ -6596,6 +6604,7 @@ async function analyzeSource(manifest, extractedText, provider, paths, schema) {
       entities: [],
       claims: [],
       questions: [],
+      tags: [],
       rationales: [],
       producedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -6967,7 +6976,14 @@ var deepLintResponseSchema = z5.object({
   findings: z5.array(
     z5.object({
       severity: z5.string().optional().default("info"),
-      code: z5.enum(["coverage_gap", "contradiction_candidate", "missing_citation", "candidate_page", "follow_up_question"]),
+      code: z5.enum([
+        "coverage_gap",
+        "contradiction_candidate",
+        "contradiction",
+        "missing_citation",
+        "candidate_page",
+        "follow_up_question"
+      ]),
       message: z5.string().min(1),
       relatedSourceIds: z5.array(z5.string()).default([]),
       relatedPageIds: z5.array(z5.string()).default([]),
@@ -7100,6 +7116,7 @@ async function runDeepLint(rootDir, structuralFindings, options = {}) {
         system: "You are an auditor for a local-first LLM knowledge vault. Return advisory findings only. Do not propose direct file edits.",
         prompt: [
           "Review this SwarmVault state and return high-signal advisory findings.",
+          "Look for claims that contradict each other across different sources. When you find a genuine contradiction, use code 'contradiction' and include both source IDs in relatedSourceIds.",
           "",
           "Schema:",
           schema.content,
@@ -8962,6 +8979,13 @@ function buildGraphReportArtifact(input) {
       title: page.title,
       sourceType: page.sourceType,
       updatedAt: page.updatedAt
+    })),
+    contradictions: (input.contradictions ?? []).map((c) => ({
+      sourceIdA: c.sourceIdA,
+      sourceIdB: c.sourceIdB,
+      claimA: c.claimA.text,
+      claimB: c.claimB.text,
+      confidenceDelta: Math.abs(c.claimA.confidence - c.claimB.confidence)
     }))
   };
 }
@@ -9081,6 +9105,12 @@ function buildGraphReportPage(input) {
       return `- ${sourceLabel} ${connection.relation} ${targetLabel} (${connection.evidenceClass}, ${connection.confidence.toFixed(2)}). Why: ${connection.why}. ${connection.explanation} Path: ${connection.pathSummary}.`;
     }) : ["- No cross-community links detected."],
     "",
+    "## Contradictions",
+    "",
+    ...input.report.contradictions.length ? input.report.contradictions.map(
+      (c) => `- **${c.claimA}** vs **${c.claimB}** (sources: \`${c.sourceIdA}\`, \`${c.sourceIdB}\`, confidence delta: ${c.confidenceDelta.toFixed(2)})`
+    ) : ["- No contradictions detected."],
+    "",
     "## Group Patterns",
     "",
     ...input.report.groupPatterns.length ? input.report.groupPatterns.map((hyperedge) => {
@@ -10983,21 +11013,64 @@ function buildGoPackageSymbolLookups(analyses, manifestsById) {
     ])
   );
 }
+function claimTokens(text) {
+  return new Set(
+    text.toLowerCase().match(/[a-z][a-z0-9-]{2,}/g)?.filter((t) => !(/* @__PURE__ */ new Set(["the", "and", "for", "that", "this", "with", "are", "was", "from", "has", "not", "all", "but"])).has(t)) ?? []
+  );
+}
+function claimJaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token)) intersection++;
+  }
+  return intersection / (a.size + b.size - intersection);
+}
+function detectContradictions(analyses) {
+  const contradictions = [];
+  const claimsWithTokens = analyses.flatMap(
+    (analysis) => analysis.claims.filter((c) => c.polarity === "positive" || c.polarity === "negative").map((c) => ({ sourceId: analysis.sourceId, claim: c, tokens: claimTokens(c.text) }))
+  );
+  for (let i = 0; i < claimsWithTokens.length; i++) {
+    for (let j = i + 1; j < claimsWithTokens.length; j++) {
+      const a = claimsWithTokens[i];
+      const b = claimsWithTokens[j];
+      if (a.sourceId === b.sourceId) continue;
+      if (a.claim.polarity === b.claim.polarity) continue;
+      const similarity = claimJaccardSimilarity(a.tokens, b.tokens);
+      if (similarity >= 0.3) {
+        contradictions.push({
+          sourceIdA: a.sourceId,
+          sourceIdB: b.sourceId,
+          claimA: { text: a.claim.text, confidence: a.claim.confidence },
+          claimB: { text: b.claim.text, confidence: b.claim.confidence },
+          similarity
+        });
+      }
+    }
+  }
+  return contradictions;
+}
 function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
   const manifestsById = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
   const goPackageSymbolLookups = buildGoPackageSymbolLookups(analyses, manifestsById);
-  const sourceNodes = manifests.map((manifest) => ({
-    id: `source:${manifest.sourceId}`,
-    type: "source",
-    label: manifest.title,
-    pageId: `source:${manifest.sourceId}`,
-    freshness: "fresh",
-    confidence: 1,
-    sourceIds: [manifest.sourceId],
-    projectIds: scopedProjectIdsFromSources([manifest.sourceId], sourceProjects),
-    sourceClass: manifest.sourceClass,
-    language: manifest.language
-  }));
+  const analysesBySourceId = new Map(analyses.map((analysis) => [analysis.sourceId, analysis]));
+  const sourceNodes = manifests.map((manifest) => {
+    const analysis = analysesBySourceId.get(manifest.sourceId);
+    return {
+      id: `source:${manifest.sourceId}`,
+      type: "source",
+      label: manifest.title,
+      pageId: `source:${manifest.sourceId}`,
+      freshness: "fresh",
+      confidence: 1,
+      sourceIds: [manifest.sourceId],
+      projectIds: scopedProjectIdsFromSources([manifest.sourceId], sourceProjects),
+      sourceClass: manifest.sourceClass,
+      language: manifest.language,
+      tags: analysis?.tags ?? []
+    };
+  });
   const conceptMap = /* @__PURE__ */ new Map();
   const entityMap = /* @__PURE__ */ new Map();
   const moduleMap = /* @__PURE__ */ new Map();
@@ -11012,7 +11085,6 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
     edgesById.add(edge.id);
     edges.push(edge);
   };
-  const analysesBySourceId = new Map(analyses.map((analysis) => [analysis.sourceId, analysis]));
   for (const analysis of analyses) {
     for (const concept of analysis.concepts) {
       const existing = conceptMap.get(concept.id);
@@ -11362,7 +11434,7 @@ function recentResearchSourcePages(graph, previousCompiledAt) {
     sourceType: page.sourceType
   }));
 }
-async function buildGraphOrientationPages(graph, paths, schemaHash, previousCompiledAt) {
+async function buildGraphOrientationPages(graph, paths, schemaHash, previousCompiledAt, contradictions = []) {
   const benchmark = await readJsonFile(paths.benchmarkPath);
   const communityRecords = [];
   for (const community of graph.communities ?? []) {
@@ -11392,7 +11464,8 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
     benchmark,
     benchmarkStale: benchmark ? benchmark.graphHash !== graphHash(graph) : false,
     recentResearchSources: recentResearchSourcePages(graph, previousCompiledAt),
-    graphHash: graphHash(graph)
+    graphHash: graphHash(graph),
+    contradictions
   });
   const reportAbsolutePath = path21.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
@@ -11656,7 +11729,7 @@ async function syncVaultArtifacts(rootDir, input) {
         modulePreview ?? void 0,
         {
           projectIds: sourceProjectIds,
-          extraTags: sourceCategoryTags,
+          extraTags: [...sourceCategoryTags, ...analysis.tags ?? []],
           sourceClass: manifest.sourceClass
         }
       )
@@ -11702,7 +11775,7 @@ async function syncVaultArtifacts(rootDir, input) {
             localModules,
             relatedOutputs: relatedOutputsForPage(modulePreview, input.outputPages),
             projectIds: sourceProjectIds,
-            extraTags: sourceCategoryTags
+            extraTags: [...sourceCategoryTags, ...analysis.tags ?? []]
           })
         )
       );
@@ -11782,6 +11855,22 @@ async function syncVaultArtifacts(rootDir, input) {
   const compiledPages = records.map((record) => record.page);
   const basePages = [...compiledPages, ...input.outputPages, ...input.insightPages];
   const structuralGraph = buildGraph(input.manifests, input.analyses, basePages, input.sourceProjects, input.codeIndex);
+  const contradictions = detectContradictions(input.analyses);
+  for (const contradiction of contradictions) {
+    const edgeId = `contradiction:${contradiction.sourceIdA}->${contradiction.sourceIdB}`;
+    if (!structuralGraph.edges.some((e) => e.id === edgeId)) {
+      structuralGraph.edges.push({
+        id: edgeId,
+        source: `source:${contradiction.sourceIdA}`,
+        target: `source:${contradiction.sourceIdB}`,
+        relation: "contradicts",
+        status: "conflicted",
+        evidenceClass: "ambiguous",
+        confidence: Math.abs(contradiction.claimA.confidence - contradiction.claimB.confidence),
+        provenance: [contradiction.sourceIdA, contradiction.sourceIdB]
+      });
+    }
+  }
   const embeddingEdges = await embeddingSimilarityEdges(rootDir, structuralGraph).catch(() => []);
   const baseGraph = embeddingEdges.length > 0 ? (() => {
     const edges = uniqueBy([...structuralGraph.edges, ...embeddingEdges], (edge) => edge.id).sort(
@@ -11795,7 +11884,13 @@ async function syncVaultArtifacts(rootDir, input) {
       communities: metrics.communities
     };
   })() : structuralGraph;
-  const graphOrientation = await buildGraphOrientationPages(baseGraph, paths, globalSchemaHash, input.previousState?.generatedAt);
+  const graphOrientation = await buildGraphOrientationPages(
+    baseGraph,
+    paths,
+    globalSchemaHash,
+    input.previousState?.generatedAt,
+    contradictions
+  );
   records.push(...graphOrientation.records);
   const allPages = [...basePages, ...graphOrientation.records.map((record) => record.page)];
   const graph = {
@@ -12466,6 +12561,58 @@ function updateCandidateHistory(compileState, page, deleted = false) {
 function sortGraphPages(pages) {
   return [...pages].sort((left, right) => left.path.localeCompare(right.path) || left.title.localeCompare(right.title));
 }
+function computeUnifiedDiff(current, staged, label) {
+  const currentLines = current.split("\n");
+  const stagedLines = staged.split("\n");
+  const output = [`--- a/${label}`, `+++ b/${label}`];
+  const n = currentLines.length;
+  const m = stagedLines.length;
+  const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      dp[i2][j2] = currentLines[i2] === stagedLines[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  let i = 0;
+  let j = 0;
+  while (i < n || j < m) {
+    if (i < n && j < m && currentLines[i] === stagedLines[j]) {
+      output.push(` ${currentLines[i]}`);
+      i++;
+      j++;
+    } else if (j < m && (i >= n || dp[i][j + 1] >= dp[i + 1][j])) {
+      output.push(`+${stagedLines[j]}`);
+      j++;
+    } else {
+      output.push(`-${currentLines[i]}`);
+      i++;
+    }
+  }
+  return output.join("\n");
+}
+function computeChangeSummary(current, staged, changeType) {
+  if (changeType === "create") return "New page";
+  if (changeType === "delete") return "Removed page";
+  if (changeType === "promote") return "Promoted from candidate";
+  if (!current || !staged) return "Updated page";
+  const currentParsed = matter9(current);
+  const stagedParsed = matter9(staged);
+  const changes = [];
+  const currentTags = currentParsed.data.tags ?? [];
+  const stagedTags = stagedParsed.data.tags ?? [];
+  const addedTags = stagedTags.filter((t) => !currentTags.includes(t));
+  const removedTags = currentTags.filter((t) => !stagedTags.includes(t));
+  if (addedTags.length) changes.push(`added ${addedTags.length} tag(s)`);
+  if (removedTags.length) changes.push(`removed ${removedTags.length} tag(s)`);
+  if (currentParsed.data.title !== stagedParsed.data.title) changes.push("updated title");
+  const currentLines = currentParsed.content.trim().split("\n").length;
+  const stagedLines = stagedParsed.content.trim().split("\n").length;
+  const lineDelta = stagedLines - currentLines;
+  if (lineDelta > 0) changes.push(`added ${lineDelta} line(s)`);
+  else if (lineDelta < 0) changes.push(`removed ${Math.abs(lineDelta)} line(s)`);
+  else if (currentParsed.content !== stagedParsed.content) changes.push("modified content");
+  return changes.length ? changes.join(", ") : "no visible changes";
+}
 async function listApprovals(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifests = await Promise.all(
@@ -12479,7 +12626,7 @@ async function listApprovals(rootDir) {
   );
   return manifests.filter((manifest) => Boolean(manifest)).map(approvalSummary).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 }
-async function readApproval(rootDir, approvalId) {
+async function readApproval(rootDir, approvalId, options) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifest = await readApprovalManifest(paths, approvalId);
   const details = await Promise.all(
@@ -12487,11 +12634,16 @@ async function readApproval(rootDir, approvalId) {
       const currentPath = entry.previousPath ?? entry.nextPath;
       const currentContent = currentPath ? await fs17.readFile(path21.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
       const stagedContent = entry.nextPath ? await fs17.readFile(path21.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
-      return {
+      const detail = {
         ...entry,
         currentContent,
         stagedContent
       };
+      detail.changeSummary = computeChangeSummary(detail.currentContent, detail.stagedContent, detail.changeType);
+      if (options?.diff && detail.currentContent && detail.stagedContent) {
+        detail.diff = computeUnifiedDiff(detail.currentContent, detail.stagedContent, detail.nextPath ?? detail.pageId);
+      }
+      return detail;
     })
   );
   return {
@@ -13687,11 +13839,43 @@ async function lintVault(rootDir, options = {}) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       success: true,
       lintFindingCount: findings2.length,
-      lines: [`findings=${findings2.length}`, `deep=${Boolean(options.deep)}`, `web=${Boolean(options.web)}`]
+      lines: [
+        `findings=${findings2.length}`,
+        `deep=${Boolean(options.deep)}`,
+        `web=${Boolean(options.web)}`,
+        `conflicts=${Boolean(options.conflicts)}`
+      ]
     });
     return findings2;
   }
+  const contradictionFindings = options.conflicts ? graph.edges.filter((edge) => edge.relation === "contradicts").map((edge) => {
+    const sourceIdA = edge.provenance[0] ?? edge.source.replace(/^source:/, "");
+    const sourceIdB = edge.provenance[1] ?? edge.target.replace(/^source:/, "");
+    return {
+      severity: "warning",
+      code: "contradiction",
+      message: `Contradicting claims detected between source "${sourceIdA}" and source "${sourceIdB}".`,
+      relatedSourceIds: [sourceIdA, sourceIdB]
+    };
+  }) : [];
+  if (options.conflicts && !options.deep) {
+    await recordSession(rootDir, {
+      operation: "lint",
+      title: `Linted ${graph.pages.length} page(s)`,
+      startedAt,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      success: true,
+      relatedPageIds: graph.pages.map((page) => page.id),
+      relatedSourceIds: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
+      lintFindingCount: contradictionFindings.length,
+      lines: [`findings=${contradictionFindings.length}`, `deep=false`, `web=false`, `conflicts=true`]
+    });
+    return contradictionFindings;
+  }
   const findings = await structuralLintFindings(rootDir, paths, graph, schemas, manifests, sourceProjects);
+  if (options.conflicts) {
+    findings.push(...contradictionFindings);
+  }
   if (options.deep) {
     findings.push(...await runDeepLint(rootDir, findings, { web: options.web }));
   }
@@ -13706,7 +13890,12 @@ async function lintVault(rootDir, options = {}) {
     relatedPageIds: graph.pages.map((page) => page.id),
     relatedSourceIds: uniqueStrings3(graph.pages.flatMap((page) => page.sourceIds)),
     lintFindingCount: findings.length,
-    lines: [`findings=${findings.length}`, `deep=${Boolean(options.deep)}`, `web=${Boolean(options.web)}`]
+    lines: [
+      `findings=${findings.length}`,
+      `deep=${Boolean(options.deep)}`,
+      `web=${Boolean(options.web)}`,
+      `conflicts=${Boolean(options.conflicts)}`
+    ]
   });
   return findings;
 }
@@ -13724,7 +13913,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.30";
+var SERVER_VERSION = "0.1.32";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -14554,6 +14743,7 @@ async function watchVault(rootDir, options = {}) {
   let consecutiveFailures = 0;
   let currentDebounceMs = baseDebounceMs;
   const reasons = /* @__PURE__ */ new Set();
+  let activeCycle = null;
   const watcher = chokidar.watch(watchTargets, {
     ignoreInitial: true,
     usePolling: true,
@@ -14598,7 +14788,12 @@ async function watchVault(rootDir, options = {}) {
       clearTimeout(timer);
     }
     timer = setTimeout(() => {
-      void runCycle();
+      const cycle = runCycle();
+      activeCycle = cycle.finally(() => {
+        if (activeCycle === cycle) {
+          activeCycle = null;
+        }
+      });
     }, currentDebounceMs);
   };
   const runCycle = async () => {
@@ -14766,6 +14961,7 @@ async function watchVault(rootDir, options = {}) {
         clearTimeout(timer);
       }
       await watcher.close();
+      await activeCycle;
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmvaultai/engine",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "Core engine for SwarmVault: ingest, compile, query, lint, and provider abstractions.",
   "type": "module",
   "main": "dist/index.js",