@productbrain/mcp 0.0.1-beta.69 → 0.0.1-beta.70

package/dist/{chunk-3HM3XRC7.js → chunk-JOJWCU7A.js}

@@ -2004,6 +2004,635 @@ import { z as z9 } from "zod";
 
 // src/tools/wrapup.ts
 import { z as z8 } from "zod";
+
+// src/lib/coherence/data.ts
+var REGISTRY_MANIFEST = [
+  // ── Canonical UI registries ──────────────────────────────────────
+  {
+    id: "ui-colors",
+    path: "src/lib/utils/collection-colors.ts",
+    exportName: "COLLECTION_COLORS",
+    description: "CSS color mapping for UI components",
+    expectedCoverage: "curated",
+    keyExtraction: "object-keys"
+  },
+  {
+    id: "routes",
+    path: "src/lib/navigation.ts",
+    exportName: "COLLECTION_ROUTES",
+    description: "Collection slug to dedicated route path",
+    expectedCoverage: "curated",
+    keyExtraction: "object-keys"
+  },
+  {
+    id: "gap-paths",
+    path: "src/lib/navigation.ts",
+    exportName: "GAP_PATHS",
+    description: "Readiness gap ID to workspace-relative route path",
+    expectedCoverage: "curated",
+    keyExtraction: "object-keys"
+  },
+  {
+    id: "sidebar-collections",
+    path: "src/lib/navigation.ts",
+    exportName: "SIDEBAR_COLLECTION_SLUGS",
+    description: "Collection slugs with dedicated sidebar entries",
+    expectedCoverage: "subset",
+    keyExtraction: "set-values"
+  },
+  {
+    id: "display-fields",
+    path: "src/lib/components/EntryPreviewModal.svelte",
+    exportName: "DISPLAY_FIELDS",
+    description: "Fields displayed in entry preview modal per collection",
+    expectedCoverage: "curated",
+    keyExtraction: "object-keys"
+  },
+  // ── Brain Chat registries ────────────────────────────────────────
+  {
+    id: "brain-colors",
+    path: "src/lib/components/brain/brain-types.ts",
+    exportName: "COLLECTION_COLORS",
+    description: "Brain Chat collection color palette",
+    expectedCoverage: "subset",
+    keyExtraction: "object-keys"
+  },
+  {
+    id: "brain-icons",
+    path: "src/lib/components/brain/brain-types.ts",
+    exportName: "COLLECTION_ICONS",
+    description: "Brain Chat collection icons",
+    expectedCoverage: "subset",
+    keyExtraction: "object-keys"
+  },
+  // ── Graph visualization registries ───────────────────────────────
+  {
+    id: "graph-colors",
+    path: "src/lib/utils/graphToVisNetwork.ts",
+    exportName: "GRAPH_COLLECTION_COLORS",
+    description: "Graph visualization hex color palette",
+    expectedCoverage: "subset",
+    keyExtraction: "object-keys"
+  },
+  {
+    id: "graph-type-colors",
+    path: "src/lib/components/graph/graph.types.ts",
+    exportName: "COLLECTION_COLORS",
+    description: "Chain Graph collection colors (distinct palette)",
+    expectedCoverage: "subset",
+    keyExtraction: "object-keys"
+  },
+  // ── Studio registries ────────────────────────────────────────────
+  {
+    id: "renderers",
+    path: "src/lib/components/studio/renderers/index.ts",
+    exportName: "COLLECTION_RENDERERS",
+    description: "Custom Svelte renderer component per collection",
+    expectedCoverage: "subset",
+    keyExtraction: "object-keys"
+  },
+  // ── Backend registries ───────────────────────────────────────────
+  {
+    id: "classification-map",
+    path: "convex/lib/collectionClassification.ts",
+    exportName: "CLASSIFICATION_MAP",
+    description: "Collection classification: governance, nav group, ID prefix",
+    expectedCoverage: "all",
+    keyExtraction: "object-keys"
+  },
+  {
+    id: "default-collections",
+    path: "convex/lib/collectionClassification.ts",
+    exportName: "DEFAULT_COLLECTIONS",
+    description: "Default collection definitions with field schemas and purposes",
+    expectedCoverage: "all",
+    keyExtraction: "array-slug"
+  },
+  {
+    id: "classification-meta",
+    path: "convex/mcpKnowledge/classifierPrompt.ts",
+    exportName: "CLASSIFICATION_META",
+    description: "LLM classifier decision checks per collection",
+    expectedCoverage: "all",
+    keyExtraction: "object-keys"
+  },
+  {
+    id: "collection-floors",
+    path: "convex/workspaceReadiness.ts",
+    exportName: "COLLECTION_FLOORS",
+    description: "Minimum user-authored entries required per collection",
+    expectedCoverage: "curated",
+    keyExtraction: "object-keys"
+  }
+];
+var COLLECTION_REGISTRY_RULES = [
+  // ── Sync: authoritative registries must agree ─────────────────────
+  {
+    id: "sync-classification-defaults",
+    type: "sync",
+    description: "CLASSIFICATION_MAP and DEFAULT_COLLECTIONS should cover the same collections",
+    subject: "classification-map",
+    reference: "default-collections"
+  },
+  {
+    id: "sync-classification-classifier",
+    type: "sync",
+    description: "CLASSIFICATION_MAP and CLASSIFICATION_META should cover the same collections",
+    subject: "classification-map",
+    reference: "classification-meta"
+  },
+  // ── Coverage: downstream registries should cover important collections ──
+  {
+    id: "coverage-floors",
+    type: "coverage",
+    description: "COLLECTION_FLOORS should cover all classified collections",
+    subject: "collection-floors",
+    reference: "classification-map"
+  },
+  {
+    id: "coverage-ui-colors",
+    type: "coverage",
+    description: "UI colors should cover collections that have sidebar routes",
+    subject: "ui-colors",
+    reference: "routes"
+  },
+  // ── Subset: specialized registries should only reference known collections ──
+  {
+    id: "subset-brain-colors",
+    type: "subset",
+    description: "Brain colors should only reference classified collections",
+    subject: "brain-colors",
+    reference: "classification-map"
+  },
+  {
+    id: "subset-brain-icons",
+    type: "subset",
+    description: "Brain icons should only reference classified collections",
+    subject: "brain-icons",
+    reference: "classification-map"
+  },
+  {
+    id: "subset-renderers",
+    type: "subset",
+    description: "Renderers should only reference classified collections",
+    subject: "renderers",
+    reference: "classification-map"
+  },
+  {
+    id: "subset-display-fields",
+    type: "subset",
+    description: "Display fields should only reference classified collections",
+    subject: "display-fields",
+    reference: "classification-map"
+  },
+  {
+    id: "subset-graph-colors",
+    type: "subset",
+    description: "Graph colors should only reference classified collections",
+    subject: "graph-colors",
+    reference: "classification-map"
+  },
+  {
+    id: "subset-graph-type-colors",
+    type: "subset",
+    description: "Graph type colors should only reference classified collections",
+    subject: "graph-type-colors",
+    reference: "classification-map"
+  },
+  // ── Implication: presence in one registry implies presence in another ──
+  {
+    id: "implication-routes-need-colors",
+    type: "implication",
+    description: "Collections with routes should also have UI colors",
+    subject: "routes",
+    reference: "ui-colors"
+  },
+  {
+    id: "implication-sidebar-needs-route",
+    type: "implication",
+    description: "Sidebar collections should have a route defined",
+    subject: "sidebar-collections",
+    reference: "routes"
+  }
+];
+
+// src/lib/coherence/engine.ts
+var MAX_VIOLATIONS = 50;
+var SEVERITY_RANK = { error: 0, warning: 1, info: 2 };
+function severityFromCoverage(coverage) {
+  switch (coverage) {
+    case "all":
+      return "error";
+    case "curated":
+      return "warning";
+    case "subset":
+      return "info";
+  }
+}
+function evaluateCoverage({ rule, subjectRef, subjectKeys, referenceKeys }) {
+  const severity = rule.severityOverride ?? severityFromCoverage(subjectRef.expectedCoverage);
+  const violations = [];
+  for (const slug of referenceKeys) {
+    if (!subjectKeys.has(slug)) {
+      violations.push({
+        ruleId: rule.id,
+        ruleType: "coverage",
+        registryId: rule.subject,
+        collectionSlug: slug,
+        message: `"${slug}" missing from ${subjectRef.exportName} (${subjectRef.path})`,
+        severity,
+        fix: `Add "${slug}" to ${subjectRef.exportName} in ${subjectRef.path}`
+      });
+    }
+  }
+  return violations;
+}
+function evaluateSync({ rule, subjectRef, subjectKeys, referenceRef, referenceKeys }) {
+  const violations = [];
+  for (const slug of referenceKeys) {
+    if (!subjectKeys.has(slug)) {
+      violations.push({
+        ruleId: rule.id,
+        ruleType: "sync",
+        registryId: rule.subject,
+        collectionSlug: slug,
+        message: `"${slug}" in ${referenceRef.exportName} but missing from ${subjectRef.exportName}`,
+        severity: "error",
+        fix: `Add "${slug}" to ${subjectRef.exportName} in ${subjectRef.path}`
+      });
+    }
+  }
+  for (const slug of subjectKeys) {
+    if (!referenceKeys.has(slug)) {
+      violations.push({
+        ruleId: rule.id,
+        ruleType: "sync",
+        registryId: referenceRef.id,
+        collectionSlug: slug,
+        message: `"${slug}" in ${subjectRef.exportName} but missing from ${referenceRef.exportName}`,
+        severity: "error",
+        fix: `Add "${slug}" to ${referenceRef.exportName} in ${referenceRef.path}`
+      });
+    }
+  }
+  return violations;
+}
+function evaluateSubset({ rule, subjectRef, subjectKeys, referenceRef, referenceKeys }) {
+  const severity = rule.severityOverride ?? severityFromCoverage(subjectRef.expectedCoverage);
+  const violations = [];
+  for (const slug of subjectKeys) {
+    if (!referenceKeys.has(slug)) {
+      violations.push({
+        ruleId: rule.id,
+        ruleType: "subset",
+        registryId: rule.subject,
+        collectionSlug: slug,
+        message: `"${slug}" in ${subjectRef.exportName} is not a classified collection`,
+        severity,
+        fix: `Remove "${slug}" from ${subjectRef.exportName}, or add it to ${referenceRef.exportName}`
+      });
+    }
+  }
+  return violations;
+}
+function evaluateImplication({ rule, subjectRef, subjectKeys, referenceRef, referenceKeys }) {
+  const severity = rule.severityOverride ?? severityFromCoverage(referenceRef.expectedCoverage);
+  const violations = [];
+  for (const slug of subjectKeys) {
+    if (!referenceKeys.has(slug)) {
+      violations.push({
+        ruleId: rule.id,
+        ruleType: "implication",
+        registryId: referenceRef.id,
+        collectionSlug: slug,
+        message: `"${slug}" has ${subjectRef.description} but no ${referenceRef.description}`,
+        severity,
+        fix: `Add "${slug}" to ${referenceRef.exportName} in ${referenceRef.path}`
+      });
+    }
+  }
+  return violations;
+}
+var EVALUATORS = {
+  coverage: evaluateCoverage,
+  sync: evaluateSync,
+  subset: evaluateSubset,
+  implication: evaluateImplication
+};
+function evaluateCoherence(manifest, rules, resolved, checkedAt) {
+  const registryMap = new Map(manifest.map((r) => [r.id, r]));
+  const allViolations = [];
+  for (const rule of rules) {
+    const subjectRef = registryMap.get(rule.subject);
+    if (!subjectRef) continue;
+    const subjectKeys = resolved[rule.subject];
+    if (!subjectKeys) continue;
+    if (!rule.reference) continue;
+    const referenceRef = registryMap.get(rule.reference);
+    if (!referenceRef) continue;
+    const referenceKeys = resolved[rule.reference];
+    if (!referenceKeys) continue;
+    allViolations.push(
+      ...EVALUATORS[rule.type]({ rule, subjectRef, subjectKeys, referenceRef, referenceKeys })
+    );
+  }
+  allViolations.sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity]);
+  const capped = allViolations.slice(0, MAX_VIOLATIONS);
+  return {
+    checkedAt: checkedAt ?? Date.now(),
+    totalRegistries: manifest.length,
+    totalRules: rules.length,
+    violations: capped,
+    summary: {
+      errors: capped.filter((v) => v.severity === "error").length,
+      warnings: capped.filter((v) => v.severity === "warning").length,
+      infos: capped.filter((v) => v.severity === "info").length,
+      total: capped.length
+    }
+  };
+}
+function toSnapshot(report, maxTopGaps = 10) {
+  return {
+    checkedAt: report.checkedAt,
+    totalGaps: report.summary.total,
+    topGaps: report.violations.filter((v) => v.severity !== "info").slice(0, maxTopGaps).map((v) => ({ registry: v.registryId, slug: v.collectionSlug, severity: v.severity }))
+  };
+}
+
+// src/lib/coherence/resolver.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function resolveRegistries(projectRoot, manifest) {
+  const resolved = {};
+  for (const ref of manifest) {
+    try {
+      const filePath = resolve(projectRoot, ref.path);
+      const content = readFileSync(filePath, "utf-8");
+      const block = extractBlock(content, ref.exportName);
+      if (!block) continue;
+      const keys = extractKeys(block, ref.keyExtraction);
+      if (keys.size > 0) {
+        resolved[ref.id] = keys;
+      }
+    } catch {
+    }
+  }
+  return resolved;
+}
+function extractBlock(content, exportName) {
+  const escaped = exportName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `(?:export\\s+)?(?:const|let|var)\\s+${escaped}\\b[^=]*=\\s*`
+  );
+  const match = pattern.exec(content);
+  if (!match) return null;
+  let pos = match.index + match[0].length;
+  while (pos < content.length && /\s/.test(content[pos])) pos++;
+  const ch = content[pos];
+  if (ch === "{" || ch === "[") {
+    return extractBalanced(content, pos, ch, ch === "{" ? "}" : "]");
+  }
+  if (content.slice(pos).startsWith("new Set") || content.slice(pos).startsWith("new\nSet") || content.slice(pos).startsWith("new\n	Set")) {
+    const setMatch = content.slice(pos).match(/^new\s+Set\s*\(\s*\[/);
+    if (setMatch) {
+      return extractBalanced(content, pos + setMatch[0].length - 1, "[", "]");
+    }
+  }
+  return null;
+}
+function extractBalanced(content, openPos, openChar, closeChar) {
+  let depth = 1;
+  let i = openPos + 1;
+  while (i < content.length && depth > 0) {
+    const ch = content[i];
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipString(content, i, ch);
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "/") {
+      while (i < content.length && content[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "*") {
+      i += 2;
+      while (i < content.length && !(content[i - 1] === "*" && content[i] === "/")) i++;
+      i++;
+      continue;
+    }
+    if (ch === openChar) depth++;
+    else if (ch === closeChar) depth--;
+    i++;
+  }
+  if (depth !== 0) return null;
+  return content.slice(openPos + 1, i - 1);
+}
+function skipString(content, start, quote) {
+  let i = start + 1;
+  while (i < content.length) {
+    if (content[i] === "\\" && quote !== "`") {
+      i += 2;
+      continue;
+    }
+    if (content[i] === quote) return i + 1;
+    i++;
+  }
+  return i;
+}
+function extractKeys(block, extraction) {
+  switch (extraction) {
+    case "object-keys":
+      return extractObjectKeys(block);
+    case "array-slug":
+      return extractArraySlugs(block);
+    case "set-values":
+      return extractSetValues(block);
+  }
+}
+function extractObjectKeys(block) {
+  const keys = /* @__PURE__ */ new Set();
+  let depth = 0;
+  let i = 0;
+  while (i < block.length) {
+    const ch = block[i];
+    if (ch === "/" && block[i + 1] === "/") {
+      while (i < block.length && block[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && block[i + 1] === "*") {
+      i += 2;
+      while (i < block.length && !(block[i - 1] === "*" && block[i] === "/")) i++;
+      i++;
+      continue;
+    }
+    if (depth === 0) {
+      const rest = block.slice(i);
+      const quoted = rest.match(/^(['"])([\w-]+)\1\s*:/);
+      if (quoted) {
+        keys.add(quoted[2]);
+        i += quoted[0].length;
+        continue;
+      }
+      const ident = rest.match(/^([\w-]+)\s*:/);
+      if (ident) {
+        keys.add(ident[1]);
+        i += ident[0].length;
+        continue;
+      }
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipString(block, i, ch);
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === "}" || ch === "]" || ch === ")") {
+      depth--;
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return keys;
+}
+function extractArraySlugs(block) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const m of block.matchAll(/slug:\s*['"](\w[\w-]*)['"]/g)) {
+    slugs.add(m[1]);
+  }
+  return slugs;
+}
+function extractSetValues(block) {
+  const values = /* @__PURE__ */ new Set();
+  for (const m of block.matchAll(/['"](\w[\w-]*)['"]/g)) {
+    values.add(m[1]);
+  }
+  return values;
+}
+
+// src/lib/coherence/git-detection.ts
+import { execSync } from "child_process";
+function detectTouchedRegistries(projectRoot) {
+  const manifestPaths = new Set(REGISTRY_MANIFEST.map((r) => r.path));
+  const touched = /* @__PURE__ */ new Set();
+  try {
+    const raw = execSync("git diff --name-only HEAD 2>/dev/null || git diff --name-only", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && manifestPaths.has(trimmed)) {
+        touched.add(trimmed);
+      }
+    }
+  } catch {
+  }
+  return touched;
+}
+
+// src/lib/coherence/index.ts
+function runCoherenceCheck(projectRoot) {
+  const resolved = resolveRegistries(projectRoot, REGISTRY_MANIFEST);
+  if (Object.keys(resolved).length < 2) return null;
+  return evaluateCoherence(REGISTRY_MANIFEST, COLLECTION_REGISTRY_RULES, resolved);
+}
+function renderCoherenceLines(report) {
+  const lines = ["## Codebase Coherence"];
+  if (report.summary.total === 0) {
+    lines.push("All registries aligned \u2014 no gaps detected.");
+    lines.push("");
+    return lines;
+  }
+  const parts = [];
+  if (report.summary.errors > 0) parts.push(`${report.summary.errors} error${report.summary.errors === 1 ? "" : "s"}`);
+  if (report.summary.warnings > 0) parts.push(`${report.summary.warnings} warning${report.summary.warnings === 1 ? "" : "s"}`);
+  if (report.summary.infos > 0) parts.push(`${report.summary.infos} info`);
+  lines.push(`**${report.summary.total} gap${report.summary.total === 1 ? "" : "s"}** across ${report.totalRegistries} registries (${parts.join(", ")})`);
+  const errors = report.violations.filter((v) => v.severity === "error");
+  const warnings = report.violations.filter((v) => v.severity === "warning");
+  if (errors.length > 0) {
+    lines.push("");
+    lines.push("**Errors** (must fix):");
+    for (const v of errors.slice(0, 5)) {
+      lines.push(`- ${v.message}`);
+    }
+    if (errors.length > 5) lines.push(`- ...and ${errors.length - 5} more`);
+  }
+  if (warnings.length > 0) {
+    lines.push("");
+    lines.push("**Warnings**:");
+    for (const v of warnings.slice(0, 3)) {
+      lines.push(`- ${v.message}`);
+    }
+    if (warnings.length > 3) lines.push(`- ...and ${warnings.length - 3} more`);
+  }
+  lines.push("");
+  return lines;
+}
+function checkAndRender(projectRoot) {
+  const report = runCoherenceCheck(projectRoot);
+  if (!report) return null;
+  return {
+    lines: renderCoherenceLines(report),
+    snapshot: toSnapshot(report)
+  };
+}
+function computeDelta(before, after) {
+  const beforeSet = new Set(before.topGaps.map((g) => `${g.registry}::${g.slug}`));
+  const afterSet = new Set(after.topGaps.map((g) => `${g.registry}::${g.slug}`));
+  let gapsFixed = 0;
+  for (const key of beforeSet) {
+    if (!afterSet.has(key)) gapsFixed++;
+  }
+  let gapsIntroduced = 0;
+  for (const key of afterSet) {
+    if (!beforeSet.has(key)) gapsIntroduced++;
+  }
+  const netChange = after.totalGaps - before.totalGaps;
+  const verdict = netChange < 0 ? "improved" : netChange > 0 ? "degraded" : "unchanged";
+  return { before, after, gapsFixed, gapsIntroduced, netChange, verdict };
+}
+function renderCoherenceDelta(delta) {
+  const lines = ["### Coherence Delta"];
+  const p = (n) => n === 1 ? "" : "s";
+  if (delta.verdict === "improved") {
+    lines.push(
+      `Registry coherence **improved**: ${delta.gapsFixed} gap${p(delta.gapsFixed)} fixed` + (delta.gapsIntroduced > 0 ? `, ${delta.gapsIntroduced} introduced` : "") + ` (net ${delta.netChange}). ${delta.after.totalGaps} gap${p(delta.after.totalGaps)} remain${delta.after.totalGaps === 1 ? "s" : ""}.`
+    );
+  } else if (delta.verdict === "degraded") {
+    lines.push(
+      `**Registry coherence degraded**: ${delta.gapsIntroduced} new gap${p(delta.gapsIntroduced)} introduced` + (delta.gapsFixed > 0 ? `, ${delta.gapsFixed} fixed` : "") + ` (net +${delta.netChange}). ${delta.after.totalGaps} gap${p(delta.after.totalGaps)} total.`
+    );
+  } else {
+    lines.push(
+      `Registry coherence unchanged. ${delta.after.totalGaps} gap${p(delta.after.totalGaps)} remain${delta.after.totalGaps === 1 ? "s" : ""}` + (delta.gapsFixed > 0 ? ` (${delta.gapsFixed} fixed, ${delta.gapsIntroduced} introduced)` : "") + "."
+    );
+  }
+  lines.push("");
+  return lines;
+}
+
+// src/lib/resolve-project-root.ts
+import { existsSync } from "fs";
+import { resolve as resolve2 } from "path";
+function resolveProjectRoot() {
+  const candidates = [
+    process.env.WORKSPACE_PATH,
+    process.cwd(),
+    resolve2(process.cwd(), "..")
+  ].filter(Boolean);
+  for (const dir of candidates) {
+    const resolved = resolve2(dir);
+    if (existsSync(resolve2(resolved, "convex/schema.ts"))) return resolved;
+  }
+  return null;
+}
+
+// src/tools/wrapup.ts
 async function mapWithConcurrency(items, mapper, concurrency = 3) {
   const results = new Array(items.length);
   let index = 0;
@@ -2023,6 +2652,19 @@ async function mapWithConcurrency(items, mapper, concurrency = 3) {
   );
   return results;
 }
+async function fetchSessionCoherenceSnapshot(sessionId) {
+  try {
+    const session = await mcpCall("agent.getSession", {
+      sessionId
+    });
+    const raw = session?.coherenceSnapshot;
+    if (raw && typeof raw.checkedAt === "number" && typeof raw.totalGaps === "number") {
+      return raw;
+    }
+  } catch {
+  }
+  return null;
+}
 async function suggestLinksForEntries(entries) {
   const suggestions = [];
   const results = await mapWithConcurrency(
@@ -2117,6 +2759,46 @@ async function runWrapupReview() {
     lines.push("_Capturing these will make future sessions more effective._");
     lines.push("");
   }
+  let coherenceVerdict;
+  try {
+    const projectRoot = resolveProjectRoot();
+    if (projectRoot) {
+      const touchedFiles = detectTouchedRegistries(projectRoot);
+      const sessionSnapshot = await fetchSessionCoherenceSnapshot(sessionId);
+      const shouldCheck = touchedFiles.size > 0 || sessionSnapshot !== null;
+      if (shouldCheck) {
+        const report = runCoherenceCheck(projectRoot);
+        if (report) {
+          const afterSnapshot = toSnapshot(report);
+          if (sessionSnapshot) {
+            const delta = computeDelta(sessionSnapshot, afterSnapshot);
+            coherenceVerdict = delta.verdict;
+            const deltaLines = renderCoherenceDelta(delta);
+            lines.push(...deltaLines);
+            if (touchedFiles.size > 0) {
+              lines.push(
+                `_This session touched ${touchedFiles.size} registry file${touchedFiles.size === 1 ? "" : "s"}: ${[...touchedFiles].slice(0, 3).map((f) => `\`${f}\``).join(", ")}${touchedFiles.size > 3 ? ` and ${touchedFiles.size - 3} more` : ""}._`
+              );
+              lines.push("");
+            }
+          } else if (touchedFiles.size > 0) {
+            lines.push("### Coherence Check");
+            lines.push(
+              `This session touched ${touchedFiles.size} registry file${touchedFiles.size === 1 ? "" : "s"} but no session-start snapshot exists \u2014 showing absolute state.`
+            );
+            const { summary } = report;
+            if (summary.total === 0) {
+              lines.push("All registries aligned \u2014 no gaps.");
+            } else {
+              lines.push(`**${summary.total} gap${summary.total === 1 ? "" : "s"}**: ${summary.errors} error${summary.errors === 1 ? "" : "s"}, ${summary.warnings} warning${summary.warnings === 1 ? "" : "s"}, ${summary.infos} info.`);
+            }
+            lines.push("");
+          }
+        }
+      }
+    }
+  } catch {
+  }
   if (data.drafts.length > 0) {
     const draftIds = data.drafts.map((d) => `\`${d.entryId}\``).join(", ");
     lines.push("### Actions", "");
@@ -2125,7 +2807,7 @@ async function runWrapupReview() {
     lines.push("- **Skip:** call `session action=close` \u2014 drafts remain for next session's orient recovery.");
   }
   const gapCount = getSessionGaps().length;
-  return { text: lines.join("\n"), data, suggestions, gapCount };
+  return { text: lines.join("\n"), data, suggestions, gapCount, coherenceVerdict };
 }
 async function runWrapupCommitAll(data, cachedSuggestions) {
   requireWriteAccess();
@@ -2250,7 +2932,7 @@ function registerWrapupTools(server) {
         }
       );
     }
-    const { text, data, suggestions, failureCode, gapCount } = await runWrapupReview();
+    const { text, data, suggestions, failureCode, gapCount, coherenceVerdict } = await runWrapupReview();
     lastReviewData = data;
     lastReviewSuggestions = suggestions;
     lastReviewSessionId = getAgentSessionId();
@@ -2262,15 +2944,17 @@ ${text}` : text;
     }
     const next = data.drafts.length > 0 ? [{ tool: "session-wrapup", description: "Commit all drafts", parameters: { action: "commit-all" } }] : void 0;
     const gapsSummary = gapCount ? `, ${gapCount} knowledge gaps detected` : "";
+    const coherenceSummary = coherenceVerdict ? `, coherence: ${coherenceVerdict}` : "";
     return successResult(
       fullText,
-      `Session review: ${data.drafts.length} uncommitted, ${data.committed.length} committed, ${suggestions.length} link suggestions${gapsSummary}.`,
+      `Session review: ${data.drafts.length} uncommitted, ${data.committed.length} committed, ${suggestions.length} link suggestions${gapsSummary}${coherenceSummary}.`,
       {
         drafts: data.drafts.length,
         committed: data.committed.length,
         uncommitted: data.summary.uncommitted,
         suggestedLinks: suggestions.length,
-        knowledgeGaps: gapCount ?? 0
+        knowledgeGaps: gapCount ?? 0,
+        ...coherenceVerdict ? { coherenceVerdict } : {}
       },
       next
     );
@@ -3271,11 +3955,11 @@ This block is the final deliverable of the review. Everything else is supporting
       num: "02",
       label: "Standards & Chain Coherence",
       type: "open",
-      instruction: "Run quality check, chain-review gate (if applicable), and review-against-rules. Is the implementation coherent with the Chain SSOT?",
-      facilitatorGuidance: "For the BET/entry: quality action=check entryId='<ID>'. If the work produced a chain artifact: chain-review action=gate. Call review-against-rules with the relevant domain (e.g. 'Governance & Decision-Making'). Present: quality score, gate result, rule compliance. Flag any conflicts with Chain entries.",
+      instruction: "Run quality check, chain-review gate (if applicable), review-against-rules, and codebase coherence gate. Is the implementation coherent with the Chain SSOT? Did it introduce or fix registry drift?",
+      facilitatorGuidance: "For the BET/entry: quality action=check entryId='<ID>'. If the work produced a chain artifact: chain-review action=gate. Call review-against-rules with the relevant domain (e.g. 'Governance & Decision-Making'). **Codebase Coherence Gate (BET-99/FEAT-183):** Compare the Codebase Coherence section from Round 01's orient output against the current state. If orient showed coherence gaps and this implementation touched registry files (collection colors, routes, classification, renderers, etc.), check whether gaps increased or decreased. Gaps increased \u2192 flag as 'Coherence: WARN \u2014 N new gaps introduced' and list them. Gaps decreased \u2192 celebrate as 'Coherence: PASS \u2014 N gaps fixed.' No change \u2192 note as 'Coherence: PASS \u2014 no change.' If Round 01 did not show a coherence section, skip the gate \u2014 do not block on missing baseline. Present: quality score, gate result, rule compliance, coherence gate verdict.",
       outputSchema: {
         field: "standards",
-        description: "Quality score, gate result, rule compliance",
+        description: "Quality score, gate result, rule compliance, coherence gate verdict (improved/degraded/unchanged)",
         format: "structured"
       },
       maxDurationHint: "5 min"
@@ -6468,23 +7152,11 @@ No constellation entries were committed.`
 }
 
 // src/tools/verify.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
 import { z as z13 } from "zod";
-function resolveProjectRoot() {
-  const candidates = [
-    process.env.WORKSPACE_PATH,
-    process.cwd(),
-    resolve(process.cwd(), "..")
-  ].filter(Boolean);
-  for (const dir of candidates) {
-    const resolved = resolve(dir);
-    if (existsSync(resolve(resolved, "convex/schema.ts"))) return resolved;
-  }
-  return null;
-}
 function parseConvexSchema(schemaPath) {
-  const content = readFileSync(schemaPath, "utf-8");
+  const content = readFileSync2(schemaPath, "utf-8");
   const tables = /* @__PURE__ */ new Map();
   let currentTable = null;
   for (const line of content.split("\n")) {
@@ -6523,8 +7195,8 @@ function classifyRef(cleaned) {
 }
 function checkFileRef(ref, root) {
   const filePart = ref.split(/\s+/)[0];
-  const fullPath = resolve(root, filePart);
-  if (existsSync(fullPath)) return { result: "verified", reason: "exists" };
+  const fullPath = resolve3(root, filePart);
+  if (existsSync2(fullPath)) return { result: "verified", reason: "exists" };
   return { result: "drifted", reason: `not found: ${filePart}` };
 }
 function checkSchemaRef(ref, schema) {
@@ -6636,7 +7308,7 @@ function registerVerifyTools(server) {
           "Cannot find project root. Set WORKSPACE_PATH in .env.mcp."
         );
       }
-      const schema = parseConvexSchema(resolve(projectRoot, "convex/schema.ts"));
+      const schema = parseConvexSchema(resolve3(projectRoot, "convex/schema.ts"));
       await server.sendLoggingMessage({
         level: "info",
         data: `Verifying "${collection}" against ${schema.size} schema tables at ${projectRoot}`,
@@ -7011,6 +7683,14 @@ function buildPlannedWorkSection(work, priorSessions, recoveryBlock) {
 }
 
 // src/tools/orient-shared.ts
+function buildCoherenceSection(projectRoot) {
+  try {
+    const root = projectRoot ?? resolveProjectRoot() ?? process.cwd();
+    return checkAndRender(root);
+  } catch {
+    return null;
+  }
+}
 function runAlignmentCheck(task, activeBets, taskContextHits) {
   const betNames = activeBets.map((b) => b.name);
   const taskWords = task.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
@@ -7283,10 +7963,13 @@ function buildInterviewResponse(workspaceName) {
 }
 
 // src/tools/start.ts
-async function tryMarkOriented(agentSessionId) {
+async function tryMarkOriented(agentSessionId, coherenceSnapshot) {
   if (!agentSessionId) return { oriented: false, orientationStatus: "no_session" };
   try {
-    await mcpCall("agent.markOriented", { sessionId: agentSessionId });
+    await mcpCall("agent.markOriented", {
+      sessionId: agentSessionId,
+      ...coherenceSnapshot ? { coherenceSnapshot } : {}
+    });
     setSessionOriented(true);
     return { oriented: true, orientationStatus: "complete" };
   } catch {
@@ -7640,6 +8323,7 @@ async function buildOrientResponse(wsCtx, agentSessionId, errors, task) {
   const isHighReadiness = readiness !== null && readiness.score >= 50;
   const stage = readiness?.stage ?? null;
   const captureBehaviorNote = wsFullCtx.governanceMode === "open" ? "_In Open mode, user-authored captures commit immediately unless you ask me to keep them as drafts._" : "_Everything I capture stays pending until you confirm._";
+  const coherence = buildCoherenceSection();
   lines.push(`# ${wsCtx.workspaceName}`);
   lines.push("_Product Brain is ready._");
   lines.push("");
@@ -7711,6 +8395,9 @@ async function buildOrientResponse(wsCtx, agentSessionId, errors, task) {
         standards: wsStandards.map(mapGovEntry),
         businessRules: wsBusinessRules.map(mapGovEntry)
       }, task));
+      if (coherence) {
+        lines.push(...coherence.lines);
+      }
       const plannedWork = await queryPlannedWork();
       if (hasPlannedWork(plannedWork)) {
         lines.push("");
@@ -7746,6 +8433,9 @@ async function buildOrientResponse(wsCtx, agentSessionId, errors, task) {
         lines.push("");
       }
       lines.push(...buildOperatingProtocol());
+      if (coherence) {
+        lines.push(...coherence.lines);
+      }
       if (priorSessions.length > 0 && !recoveryBlock) {
         const last = priorSessions[0];
         const date = last.startedAt ? new Date(last.startedAt).toISOString().split("T")[0] : "unknown";
@@ -7767,7 +8457,7 @@ async function buildOrientResponse(wsCtx, agentSessionId, errors, task) {
     for (const err of errors) lines.push(`- ${err}`);
     lines.push("");
   }
-  const { oriented, orientationStatus } = await tryMarkOriented(agentSessionId);
+  const { oriented, orientationStatus } = await tryMarkOriented(agentSessionId, coherence?.snapshot);
   const stageLabel = stage ?? "active";
   const gapCount = readiness?.gaps?.length ?? 0;
   const summaryParts = [`Product Brain ready. Stage: ${stageLabel}.`];
@@ -8888,8 +9578,8 @@ Use \`map-slot action=add mapEntryId="${mapEntryId}" slotId="..." ingredientEntr
 }
 
 // src/tools/architecture.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
-import { resolve as resolve2, relative, dirname, normalize } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync, statSync } from "fs";
+import { resolve as resolve4, relative, dirname, normalize } from "path";
 import { z as z19 } from "zod";
 var COLLECTION_SLUG = "architecture";
 var COLLECTION_FIELDS = [
@@ -9224,7 +9914,7 @@ Use \`architecture action=show\` to view the map.`
         };
       }
       if (action === "check") {
-        const projectRoot = resolveProjectRoot2();
+        const projectRoot = resolveProjectRoot();
         if (!projectRoot) {
           return {
             content: [{
@@ -9261,18 +9951,6 @@ Use \`architecture action=show\` to view the map.`
   );
   trackWriteTool(archAdminTool);
 }
-function resolveProjectRoot2() {
-  const candidates = [
-    process.env.WORKSPACE_PATH,
-    process.cwd(),
-    resolve2(process.cwd(), "..")
-  ].filter(Boolean);
-  for (const dir of candidates) {
-    const resolved = resolve2(dir);
-    if (existsSync2(resolve2(resolved, "convex/schema.ts"))) return resolved;
-  }
-  return null;
-}
 function scanDependencies(projectRoot, layers, nodes) {
   const layerMap = /* @__PURE__ */ new Map();
   for (const l of layers) layerMap.set(l.entryId, l);
@@ -9291,7 +9969,7 @@ function scanDependencies(projectRoot, layers, nodes) {
     const nodeViolations = [];
     let nodeFileCount = 0;
     for (const fp of filePaths) {
-      const absPath = resolve2(projectRoot, fp);
+      const absPath = resolve4(projectRoot, fp);
       const files = collectFiles(absPath);
       for (const file of files) {
         nodeFileCount++;
@@ -9368,7 +10046,7 @@ function parseFilePaths(node) {
   return raw.split(",").map((p) => p.trim()).filter(Boolean);
 }
 function collectFiles(absPath) {
-  if (!existsSync2(absPath)) return [];
+  if (!existsSync3(absPath)) return [];
   const stat = statSync(absPath);
   if (stat.isFile()) {
     return isScannableFile(absPath) ? [absPath] : [];
@@ -9378,7 +10056,7 @@ function collectFiles(absPath) {
   const walk = (dir) => {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const full = resolve2(dir, entry.name);
+      const full = resolve4(dir, entry.name);
       if (entry.isDirectory()) walk(full);
       else if (isScannableFile(full)) results.push(full);
     }
@@ -9391,7 +10069,7 @@ function isScannableFile(p) {
 }
 function parseImports(filePath) {
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     const re = /(?:^|\n)\s*import\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
     const imports = [];
     let match;
@@ -9405,10 +10083,10 @@ function parseImports(filePath) {
 }
 var EXTENSIONS = [".ts", ".js", ".svelte", "/index.ts", "/index.js", "/index.svelte"];
 function tryResolveWithExtension(absPath) {
-  if (existsSync2(absPath) && statSync(absPath).isFile()) return absPath;
+  if (existsSync3(absPath) && statSync(absPath).isFile()) return absPath;
   for (const ext of EXTENSIONS) {
     const withExt = absPath + ext;
-    if (existsSync2(withExt)) return withExt;
+    if (existsSync3(withExt)) return withExt;
   }
   return null;
 }
@@ -9419,11 +10097,11 @@ function resolveImport(imp, fromFile, root) {
   else if (imp.startsWith("$env/") || imp.startsWith("$app/")) return null;
   else if (imp.startsWith("./") || imp.startsWith("../")) {
     const fromDir = dirname(fromFile);
-    const abs2 = resolve2(fromDir, imp);
+    const abs2 = resolve4(fromDir, imp);
     rel = relative(root, abs2);
   }
   if (!rel) return null;
-  const abs = resolve2(root, rel);
+  const abs = resolve4(root, rel);
   const actual = tryResolveWithExtension(abs);
   return actual ? relative(root, actual) : rel;
 }
@@ -10125,6 +10803,13 @@ function registerHealthTools(server) {
           const modified = Array.isArray(last.entriesModified) ? last.entriesModified.length : last.entriesModified ?? 0;
           lines.push(`Last session (${date}): ${created} created, ${modified} modified`);
         }
+        let coherenceSnapshot;
+        const coherence = buildCoherenceSection();
+        if (coherence) {
+          lines.push("");
+          lines.push(...coherence.lines);
+          coherenceSnapshot = coherence.snapshot;
+        }
         if (orientEntries) {
           lines.push("");
           if (task) {
@@ -10144,7 +10829,10 @@ function registerHealthTools(server) {
         }
         if (agentSessionId) {
           try {
-            await mcpCall("agent.markOriented", { sessionId: agentSessionId });
+            await mcpCall("agent.markOriented", {
+              sessionId: agentSessionId,
+              ...coherenceSnapshot ? { coherenceSnapshot } : {}
+            });
             setSessionOriented(true);
           } catch {
           }
@@ -10205,6 +10893,11 @@ function registerHealthTools(server) {
           const stratum = e.stratum ?? "?";
           return `- \`${e.entryId ?? e._id}\` [${type} \xB7 ${stratum}] ${e.name}`;
         };
+        let fullCoherenceSnapshot2;
+        const fullCoherence = buildCoherenceSection();
+        if (fullCoherence) {
+          fullCoherenceSnapshot2 = fullCoherence.snapshot;
+        }
         if (task) {
           lines.push(`**Brain stage: ${orientStage}.** Working on: **${task}**`);
           lines.push("");
@@ -10265,6 +10958,9 @@ function registerHealthTools(server) {
             );
             lines.push(...buildAlignmentCheckLines(result));
           }
+          if (fullCoherence) {
+            lines.push(...fullCoherence.lines);
+          }
           if (orientEntries) {
             if (orientEntries.activeBets?.length > 0) {
               lines.push("## Active bets \u2014 current scope");
@@ -10344,6 +11040,9 @@ function registerHealthTools(server) {
             lines.push("");
           }
           lines.push(...buildOperatingProtocol());
+          if (fullCoherence) {
+            lines.push(...fullCoherence.lines);
+          }
           if (priorSessions.length > 0 && !recoveryBlock) {
             const last = priorSessions[0];
             const date = last.startedAt ? new Date(last.startedAt).toISOString().split("T")[0] : "unknown";
@@ -10366,7 +11065,10 @@ function registerHealthTools(server) {
       }
       if (agentSessionId) {
         try {
-          await mcpCall("agent.markOriented", { sessionId: agentSessionId });
+          await mcpCall("agent.markOriented", {
+            sessionId: agentSessionId,
+            ...fullCoherenceSnapshot ? { coherenceSnapshot: fullCoherenceSnapshot } : {}
+          });
           setSessionOriented(true);
           lines.push("---");
           lines.push(`Orientation complete. Session ${agentSessionId}. Write tools available.`);
@@ -10400,16 +11102,16 @@ function registerHealthTools(server) {
 }
 
 // src/resources/index.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname2, join, resolve as resolve3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname2, join, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 var MODULE_DIR = dirname2(fileURLToPath(import.meta.url));
 var UI_VIEW_BASE_CANDIDATES = [
-  resolve3(MODULE_DIR, "views"),
-  resolve3(MODULE_DIR, "..", "views"),
-  resolve3(MODULE_DIR, "..", "..", "dist", "views"),
-  resolve3(MODULE_DIR, "..", "..", "..", "mcp-views", "dist")
+  resolve5(MODULE_DIR, "views"),
+  resolve5(MODULE_DIR, "..", "views"),
+  resolve5(MODULE_DIR, "..", "..", "dist", "views"),
+  resolve5(MODULE_DIR, "..", "..", "..", "mcp-views", "dist")
 ];
 function formatEntryMarkdown(entry) {
   const id = entry.entryId ? `${entry.entryId}: ` : "";
@@ -11755,4 +12457,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-3HM3XRC7.js.map
+//# sourceMappingURL=chunk-JOJWCU7A.js.map