@warpgogol/forge 4.2.1 → 4.2.3

package/os/compass/handlers/compass-inventory-handler.ts

@@ -17,12 +17,19 @@ contract block specs alongside built-in MODULE_CONTRACT and CHANGE_SUMMARY check
   <item>RFC-0556: moved from @warpgogol/site-kernel-checks to @warpgogol/forge for autonomous mode.</item>
   <item>Game extensions: added COMPASS-SYNTAX-01 diagnostic validating comment syntax per file type (.gd needs # prefix, .tscn/.tres need ; prefix, .ts/.cs need block comment).</item>
   <item>RFC-0943: added COMPASS-PLUGIN-01/02/03 diagnostics for pack-declared contract block specs from forge.plugin.yaml extensionPoints.</item>
+  <item>RFC-1094: --mode warning|error on compass.validate; mode-aware v2 diagnostics (KD/ORDER/PURPOSE) with severity field; inventory data.entries now carries full entries and XML gains v2 fields.</item>
 </CHANGE_SUMMARY>
 */
 
 import { resolve } from "node:path";
 import { readFile } from "node:fs/promises";
-import { createCompassInventoryEntries, type CompassInventoryEntry } from "./compass-inventory.ts";
+import {
+  createCompassInventoryEntries,
+  evaluateV2Rules,
+  getEntrySource,
+  resolveCompassMode,
+  type CompassInventoryEntry,
+} from "./compass-inventory.ts";
 import { resolveCompassScanRoot } from "./resolve-scan-root.ts";
 import { writeFileIfChanged } from "../../../src/utils/fs-idempotent.ts";
 import { loadForgeConfig } from "../../../src/config/forge-config.ts";
@@ -201,6 +208,21 @@ function renderInventoryXml(
     lines.push(
       `      <has-change-summary>${entry.hasChangeSummary ? "true" : "false"}</has-change-summary>`,
     );
+    lines.push(
+      `      <has-key-decisions>${entry.hasKeyDecisions ? "true" : "false"}</has-key-decisions>`,
+    );
+    lines.push(
+      `      <key-decisions-item-count>${entry.keyDecisionsItemCount}</key-decisions-item-count>`,
+    );
+    lines.push(
+      `      <key-decisions-required>${entry.keyDecisionsRequired ? "true" : "false"}</key-decisions-required>`,
+    );
+    lines.push(
+      `      <change-summary-item-count>${entry.changeSummaryItemCount}</change-summary-item-count>`,
+    );
+    if (entry.historyIds.length > 0) {
+      lines.push(`      <history-ids>${escapeXml(entry.historyIds.join(", "))}</history-ids>`);
+    }
     lines.push(
       `      <has-ai-invariant>${entry.hasAiInvariant ? "true" : "false"}</has-ai-invariant>`,
     );
@@ -233,7 +255,11 @@ export async function runCompassInventory(
   input: ForgeCommandInput,
   context: ForgeRuntimeContext,
 ): Promise<
-  ForgeCommandResult<{ entries: number; outputPath: string; summary: CompassInventorySummary }>
+  ForgeCommandResult<{
+    entries: CompassInventoryEntry[];
+    outputPath: string;
+    summary: CompassInventorySummary;
+  }>
 > {
   const scanRoot = resolveCompassScanRoot(input, context) ?? context.workspaceRoot;
   const entries = await createCompassInventoryEntries(scanRoot, input);
@@ -248,7 +274,7 @@ export async function runCompassInventory(
       `[compass.inventory] dry-run active — skipped writing ${INVENTORY_OUTPUT_PATH}`,
     );
     return {
-      data: { entries: entries.length, outputPath: INVENTORY_OUTPUT_PATH, summary },
+      data: { entries, outputPath: INVENTORY_OUTPUT_PATH, summary },
       summary: `[compass.inventory] previewed ${INVENTORY_OUTPUT_PATH}`,
       nextSteps: [
         {
@@ -264,7 +290,7 @@ export async function runCompassInventory(
   await writeFileIfChanged(outputPath, xml);
 
   return {
-    data: { entries: entries.length, outputPath, summary },
+    data: { entries, outputPath, summary },
     summary: `[compass.inventory] ${context.dryRun ? "previewed" : "wrote"} ${INVENTORY_OUTPUT_PATH}`,
     nextSteps: context.dryRun
       ? [
@@ -300,6 +326,15 @@ export async function runCompassValidation(
   }>
 > {
   const scanRoot = resolveCompassScanRoot(input, context);
+  let mode: ReturnType<typeof resolveCompassMode>;
+  try {
+    mode = resolveCompassMode(input);
+  } catch {
+    context.logger.error(
+      `[compass.validate] invalid --mode value: ${String(input.flags["mode"])} (expected warning|error)`,
+    );
+    return { exitCode: 1, summary: "invalid --mode value" };
+  }
   const entries = await createCompassInventoryEntries(context.workspaceRoot, input, scanRoot);
   const summary = summarizeInventory(entries);
   const failures = entries.filter(
@@ -311,13 +346,45 @@ export async function runCompassValidation(
 
   const diagnostics: Array<{
     ruleId: string;
-    severity: string;
+    severity: "warning" | "error";
     file: string;
     message: string;
     fix: string;
     pack?: string;
   }> = [];
 
+  // RFC-1094: v2 rules are mode-aware — warnings in `warning` mode (default
+  // during the migration window), errors in `error` mode. Owned subset:
+  // COMPASS-KD-*, COMPASS-ORDER-01, COMPASS-PURPOSE-*. CS-* rules are emitted
+  // by compass.changesummary.validate.
+  const V2_VALIDATE_RULE_PREFIXES = ["COMPASS-KD-", "COMPASS-ORDER-", "COMPASS-PURPOSE-"];
+  const v2Severity = mode === "error" ? "error" : "warning";
+  const authoredEntries = entries.filter(
+    (entry) => entry.authoringStatus === "authored" && entry.requiredScaffolding !== "none",
+  );
+  for (const entry of authoredEntries) {
+    const absPath = resolve(context.workspaceRoot, entry.path);
+    const source = getEntrySource(entry) ?? (await readFile(absPath, "utf8"));
+    for (const v2 of evaluateV2Rules(entry, source)) {
+      if (!V2_VALIDATE_RULE_PREFIXES.some((prefix) => v2.ruleId.startsWith(prefix))) {
+        continue;
+      }
+      const log = `[compass.validate] ${v2.ruleId}: ${entry.path}: ${v2.message}`;
+      if (v2Severity === "error") {
+        context.logger.error(log);
+      } else {
+        context.logger.warn(log);
+      }
+      diagnostics.push({
+        ruleId: v2.ruleId,
+        severity: v2Severity,
+        file: entry.path,
+        message: v2.message,
+        fix: v2.fix,
+      });
+    }
+  }
+
   for (const failure of failures) {
     for (const violation of failure.violations) {
       let ruleId = "COMPASS-CONTRACT-01";
@@ -477,7 +544,9 @@ export async function runCompassValidation(
     }
   }
 
-  const hasFailures = diagnostics.length > 0;
+  const hasErrors = diagnostics.some((d) => d.severity === "error");
+  const warningCount =
+    diagnostics.length - diagnostics.filter((d) => d.severity === "error").length;
 
   return {
     data: {
@@ -486,9 +555,9 @@ export async function runCompassValidation(
       summary,
       diagnostics,
     },
-    exitCode: hasFailures ? 1 : 0,
-    summary: hasFailures
+    exitCode: hasErrors ? 1 : 0,
+    summary: hasErrors
       ? undefined
-      : `[compass.validate] OK (${summary.authoredFiles} authored files checked)`,
+      : `[compass.validate] OK (${summary.authoredFiles} authored files checked${warningCount > 0 ? `, ${warningCount} v2 warnings` : ""})`,
   };
 }

package/os/compass/handlers/compass-inventory.ts

@@ -16,6 +16,7 @@ for Compass source-file inventory.</purpose>
   <item>RFC-0556: moved canonical implementation from @warpgogol/site-kernel to @warpgogol/forge for autonomous mode.</item>
   <item>Game extensions: added .cs, .tscn, .tres, .gd to SOURCE_EXTENSIONS; createCompassInventoryEntries now reads forge.yaml compass.fileExtensions at runtime and merges with hardcoded set.</item>
   <item>Added .md to SOURCE_EXTENSIONS for SKILL.md Compass coverage; detectAuthoringStatus excludes non-SKILL.md markdown files.</item>
+  <item>RFC-1094: v2 contract — KEY_DECISIONS/history parsing, new inventory fields, evaluateV2Rules, deriveFileTokens, resolveCompassMode, shared GOVERNANCE_ID_RE.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -84,7 +85,6 @@ const HIGH_RISK_EXACT_RELATIVE_PATHS = new Set([
   "packages/os/site-kernel/src/runtime.ts",
   "packages/os/site-kernel/src/types.ts",
 ]);
-const REQUIRED_MARKERS = ["<MODULE_CONTRACT>", "<CHANGE_SUMMARY>"] as const;
 function forbiddenMarkerPattern(tagName: string): RegExp {
   return new RegExp(`<${tagName}\\b`);
 }
@@ -96,6 +96,55 @@ const FORBIDDEN_PATTERNS: Array<{ name: string; regex: RegExp }> = [
   { name: "COMPASS_BLOCK", regex: new RegExp(`</?${"COMPASS_BLOCK"}\\b`) },
 ];
 
+// RFC-1094: v2 contract constants. GOVERNANCE_ID_RE is the canonical
+// governance-ID pattern shared with the change-summary handler.
+export const GOVERNANCE_ID_RE = /\b([A-Z][A-Z0-9]*-)+\d+\b/;
+const GOVERNANCE_ID_PREFIX_RE = /^([A-Z][A-Z0-9]*-)+\d+\b/;
+const HISTORY_ID_RE = /^([A-Z][A-Z0-9]*-)+\d+$/;
+const HISTORY_ID_PARTS_RE = /^(([A-Z][A-Z0-9]*-)+)(\d+)$/;
+const TODO_PLACEHOLDER_RE = /^TODO\b/i;
+
+const GENERIC_STEMS = new Set([
+  "index",
+  "styles",
+  "style",
+  "local",
+  "global",
+  "utils",
+  "helpers",
+  "types",
+  "constants",
+  "readme",
+]);
+const SYMBOL_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts"]);
+const EXPORTED_SYMBOL_RE =
+  /export\s+(?:async\s+)?(?:function|const|let|class|interface|type|enum)\s+(\w+)/g;
+
+const PURPOSE_BOILERPLATE_PATTERNS: RegExp[] = [
+  /^(this file|the file|a file|this module|a module)\b/i,
+  /^(utility|utilities|helper|helpers|misc)\b/i,
+  /^(todo|placeholder|fixme)\b/i,
+];
+
+const KEY_DECISIONS_MAX_ITEMS = 7;
+const KEY_DECISIONS_MAX_WORDS = 20;
+const CHANGE_SUMMARY_MAX_ITEMS = 5;
+
+export type CompassValidationMode = "warning" | "error";
+
+export interface CompassV2Diagnostic {
+  ruleId: string;
+  message: string;
+  fix: string;
+}
+
+export function resolveCompassMode(input: ForgeCommandInput): CompassValidationMode {
+  const raw = input.flags["mode"];
+  if (raw === undefined) return "warning";
+  if (raw === "warning" || raw === "error") return raw;
+  throw new Error(`--mode must be "warning" or "error", got "${String(raw)}"`);
+}
+
 type CompassWorkspaceKind = "app" | "package" | "service";
 type CompassRiskClass = "high" | "medium" | "low";
 type CompassComplexity = "non-trivial" | "trivial";
@@ -116,6 +165,11 @@ export interface CompassInventoryEntry {
   nonEmptyLineCount: number;
   hasModuleContract: boolean;
   hasChangeSummary: boolean;
+  hasKeyDecisions: boolean;
+  keyDecisionsItemCount: number;
+  keyDecisionsRequired: boolean;
+  changeSummaryItemCount: number;
+  historyIds: string[];
   hasAiInvariant: boolean;
   hasPurpose: boolean;
   hasNonGoals: boolean;
@@ -478,23 +532,274 @@ function detectComplianceViolations(
   return violations;
 }
 
+interface CompassBlockParse {
+  hasModuleContract: boolean;
+  hasKeyDecisions: boolean;
+  hasChangeSummary: boolean;
+  keyDecisionsItems: string[];
+  changeSummaryItems: string[];
+  historyIds: string[];
+  historyRaw: string | null;
+  purposeText: string;
+  positions: {
+    moduleContract: number;
+    keyDecisions: number;
+    changeSummary: number;
+  };
+}
+
+function extractItems(block: string): string[] {
+  const items: string[] = [];
+  const re = /<item>([\s\S]*?)<\/item>/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(block)) !== null) {
+    items.push(m[1]!.trim());
+  }
+  return items;
+}
+
+function parseCompassBlocks(source: string): CompassBlockParse {
+  const positions = {
+    moduleContract: source.indexOf("<MODULE_CONTRACT>"),
+    keyDecisions: source.indexOf("<KEY_DECISIONS>"),
+    changeSummary: source.indexOf("<CHANGE_SUMMARY>"),
+  };
+
+  const contractBlock = extractBlockContent(source, "MODULE_CONTRACT");
+  const keyDecisionsBlock = extractBlockContent(source, "KEY_DECISIONS");
+  const changeSummaryBlock = extractBlockContent(source, "CHANGE_SUMMARY");
+
+  let purposeText = "";
+  if (contractBlock) {
+    const purposeBlock = extractBlockContent(contractBlock, "purpose");
+    if (purposeBlock) {
+      purposeText = purposeBlock.replace(/<[^>]+>/g, " ").trim();
+    }
+  }
+
+  let historyRaw: string | null = null;
+  let historyIds: string[] = [];
+  if (changeSummaryBlock) {
+    const historyMatch = changeSummaryBlock.match(/<history>([\s\S]*?)<\/history>/);
+    if (historyMatch) {
+      historyRaw = historyMatch[1]!.trim();
+      historyIds = historyRaw
+        .split(",")
+        .map((token) => token.trim())
+        .filter(Boolean);
+    }
+  }
+
+  return {
+    hasModuleContract: positions.moduleContract >= 0,
+    hasKeyDecisions: positions.keyDecisions >= 0,
+    hasChangeSummary: positions.changeSummary >= 0,
+    keyDecisionsItems: keyDecisionsBlock ? extractItems(keyDecisionsBlock) : [],
+    changeSummaryItems: changeSummaryBlock ? extractItems(changeSummaryBlock) : [],
+    historyIds,
+    historyRaw,
+    purposeText,
+    positions,
+  };
+}
+
+function splitIdentifier(name: string): string[] {
+  return name
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_-]+/g, " ")
+    .toLowerCase()
+    .split(" ")
+    .filter(Boolean);
+}
+
+export function deriveFileTokens(pathFromRoot: string, source: string): Set<string> {
+  const segments = pathFromRoot.split("/").filter(Boolean);
+  const filename = segments[segments.length - 1] ?? "";
+  const dotIndex = filename.lastIndexOf(".");
+  const stem = dotIndex > 0 ? filename.slice(0, dotIndex) : filename;
+  const extension = dotIndex > 0 ? filename.slice(dotIndex) : "";
+
+  const tokens = new Set<string>();
+  for (const segment of stem.split("-").filter(Boolean)) {
+    tokens.add(segment.toLowerCase());
+  }
+
+  if (SYMBOL_EXTENSIONS.has(extension)) {
+    for (const match of source.matchAll(EXPORTED_SYMBOL_RE)) {
+      for (const word of splitIdentifier(match[1]!)) {
+        tokens.add(word);
+      }
+    }
+  }
+
+  if (GENERIC_STEMS.has(stem.toLowerCase())) {
+    const parent = segments[segments.length - 2] ?? "";
+    for (const segment of parent.split("-").filter(Boolean)) {
+      tokens.add(segment.toLowerCase());
+    }
+  }
+
+  return tokens;
+}
+
+function validateHistoryIds(historyIds: string[]): string | null {
+  for (const token of historyIds) {
+    if (!HISTORY_ID_RE.test(token)) {
+      return `<history> contains a non-ID token: "${token}"`;
+    }
+  }
+  if (new Set(historyIds).size !== historyIds.length) {
+    return "<history> contains duplicate IDs";
+  }
+  const lastSeenByNamespace = new Map<string, number>();
+  for (const token of historyIds) {
+    const parts = token.match(HISTORY_ID_PARTS_RE)!;
+    const namespace = parts[1]!.replace(/-$/, "");
+    const numeric = Number(parts[3]);
+    const last = lastSeenByNamespace.get(namespace);
+    if (last !== undefined && numeric <= last) {
+      return `<history> IDs are not in per-namespace ascending numeric order (${token} after ${namespace}-${last})`;
+    }
+    lastSeenByNamespace.set(namespace, numeric);
+  }
+  return null;
+}
+
+export function evaluateV2Rules(
+  entry: Pick<CompassInventoryEntry, "path" | "keyDecisionsRequired">,
+  source: string,
+): CompassV2Diagnostic[] {
+  const parse = parseCompassBlocks(source);
+  const diagnostics: CompassV2Diagnostic[] = [];
+
+  const orderedPositions = [
+    parse.positions.moduleContract,
+    parse.positions.keyDecisions,
+    parse.positions.changeSummary,
+  ].filter((position) => position >= 0);
+  if (orderedPositions.length >= 2) {
+    const sorted = [...orderedPositions].sort((a, b) => a - b);
+    const inOrder = orderedPositions.every((position, index) => position === sorted[index]);
+    if (!inOrder) {
+      diagnostics.push({
+        ruleId: "COMPASS-ORDER-01",
+        message:
+          "Compass blocks out of canonical order (MODULE_CONTRACT → KEY_DECISIONS → CHANGE_SUMMARY)",
+        fix: "fix: reorder blocks to MODULE_CONTRACT, KEY_DECISIONS, CHANGE_SUMMARY",
+      });
+    }
+  }
+
+  if (entry.keyDecisionsRequired && !parse.hasKeyDecisions) {
+    diagnostics.push({
+      ruleId: "COMPASS-KD-01",
+      message: "missing KEY_DECISIONS (required for medium/high riskClass)",
+      fix: "fix: add a KEY_DECISIONS block with 1-7 current-state design items",
+    });
+  }
+  if (parse.hasKeyDecisions) {
+    const items = parse.keyDecisionsItems;
+    const realItems = items.filter((item) => item.length > 0 && !TODO_PLACEHOLDER_RE.test(item));
+    if (items.length === 0 || realItems.length === 0) {
+      diagnostics.push({
+        ruleId: "COMPASS-KD-02",
+        message: "KEY_DECISIONS block is empty or contains only TODO placeholder items",
+        fix: "fix: write real current-state decisions or remove the block",
+      });
+    }
+    for (const item of items) {
+      if (countWords(item) > KEY_DECISIONS_MAX_WORDS) {
+        diagnostics.push({
+          ruleId: "COMPASS-KD-03",
+          message: `KEY_DECISIONS item exceeds ${KEY_DECISIONS_MAX_WORDS} words`,
+          fix: "fix: compress the item to a single decision statement",
+        });
+      }
+      if (GOVERNANCE_ID_PREFIX_RE.test(item)) {
+        diagnostics.push({
+          ruleId: "COMPASS-KD-05",
+          message:
+            "KEY_DECISIONS item starts with a governance-ID prefix — history belongs in CHANGE_SUMMARY",
+          fix: "fix: rewrite the item as a current-state decision without an ID prefix",
+        });
+      }
+    }
+    if (items.length > KEY_DECISIONS_MAX_ITEMS) {
+      diagnostics.push({
+        ruleId: "COMPASS-KD-04",
+        message: `KEY_DECISIONS has ${items.length} items (cap is ${KEY_DECISIONS_MAX_ITEMS})`,
+        fix: "fix: keep only the decisions that still govern the file",
+      });
+    }
+  }
+
+  if (parse.purposeText.length > 0) {
+    if (PURPOSE_BOILERPLATE_PATTERNS.some((pattern) => pattern.test(parse.purposeText))) {
+      diagnostics.push({
+        ruleId: "COMPASS-PURPOSE-01",
+        message: "<purpose> matches a boilerplate pattern",
+        fix: "fix: write a specific purpose naming what this file does",
+      });
+    }
+    const tokens = deriveFileTokens(entry.path, source);
+    const purposeWords = new Set(
+      parse.purposeText
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean),
+    );
+    const hasToken = [...tokens].some((token) => purposeWords.has(token));
+    if (!hasToken) {
+      diagnostics.push({
+        ruleId: "COMPASS-PURPOSE-02",
+        message: "<purpose> contains no file-derived token (stem, parent dir, or exported symbol)",
+        fix: "fix: mention the file's own name or an exported symbol in <purpose>",
+      });
+    }
+  }
+
+  if (parse.hasChangeSummary) {
+    if (parse.changeSummaryItems.length > CHANGE_SUMMARY_MAX_ITEMS) {
+      diagnostics.push({
+        ruleId: "COMPASS-CS-05",
+        message: `CHANGE_SUMMARY has ${parse.changeSummaryItems.length} items (cap is ${CHANGE_SUMMARY_MAX_ITEMS}); collapse oldest into <history>`,
+        fix: "fix: keep the 5 newest items and collapse older IDs into <history>",
+      });
+    }
+    for (const item of parse.changeSummaryItems) {
+      if (!GOVERNANCE_ID_RE.test(item)) {
+        diagnostics.push({
+          ruleId: "COMPASS-CS-06",
+          message: `CHANGE_SUMMARY item lacks a governance-ID reference: "${item.slice(0, 60)}"`,
+          fix: "fix: prefix the item with its RFC/ADR/ticket ID or remove it",
+        });
+      }
+    }
+    if (parse.historyRaw !== null) {
+      const historyError = validateHistoryIds(parse.historyIds);
+      if (historyError) {
+        diagnostics.push({
+          ruleId: "COMPASS-CS-07",
+          message: historyError,
+          fix: "fix: <history> carries comma-separated governance IDs only, deduplicated, per-namespace ascending",
+        });
+      }
+    }
+  }
+
+  return diagnostics;
+}
+
 function detectMarkup(source: string) {
-  const hasModuleContract = source.includes(REQUIRED_MARKERS[0]);
-  const hasChangeSummary = source.includes(REQUIRED_MARKERS[1]);
+  const parse = parseCompassBlocks(source);
   const hasAiInvariant = /@ai-invariant\b/.test(source);
 
-  let hasPurpose = false;
+  const hasPurpose = countWords(parse.purposeText) >= 10;
   let hasNonGoals = false;
 
-  if (hasModuleContract) {
+  if (parse.hasModuleContract) {
     const contractBlock = extractBlockContent(source, "MODULE_CONTRACT");
     if (contractBlock) {
-      const purposeBlock = extractBlockContent(contractBlock, "purpose");
-      if (purposeBlock) {
-        const purposeText = purposeBlock.replace(/<[^>]+>/g, " ");
-        hasPurpose = countWords(purposeText) >= 10;
-      }
-
       const nonGoalsBlock = extractBlockContent(contractBlock, "non-goals");
       if (nonGoalsBlock) {
         hasNonGoals = (nonGoalsBlock.match(/<item>/g) ?? []).length >= 1;
@@ -510,8 +815,12 @@ function detectMarkup(source: string) {
   }
 
   return {
-    hasModuleContract,
-    hasChangeSummary,
+    hasModuleContract: parse.hasModuleContract,
+    hasChangeSummary: parse.hasChangeSummary,
+    hasKeyDecisions: parse.hasKeyDecisions,
+    keyDecisionsItemCount: parse.keyDecisionsItems.length,
+    changeSummaryItemCount: parse.changeSummaryItems.length,
+    historyIds: parse.historyIds,
     hasAiInvariant,
     hasPurpose,
     hasNonGoals,
@@ -519,6 +828,13 @@ function detectMarkup(source: string) {
   };
 }
 
+const entrySources = new WeakMap<CompassInventoryEntry, string>();
+
+/** Returns the source text captured during `createCompassInventoryEntries`, if still cached. */
+export function getEntrySource(entry: CompassInventoryEntry): string | undefined {
+  return entrySources.get(entry);
+}
+
 export async function createCompassInventoryEntries(
   workspaceRoot: string,
   input: ForgeCommandInput,
@@ -546,6 +862,10 @@ export async function createCompassInventoryEntries(
     );
     const requiredScaffolding = detectRequiredScaffolding(authoringStatus);
     const markup = detectMarkup(source);
+    const keyDecisionsRequired =
+      authoringStatus === "authored" &&
+      requiredScaffolding === "standard" &&
+      (riskClass === "medium" || riskClass === "high");
     const nonEmptyLineCount = source.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
     const candidate: CompassInventoryEntry = {
       path: pathFromRoot,
@@ -564,6 +884,11 @@ export async function createCompassInventoryEntries(
       nonEmptyLineCount,
       hasModuleContract: markup.hasModuleContract,
       hasChangeSummary: markup.hasChangeSummary,
+      hasKeyDecisions: markup.hasKeyDecisions,
+      keyDecisionsItemCount: markup.keyDecisionsItemCount,
+      keyDecisionsRequired,
+      changeSummaryItemCount: markup.changeSummaryItemCount,
+      historyIds: markup.historyIds,
       hasAiInvariant: markup.hasAiInvariant,
       hasPurpose: markup.hasPurpose,
       hasNonGoals: markup.hasNonGoals,
@@ -573,6 +898,7 @@ export async function createCompassInventoryEntries(
     };
     candidate.violations = detectComplianceViolations(candidate);
     candidate.compliant = candidate.violations.length === 0;
+    entrySources.set(candidate, source);
     entries.push(candidate);
   }