@decantr/mcp-server 2.4.0 → 3.0.0-next.0

package/dist/{chunk-P2K3R43N.js → chunk-IB5HP7DE.js}

@@ -4,10 +4,23 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
 // src/tools.ts
+import { createHash } from "crypto";
 import { execFileSync } from "child_process";
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import { basename as basename2, dirname as dirname2, join as join2, relative as relative2 } from "path";
+import { basename as basename2, dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2 } from "path";
+import {
+  GRAPH_NODE_TYPES,
+  GRAPH_RELATIONS,
+  buildGraphImpactContext,
+  buildGraphRouteContext,
+  createMemoryGraphStore,
+  diffGraphSnapshots,
+  graphPayloadString,
+  sortGraphEdges,
+  sortGraphNodes,
+  summarizeGraphDiff
+} from "@decantr/core";
 import { evaluateGuard, isV4 as isV42, validateEssence } from "@decantr/essence-spec";
 import {
   isContentIntelligenceSource,
@@ -15,6 +28,12 @@ import {
   rankPatternCandidates,
   resolvePatternPreset
 } from "@decantr/registry";
+import {
+  anchorFindingsToGraph,
+  buildProjectHealthRepairPlan,
+  deriveVerificationDiagnostic,
+  KNOWN_VERIFICATION_DIAGNOSTICS
+} from "@decantr/verifier";
 
 // src/helpers.ts
 import { realpathSync } from "fs";
@@ -138,6 +157,518 @@ function readJsonIfExists(path) {
     return null;
   }
 }
+function graphProjectRoot(args) {
+  const projectPath = args.project_path;
+  return typeof projectPath === "string" && projectPath.trim() ? resolveWorkspacePath(projectPath) : process.cwd();
+}
+function graphArtifactPath(projectRoot, file) {
+  return join2(projectRoot, ".decantr", "graph", file);
+}
+function graphSnapshotHistoryFileName(snapshotId) {
+  return `${snapshotId.replace(/[^a-zA-Z0-9_.-]+/g, "-")}.json`;
+}
+function graphSnapshotHistoryPath(projectRoot, snapshotId) {
+  return graphArtifactPath(
+    projectRoot,
+    join2("snapshots", graphSnapshotHistoryFileName(snapshotId))
+  );
+}
+function graphSnapshotHistoryCount(projectRoot) {
+  const snapshotsDir = graphArtifactPath(projectRoot, "snapshots");
+  if (!existsSync(snapshotsDir)) return 0;
+  try {
+    return readdirSync(snapshotsDir).filter((entry) => entry.endsWith(".json")).length;
+  } catch {
+    return 0;
+  }
+}
+function readGraphSnapshotHistory(projectRoot, limit = 20) {
+  const snapshotsDir = graphArtifactPath(projectRoot, "snapshots");
+  if (!existsSync(snapshotsDir)) return [];
+  try {
+    return readdirSync(snapshotsDir).filter((entry) => entry.endsWith(".json")).map((entry) => {
+      const absolutePath = join2(snapshotsDir, entry);
+      const snapshot = readJsonIfExists(absolutePath);
+      if (!snapshot) return null;
+      return {
+        id: snapshot.id,
+        path: displayWorkspacePath(absolutePath),
+        created_at: snapshot.created_at,
+        source_hash: snapshot.source_hash,
+        parent_id: snapshot.parent_id ?? null,
+        summary: snapshot.summary
+      };
+    }).filter((entry) => Boolean(entry)).sort(
+      (a, b) => b.created_at.localeCompare(a.created_at) || a.id.localeCompare(b.id)
+    ).slice(0, Math.max(1, Math.min(100, limit)));
+  } catch {
+    return [];
+  }
+}
+function readGraphSnapshotById(projectRoot, snapshotId) {
+  const currentPath = graphArtifactPath(projectRoot, "graph.snapshot.json");
+  const currentSnapshot = readJsonIfExists(currentPath);
+  if (!snapshotId || snapshotId === "current" || currentSnapshot?.id === snapshotId) {
+    return { snapshot: currentSnapshot, path: currentPath };
+  }
+  const path = graphSnapshotHistoryPath(projectRoot, snapshotId);
+  return { snapshot: readJsonIfExists(path), path };
+}
+function readMcpGraphSnapshot(projectRoot) {
+  return readJsonIfExists(graphArtifactPath(projectRoot, "graph.snapshot.json"));
+}
+function mcpAnchorHealthFindings(projectRoot, findings) {
+  return anchorFindingsToGraph(readMcpGraphSnapshot(projectRoot), findings);
+}
+function displayWorkspacePath(path) {
+  const rel = relative2(process.cwd(), path).replace(/\\/g, "/");
+  return rel && !rel.startsWith("..") ? rel : path;
+}
+function displayProjectFile(projectRoot, path) {
+  if (!path) return null;
+  if (/^[a-z]+:\/\//i.test(path)) return path;
+  if (isAbsolute2(path)) return displayWorkspacePath(path);
+  return displayWorkspacePath(join2(projectRoot, path));
+}
+function graphAvailableRoutes(snapshot) {
+  return snapshot.nodes.filter((node) => node.type === "Route").map((node) => graphPayloadString(node.payload, "path") ?? node.id.replace(/^rt:/, "")).sort();
+}
+function graphProjectRelativePath(projectRoot, value) {
+  if (!value) return null;
+  const absolutePath = isAbsolute2(value) ? value : join2(projectRoot, value);
+  const relativePath = relative2(projectRoot, absolutePath).replace(/\\/g, "/");
+  if (!relativePath || relativePath.startsWith("..") || isAbsolute2(relativePath)) {
+    return null;
+  }
+  return relativePath;
+}
+function graphSourceNodeIdForFile(projectRoot, snapshot, filePath) {
+  if (!filePath) return null;
+  const trimmed = filePath.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("src:") && snapshot.nodes.some((node) => node.id === trimmed)) {
+    return trimmed;
+  }
+  const candidates = /* @__PURE__ */ new Set();
+  const projectRelative = graphProjectRelativePath(projectRoot, trimmed);
+  if (projectRelative) candidates.add(projectRelative);
+  try {
+    const workspaceRelative = graphProjectRelativePath(projectRoot, resolveWorkspacePath(trimmed));
+    if (workspaceRelative) candidates.add(workspaceRelative);
+  } catch {
+  }
+  for (const candidate of candidates) {
+    const nodeId = `src:${candidate}`;
+    if (snapshot.nodes.some((node) => node.id === nodeId)) return nodeId;
+  }
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "SourceArtifact") return false;
+    const path = graphPayloadString(node.payload, "path");
+    return Boolean(path && (path === trimmed || candidates.has(path)));
+  })?.id ?? null;
+}
+function graphAvailableSourceArtifacts(snapshot) {
+  return snapshot.nodes.filter((node) => node.type === "SourceArtifact").map((node) => ({
+    id: node.id,
+    path: graphPayloadString(node.payload, "path") ?? node.id.replace(/^src:/, ""),
+    kind: graphPayloadString(node.payload, "kind") ?? null
+  })).sort((a, b) => a.path.localeCompare(b.path));
+}
+function readProjectEssence(projectRoot) {
+  return readJsonIfExists(join2(projectRoot, "decantr.essence.json"));
+}
+function readProjectPackManifest(projectRoot) {
+  return readJsonIfExists(
+    join2(projectRoot, ".decantr", "context", "pack-manifest.json")
+  );
+}
+function mcpHashFile(path) {
+  if (!existsSync(path)) return null;
+  return `sha256:${createHash("sha256").update(readFileSync(path)).digest("hex")}`;
+}
+function mcpStableJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => mcpStableJson(item)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${mcpStableJson(record[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function mcpHashJson(value) {
+  return `sha256:${createHash("sha256").update(mcpStableJson(value)).digest("hex")}`;
+}
+function mcpVisualManifestSourceHash(path) {
+  const manifest = readJsonIfExists(path);
+  if (!manifest) return null;
+  return mcpHashJson({
+    version: manifest.version,
+    localOnly: manifest.localOnly,
+    baseUrl: manifest.baseUrl ?? null,
+    routes: (manifest.routes ?? []).map((route) => ({
+      route: route.route,
+      url: route.url,
+      screenshot: route.screenshot,
+      screenshotHash: route.screenshotHash ?? null,
+      status: route.status,
+      error: route.error
+    }))
+  });
+}
+function mcpStableFindingGraphAnchor(finding) {
+  if (!finding.graph) return void 0;
+  return {
+    node_id: finding.graph.node_id,
+    node_type: finding.graph.node_type,
+    route: finding.graph.route,
+    confidence: finding.graph.confidence,
+    reason: finding.graph.reason
+  };
+}
+function mcpEvidenceBundleSourceHash(path) {
+  const bundle = readJsonIfExists(path);
+  if (!bundle) return null;
+  return mcpHashJson({
+    health: bundle.health ? {
+      status: bundle.health.status,
+      score: bundle.health.score,
+      errorCount: bundle.health.errorCount,
+      warnCount: bundle.health.warnCount,
+      infoCount: bundle.health.infoCount,
+      findingCount: bundle.health.findingCount
+    } : null,
+    provenance: Object.entries(bundle.provenance ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => ({
+      key,
+      path: entry.path,
+      present: entry.present,
+      hash: entry.hash ?? null
+    })),
+    findings: (bundle.findings ?? []).map((finding) => ({
+      id: finding.id,
+      code: finding.code,
+      source: finding.source,
+      category: finding.category,
+      severity: finding.severity,
+      message: finding.message,
+      target: finding.target,
+      rule: finding.rule,
+      suggestedFix: finding.suggestedFix,
+      graph: mcpStableFindingGraphAnchor(finding),
+      repair: finding.repair?.id,
+      repairPlan: finding.repairPlan ? {
+        id: finding.repairPlan.id,
+        actions: finding.repairPlan.actions,
+        readTargets: finding.repairPlan.readTargets,
+        commands: finding.repairPlan.commands
+      } : void 0,
+      evidence: finding.evidence,
+      commands: finding.commands
+    }))
+  });
+}
+function mcpAnalysisSourceHash(path) {
+  const analysis = readJsonIfExists(path);
+  if (!analysis) return null;
+  return mcpHashJson({
+    project: {
+      framework: analysis.project?.framework,
+      frameworkVersion: analysis.project?.frameworkVersion,
+      packageManager: analysis.project?.packageManager,
+      hasTypeScript: analysis.project?.hasTypeScript,
+      hasTailwind: analysis.project?.hasTailwind,
+      projectScope: analysis.project?.projectScope
+    },
+    routes: {
+      strategy: analysis.routes?.strategy,
+      routes: (analysis.routes?.routes ?? []).map((route) => ({
+        path: route.path,
+        file: route.file,
+        hasLayout: route.hasLayout
+      }))
+    },
+    styling: {
+      approach: analysis.styling?.approach,
+      configFile: analysis.styling?.configFile,
+      darkMode: analysis.styling?.darkMode,
+      cssVariables: analysis.styling?.cssVariables
+    },
+    layout: {
+      shellPattern: analysis.layout?.shellPattern
+    },
+    features: {
+      detected: analysis.features?.detected
+    }
+  });
+}
+function mcpHealthBaselineDiffSourceHash(path) {
+  const diff = readJsonIfExists(path);
+  if (!diff) return null;
+  return mcpHashJson({
+    savedAt: diff.savedAt ?? null,
+    statusChanged: diff.statusChanged ?? false,
+    scoreDelta: diff.scoreDelta ?? null,
+    addedFindings: diff.addedFindings ?? [],
+    resolvedFindings: diff.resolvedFindings ?? [],
+    changedFiles: diff.changedFiles ?? [],
+    changedRoutes: diff.changedRoutes ?? [],
+    changedScreenshots: diff.changedScreenshots ?? [],
+    contractDrift: diff.contractDrift ?? []
+  });
+}
+function mcpHashGraphSource(projectRoot, source) {
+  if (!source.path) return null;
+  const path = join2(projectRoot, String(source.path));
+  if (source.kind === "brownfield-analysis") return mcpAnalysisSourceHash(path);
+  if (source.kind === "health-baseline-diff") return mcpHealthBaselineDiffSourceHash(path);
+  if (source.kind === "visual-manifest") return mcpVisualManifestSourceHash(path);
+  if (source.kind === "evidence-bundle") return mcpEvidenceBundleSourceHash(path);
+  return mcpHashFile(path);
+}
+function inspectMcpGraphFreshness(projectRoot) {
+  const manifest = readJsonIfExists(
+    graphArtifactPath(projectRoot, "graph.manifest.json")
+  );
+  if (!manifest) {
+    return { manifest: null, current: null, staleSources: [] };
+  }
+  const staleSources = (manifest.sources ?? []).filter((source) => source.path && source.hash).map((source) => {
+    const actualHash = mcpHashGraphSource(projectRoot, source);
+    return {
+      path: String(source.path),
+      expected_hash: source.hash,
+      actual_hash: actualHash
+    };
+  }).filter((source) => source.actual_hash !== source.expected_hash);
+  return {
+    manifest,
+    current: staleSources.length === 0,
+    staleSources
+  };
+}
+function mcpInspectProjectHealthGraph(projectRoot) {
+  const graphDir = join2(projectRoot, ".decantr", "graph");
+  const snapshotPath = graphArtifactPath(projectRoot, "graph.snapshot.json");
+  const manifestPath = graphArtifactPath(projectRoot, "graph.manifest.json");
+  const diffPath = graphArtifactPath(projectRoot, "graph.diff.json");
+  const capsulePath = graphArtifactPath(projectRoot, "contract-capsule.json");
+  const graphDirPresent = existsSync(graphDir);
+  const projectMetadataPresent = existsSync(join2(projectRoot, ".decantr", "project.json"));
+  const snapshot = readJsonIfExists(snapshotPath);
+  const capsule = readJsonIfExists(capsulePath);
+  const freshness = inspectMcpGraphFreshness(projectRoot);
+  const requiredArtifactPaths = [snapshotPath, manifestPath, diffPath, capsulePath];
+  const missingArtifacts = requiredArtifactPaths.filter((path) => !existsSync(path)).map((path) => relative2(projectRoot, path).replace(/\\/g, "/"));
+  const current = graphDirPresent || projectMetadataPresent ? missingArtifacts.length === 0 && freshness.current === true : null;
+  return {
+    present: graphDirPresent,
+    ready: current === true && Boolean(snapshot) && Boolean(capsule),
+    current,
+    snapshotPresent: existsSync(snapshotPath),
+    manifestPresent: existsSync(manifestPath),
+    diffPresent: existsSync(diffPath),
+    capsulePresent: existsSync(capsulePath),
+    snapshotId: snapshot?.id ?? null,
+    sourceHash: snapshot?.source_hash ?? null,
+    contractHash: capsule?.contract_hash ?? null,
+    contractCacheKey: capsule?.contract_cache_key ?? null,
+    sourceArtifactCount: snapshot?.nodes.filter((node) => node.type === "SourceArtifact").length ?? capsule?.summary?.source_artifacts ?? 0,
+    capsuleSourceArtifactLimit: capsule?.source_artifact_limit ?? null,
+    capsuleSourceArtifactsTruncated: capsule?.source_artifacts_truncated ?? null,
+    staleArtifacts: current === false ? [
+      ...missingArtifacts,
+      ...freshness.staleSources.map(
+        (source) => `${source.path} changed since graph manifest generation`
+      )
+    ] : [],
+    error: null
+  };
+}
+var MCP_GRAPH_NODE_TYPES = new Set(GRAPH_NODE_TYPES);
+var MCP_GRAPH_RELATIONS = new Set(GRAPH_RELATIONS);
+var MCP_GRAPH_DEFAULT_LIMIT = 200;
+var MCP_GRAPH_MAX_LIMIT = 500;
+function mcpGraphEdgeKey(edge) {
+  return [edge.src, edge.relation, edge.dst, String(edge.idx ?? "")].join("\0");
+}
+function graphToolLimit(args) {
+  if (typeof args.limit !== "number" || !Number.isFinite(args.limit)) {
+    return MCP_GRAPH_DEFAULT_LIMIT;
+  }
+  return Math.max(1, Math.min(MCP_GRAPH_MAX_LIMIT, Math.floor(args.limit)));
+}
+function stringListArg(args, key) {
+  const value = args[key];
+  if (value === void 0) return {};
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? { values: [trimmed] } : { values: [] };
+  }
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    return { error: `Optional parameter "${key}" must be a string or an array of strings.` };
+  }
+  return {
+    values: value.map((item) => item.trim()).filter(Boolean)
+  };
+}
+function graphNodeTypeArg(args, key) {
+  const value = args[key];
+  if (value === void 0) return {};
+  if (typeof value !== "string" || !MCP_GRAPH_NODE_TYPES.has(value)) {
+    return {
+      error: `Optional parameter "${key}" must be one of: ${GRAPH_NODE_TYPES.join(", ")}.`
+    };
+  }
+  return { value };
+}
+function graphNodeTypesArg(args, key) {
+  const parsed = stringListArg(args, key);
+  if (parsed.error) return { error: parsed.error };
+  if (!parsed.values) return {};
+  const invalid = parsed.values.find((value) => !MCP_GRAPH_NODE_TYPES.has(value));
+  if (invalid) {
+    return {
+      error: `Optional parameter "${key}" contains invalid node type "${invalid}". Expected one of: ${GRAPH_NODE_TYPES.join(", ")}.`
+    };
+  }
+  return { values: parsed.values };
+}
+function graphRelationArg(args, key) {
+  const value = args[key];
+  if (value === void 0) return {};
+  if (typeof value !== "string" || !MCP_GRAPH_RELATIONS.has(value)) {
+    return {
+      error: `Optional parameter "${key}" must be one of: ${GRAPH_RELATIONS.join(", ")}.`
+    };
+  }
+  return { value };
+}
+function graphRelationsArg(args, key) {
+  const parsed = stringListArg(args, key);
+  if (parsed.error) return { error: parsed.error };
+  if (!parsed.values) return {};
+  const invalid = parsed.values.find((value) => !MCP_GRAPH_RELATIONS.has(value));
+  if (invalid) {
+    return {
+      error: `Optional parameter "${key}" contains invalid relation "${invalid}". Expected one of: ${GRAPH_RELATIONS.join(", ")}.`
+    };
+  }
+  return { values: parsed.values };
+}
+function graphTraverseDirectionArg(args) {
+  const value = args.direction;
+  if (value === void 0) return {};
+  if (value !== "out" && value !== "in" && value !== "both") {
+    return { error: 'Optional parameter "direction" must be one of: out, in, both.' };
+  }
+  return { value };
+}
+function graphTraverseDepthArg(args) {
+  const value = args.depth;
+  if (value === void 0) return { value: 1 };
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return { value: 1, error: 'Optional parameter "depth" must be a number.' };
+  }
+  return { value: Math.max(0, Math.min(4, Math.floor(value))) };
+}
+function dedupeGraphNodes(nodes) {
+  return sortGraphNodes([...new Map(nodes.map((node) => [node.id, node])).values()]);
+}
+function dedupeGraphEdges(edges) {
+  return sortGraphEdges([...new Map(edges.map((edge) => [mcpGraphEdgeKey(edge), edge])).values()]);
+}
+function graphPayloadFilterArgs(args) {
+  const key = args.payload_key;
+  const value = args.payload_value;
+  const contains = args.payload_contains;
+  if (key !== void 0 && typeof key !== "string") {
+    return { error: 'Optional parameter "payload_key" must be a string.' };
+  }
+  if (value !== void 0 && typeof value !== "string") {
+    return { error: 'Optional parameter "payload_value" must be a string.' };
+  }
+  if (contains !== void 0 && typeof contains !== "string") {
+    return { error: 'Optional parameter "payload_contains" must be a string.' };
+  }
+  if (value !== void 0 && (typeof key !== "string" || !key.trim())) {
+    return { error: 'Optional parameter "payload_value" requires "payload_key".' };
+  }
+  return {
+    key: typeof key === "string" && key.trim() ? key.trim() : void 0,
+    value: typeof value === "string" ? value : void 0,
+    contains: typeof contains === "string" && contains.trim() ? contains.trim() : void 0
+  };
+}
+function limitGraphSubgraph(nodes, edges, limit) {
+  const limitedNodes = nodes.slice(0, limit);
+  const allowedNodeIds = new Set(limitedNodes.map((node) => node.id));
+  const limitedEdges = edges.filter((edge) => allowedNodeIds.has(edge.src) && allowedNodeIds.has(edge.dst)).slice(0, limit);
+  return {
+    nodes: limitedNodes,
+    edges: limitedEdges,
+    truncated: nodes.length > limitedNodes.length || edges.length > limitedEdges.length
+  };
+}
+function buildTaskTypedGraphContext(projectRoot, route, task = "", changedFiles = []) {
+  const snapshotPath = graphArtifactPath(projectRoot, "graph.snapshot.json");
+  const snapshot = readJsonIfExists(snapshotPath);
+  if (!snapshot) return null;
+  const capsule = readJsonIfExists(graphArtifactPath(projectRoot, "contract-capsule.json"));
+  const freshness = inspectMcpGraphFreshness(projectRoot);
+  const routeContext = route ? buildGraphRouteContext(snapshot, route, { task }) : null;
+  const limitedRouteContext = routeContext ? limitGraphSubgraph(routeContext.nodes, routeContext.edges, 120) : null;
+  const changedFileNodeIds = [
+    ...new Set(
+      changedFiles.map((file) => graphSourceNodeIdForFile(projectRoot, snapshot, file)).filter((nodeId) => Boolean(nodeId))
+    )
+  ];
+  const changedFileImpact = changedFileNodeIds.length > 0 ? buildGraphImpactContext(snapshot, changedFileNodeIds, { task, limit: 120 }) : null;
+  const limitedChangedFileImpact = changedFileImpact ? limitGraphSubgraph(changedFileImpact.nodes, changedFileImpact.edges, 120) : null;
+  return {
+    source: "local_graph",
+    artifact_path: displayWorkspacePath(snapshotPath),
+    snapshot_id: snapshot.id,
+    schema_version: snapshot.schema_version,
+    project_id: snapshot.project_id,
+    source_hash: snapshot.source_hash,
+    current: freshness.current,
+    stale_sources: freshness.staleSources,
+    contract: capsule ? {
+      cache_key: capsule.cache_key ?? null,
+      contract_hash: capsule.contract_hash ?? null,
+      contract_cache_key: capsule.contract_cache_key ?? null,
+      summary: capsule.summary ?? null
+    } : null,
+    route_context: routeContext ? {
+      route,
+      ranking: routeContext.ranking,
+      summary: routeContext.summary,
+      ids: routeContext.ids,
+      ranked: routeContext.ranked.slice(0, 24),
+      nodes: limitedRouteContext?.nodes ?? [],
+      edges: limitedRouteContext?.edges ?? [],
+      truncated: limitedRouteContext?.truncated ?? false
+    } : route ? {
+      route,
+      error: "Route not found in graph snapshot.",
+      available_routes: graphAvailableRoutes(snapshot)
+    } : null,
+    changed_file_context: changedFiles.length > 0 ? {
+      changed_files: changedFiles.slice(0, 40),
+      resolved_node_ids: changedFileNodeIds,
+      missing_files: changedFiles.filter((file) => !changedFileNodeIds.includes(`src:${file}`)).slice(0, 40),
+      impact: changedFileImpact ? {
+        ranking: changedFileImpact.ranking,
+        summary: changedFileImpact.summary,
+        ids: changedFileImpact.ids,
+        ranked: changedFileImpact.ranked.slice(0, 24),
+        nodes: limitedChangedFileImpact?.nodes ?? [],
+        edges: limitedChangedFileImpact?.edges ?? [],
+        truncated: limitedChangedFileImpact?.truncated ?? false
+      } : null
+    } : null
+  };
+}
 function changedFilesForTask(projectRoot) {
   const changed = /* @__PURE__ */ new Set();
   try {
@@ -191,12 +722,29 @@ function localLawSummary(projectRoot) {
     })) ?? []
   };
 }
+function styleBridgeSummary(projectRoot) {
+  const bridge = readJsonIfExists(join2(projectRoot, ".decantr", "style-bridge.json"));
+  return {
+    path: bridge ? ".decantr/style-bridge.json" : null,
+    status: bridge?.status ?? null,
+    styling_approach: bridge?.styling?.approach ?? null,
+    theme_modes: bridge?.styling?.themeModes ?? [],
+    mappings: bridge?.mappings?.map((mapping) => ({
+      id: mapping.id ?? "unknown",
+      label: mapping.label ?? null,
+      token_hints: mapping.tokenHints?.slice(0, 6) ?? [],
+      class_hints: mapping.classHints?.slice(0, 4) ?? [],
+      guardrails: mapping.guardrails?.slice(0, 3) ?? []
+    })) ?? []
+  };
+}
 function mentionsWord(text, term) {
   const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   return new RegExp(`\\b${escaped}\\b`, "i").test(text);
 }
 function taskAuthoritySummary(input) {
   const hasLocalLaw = input.localLaw.patterns.length > 0 || input.localLaw.rules.length > 0;
+  const hasStyleBridge = Boolean(input.styleBridge.path) || input.adoptionMode === "style-bridge";
   let lane = "Brownfield contract-only";
   let sourceAuthority = "Existing app is authoritative; Decantr supplies contract context.";
   let styleAuthority = "Use the existing styling system.";
@@ -209,11 +757,11 @@ function taskAuthoritySummary(input) {
     sourceAuthority = "Existing app remains authoritative except where Decantr CSS is explicitly adopted.";
     styleAuthority = "Decantr CSS runtime is active where adopted.";
     activeAuthorities.push("Decantr CSS runtime");
-  } else if (input.workflowMode === "brownfield-attach" && input.adoptionMode === "style-bridge") {
+  } else if (input.workflowMode === "brownfield-attach" && hasStyleBridge) {
     lane = "Hybrid style bridge";
     sourceAuthority = "Existing app remains authoritative; Decantr intent maps through the style bridge.";
     styleAuthority = "Use bridge tokens/classes as a mapping layer onto the app styling system.";
-    activeAuthorities.push("style bridge");
+    activeAuthorities.push("accepted style bridge");
   } else if (input.workflowMode === "brownfield-attach" && hasLocalLaw) {
     lane = "Hybrid local law";
     sourceAuthority = "Existing app plus accepted project-owned UI law are authoritative.";
@@ -664,6 +1212,10 @@ function mcpCommandsForFinding(source) {
       return ["decantr check", "decantr health"];
     case "design-token":
       return ["decantr export --to figma-tokens", "decantr health --evidence"];
+    case "style-bridge":
+      return ["decantr codify --style-bridge", "decantr verify --evidence"];
+    case "graph":
+      return ["decantr graph", "decantr health --evidence"];
     case "interaction":
       return ["decantr check --strict", "decantr health"];
     case "pack":
@@ -691,6 +1243,9 @@ function mcpSourceFromFinding(finding) {
   if (category.includes("interaction") || id.includes("interaction") || rule.includes("interaction")) {
     return "interaction";
   }
+  if (category.includes("style bridge") || id.includes("style-bridge") || rule.includes("style-bridge")) {
+    return "style-bridge";
+  }
   return "audit";
 }
 function mcpBuildRepairPrompt(input) {
@@ -703,7 +1258,9 @@ function mcpBuildRepairPrompt(input) {
     `Source: ${input.source}`,
     `Severity: ${input.severity}`,
     `Category: ${input.category}`,
+    input.code ? `Code: ${input.code}` : null,
     `Message: ${input.message}`,
+    input.repair ? `Repair: ${input.repair.id}` : null,
     input.evidence.length > 0 ? `Evidence:
 ${input.evidence.map((entry) => `- ${entry}`).join("\n")}` : null,
     input.suggestedFix ? `Suggested fix: ${input.suggestedFix}` : null,
@@ -718,8 +1275,22 @@ ${input.commands.map((command) => `- ${command}`).join("\n")}`
 function mcpHealthFinding(input) {
   const id = `${input.source}-${mcpSlug(input.baseId || input.rule || `${input.category}-${input.message}`)}`;
   const commands = mcpCommandsForFinding(input.source);
+  const diagnostic = deriveVerificationDiagnostic({
+    id,
+    source: input.source,
+    category: input.category,
+    message: input.message,
+    rule: input.rule,
+    target: input.target,
+    file: input.file,
+    suggestedFix: input.suggestedFix,
+    evidence: input.evidence
+  });
+  const code = input.code ?? diagnostic.code;
+  const repair = input.repair ?? diagnostic.repair;
   return {
     id,
+    code,
     source: input.source,
     category: input.category,
     severity: input.severity,
@@ -729,6 +1300,7 @@ function mcpHealthFinding(input) {
     file: input.file,
     rule: input.rule,
     suggestedFix: input.suggestedFix,
+    repair,
     remediation: {
       summary: input.suggestedFix || `Resolve ${input.category.toLowerCase()} finding.`,
       commands,
@@ -738,13 +1310,69 @@ function mcpHealthFinding(input) {
         category: input.category,
         severity: input.severity,
         message: input.message,
+        code,
         evidence: input.evidence ?? [],
         suggestedFix: input.suggestedFix,
+        repair,
         commands
       })
     }
   };
 }
+function mcpCollectGraphArtifactFindings(projectRoot) {
+  const graphDirPresent = existsSync(join2(projectRoot, ".decantr", "graph"));
+  const projectMetadataPresent = existsSync(join2(projectRoot, ".decantr", "project.json"));
+  if (!graphDirPresent && !projectMetadataPresent) {
+    return [];
+  }
+  const essence = readProjectEssence(projectRoot);
+  if (essence && !isV42(essence)) {
+    return [
+      mcpHealthFinding({
+        source: "graph",
+        category: "Typed Contract Graph",
+        severity: "warn",
+        message: "Typed Contract graph could not be derived: active graph workflows require Essence v4.0.0.",
+        evidence: [
+          "Graph derivation reads decantr.essence.json, local rules, style bridge, visual manifest, and saved evidence bundle artifacts."
+        ],
+        target: ".decantr/graph",
+        rule: "typed-graph-current",
+        suggestedFix: "Run `decantr migrate --to v4`, then run `decantr graph`.",
+        baseId: "typed-graph-current"
+      })
+    ];
+  }
+  const graphDir = join2(projectRoot, ".decantr", "graph");
+  const requiredArtifacts = [
+    "graph.snapshot.json",
+    "graph.manifest.json",
+    "graph.diff.json",
+    "contract-capsule.json"
+  ];
+  const missingArtifacts = requiredArtifacts.map((file) => join2(graphDir, file)).filter((path) => !existsSync(path)).map((path) => relative2(projectRoot, path).replace(/\\/g, "/"));
+  const graphFreshness = inspectMcpGraphFreshness(projectRoot);
+  const staleSources = graphFreshness.staleSources.map((source) => source.path);
+  if (!missingArtifacts.length && !staleSources.length) {
+    return [];
+  }
+  return [
+    mcpHealthFinding({
+      source: "graph",
+      category: "Typed Contract Graph",
+      severity: "warn",
+      message: "Typed Contract graph artifacts are missing or stale.",
+      evidence: [
+        ...missingArtifacts,
+        ...staleSources.map((path) => `${path} changed since graph manifest generation`)
+      ].slice(0, 8),
+      target: ".decantr/graph",
+      rule: "typed-graph-current",
+      suggestedFix: "Run `decantr graph` to regenerate graph snapshot, history, diff, manifest, and capsule.",
+      baseId: "typed-graph-current"
+    })
+  ];
+}
 function mcpCollectDeclaredRoutes(essence) {
   if (!essence || !isV42(essence)) return [];
   return Object.keys(essence.blueprint.routes ?? {}).sort();
@@ -770,6 +1398,8 @@ function mcpReportFromAudit(projectRoot, audit, assertions) {
         file: finding.file,
         rule: finding.rule,
         suggestedFix: finding.suggestedFix,
+        code: finding.code,
+        repair: finding.repair,
         baseId: finding.id
       })
     );
@@ -803,10 +1433,17 @@ function mcpReportFromAudit(projectRoot, audit, assertions) {
       })
     );
   }
+  for (const finding of mcpCollectGraphArtifactFindings(projectRoot)) {
+    pushUnique(finding);
+  }
+  const anchoredFindings = mcpAnchorHealthFindings(projectRoot, findings).map((finding) => ({
+    ...finding,
+    repairPlan: buildProjectHealthRepairPlan(projectRoot, finding)
+  }));
   const counts = {
-    errorCount: findings.filter((finding) => finding.severity === "error").length,
-    warnCount: findings.filter((finding) => finding.severity === "warn").length,
-    infoCount: findings.filter((finding) => finding.severity === "info").length
+    errorCount: anchoredFindings.filter((finding) => finding.severity === "error").length,
+    warnCount: anchoredFindings.filter((finding) => finding.severity === "warn").length,
+    infoCount: anchoredFindings.filter((finding) => finding.severity === "info").length
   };
   const manifest = audit.packManifest;
   return {
@@ -817,7 +1454,7 @@ function mcpReportFromAudit(projectRoot, audit, assertions) {
     score: mcpScoreFromCounts(counts),
     summary: {
       ...counts,
-      findingCount: findings.length,
+      findingCount: anchoredFindings.length,
       workflowMode: null,
       adoptionMode: null,
       essenceVersion: audit.summary.essenceVersion,
@@ -832,7 +1469,7 @@ function mcpReportFromAudit(projectRoot, audit, assertions) {
       runtimeChecked: audit.runtimeAudit.routeHintsChecked,
       runtimeMatched: audit.runtimeAudit.routeHintsMatched,
       runtimeCoverageOk: audit.summary.runtimeAuditChecked ? audit.runtimeAudit.routeHintsCoverageOk : null,
-      issues: findings.filter(
+      issues: anchoredFindings.filter(
         (finding) => finding.category.toLowerCase().includes("route") || finding.rule?.toLowerCase().includes("route") || finding.id.toLowerCase().includes("route")
       ).map((finding) => finding.message)
     },
@@ -845,11 +1482,12 @@ function mcpReportFromAudit(projectRoot, audit, assertions) {
       mutationPackCount: manifest?.mutations?.length ?? 0,
       generatedAt: typeof manifest?.generatedAt === "string" ? manifest.generatedAt : null
     },
+    graph: mcpInspectProjectHealthGraph(projectRoot),
     ci: {
       recommendedCommand: "decantr health --ci --fail-on error",
       failOn: "error"
     },
-    findings
+    findings: anchoredFindings
   };
 }
 function resolveMcpProjectRoot(value) {
@@ -873,6 +1511,170 @@ async function getMcpHealthState(projectRoot) {
   });
   return { audit, assertions, report, evidence };
 }
+function compactMcpFinding(finding, includePrompt) {
+  return {
+    id: finding.id,
+    code: finding.code,
+    source: finding.source,
+    category: finding.category,
+    severity: finding.severity,
+    message: finding.message,
+    evidence: finding.evidence,
+    target: finding.target,
+    file: finding.file,
+    rule: finding.rule,
+    suggestedFix: finding.suggestedFix,
+    graph: finding.graph,
+    repair: finding.repair,
+    repairPlan: finding.repairPlan,
+    remediation: {
+      summary: finding.remediation.summary,
+      commands: finding.remediation.commands,
+      prompt: includePrompt ? finding.remediation.prompt : void 0
+    }
+  };
+}
+function selectMcpRepairFinding(report, options = {}) {
+  return (options.findingId ? report.findings.find((entry) => entry.id === options.findingId) : void 0) ?? (options.code ? report.findings.find((entry) => entry.code === options.code) : void 0) ?? report.findings.find((entry) => entry.severity === "error") ?? report.findings.find((entry) => entry.severity === "warn") ?? report.findings[0] ?? null;
+}
+function mcpRepairPlanAction(finding) {
+  const repairId = finding.repair?.id ?? "manual-repair";
+  if (repairId === "regenerate-typed-graph" || finding.source === "graph") {
+    return {
+      id: repairId,
+      kind: "regenerate_artifact",
+      target: ".decantr/graph",
+      description: "Regenerate the typed Contract graph artifacts from the current project sources.",
+      payload: finding.repair?.payload ?? {}
+    };
+  }
+  if (repairId === "import-existing-component") {
+    return {
+      id: repairId,
+      kind: "replace_duplicate_with_import",
+      target: finding.file ?? finding.target ?? null,
+      description: "Remove the locally redeclared UI primitive and import the existing project-owned component.",
+      payload: finding.repair?.payload ?? {}
+    };
+  }
+  if (repairId === "replace-raw-control-with-local-component") {
+    return {
+      id: repairId,
+      kind: "replace_raw_control_with_component",
+      target: finding.file ?? finding.target ?? null,
+      description: "Replace the raw JSX control with the existing project-owned primitive component.",
+      payload: finding.repair?.payload ?? {}
+    };
+  }
+  if (repairId === "replace-arbitrary-style-with-bridge-token") {
+    return {
+      id: repairId,
+      kind: "replace_arbitrary_style_with_bridge_token",
+      target: finding.file ?? finding.target ?? null,
+      description: "Replace the arbitrary Tailwind value with an accepted project token/class from the style bridge, or update the bridge if the value is approved.",
+      payload: finding.repair?.payload ?? {}
+    };
+  }
+  return {
+    id: repairId,
+    kind: "manual_repair",
+    target: finding.file ?? finding.target ?? null,
+    description: finding.suggestedFix ?? finding.remediation.summary,
+    payload: finding.repair?.payload ?? {}
+  };
+}
+function mcpRepairReadTargets(finding) {
+  const targets = /* @__PURE__ */ new Set(["DECANTR.md", "decantr.essence.json"]);
+  if (finding.source === "graph") {
+    targets.add(".decantr/graph/graph.manifest.json");
+    targets.add(".decantr/graph/graph.snapshot.json");
+    targets.add(".decantr/graph/graph.diff.json");
+    targets.add(".decantr/graph/snapshots/");
+  }
+  if (finding.source === "style-bridge") {
+    targets.add(".decantr/style-bridge.json");
+  }
+  if (finding.source === "pack" || finding.source === "assertion") {
+    targets.add(".decantr/context/pack-manifest.json");
+  }
+  if (finding.graph?.node_id) {
+    targets.add(".decantr/graph/contract-capsule.json");
+  }
+  if (finding.file) {
+    targets.add(finding.file);
+  }
+  if (finding.target && !finding.target.startsWith("http")) {
+    targets.add(finding.target);
+  }
+  return [...targets];
+}
+function mcpRepairImpactContext(projectRoot, finding) {
+  const nodeId = finding.graph?.node_id;
+  if (!nodeId) return null;
+  const impact = buildGraphImpactContext(readMcpGraphSnapshot(projectRoot), nodeId, {
+    task: finding.message,
+    limit: 120
+  });
+  if (!impact) return null;
+  return {
+    snapshot_id: impact.snapshotId,
+    source_hash: impact.sourceHash,
+    seed_nodes: impact.seedNodes,
+    summary: impact.summary,
+    ids: impact.ids,
+    ranked: impact.ranked,
+    nodes: impact.nodes,
+    edges: impact.edges
+  };
+}
+function buildMcpRepairPlan(input) {
+  if (!input.finding) {
+    return {
+      project: input.evidence.project,
+      health: input.evidence.health,
+      finding: null,
+      plan: null,
+      message: "No Project Health findings require repair.",
+      commands: ["decantr health --evidence"]
+    };
+  }
+  const finding = input.finding;
+  const action = mcpRepairPlanAction(finding);
+  return {
+    project: input.evidence.project,
+    health: input.evidence.health,
+    finding: compactMcpFinding(finding, false),
+    plan: {
+      id: `repair-plan:${finding.id}`,
+      finding_id: finding.id,
+      diagnostic_code: finding.code ?? null,
+      repair_id: finding.repair?.id ?? null,
+      severity: finding.severity,
+      source: finding.source,
+      category: finding.category,
+      graph_anchor: finding.graph ?? null,
+      impact_context: mcpRepairImpactContext(input.projectRoot, finding),
+      actions: [action],
+      evidence: finding.evidence.map((entry, index) => ({
+        id: `evidence:${finding.id}:${index + 1}`,
+        text: entry
+      })),
+      read_targets: mcpRepairReadTargets(finding),
+      preserve: [
+        "existing framework, routing, and styling system",
+        "existing production behavior unrelated to this finding",
+        "accepted local law, style bridge mappings, and graph anchors"
+      ],
+      avoid: [
+        "rewriting unrelated routes",
+        "replacing the app styling system",
+        "regenerating Decantr artifacts unless the finding is about generated context or graph freshness"
+      ],
+      commands: finding.remediation.commands,
+      prompt: input.includePrompt === true ? finding.remediation.prompt : void 0
+    }
+  };
+}
 function discoverMcpWorkspaceProjects(root, maxProjects = 500) {
   const projects = [];
   function walk(dir, depth) {
@@ -994,8 +1796,8 @@ var TOOLS = [
   // 3. decantr_search_registry — network
   {
     name: "decantr_search_registry",
-    title: "Search Registry",
-    description: "Search the Decantr community content registry for patterns, archetypes, themes, and shells.",
+    title: "Search Vocabulary",
+    description: "Search Decantr official/community vocabulary for patterns, archetypes, themes, and shells.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1239,69 +2041,297 @@ var TOOLS = [
           type: "string",
           description: 'Section ID (archetype ID, e.g., "ai-chatbot", "auth-full", "settings-full")'
         },
-        path: {
+        path: {
+          type: "string",
+          description: "Optional path to an essence file when using hosted fallback compilation. Defaults to ./decantr.essence.json."
+        },
+        namespace: {
+          type: "string",
+          description: 'Optional preferred public namespace for hosted fallback compilation. Defaults to "@official".'
+        }
+      },
+      required: ["section_id"]
+    },
+    annotations: READ_ONLY
+  },
+  // 15. decantr_get_page_context — local read
+  {
+    name: "decantr_get_page_context",
+    title: "Get Page Context",
+    description: "Get the route-local context for a specific page. Returns the compiled page execution pack plus its parent section pack and section context when available. Falls back to hosted execution-pack compilation when local pack artifacts are missing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        page_id: {
+          type: "string",
+          description: 'Page ID (for example "overview", "settings", or "home").'
+        },
+        path: {
+          type: "string",
+          description: "Optional path to an essence file when using hosted fallback compilation. Defaults to ./decantr.essence.json."
+        },
+        namespace: {
+          type: "string",
+          description: 'Optional preferred public namespace for hosted fallback compilation. Defaults to "@official".'
+        }
+      },
+      required: ["page_id"]
+    },
+    annotations: READ_ONLY
+  },
+  // 16. decantr_get_project_state — local read
+  {
+    name: "decantr_get_project_state",
+    title: "Get Project State",
+    description: "Read a compact typed summary of the active Decantr project: Essence version, routes, generated packs, typed graph artifacts, local law, style bridge, diagnostic catalog, and recommended next MCP tools.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_path: {
+          type: "string",
+          description: "Optional relative project path inside the active workspace. Defaults to the current working directory."
+        }
+      }
+    },
+    annotations: READ_ONLY
+  },
+  // 17. decantr_prepare_task_context — local read
+  {
+    name: "decantr_prepare_task_context",
+    title: "Prepare Task Context",
+    description: "Resolve compact Brownfield/Essence task-time context for a route or page before editing. Returns route, section, page pack, directives, patterns, shared components, visual target, health evidence, and local screenshot references when available.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_path: {
+          type: "string",
+          description: "Optional relative project path inside the active workspace. Defaults to the current working directory."
+        },
+        route: {
+          type: "string",
+          description: 'Route being edited, for example "/feed". Preferred when known.'
+        },
+        page_id: {
+          type: "string",
+          description: "Page ID when route is unknown."
+        },
+        task: {
+          type: "string",
+          description: "Short task description used to rank relevant patterns and context."
+        }
+      }
+    },
+    annotations: READ_ONLY
+  },
+  // 17. decantr_get_contract_capsule — local typed graph read
+  {
+    name: "decantr_get_contract_capsule",
+    title: "Get Contract Capsule",
+    description: "Read the Decantr typed Contract capsule generated by `decantr graph`. This is the compact, cache-friendly Contract summary agents should load near session start.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_path: {
+          type: "string",
+          description: "Optional relative project path inside the active workspace. Defaults to the current working directory."
+        }
+      }
+    },
+    annotations: READ_ONLY
+  },
+  // 18. decantr_get_graph_snapshot — local typed graph read
+  {
+    name: "decantr_get_graph_snapshot",
+    title: "Get Graph Snapshot",
+    description: "Read the Decantr typed graph snapshot generated by `decantr graph`. By default returns snapshot metadata and available routes; pass route for a scoped route subgraph, include_history for a compact local timeline, or include_full for the full snapshot.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_path: {
+          type: "string",
+          description: "Optional relative project path inside the active workspace. Defaults to the current working directory."
+        },
+        route: {
+          type: "string",
+          description: 'Optional route path, for example "/settings", to return a scoped subgraph.'
+        },
+        node_id: {
+          type: "string",
+          description: 'Optional graph node ID, for example "cmp:button" or "tkn:surface", to return dependency impact context.'
+        },
+        file_path: {
+          type: "string",
+          description: 'Optional project-relative source file path, for example "src/app/page.tsx", to return dependency impact context for its SourceArtifact node.'
+        },
+        snapshot_id: {
+          type: "string",
+          description: 'Optional graph snapshot id to read from .decantr/graph/snapshots. Use "current" or omit for graph.snapshot.json.'
+        },
+        compare_to: {
+          type: "string",
+          description: 'Optional snapshot id to diff against the selected snapshot. Use "current" for graph.snapshot.json.'
+        },
+        include_diff_ops: {
+          type: "boolean",
+          description: "Include diff operation details when compare_to is provided. Defaults to false."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum diff operations or impact nodes to return. Defaults to 200, maximum 500."
+        },
+        include_full: {
+          type: "boolean",
+          description: "Return the full graph snapshot instead of metadata. Defaults to false."
+        },
+        include_history: {
+          type: "boolean",
+          description: "Include a compact index of local snapshot history entries from .decantr/graph/snapshots. Defaults to false."
+        },
+        task: {
+          type: "string",
+          description: "Optional task description used to boost matching nodes in route-scoped or impact ranked context."
+        }
+      }
+    },
+    annotations: READ_ONLY
+  },
+  // 19. decantr_query_graph — local typed graph read
+  {
+    name: "decantr_query_graph",
+    title: "Query Graph",
+    description: "Run a narrow typed query against the local Decantr graph snapshot generated by `decantr graph`. Use for direct node/type/relation lookups instead of reading the full graph.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_path: {
+          type: "string",
+          description: "Optional relative project path inside the active workspace. Defaults to the current working directory."
+        },
+        snapshot_id: {
+          type: "string",
+          description: 'Optional snapshot id from local graph history, or "current". Defaults to current.'
+        },
+        node_ids: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Optional exact graph node IDs to return, for example ["rt:/feed"].'
+        },
+        file_path: {
+          type: "string",
+          description: 'Optional project-relative source file path, for example "src/app/page.tsx", resolved to a SourceArtifact node selector.'
+        },
+        node_type: {
+          type: "string",
+          enum: [...GRAPH_NODE_TYPES],
+          description: 'Optional single node type selector, for example "Route" or "Component".'
+        },
+        node_types: {
+          type: "array",
+          items: { type: "string", enum: [...GRAPH_NODE_TYPES] },
+          description: "Optional node type selectors."
+        },
+        payload_key: {
+          type: "string",
+          description: 'Optional node payload key or dotted path filter, for example "code" for Finding nodes.'
+        },
+        payload_value: {
+          type: "string",
+          description: 'Optional exact stringified payload value used with payload_key, for example "COMP010".'
+        },
+        payload_contains: {
+          type: "string",
+          description: "Optional case-insensitive substring filter over the node payload JSON."
+        },
+        edge_src: {
+          type: "string",
+          description: "Optional edge source node ID selector."
+        },
+        edge_dst: {
+          type: "string",
+          description: "Optional edge destination node ID selector."
+        },
+        relation: {
+          type: "string",
+          enum: [...GRAPH_RELATIONS],
+          description: 'Optional single edge relation selector, for example "PAGE_COMPOSES_PATTERN".'
+        },
+        relations: {
+          type: "array",
+          items: { type: "string", enum: [...GRAPH_RELATIONS] },
+          description: "Optional edge relation selectors."
+        },
+        include_edges: {
+          type: "boolean",
+          description: "When querying nodes, include incident edges and their opposite endpoint nodes. Defaults to false unless edge selectors are present."
+        },
+        include_impact: {
+          type: "boolean",
+          description: "When querying nodes, also return the dependency impact context for the matched node IDs."
+        },
+        task: {
           type: "string",
-          description: "Optional path to an essence file when using hosted fallback compilation. Defaults to ./decantr.essence.json."
+          description: "Optional task description used to boost matching nodes in the impact ranking when include_impact is true."
         },
-        namespace: {
-          type: "string",
-          description: 'Optional preferred public namespace for hosted fallback compilation. Defaults to "@official".'
+        limit: {
+          type: "number",
+          description: "Maximum nodes and edges to return. Defaults to 200, maximum 500."
         }
-      },
-      required: ["section_id"]
+      }
     },
     annotations: READ_ONLY
   },
-  // 15. decantr_get_page_context — local read
+  // 20. decantr_traverse_graph — local typed graph read
   {
-    name: "decantr_get_page_context",
-    title: "Get Page Context",
-    description: "Get the route-local context for a specific page. Returns the compiled page execution pack plus its parent section pack and section context when available. Falls back to hosted execution-pack compilation when local pack artifacts are missing.",
+    name: "decantr_traverse_graph",
+    title: "Traverse Graph",
+    description: "Traverse the local Decantr graph from one or more node IDs or a source file by relation, direction, and depth. Use for questions like which pages use this token or which graph nodes point at this source file.",
     inputSchema: {
       type: "object",
       properties: {
-        page_id: {
+        project_path: {
           type: "string",
-          description: 'Page ID (for example "overview", "settings", or "home").'
+          description: "Optional relative project path inside the active workspace. Defaults to the current working directory."
         },
-        path: {
+        snapshot_id: {
           type: "string",
-          description: "Optional path to an essence file when using hosted fallback compilation. Defaults to ./decantr.essence.json."
+          description: 'Optional snapshot id from local graph history, or "current". Defaults to current.'
         },
-        namespace: {
-          type: "string",
-          description: 'Optional preferred public namespace for hosted fallback compilation. Defaults to "@official".'
-        }
-      },
-      required: ["page_id"]
-    },
-    annotations: READ_ONLY
-  },
-  // 16. decantr_prepare_task_context — local read
-  {
-    name: "decantr_prepare_task_context",
-    title: "Prepare Task Context",
-    description: "Resolve compact Brownfield/Essence task-time context for a route or page before editing. Returns route, section, page pack, directives, patterns, shared components, visual target, health evidence, and local screenshot references when available.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        route: {
+        from: {
           type: "string",
-          description: 'Route being edited, for example "/feed". Preferred when known.'
+          description: 'Start node ID, for example "rt:/feed" or "tkn:color.primary".'
         },
-        page_id: {
+        from_ids: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional start node IDs. Used when traversing from multiple anchors."
+        },
+        file_path: {
           type: "string",
-          description: "Page ID when route is unknown."
+          description: 'Optional project-relative source file path, for example "src/app/page.tsx", resolved to a SourceArtifact start node.'
         },
-        task: {
+        relations: {
+          type: "array",
+          items: { type: "string", enum: [...GRAPH_RELATIONS] },
+          description: "Optional relation allow-list. When omitted, all relations are traversed."
+        },
+        direction: {
           type: "string",
-          description: "Short task description used to rank relevant patterns and context."
+          enum: ["out", "in", "both"],
+          description: "Traversal direction. Defaults to out."
+        },
+        depth: {
+          type: "number",
+          description: "Traversal depth. Defaults to 1, maximum 4."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum nodes and edges to return. Defaults to 200, maximum 500."
         }
       }
     },
     annotations: READ_ONLY
   },
-  // 17. decantr_get_execution_pack — local read
+  // 21. decantr_get_execution_pack — local read
   {
     name: "decantr_get_execution_pack",
     title: "Get Execution Pack",
@@ -1457,7 +2487,85 @@ var TOOLS = [
     },
     annotations: READ_ONLY_NETWORK
   },
-  // 22. decantr_get_evidence_bundle — local reliability artifact
+  // 24. decantr_get_findings — local typed findings read
+  {
+    name: "decantr_get_findings",
+    title: "Get Findings",
+    description: "Return typed Project Health findings for the current Decantr project, with stable codes, repair IDs, graph anchors when available, and optional repair prompts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_path: {
+          type: "string",
+          description: "Optional relative project path inside the active workspace. Defaults to the current working directory."
+        },
+        severity: {
+          type: "string",
+          enum: ["error", "warn", "info"],
+          description: "Optional severity filter."
+        },
+        source: {
+          type: "string",
+          enum: [
+            "audit",
+            "assertion",
+            "browser",
+            "check",
+            "brownfield",
+            "design-token",
+            "style-bridge",
+            "graph",
+            "runtime",
+            "pack",
+            "interaction"
+          ],
+          description: "Optional finding source filter."
+        },
+        code: {
+          type: "string",
+          description: 'Optional stable diagnostic code filter, for example "TOKEN010".'
+        },
+        include_prompts: {
+          type: "boolean",
+          description: "Include full repair prompts on each finding. Defaults to false to keep context compact."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum findings to return. Defaults to 50, maximum 200."
+        }
+      }
+    },
+    annotations: READ_ONLY
+  },
+  // 25. decantr_get_repair_plan — local structured repair loop
+  {
+    name: "decantr_get_repair_plan",
+    title: "Get Repair Plan",
+    description: "Return a typed repair plan for one Project Health finding: diagnostic code, repair ID, graph anchor, action payload, evidence, read targets, preserve/avoid constraints, rerun commands, and optional prompt text.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_path: {
+          type: "string",
+          description: "Optional relative project path inside the active workspace. Defaults to the current working directory."
+        },
+        finding_id: {
+          type: "string",
+          description: "Optional finding id. Defaults to the first error or warning, then the first finding."
+        },
+        code: {
+          type: "string",
+          description: 'Optional stable diagnostic code selector, for example "GRAPH001".'
+        },
+        include_prompt: {
+          type: "boolean",
+          description: "Include the human-readable repair prompt alongside the typed plan."
+        }
+      }
+    },
+    annotations: READ_ONLY
+  },
+  // 26. decantr_get_evidence_bundle — local reliability artifact
   {
     name: "decantr_get_evidence_bundle",
     title: "Get Evidence Bundle",
@@ -2111,6 +3219,576 @@ async function handleTool(name, args) {
         return { error: `Failed to update essence: ${e.message}` };
       }
     }
+    case "decantr_get_project_state": {
+      try {
+        const projectRoot = graphProjectRoot(args);
+        const essence = readProjectEssence(projectRoot);
+        const packManifest = readProjectPackManifest(projectRoot);
+        const graphDir = join2(projectRoot, ".decantr", "graph");
+        const snapshotPath = graphArtifactPath(projectRoot, "graph.snapshot.json");
+        const manifestPath = graphArtifactPath(projectRoot, "graph.manifest.json");
+        const diffPath = graphArtifactPath(projectRoot, "graph.diff.json");
+        const capsulePath = graphArtifactPath(projectRoot, "contract-capsule.json");
+        const snapshot = readJsonIfExists(snapshotPath);
+        const graphDiff = readJsonIfExists(diffPath);
+        const snapshotHistoryPath = snapshot ? graphSnapshotHistoryPath(projectRoot, snapshot.id) : null;
+        const snapshotHistoryPresent = snapshotHistoryPath ? existsSync(snapshotHistoryPath) : false;
+        const snapshotHistoryCount = graphSnapshotHistoryCount(projectRoot);
+        const capsule = readJsonIfExists(capsulePath);
+        const graphFreshness = inspectMcpGraphFreshness(projectRoot);
+        const projectConfig = readJsonIfExists(join2(projectRoot, ".decantr", "project.json"));
+        const localPatternsPresent = existsSync(join2(projectRoot, ".decantr", "local-patterns.json"));
+        const localRulesPresent = existsSync(join2(projectRoot, ".decantr", "rules.json"));
+        const styleBridgePresent = existsSync(join2(projectRoot, ".decantr", "style-bridge.json"));
+        const hasGraphArtifacts = existsSync(snapshotPath) && snapshotHistoryPresent && existsSync(manifestPath) && existsSync(diffPath) && existsSync(capsulePath);
+        const graphReady = Boolean(snapshot) && hasGraphArtifacts && graphFreshness.current === true;
+        return {
+          source: "local_workspace",
+          project_root: displayWorkspacePath(projectRoot),
+          essence: essence ? {
+            present: true,
+            version: typeof essence.version === "string" ? essence.version : null,
+            active_v4: isV42(essence),
+            routes: isV42(essence) ? Object.keys(essence.blueprint.routes ?? {}).sort() : [],
+            sections: isV42(essence) ? essence.blueprint.sections.map((section) => ({
+              id: section.id,
+              role: section.role,
+              pages: section.pages.length
+            })) : [],
+            features: isV42(essence) ? essence.blueprint.features : [],
+            guard: isV42(essence) ? essence.meta.guard : null
+          } : {
+            present: false,
+            version: null,
+            active_v4: false,
+            routes: [],
+            sections: [],
+            features: [],
+            guard: null
+          },
+          project_config: {
+            present: Boolean(projectConfig),
+            workflow_mode: projectConfig?.workflowMode ?? null,
+            adoption_mode: projectConfig?.adoptionMode ?? null,
+            telemetry_enabled: projectConfig?.telemetry === true
+          },
+          context: {
+            manifest_present: Boolean(packManifest),
+            scaffold_pack_present: Boolean(packManifest?.scaffold),
+            review_pack_present: Boolean(packManifest?.review),
+            section_pack_count: packManifest?.sections.length ?? 0,
+            page_pack_count: packManifest?.pages.length ?? 0,
+            mutation_pack_count: packManifest?.mutations?.length ?? 0,
+            generated_at: packManifest && typeof packManifest.generatedAt === "string" ? packManifest.generatedAt : null
+          },
+          graph: {
+            graph_dir_present: existsSync(graphDir),
+            manifest_present: Boolean(graphFreshness.manifest),
+            snapshot_present: Boolean(snapshot),
+            snapshot_history_present: snapshotHistoryPresent,
+            snapshot_history_path: snapshotHistoryPath ? displayWorkspacePath(snapshotHistoryPath) : null,
+            snapshot_history_count: snapshotHistoryCount,
+            capsule_present: existsSync(capsulePath),
+            diff_present: existsSync(diffPath),
+            ready: graphReady,
+            current: graphFreshness.current,
+            stale_sources: graphFreshness.staleSources,
+            snapshot_id: snapshot?.id ?? null,
+            schema_version: snapshot?.schema_version ?? null,
+            source_hash: snapshot?.source_hash ?? null,
+            cache_key: capsule?.cache_key ?? null,
+            contract_hash: capsule?.contract_hash ?? null,
+            contract_cache_key: capsule?.contract_cache_key ?? null,
+            capsule_source_artifact_count: capsule?.summary?.source_artifacts ?? null,
+            capsule_source_artifact_limit: capsule?.source_artifact_limit ?? null,
+            capsule_source_artifacts_truncated: capsule?.source_artifacts_truncated ?? null,
+            summary: snapshot?.summary ?? null,
+            diff_summary: graphDiff ? summarizeGraphDiff(graphDiff) : null,
+            available_routes: snapshot ? graphAvailableRoutes(snapshot) : [],
+            source_artifact_count: snapshot ? snapshot.nodes.filter((node) => node.type === "SourceArtifact").length : 0,
+            available_source_artifacts: snapshot ? graphAvailableSourceArtifacts(snapshot).slice(0, 40) : []
+          },
+          local_authority: {
+            local_patterns_present: localPatternsPresent,
+            local_rules_present: localRulesPresent,
+            style_bridge_present: styleBridgePresent
+          },
+          diagnostics: {
+            known_count: KNOWN_VERIFICATION_DIAGNOSTICS.length,
+            families: [
+              ...new Set(KNOWN_VERIFICATION_DIAGNOSTICS.map((entry) => entry.family))
+            ].sort(),
+            codes: KNOWN_VERIFICATION_DIAGNOSTICS.map((entry) => ({
+              code: entry.code,
+              rule: entry.rule,
+              repair_id: entry.repairId,
+              family: entry.family
+            })).sort((a, b) => a.code.localeCompare(b.code) || a.rule.localeCompare(b.rule))
+          },
+          recommended_next_tools: [
+            graphReady ? "decantr_get_contract_capsule" : "decantr_get_findings",
+            graphReady ? null : "decantr_get_repair_plan",
+            snapshot ? "decantr_get_graph_snapshot" : null,
+            "decantr_prepare_task_context",
+            "decantr_get_findings",
+            "decantr_get_evidence_bundle"
+          ].filter((tool) => Boolean(tool))
+        };
+      } catch (e) {
+        return { error: `Could not read project state: ${e.message}` };
+      }
+    }
+    case "decantr_get_contract_capsule": {
+      try {
+        const projectRoot = graphProjectRoot(args);
+        const capsulePath = graphArtifactPath(projectRoot, "contract-capsule.json");
+        const capsule = readJsonIfExists(capsulePath);
+        if (!capsule) {
+          return {
+            error: "Contract capsule not found. Run `decantr graph` from the project root, or `decantr graph --project <path>` from a workspace root.",
+            expected_path: displayWorkspacePath(capsulePath)
+          };
+        }
+        return {
+          source: "local_graph",
+          artifact_path: displayWorkspacePath(capsulePath),
+          capsule
+        };
+      } catch (e) {
+        return { error: `Could not read contract capsule: ${e.message}` };
+      }
+    }
+    case "decantr_get_graph_snapshot": {
+      try {
+        const projectRoot = graphProjectRoot(args);
+        const snapshotPath = graphArtifactPath(projectRoot, "graph.snapshot.json");
+        const diffPath = graphArtifactPath(projectRoot, "graph.diff.json");
+        const currentSnapshot = readJsonIfExists(snapshotPath);
+        const graphDiff = readJsonIfExists(diffPath);
+        if (!currentSnapshot) {
+          return {
+            error: "Graph snapshot not found. Run `decantr graph` from the project root, or `decantr graph --project <path>` from a workspace root.",
+            expected_path: displayWorkspacePath(snapshotPath)
+          };
+        }
+        const snapshotId = typeof args.snapshot_id === "string" ? args.snapshot_id.trim() : "";
+        if (args.snapshot_id !== void 0 && typeof args.snapshot_id !== "string") {
+          return { error: 'Optional parameter "snapshot_id" must be a string.' };
+        }
+        const selected = readGraphSnapshotById(projectRoot, snapshotId || void 0);
+        if (!selected.snapshot) {
+          return {
+            error: `Graph snapshot not found in local history: ${snapshotId}`,
+            expected_path: displayWorkspacePath(selected.path),
+            current_snapshot_id: currentSnapshot.id,
+            history: readGraphSnapshotHistory(projectRoot)
+          };
+        }
+        const snapshot = selected.snapshot;
+        const snapshotHistoryPath = graphSnapshotHistoryPath(projectRoot, snapshot.id);
+        let comparison = null;
+        if (args.compare_to !== void 0 && typeof args.compare_to !== "string") {
+          return { error: 'Optional parameter "compare_to" must be a string.' };
+        }
+        const compareTo = typeof args.compare_to === "string" ? args.compare_to.trim() : "";
+        if (compareTo) {
+          const baseline = readGraphSnapshotById(projectRoot, compareTo);
+          if (!baseline.snapshot) {
+            return {
+              error: `Comparison graph snapshot not found in local history: ${compareTo}`,
+              expected_path: displayWorkspacePath(baseline.path),
+              current_snapshot_id: currentSnapshot.id,
+              selected_snapshot_id: snapshot.id,
+              history: readGraphSnapshotHistory(projectRoot)
+            };
+          }
+          const diff = diffGraphSnapshots(baseline.snapshot, snapshot);
+          const limit = graphToolLimit(args);
+          comparison = {
+            from: baseline.snapshot.id,
+            to: snapshot.id,
+            summary: summarizeGraphDiff(diff),
+            ...args.include_diff_ops === true ? {
+              ops: diff.ops.slice(0, limit),
+              ops_truncated: diff.ops.length > limit,
+              limit
+            } : {}
+          };
+        }
+        const route = typeof args.route === "string" ? args.route : void 0;
+        const task = typeof args.task === "string" ? args.task : "";
+        if (args.node_id !== void 0 && typeof args.node_id !== "string") {
+          return { error: 'Optional parameter "node_id" must be a string.' };
+        }
+        if (args.file_path !== void 0 && typeof args.file_path !== "string") {
+          return { error: 'Optional parameter "file_path" must be a string.' };
+        }
+        const nodeId = typeof args.node_id === "string" ? args.node_id.trim() : "";
+        const filePath = typeof args.file_path === "string" ? args.file_path.trim() : "";
+        const fileNodeId = graphSourceNodeIdForFile(projectRoot, snapshot, filePath || void 0);
+        if (filePath && !fileNodeId) {
+          return {
+            error: `Source file not found in graph snapshot: ${filePath}`,
+            snapshot_id: snapshot.id,
+            available_routes: graphAvailableRoutes(snapshot),
+            available_source_artifacts: graphAvailableSourceArtifacts(snapshot)
+          };
+        }
+        if (route) {
+          const subgraph = buildGraphRouteContext(snapshot, route, { task });
+          if (!subgraph) {
+            return {
+              error: `Route not found in graph snapshot: ${route}`,
+              snapshot_id: snapshot.id,
+              available_routes: graphAvailableRoutes(snapshot)
+            };
+          }
+          return {
+            source: "local_graph",
+            artifact_path: displayWorkspacePath(selected.path),
+            current_snapshot_id: currentSnapshot.id,
+            snapshot_id: snapshot.id,
+            schema_version: snapshot.schema_version,
+            project_id: snapshot.project_id,
+            source_hash: snapshot.source_hash,
+            route,
+            comparison,
+            ranking: subgraph.ranking,
+            summary: subgraph.summary,
+            route_node: subgraph.routeNode,
+            ids: subgraph.ids,
+            ranked: subgraph.ranked,
+            nodes: subgraph.nodes,
+            edges: subgraph.edges
+          };
+        }
+        const impactSeedIds = [
+          ...new Set([nodeId, fileNodeId].filter((value) => Boolean(value)))
+        ];
+        if (impactSeedIds.length > 0) {
+          const limit = graphToolLimit(args);
+          const impact = buildGraphImpactContext(snapshot, impactSeedIds, { task, limit });
+          if (!impact) {
+            return {
+              error: `Impact seed not found in graph snapshot: ${impactSeedIds.join(", ")}`,
+              snapshot_id: snapshot.id,
+              available_routes: graphAvailableRoutes(snapshot),
+              available_source_artifacts: graphAvailableSourceArtifacts(snapshot)
+            };
+          }
+          return {
+            source: "local_graph",
+            artifact_path: displayWorkspacePath(selected.path),
+            current_snapshot_id: currentSnapshot.id,
+            snapshot_id: snapshot.id,
+            schema_version: snapshot.schema_version,
+            project_id: snapshot.project_id,
+            source_hash: snapshot.source_hash,
+            node_id: nodeId || void 0,
+            file_path: filePath || void 0,
+            resolved_node_ids: impactSeedIds,
+            comparison,
+            ranking: impact.ranking,
+            summary: impact.summary,
+            seed_nodes: impact.seedNodes,
+            missing_node_ids: impact.missingNodeIds,
+            ids: impact.ids,
+            ranked: impact.ranked,
+            nodes: impact.nodes,
+            edges: impact.edges
+          };
+        }
+        if (args.include_full === true) {
+          return {
+            source: "local_graph",
+            artifact_path: displayWorkspacePath(selected.path),
+            current_snapshot_id: currentSnapshot.id,
+            comparison,
+            snapshot
+          };
+        }
+        return {
+          source: "local_graph",
+          artifact_path: displayWorkspacePath(selected.path),
+          snapshot_history_path: displayWorkspacePath(snapshotHistoryPath),
+          snapshot_history_present: existsSync(snapshotHistoryPath),
+          snapshot_history_count: graphSnapshotHistoryCount(projectRoot),
+          current_snapshot_id: currentSnapshot.id,
+          snapshot_id: snapshot.id,
+          schema_version: snapshot.schema_version,
+          project_id: snapshot.project_id,
+          created_at: snapshot.created_at,
+          source_hash: snapshot.source_hash,
+          summary: snapshot.summary,
+          history: args.include_history === true ? readGraphSnapshotHistory(projectRoot) : void 0,
+          diff_summary: !snapshotId || snapshot.id === currentSnapshot.id ? graphDiff ? summarizeGraphDiff(graphDiff) : null : null,
+          comparison,
+          available_routes: graphAvailableRoutes(snapshot)
+        };
+      } catch (e) {
+        return { error: `Could not read graph snapshot: ${e.message}` };
+      }
+    }
+    case "decantr_query_graph": {
+      try {
+        const projectRoot = graphProjectRoot(args);
+        const snapshotId = typeof args.snapshot_id === "string" ? args.snapshot_id.trim() : "";
+        if (args.snapshot_id !== void 0 && typeof args.snapshot_id !== "string") {
+          return { error: 'Optional parameter "snapshot_id" must be a string.' };
+        }
+        const selected = readGraphSnapshotById(projectRoot, snapshotId || void 0);
+        const snapshotPath = selected.path;
+        const snapshot = selected.snapshot;
+        if (!snapshot) {
+          return {
+            error: snapshotId && snapshotId !== "current" ? `Graph snapshot not found: ${snapshotId}. Run \`decantr graph\` to generate snapshot history.` : "Graph snapshot not found. Run `decantr graph` from the project root, or `decantr graph --project <path>` from a workspace root.",
+            expected_path: displayWorkspacePath(snapshotPath)
+          };
+        }
+        const currentSnapshot = readMcpGraphSnapshot(projectRoot);
+        const nodeIds = stringListArg(args, "node_ids");
+        if (nodeIds.error) return { error: nodeIds.error };
+        if (args.file_path !== void 0 && typeof args.file_path !== "string") {
+          return { error: 'Optional parameter "file_path" must be a string.' };
+        }
+        const filePath = typeof args.file_path === "string" ? args.file_path.trim() : "";
+        const fileNodeId = graphSourceNodeIdForFile(projectRoot, snapshot, filePath || void 0);
+        if (filePath && !fileNodeId) {
+          return {
+            error: `Source file not found in graph snapshot: ${filePath}`,
+            snapshot_id: snapshot.id,
+            available_routes: graphAvailableRoutes(snapshot),
+            available_source_artifacts: graphAvailableSourceArtifacts(snapshot)
+          };
+        }
+        const resolvedNodeIds = [
+          .../* @__PURE__ */ new Set([...nodeIds.values ?? [], ...fileNodeId ? [fileNodeId] : []])
+        ];
+        const nodeType = graphNodeTypeArg(args, "node_type");
+        if (nodeType.error) return { error: nodeType.error };
+        const nodeTypes = graphNodeTypesArg(args, "node_types");
+        if (nodeTypes.error) return { error: nodeTypes.error };
+        const relation = graphRelationArg(args, "relation");
+        if (relation.error) return { error: relation.error };
+        const relations = graphRelationsArg(args, "relations");
+        if (relations.error) return { error: relations.error };
+        const payloadFilter = graphPayloadFilterArgs(args);
+        if (payloadFilter.error) return { error: payloadFilter.error };
+        if (args.task !== void 0 && typeof args.task !== "string") {
+          return { error: 'Optional parameter "task" must be a string.' };
+        }
+        const edgeSrc = typeof args.edge_src === "string" ? args.edge_src.trim() : void 0;
+        const edgeDst = typeof args.edge_dst === "string" ? args.edge_dst.trim() : void 0;
+        if (args.edge_src !== void 0 && typeof args.edge_src !== "string") {
+          return { error: 'Optional parameter "edge_src" must be a string.' };
+        }
+        if (args.edge_dst !== void 0 && typeof args.edge_dst !== "string") {
+          return { error: 'Optional parameter "edge_dst" must be a string.' };
+        }
+        const hasNodeSelector = resolvedNodeIds.length > 0 || !!nodeType.value || !!nodeTypes.values?.length || !!payloadFilter.key || !!payloadFilter.contains;
+        const hasEdgeSelector = !!edgeSrc || !!edgeDst || !!relation.value || !!relations.values?.length;
+        if (!hasNodeSelector && !hasEdgeSelector) {
+          return {
+            error: "Provide at least one graph selector: node_ids, file_path, node_type, node_types, payload_key, payload_contains, edge_src, edge_dst, relation, or relations."
+          };
+        }
+        const store = createMemoryGraphStore({
+          nodes: snapshot.nodes,
+          edges: snapshot.edges,
+          snapshots: [snapshot]
+        });
+        const limit = graphToolLimit(args);
+        let nodes = [];
+        let edges = [];
+        if (hasNodeSelector) {
+          nodes = await store.queryNodes({
+            ids: resolvedNodeIds.length > 0 ? resolvedNodeIds : void 0,
+            type: nodeType.value,
+            types: nodeTypes.values,
+            payloadKey: payloadFilter.key,
+            payloadValue: payloadFilter.value,
+            payloadContains: payloadFilter.contains
+          });
+        }
+        if (hasEdgeSelector) {
+          edges = await store.queryEdges({
+            src: edgeSrc,
+            dst: edgeDst,
+            relation: relation.value,
+            relations: relations.values
+          });
+        }
+        const shouldIncludeEdges = args.include_edges === true || hasEdgeSelector;
+        const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+        if (shouldIncludeEdges && hasNodeSelector) {
+          const selectedIds = new Set(nodeMap.keys());
+          edges = dedupeGraphEdges([
+            ...edges,
+            ...snapshot.edges.filter(
+              (edge) => selectedIds.has(edge.src) || selectedIds.has(edge.dst)
+            )
+          ]);
+        }
+        for (const edge of edges) {
+          const srcNode = snapshot.nodes.find((node) => node.id === edge.src);
+          const dstNode = snapshot.nodes.find((node) => node.id === edge.dst);
+          if (srcNode) nodeMap.set(srcNode.id, srcNode);
+          if (dstNode) nodeMap.set(dstNode.id, dstNode);
+        }
+        nodes = dedupeGraphNodes([...nodeMap.values()]);
+        edges = dedupeGraphEdges(edges);
+        const limited = limitGraphSubgraph(nodes, edges, limit);
+        const impact = args.include_impact === true && limited.nodes.length > 0 ? buildGraphImpactContext(
+          snapshot,
+          limited.nodes.map((node) => node.id),
+          {
+            task: typeof args.task === "string" ? args.task : void 0,
+            limit
+          }
+        ) : null;
+        return {
+          source: "local_graph",
+          artifact_path: displayWorkspacePath(snapshotPath),
+          current_snapshot_id: currentSnapshot?.id ?? null,
+          snapshot_id: snapshot.id,
+          schema_version: snapshot.schema_version,
+          project_id: snapshot.project_id,
+          source_hash: snapshot.source_hash,
+          query: {
+            node_ids: resolvedNodeIds.length > 0 ? resolvedNodeIds : nodeIds.values,
+            file_path: filePath || void 0,
+            node_type: nodeType.value,
+            node_types: nodeTypes.values,
+            payload_key: payloadFilter.key,
+            payload_value: payloadFilter.value,
+            payload_contains: payloadFilter.contains,
+            edge_src: edgeSrc,
+            edge_dst: edgeDst,
+            relation: relation.value,
+            relations: relations.values,
+            include_edges: shouldIncludeEdges,
+            include_impact: args.include_impact === true,
+            task: typeof args.task === "string" ? args.task : void 0,
+            limit
+          },
+          summary: {
+            nodes: limited.nodes.length,
+            edges: limited.edges.length,
+            total_nodes: nodes.length,
+            total_edges: edges.length,
+            truncated: limited.truncated
+          },
+          nodes: limited.nodes,
+          edges: limited.edges,
+          impact
+        };
+      } catch (e) {
+        return { error: `Could not query graph snapshot: ${e.message}` };
+      }
+    }
+    case "decantr_traverse_graph": {
+      try {
+        const projectRoot = graphProjectRoot(args);
+        const snapshotId = typeof args.snapshot_id === "string" ? args.snapshot_id.trim() : "";
+        if (args.snapshot_id !== void 0 && typeof args.snapshot_id !== "string") {
+          return { error: 'Optional parameter "snapshot_id" must be a string.' };
+        }
+        const selected = readGraphSnapshotById(projectRoot, snapshotId || void 0);
+        const snapshotPath = selected.path;
+        const snapshot = selected.snapshot;
+        if (!snapshot) {
+          return {
+            error: snapshotId && snapshotId !== "current" ? `Graph snapshot not found: ${snapshotId}. Run \`decantr graph\` to generate snapshot history.` : "Graph snapshot not found. Run `decantr graph` from the project root, or `decantr graph --project <path>` from a workspace root.",
+            expected_path: displayWorkspacePath(snapshotPath)
+          };
+        }
+        const currentSnapshot = readMcpGraphSnapshot(projectRoot);
+        const fromIds = stringListArg(args, "from_ids");
+        if (fromIds.error) return { error: fromIds.error };
+        const from = typeof args.from === "string" && args.from.trim() ? [args.from.trim()] : [];
+        if (args.from !== void 0 && typeof args.from !== "string") {
+          return { error: 'Optional parameter "from" must be a string.' };
+        }
+        if (args.file_path !== void 0 && typeof args.file_path !== "string") {
+          return { error: 'Optional parameter "file_path" must be a string.' };
+        }
+        const filePath = typeof args.file_path === "string" ? args.file_path.trim() : "";
+        const fileNodeId = graphSourceNodeIdForFile(projectRoot, snapshot, filePath || void 0);
+        if (filePath && !fileNodeId) {
+          return {
+            error: `Source file not found in graph snapshot: ${filePath}`,
+            snapshot_id: snapshot.id,
+            available_routes: graphAvailableRoutes(snapshot),
+            available_source_artifacts: graphAvailableSourceArtifacts(snapshot)
+          };
+        }
+        const startIds = [
+          .../* @__PURE__ */ new Set([...from, ...fromIds.values ?? [], ...fileNodeId ? [fileNodeId] : []])
+        ];
+        if (!startIds.length) {
+          return { error: 'Provide a graph start node with "from", "from_ids", or "file_path".' };
+        }
+        const missingStartIds = startIds.filter(
+          (id) => !snapshot.nodes.some((node) => node.id === id)
+        );
+        if (missingStartIds.length) {
+          return {
+            error: `Start node not found in graph snapshot: ${missingStartIds.join(", ")}`,
+            snapshot_id: snapshot.id,
+            available_routes: graphAvailableRoutes(snapshot),
+            available_source_artifacts: graphAvailableSourceArtifacts(snapshot)
+          };
+        }
+        const relations = graphRelationsArg(args, "relations");
+        if (relations.error) return { error: relations.error };
+        const direction = graphTraverseDirectionArg(args);
+        if (direction.error) return { error: direction.error };
+        const depth = graphTraverseDepthArg(args);
+        if (depth.error) return { error: depth.error };
+        const store = createMemoryGraphStore({
+          nodes: snapshot.nodes,
+          edges: snapshot.edges,
+          snapshots: [snapshot]
+        });
+        const result = await store.traverse({
+          from: startIds,
+          relations: relations.values,
+          direction: direction.value,
+          depth: depth.value
+        });
+        const limit = graphToolLimit(args);
+        const limited = limitGraphSubgraph(result.nodes, result.edges, limit);
+        return {
+          source: "local_graph",
+          artifact_path: displayWorkspacePath(snapshotPath),
+          current_snapshot_id: currentSnapshot?.id ?? null,
+          snapshot_id: snapshot.id,
+          schema_version: snapshot.schema_version,
+          project_id: snapshot.project_id,
+          source_hash: snapshot.source_hash,
+          traversal: {
+            from: startIds,
+            file_path: filePath || void 0,
+            resolved_node_ids: startIds,
+            relations: relations.values,
+            direction: direction.value ?? "out",
+            depth: depth.value,
+            limit
+          },
+          summary: {
+            nodes: limited.nodes.length,
+            edges: limited.edges.length,
+            total_nodes: result.nodes.length,
+            total_edges: result.edges.length,
+            truncated: limited.truncated
+          },
+          nodes: limited.nodes,
+          edges: limited.edges
+        };
+      } catch (e) {
+        return { error: `Could not traverse graph snapshot: ${e.message}` };
+      }
+    }
     case "decantr_get_scaffold_context": {
       const contextDir = join2(process.cwd(), ".decantr", "context");
       const manifestPath = join2(contextDir, "pack-manifest.json");
@@ -2429,6 +4107,8 @@ async function handleTool(name, args) {
       };
     }
     case "decantr_prepare_task_context": {
+      const projectRoot = graphProjectRoot(args);
+      const projectArg = typeof args.project_path === "string" && args.project_path.trim() ? args.project_path.trim() : null;
       const routeArg = typeof args.route === "string" ? args.route : void 0;
       const pageArg = typeof args.page_id === "string" ? args.page_id : void 0;
       const task = typeof args.task === "string" ? args.task : "";
@@ -2437,7 +4117,7 @@ async function handleTool(name, args) {
       }
       let essence;
       try {
-        const result = await readEssenceFile();
+        const result = await readEssenceFile(join2(projectRoot, "decantr.essence.json"));
         essence = result.essence;
       } catch {
         return { error: "No valid essence file found. Run decantr init first." };
@@ -2463,7 +4143,10 @@ async function handleTool(name, args) {
           )
         };
       }
-      const contextDir = join2(process.cwd(), ".decantr", "context");
+      const resolvedRoute = routeArg ?? (typeof page.route === "string" ? page.route : Object.entries(essence.blueprint.routes ?? {}).find(
+        ([, entry]) => entry.section === section.id && entry.page === pageId
+      )?.[0]) ?? null;
+      const contextDir = join2(projectRoot, ".decantr", "context");
       const manifest = readJsonIfExists(join2(contextDir, "pack-manifest.json"));
       const pageManifest = manifest?.pages.find((entry) => entry.id === pageId) ?? null;
       const sectionManifest = manifest?.sections.find((entry) => entry.id === section.id) ?? null;
@@ -2474,18 +4157,28 @@ async function handleTool(name, args) {
       const sectionContext = existsSync(sectionContextPath) ? readFileSync(sectionContextPath, "utf-8") : null;
       const pagePackSummary = summarizePackJson(pagePackJson);
       const sectionPackSummary = summarizePackJson(sectionPackJson);
-      const visualManifest = readJsonIfExists(join2(process.cwd(), ".decantr", "evidence", "visual-manifest.json"));
-      const visualRoute = visualManifest?.routes?.find((entry) => entry.route === routeArg) ?? visualManifest?.routes?.find(
-        (entry) => entry.screenshot?.includes(routeSlug(routeArg ?? pageId))
+      const visualManifest = readJsonIfExists(join2(projectRoot, ".decantr", "evidence", "visual-manifest.json"));
+      const visualRoute = visualManifest?.routes?.find((entry) => entry.route === resolvedRoute) ?? visualManifest?.routes?.find(
+        (entry) => entry.screenshot?.includes(routeSlug(resolvedRoute ?? pageId))
       ) ?? null;
-      const health = readJsonIfExists(join2(process.cwd(), ".decantr", "health-baseline-diff.json"));
+      const health = readJsonIfExists(join2(projectRoot, ".decantr", "health-baseline-diff.json"));
       const themeInventory = readJsonIfExists(
-        join2(process.cwd(), ".decantr", "theme-inventory.json")
+        join2(projectRoot, ".decantr", "theme-inventory.json")
       );
-      const localLaw = localLawSummary(process.cwd());
-      const projectJson = readJsonIfExists(join2(process.cwd(), ".decantr", "project.json"));
-      const changedFiles = changedFilesForTask(process.cwd());
-      const changedRoutes = impactedRoutesForFiles(process.cwd(), changedFiles);
+      const localLaw = localLawSummary(projectRoot);
+      const styleBridge = styleBridgeSummary(projectRoot);
+      const displayedLocalLaw = {
+        ...localLaw,
+        patterns_path: displayProjectFile(projectRoot, localLaw.patterns_path),
+        rules_path: displayProjectFile(projectRoot, localLaw.rules_path)
+      };
+      const displayedStyleBridge = {
+        ...styleBridge,
+        path: displayProjectFile(projectRoot, styleBridge.path)
+      };
+      const projectJson = readJsonIfExists(join2(projectRoot, ".decantr", "project.json"));
+      const changedFiles = changedFilesForTask(projectRoot);
+      const changedRoutes = impactedRoutesForFiles(projectRoot, changedFiles);
       const patternIds = extractPagePatternIds(page);
       const ranked = rankPatternCandidates(
         {
@@ -2495,7 +4188,7 @@ async function handleTool(name, args) {
         patternIds.map((id) => patternToDiscoveryCandidate({ id, name: id, description: id }))
       );
       return {
-        route: routeArg ?? null,
+        route: resolvedRoute,
         page_id: pageId,
         section_id: section.id,
         section_role: section.role,
@@ -2513,18 +4206,18 @@ async function handleTool(name, args) {
         section_context: sectionContext,
         page_pack_excerpt: pagePackMarkdown ? pagePackMarkdown.slice(0, 12e3) : null,
         health_evidence: health ? {
-          baseline_path: health.baselinePath,
+          baseline_path: displayProjectFile(projectRoot, health.baselinePath),
           saved_at: health.savedAt,
           status_changed: health.statusChanged,
           score_delta: health.scoreDelta,
           added_findings: health.addedFindings?.slice(0, 8) ?? [],
           resolved_findings: health.resolvedFindings?.slice(0, 8) ?? [],
           changed_routes: health.changedRoutes ?? [],
-          changed_screenshots: health.changedScreenshots ?? [],
+          changed_screenshots: (health.changedScreenshots ?? []).map((path) => displayProjectFile(projectRoot, path)).filter((path) => Boolean(path)),
           contract_drift: health.contractDrift ?? []
         } : null,
         visual_evidence: visualRoute ? {
-          screenshot: visualRoute.screenshot ?? null,
+          screenshot: displayProjectFile(projectRoot, visualRoute.screenshot),
           screenshot_hash: visualRoute.screenshotHash ?? null,
           status: visualRoute.status ?? null,
           error: visualRoute.error ?? null
@@ -2532,13 +4225,15 @@ async function handleTool(name, args) {
         theme_inventory: themeInventory ? {
           modes: themeInventory.modes,
           variants: themeInventory.variants,
-          path: ".decantr/theme-inventory.json"
+          path: displayProjectFile(projectRoot, ".decantr/theme-inventory.json")
         } : null,
-        local_law: localLaw,
+        local_law: displayedLocalLaw,
+        style_bridge: displayedStyleBridge,
         authority: taskAuthoritySummary({
           workflowMode: projectJson?.initialized?.workflowMode ?? null,
           adoptionMode: projectJson?.initialized?.adoptionMode ?? null,
           localLaw,
+          styleBridge,
           hasPackManifest: Boolean(manifest),
           task
         }),
@@ -2547,16 +4242,25 @@ async function handleTool(name, args) {
           changed_file_count: changedFiles.length,
           impacted_routes: changedRoutes
         },
-        verify_command: "decantr verify --brownfield --local-patterns",
+        typed_graph: buildTaskTypedGraphContext(projectRoot, resolvedRoute, task, changedFiles),
+        verify_command: projectArg ? `decantr verify --project ${projectArg} --brownfield --local-patterns` : "decantr verify --brownfield --local-patterns",
         local_files: {
-          page_pack: pageManifest?.markdown ?? null,
-          section_pack: sectionManifest?.markdown ?? null,
-          section_context: existsSync(sectionContextPath) ? `.decantr/context/section-${section.id}.md` : null,
-          local_patterns: localLaw.patterns_path,
-          local_rules: localLaw.rules_path,
+          page_pack: displayProjectFile(
+            projectRoot,
+            pageManifest ? join2(".decantr", "context", pageManifest.markdown) : null
+          ),
+          section_pack: displayProjectFile(
+            projectRoot,
+            sectionManifest ? join2(".decantr", "context", sectionManifest.markdown) : null
+          ),
+          graph_snapshot: existsSync(join2(projectRoot, ".decantr", "graph", "graph.snapshot.json")) ? displayProjectFile(projectRoot, ".decantr/graph/graph.snapshot.json") : null,
+          section_context: existsSync(sectionContextPath) ? displayProjectFile(projectRoot, `.decantr/context/section-${section.id}.md`) : null,
+          local_patterns: displayedLocalLaw.patterns_path,
+          local_rules: displayedLocalLaw.rules_path,
+          style_bridge: displayedStyleBridge.path,
           visual_manifest: existsSync(
-            join2(process.cwd(), ".decantr", "evidence", "visual-manifest.json")
-          ) ? ".decantr/evidence/visual-manifest.json" : null
+            join2(projectRoot, ".decantr", "evidence", "visual-manifest.json")
+          ) ? displayProjectFile(projectRoot, ".decantr/evidence/visual-manifest.json") : null
         }
       };
     }
@@ -2807,6 +4511,101 @@ async function handleTool(name, args) {
       }
       return auditProject(projectRoot);
     }
+    case "decantr_get_findings": {
+      if (args.severity != null && args.severity !== "error" && args.severity !== "warn" && args.severity !== "info") {
+        return { error: "Invalid severity. Must be one of: error, warn, info." };
+      }
+      const findingSources = [
+        "audit",
+        "assertion",
+        "browser",
+        "check",
+        "brownfield",
+        "design-token",
+        "style-bridge",
+        "graph",
+        "runtime",
+        "pack",
+        "interaction"
+      ];
+      if (args.source != null && (typeof args.source !== "string" || !findingSources.includes(args.source))) {
+        return { error: `Invalid source. Must be one of: ${findingSources.join(", ")}.` };
+      }
+      if (args.code != null && typeof args.code !== "string") {
+        return { error: "Invalid code. Must be a string when provided." };
+      }
+      if (args.include_prompts != null && typeof args.include_prompts !== "boolean") {
+        return { error: "Invalid include_prompts. Must be a boolean when provided." };
+      }
+      if (args.limit != null && (typeof args.limit !== "number" || !Number.isFinite(args.limit))) {
+        return { error: "Invalid limit. Must be a finite number when provided." };
+      }
+      try {
+        const projectRoot = resolveMcpProjectRoot(args.project_path);
+        const state = await getMcpHealthState(projectRoot);
+        const severity = args.severity;
+        const source = args.source;
+        const code = typeof args.code === "string" ? args.code : void 0;
+        const includePrompts = args.include_prompts === true;
+        const limit = typeof args.limit === "number" ? Math.max(1, Math.min(200, Math.floor(args.limit))) : 50;
+        const filtered = state.report.findings.filter((finding) => {
+          if (severity && finding.severity !== severity) return false;
+          if (source && finding.source !== source) return false;
+          if (code && finding.code !== code) return false;
+          return true;
+        });
+        const findings = filtered.slice(0, limit).map((finding) => compactMcpFinding(finding, includePrompts));
+        return {
+          project: state.evidence.project,
+          health: state.evidence.health,
+          filters: {
+            severity,
+            source,
+            code,
+            include_prompts: includePrompts,
+            limit
+          },
+          summary: {
+            status: state.report.status,
+            score: state.report.score,
+            total_findings: state.report.findings.length,
+            matched_findings: filtered.length,
+            returned_findings: findings.length,
+            truncated: filtered.length > findings.length
+          },
+          findings
+        };
+      } catch (error) {
+        return { error: error.message };
+      }
+    }
+    case "decantr_get_repair_plan": {
+      if (args.finding_id != null && typeof args.finding_id !== "string") {
+        return { error: "Invalid finding_id. Must be a string when provided." };
+      }
+      if (args.code != null && typeof args.code !== "string") {
+        return { error: "Invalid code. Must be a string when provided." };
+      }
+      if (args.include_prompt != null && typeof args.include_prompt !== "boolean") {
+        return { error: "Invalid include_prompt. Must be a boolean when provided." };
+      }
+      try {
+        const projectRoot = resolveMcpProjectRoot(args.project_path);
+        const state = await getMcpHealthState(projectRoot);
+        const finding = selectMcpRepairFinding(state.report, {
+          findingId: typeof args.finding_id === "string" ? args.finding_id : void 0,
+          code: typeof args.code === "string" ? args.code : void 0
+        });
+        return buildMcpRepairPlan({
+          evidence: state.evidence,
+          finding,
+          projectRoot,
+          includePrompt: args.include_prompt === true
+        });
+      } catch (error) {
+        return { error: error.message };
+      }
+    }
     case "decantr_get_evidence_bundle": {
       try {
         const projectRoot = resolveMcpProjectRoot(args.project_path);
@@ -2836,7 +4635,9 @@ async function handleTool(name, args) {
       try {
         const projectRoot = resolveMcpProjectRoot(args.project_path);
         const state = await getMcpHealthState(projectRoot);
-        const finding = (typeof args.finding_id === "string" ? state.report.findings.find((entry) => entry.id === args.finding_id) : void 0) ?? state.report.findings.find((entry) => entry.severity === "error") ?? state.report.findings.find((entry) => entry.severity === "warn") ?? state.report.findings[0] ?? null;
+        const finding = selectMcpRepairFinding(state.report, {
+          findingId: typeof args.finding_id === "string" ? args.finding_id : void 0
+        });
         if (!finding) {
           return {
             project: state.evidence.project,
@@ -2870,12 +4671,19 @@ async function handleTool(name, args) {
       try {
         const projectRoot = resolveMcpProjectRoot(args.project_path);
         const state = await getMcpHealthState(projectRoot);
-        const finding = (typeof args.finding_id === "string" ? state.report.findings.find((entry) => entry.id === args.finding_id) : void 0) ?? state.report.findings.find((entry) => entry.severity === "error") ?? state.report.findings.find((entry) => entry.severity === "warn") ?? state.report.findings[0] ?? null;
+        const finding = selectMcpRepairFinding(state.report, {
+          findingId: typeof args.finding_id === "string" ? args.finding_id : void 0
+        });
         return {
           project: state.evidence.project,
           health: state.evidence.health,
           report: state.report,
           evidence: state.evidence,
+          repair_plan: buildMcpRepairPlan({
+            evidence: state.evidence,
+            finding,
+            projectRoot
+          }),
           repair: finding === null ? {
             finding: null,
             prompt: null,
@@ -3056,7 +4864,7 @@ function describeUpdate(operation, payload) {
 }
 
 // src/index.ts
-var VERSION = "2.2.0";
+var VERSION = "3.0.0-next.0";
 var server = new Server({ name: "decantr", version: VERSION }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   return { tools: TOOLS };