@archpilotlabs/archpilot 0.2.6 → 0.2.7

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.2.7
+
+### Added
+
+- Added `archpilot validate --regressions` to focus validation output on architecture findings introduced since the accepted governance baseline.
+- Added regression summaries showing introduced, resolved, and existing architecture findings.
+- Added regression comparison data to JSON validation output for automation and tooling.
+- Added automatic initial governance baseline creation after the first successful full local validation, so regression tracking works without additional setup.
+
+### Improved
+
+- Improved CI and pull request reporting to highlight newly introduced architecture regressions instead of presenting existing architecture debt as newly actionable.
+- Improved GitHub inline annotations to prioritize newly introduced supported findings when a governance baseline is available.
+- Improved regression reporting with separate visibility for resolved findings and existing baseline findings.
+- Improved missing-baseline guidance to clearly distinguish the governance baseline from the structural architecture baseline.
+- Scoped `--changed` and `--diff` validation now avoids unsafe full-baseline comparisons that could incorrectly report findings as resolved.
+
+### Notes
+
+- Regression comparison uses the accepted governance baseline at `.archpilot/baseline/baseline.json`.
+- The initial governance baseline is created automatically only after a successful full local validation. Existing baselines are never automatically refreshed.
+- Use `archpilot baseline refresh` when you intentionally want to accept the current architecture findings as the new governance baseline.
+- `--regressions` does not change Architecture Health Score, Setup Readiness Score, rule severities, scoring, or normal validation findings.
+- `--regressions` does not currently combine with `--changed` or `--diff`.
+- Regression reporting does not independently change CI exit or policy enforcement behavior.
+
+---
+
 ## 0.2.6
 
 ### Improved

package/README.md

@@ -45,7 +45,7 @@ ArchPilot turns architecture into something you can actually run and verify:
 - Generate architecture scores and reports
 - Surface architecture feedback in local development, PRs, and CI
 
-No runtime agents. No external services. Fully deterministic and local-first.
+**No cloud scan required. Deterministic and local-first.**
 
 ArchPilot works alongside GitHub Copilot, Claude Code, Codex, Cursor, and other AI coding tools by continuously validating architectural boundaries before architectural drift becomes technical debt.
 
@@ -172,6 +172,22 @@ Creates `.archpilot/` with architecture config, rules, and baseline artifacts.
 archpilot validate
 ```
 
+To focus on architecture changes introduced since the governance baseline:
+
+```bash
+archpilot validate --regressions
+```
+
+ArchPilot automatically creates the initial governance baseline after the first successful full local validation. Regression validation can then distinguish newly introduced, existing, and resolved architecture findings.
+
+When you intentionally accept the current architecture findings as the new reference, run:
+
+```bash
+archpilot baseline refresh
+```
+
+The governance baseline used for regression comparison is separate from the structural baseline used by `archpilot baseline create`.
+
 Example output:
 
 ```text
@@ -317,6 +333,5 @@ Proprietary. See LICENSE file for details.
 
 - Website: https://archpilot.org
 - Documentation: https://archpilot.org/docs
-- [Changelog](https://github.com/archpilotlabs/archpilot-vscode/blob/main/packages/cli/CHANGELOG.md)
 
 ---

package/dist/archpilot-cli.js

@@ -228162,6 +228162,8 @@ var transactionBoundaryDecoratorPattern = /@(?:Transactional|Transaction)\b|\[(?
 var explicitTransactionBoundaryPattern = /\b(?:\$transaction|DB::transaction)\s*\(|\b(?:knex|sequelize|typeorm|dataSource|connection|manager|transactionManager)\.transaction\s*\(|\b(?:this\.)?connection\.withTransaction\s*\(|\b(?:startTransaction|beginTransaction|BeginTransaction|BeginTransactionAsync|BeginTx)\s*\(|\bnew\s+TransactionScope\b|\bsession\.begin\s*\(|\bdb\.Transaction\s*\(/iu;
 var separateTransactionPropagationPattern = /\b(?:requiresNew|REQUIRES_NEW|Propagation\.REQUIRES_NEW)\b/u;
 var businessRulePattern = /\b(?:approve|reject|authorize|eligible|eligibility|policy|discount|limit|quota|balance|risk|compliance|settle|state|status|transition)\b/iu;
+var repositoryBusinessRulePattern = /\b(?:approve|reject|authorize|eligible|eligibility|policy|discount|quota|balance|risk|compliance|settle|transition)\b/iu;
+var decisionStructurePattern = /\bif\s*\(|\bswitch\s*\(|\bthrow\s+new\b/u;
 var transactionCallbackStartPattern = /\b(?:this\.)?(?:[\w.$:]+\.)?(?:\$transaction|transaction|Transaction)\s*\(\s*(?:async\s*)?(?:function\s*)?\(?\s*\w*\s*\)?\s*(?:=>)?\s*\{/gu;
 var explicitDomainModelEvidencePattern = /@(?:Entity|Embeddable|MappedSuperclass|Column|PrimaryGeneratedColumn|ObjectType|Field)\b|\[(?:Table|Key|Required|Column|StringLength|MaxLength)\b[^\]]*\]|\b(?:BaseModel|SQLModel|declarative_base|Mapped\[|Column\s*\(|@dataclass\b|extends\s+Model\b|\$fillable\b|\$casts\b|gorm\.Model|`[^`]*(?:gorm|db):)/u;
 var domainFrameworkLeakPattern = /\b(?:ControllerBase|IActionResult|HttpContext|Microsoft\.AspNetCore|APIRouter|FastAPI|Request|Response|Depends|Illuminate\\Http|Illuminate\\Routing|Route::|http\.ResponseWriter|http\.Request|gin\.Context|express|Router|org\.springframework\.web|jakarta\.servlet|HttpServletRequest|@Controller|@RestController|@Get|@Post|DbContext|EntityManager|Session|Repository)\b/u;
@@ -229307,6 +229309,16 @@ function hasEntitySpecificServiceBusinessRules(entityNames, methods) {
     return [...entityAliases].some((entityName) => new RegExp(`\\b${entityName}\\b`, "u").test(method.file.content));
   });
 }
+function hasScatteredDomainLogicEvidence(method) {
+  const code = maskNonCodeEvidence2(method.body);
+  if (!decisionStructurePattern.test(code)) {
+    return false;
+  }
+  if (hasRole(method.classification, "repository")) {
+    return repositoryBusinessRulePattern.test(code);
+  }
+  return businessRulePattern.test(code);
+}
 function detectDomainFindings(files, classifications, methods, contract, astCache) {
   const findings = [];
   for (const file of files) {
@@ -229376,7 +229388,7 @@ function detectDomainFindings(files, classifications, methods, contract, astCach
         }));
       }
     }
-    if (isProductionBackendGovernanceScope(method.classification.scope) && (hasRole(method.classification, "controller") || hasRole(method.classification, "repository")) && businessRulePattern.test(method.body) && /\bif\s*\(|\bswitch\s*\(|\bthrow\s+new\b/u.test(method.body)) {
+    if (isProductionBackendGovernanceScope(method.classification.scope) && (hasRole(method.classification, "controller") || hasRole(method.classification, "repository")) && hasScatteredDomainLogicEvidence(method)) {
       findings.push(createFinding3({
         id: RuleIds2.DOM_LOGIC_SCATTERED,
         message: `Business rule evidence appears in a ${hasRole(method.classification, "controller") ? "controller" : "repository"} method '${method.name}'.`,
@@ -229692,6 +229704,11 @@ function httpMethodFromDecorator(decorators, extension) {
   }
   return value;
 }
+function routeDecoratorOffsetInGroup(decorators, extension) {
+  const pattern = extension === ".java" ? /@(?:GetMapping|PostMapping|PutMapping|PatchMapping|DeleteMapping|RequestMapping)\b/u : /@(?:Get|Post|Put|Patch|Delete)\b/u;
+  const match = pattern.exec(decorators);
+  return match?.index ?? 0;
+}
 function methodPathFromDecorators(decorators, extension) {
   const pattern = extension === ".java" ? /@(?:GetMapping|PostMapping|PutMapping|PatchMapping|DeleteMapping|RequestMapping)\s*(?:\(([^)]*)\))?/u : /@(?:Get|Post|Put|Patch|Delete)\s*(?:\(([^)]*)\))?/u;
   const match = pattern.exec(decorators);
@@ -229711,11 +229728,12 @@ function extractDecoratorEndpoints(file, contract) {
     const returnType = file.extension === ".java" ? match[3] ?? "" : match[3] ?? "";
     const openBrace = (match.index ?? 0) + match[0].lastIndexOf("{");
     const end = findMatchingBrace4(file.content, openBrace);
+    const routeDecoratorOffset = routeDecoratorOffsetInGroup(decorators, file.extension);
     endpoints.push({
       httpMethod,
       path: joinEndpointPath(basePath, methodPathFromDecorators(decorators, file.extension)),
       name,
-      line: lineNumberForOffset4(file.content, match.index ?? 0),
+      line: lineNumberForOffset4(file.content, (match.index ?? 0) + routeDecoratorOffset),
       decorators,
       signature: `${returnType} ${match[0]}`,
       body: file.content.slice(openBrace, end + 1),
@@ -237063,6 +237081,41 @@ function formatRuleLine(ruleId) {
 function formatFindingLine(finding) {
   return `${formatRuleLine(finding.id)} | ${finding.message}`;
 }
+function formatRegressionFindingLine(finding) {
+  const parts = [`${finding.id} ${finding.severity}`];
+  const scope = finding.module && finding.target ? `${finding.module} -> ${finding.target}` : finding.sourceComponentName && finding.targetComponentName ? `${finding.sourceComponentName} -> ${finding.targetComponentName}` : finding.module ?? finding.target ?? finding.table ?? finding.api ?? finding.filePath;
+  if (scope) {
+    parts.push(scope);
+  }
+  if (finding.sourceFile) {
+    parts.push(
+      finding.sourceLine !== void 0 ? `${finding.sourceFile}:${finding.sourceLine}` : finding.sourceFile
+    );
+  }
+  parts.push(finding.message);
+  return parts.join(" | ");
+}
+function renderRegressionFindingLines(findings, limit) {
+  if (findings.length === 0) {
+    return "- (none)";
+  }
+  const sorted = [...findings].sort((left, right) => {
+    const idCompare = left.id.localeCompare(right.id);
+    if (idCompare !== 0) {
+      return idCompare;
+    }
+    const sourceCompare = (left.sourceFile ?? "").localeCompare(right.sourceFile ?? "");
+    if (sourceCompare !== 0) {
+      return sourceCompare;
+    }
+    return left.message.localeCompare(right.message);
+  });
+  const rendered = sorted.slice(0, limit).map((finding) => `- ${formatRegressionFindingLine(finding)}`);
+  if (sorted.length > limit) {
+    rendered.push(`- ... ${sorted.length - limit} more`);
+  }
+  return rendered.join("\n");
+}
 function parseFindingKind2(value) {
   return value === "violation" || value === "setup-gap" || value === "guidance" ? value : void 0;
 }
@@ -237087,7 +237140,7 @@ function renderArchitecturePrCommentMarkdown(input2) {
     findingKindByRule.set(finding.id, byRule);
     findingKindByRuleAndMessage.set(`${finding.id}::${finding.message}`, kind);
   }
-  const resolveKind2 = (entry) => {
+  const resolveKind3 = (entry) => {
     const explicit = readFindingKind(entry);
     if (explicit) {
       return explicit;
@@ -237105,28 +237158,28 @@ function renderArchitecturePrCommentMarkdown(input2) {
     return "violation";
   };
   const newQualityViolationLines = sortUniqueLines(
-    (input2.driftComparison?.newViolations ?? []).filter((entry) => resolveKind2(entry) === "violation").map((entry) => formatRuleLine(entry.ruleId))
+    (input2.driftComparison?.newViolations ?? []).filter((entry) => resolveKind3(entry) === "violation").map((entry) => formatRuleLine(entry.ruleId))
   );
   const newSetupGapLines = sortUniqueLines(
-    (input2.driftComparison?.newViolations ?? []).filter((entry) => resolveKind2(entry) === "setup-gap").map((entry) => formatRuleLine(entry.ruleId))
+    (input2.driftComparison?.newViolations ?? []).filter((entry) => resolveKind3(entry) === "setup-gap").map((entry) => formatRuleLine(entry.ruleId))
   );
   const newGuidanceLines = sortUniqueLines(
-    (input2.driftComparison?.newViolations ?? []).filter((entry) => resolveKind2(entry) === "guidance").map((entry) => formatRuleLine(entry.ruleId))
+    (input2.driftComparison?.newViolations ?? []).filter((entry) => resolveKind3(entry) === "guidance").map((entry) => formatRuleLine(entry.ruleId))
   );
   const resolvedViolationLines = sortUniqueLines(
-    (input2.driftComparison?.resolvedViolations ?? []).filter((entry) => resolveKind2(entry) === "violation").map((entry) => formatRuleLine(entry.ruleId))
+    (input2.driftComparison?.resolvedViolations ?? []).filter((entry) => resolveKind3(entry) === "violation").map((entry) => formatRuleLine(entry.ruleId))
   );
   const resolvedSetupGapLines = sortUniqueLines(
-    (input2.driftComparison?.resolvedViolations ?? []).filter((entry) => resolveKind2(entry) === "setup-gap").map((entry) => formatRuleLine(entry.ruleId))
+    (input2.driftComparison?.resolvedViolations ?? []).filter((entry) => resolveKind3(entry) === "setup-gap").map((entry) => formatRuleLine(entry.ruleId))
   );
   const activeQualityViolationLines = sortUniqueLines(
-    input2.summary.findings.filter((entry) => resolveKind2({ ruleId: entry.id, message: entry.message }) === "violation").map((entry) => formatFindingLine(entry))
+    input2.summary.findings.filter((entry) => resolveKind3({ ruleId: entry.id, message: entry.message }) === "violation").map((entry) => formatFindingLine(entry))
   );
   const activeSetupGapLines = sortUniqueLines(
-    input2.summary.findings.filter((entry) => resolveKind2({ ruleId: entry.id, message: entry.message }) === "setup-gap").map((entry) => formatFindingLine(entry))
+    input2.summary.findings.filter((entry) => resolveKind3({ ruleId: entry.id, message: entry.message }) === "setup-gap").map((entry) => formatFindingLine(entry))
   );
   const activeGuidanceLines = sortUniqueLines(
-    input2.summary.findings.filter((entry) => resolveKind2({ ruleId: entry.id, message: entry.message }) === "guidance").map((entry) => formatFindingLine(entry))
+    input2.summary.findings.filter((entry) => resolveKind3({ ruleId: entry.id, message: entry.message }) === "guidance").map((entry) => formatFindingLine(entry))
   );
   const activeQualityViolationCount = activeQualityViolationLines.length;
   const activeSetupGapCount = activeSetupGapLines.length;
@@ -237262,6 +237315,37 @@ function renderArchitecturePrCommentMarkdown(input2) {
     lines.push(`Setup gaps: ${activeSetupGapCount}`);
   }
   lines.push(trendLine);
+  const baselineComparison = input2.summary.baselineComparison;
+  if (baselineComparison) {
+    lines.push("");
+    lines.push("Architecture Regression Summary");
+    const comparisonAvailable = baselineComparison.baselineAvailable !== false && baselineComparison.status !== "NO_BASELINE";
+    if (!comparisonAvailable) {
+      lines.push("Architecture regression comparison is unavailable.");
+      if (baselineComparison.summary.toLowerCase().includes("no baseline")) {
+        lines.push("No governance baseline exists.");
+        lines.push("Create or refresh the governance baseline with `archpilot baseline refresh`.");
+      }
+      lines.push(`Summary: ${baselineComparison.summary}`);
+    } else {
+      lines.push(`Introduced: ${baselineComparison.newlyIntroducedFindings.length}`);
+      lines.push(`Resolved: ${baselineComparison.resolvedFindings.length}`);
+      lines.push(`Existing: ${baselineComparison.unchangedFindings.length}`);
+      if (baselineComparison.newlyIntroducedFindings.length === 0) {
+        lines.push("");
+        lines.push("No new architecture regressions detected.");
+      } else {
+        lines.push("");
+        lines.push("New architecture regressions");
+        lines.push(renderRegressionFindingLines(baselineComparison.newlyIntroducedFindings, 10));
+      }
+      if (baselineComparison.resolvedFindings.length > 0) {
+        lines.push("");
+        lines.push("Resolved architecture findings");
+        lines.push(renderRegressionFindingLines(baselineComparison.resolvedFindings, 8));
+      }
+    }
+  }
   if (input2.driftComparison?.hasPreviousSnapshot) {
     lines.push(
       `Previous score: ${input2.driftComparison.previousScore ?? "n/a"}${input2.driftComparison.scoreDelta !== void 0 ? ` (${input2.driftComparison.scoreDelta >= 0 ? "+" : ""}${input2.driftComparison.scoreDelta})` : ""}`
@@ -238426,6 +238510,190 @@ async function checkArchitectureBaseline(workspaceRoot) {
 // ../core/src/architectureGovernanceBaseline.ts
 var path42 = __toESM(require("node:path"));
 var import_node_fs36 = require("node:fs");
+
+// ../core/src/findingRegressionComparison.ts
+function normalizeToken2(value) {
+  return value.replace(/\\/g, "/").trim().toLowerCase();
+}
+function normalizeOptionalToken(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = normalizeToken2(value);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function resolveKind(input2) {
+  if (input2.kind === "violation" || input2.kind === "setup-gap" || input2.kind === "guidance") {
+    return input2.kind;
+  }
+  if (input2.classification === "violation" || input2.classification === "setup-gap" || input2.classification === "guidance") {
+    return input2.classification;
+  }
+  if (input2.type === "violation" || input2.type === "setup-gap" || input2.type === "guidance") {
+    return input2.type;
+  }
+  return "violation";
+}
+function appendPart(parts, label, value) {
+  const normalized = normalizeOptionalToken(value);
+  if (normalized) {
+    parts.push(`${label}=${normalized}`);
+  }
+}
+function normalizeDeductionIdentity(deductionKey) {
+  const normalized = normalizeOptionalToken(deductionKey);
+  if (!normalized) {
+    return void 0;
+  }
+  if (normalized.includes("|")) {
+    const parts2 = normalized.split("|");
+    if (parts2[0] === "quality" || parts2[0] === "setup" || parts2[0] === "guidance") {
+      parts2.shift();
+    }
+    if (parts2[0]?.startsWith("ap-")) {
+      parts2.shift();
+    }
+    if (parts2.length >= 4 && /^\d+$/u.test(parts2[3] ?? "")) {
+      return parts2.filter((_, index) => index !== 3).join("|");
+    }
+    return parts2.join("|");
+  }
+  const parts = normalized.split(":");
+  if (parts[0] === "quality" || parts[0] === "setup" || parts[0] === "guidance") {
+    parts.shift();
+  }
+  if (parts[0]?.startsWith("ap-")) {
+    parts.shift();
+  }
+  return parts.join(":");
+}
+function buildSemanticRegressionIdentity(input2) {
+  const parts = [`rule=${normalizeToken2(input2.id)}`, `kind=${resolveKind(input2)}`];
+  appendPart(parts, "findingtype", input2.findingType);
+  appendPart(parts, "module", input2.module);
+  appendPart(parts, "target", input2.target);
+  appendPart(parts, "table", input2.table);
+  appendPart(parts, "api", input2.api);
+  appendPart(parts, "filepath", input2.filePath);
+  appendPart(parts, "sourcefile", input2.sourceFile);
+  appendPart(parts, "dependencytype", input2.dependencyType);
+  appendPart(parts, "sourcecomponentid", input2.sourceComponentId);
+  appendPart(parts, "targetcomponentid", input2.targetComponentId);
+  appendPart(parts, "importspecifier", input2.importSpecifier);
+  appendPart(parts, "resolvedtargetpath", input2.resolvedTargetPath);
+  if (input2.isExternal !== void 0) {
+    parts.push(`external=${input2.isExternal ? "true" : "false"}`);
+  }
+  const deductionIdentity = normalizeDeductionIdentity(input2.deductionKey);
+  if (deductionIdentity) {
+    parts.push(`deduction=${deductionIdentity}`);
+  }
+  if (parts.length <= 2) {
+    return void 0;
+  }
+  return parts.join("|");
+}
+function normalizeLegacyKey(key) {
+  const normalized = normalizeOptionalToken(key);
+  if (!normalized) {
+    return void 0;
+  }
+  return `legacy=${normalized}`;
+}
+function buildFindingRegressionIdentity(input2) {
+  const persisted = normalizeOptionalToken(input2.regressionIdentity);
+  if (persisted) {
+    return { identity: persisted, source: "persisted" };
+  }
+  const semantic = buildSemanticRegressionIdentity(input2);
+  if (semantic) {
+    return { identity: semantic, source: "semantic" };
+  }
+  const legacy = normalizeLegacyKey(input2.key);
+  if (legacy) {
+    return { identity: legacy, source: "legacy-key" };
+  }
+  return {
+    identity: [
+      `rule=${normalizeToken2(input2.id)}`,
+      `kind=${resolveKind(input2)}`,
+      `message=${normalizeToken2(input2.message ?? "")}`
+    ].join("|"),
+    source: "legacy-key"
+  };
+}
+function toComparableFindingRegression(input2) {
+  const identity = buildFindingRegressionIdentity(input2);
+  return {
+    identity: identity.identity,
+    id: input2.id,
+    kind: resolveKind(input2),
+    ...input2.severity ? { severity: input2.severity } : {},
+    ...input2.message ? { message: input2.message } : {},
+    ...input2.sourceFile ? { sourceFile: input2.sourceFile.replace(/\\/g, "/") } : {},
+    ...input2.sourceLine !== void 0 ? { sourceLine: input2.sourceLine } : {},
+    ...input2.sourceColumn !== void 0 ? { sourceColumn: input2.sourceColumn } : {},
+    ...input2.module ? { module: input2.module } : {},
+    ...input2.target ? { target: input2.target } : {},
+    ...input2.findingType ? { findingType: input2.findingType } : {},
+    regressionIdentitySource: identity.source
+  };
+}
+function compareComparableFindings(left, right) {
+  const identityCompare = left.identity.localeCompare(right.identity);
+  if (identityCompare !== 0) {
+    return identityCompare;
+  }
+  const idCompare = left.id.localeCompare(right.id);
+  if (idCompare !== 0) {
+    return idCompare;
+  }
+  const sourceCompare = (left.sourceFile ?? "").localeCompare(right.sourceFile ?? "");
+  if (sourceCompare !== 0) {
+    return sourceCompare;
+  }
+  const leftLine = left.sourceLine ?? Number.MAX_SAFE_INTEGER;
+  const rightLine = right.sourceLine ?? Number.MAX_SAFE_INTEGER;
+  if (leftLine !== rightLine) {
+    return leftLine - rightLine;
+  }
+  const leftColumn = left.sourceColumn ?? Number.MAX_SAFE_INTEGER;
+  const rightColumn = right.sourceColumn ?? Number.MAX_SAFE_INTEGER;
+  if (leftColumn !== rightColumn) {
+    return leftColumn - rightColumn;
+  }
+  const severityCompare = (left.severity ?? "").localeCompare(right.severity ?? "");
+  if (severityCompare !== 0) {
+    return severityCompare;
+  }
+  return (left.message ?? "").localeCompare(right.message ?? "");
+}
+function dedupeByIdentity(findings, toComparable) {
+  const map = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const comparable = toComparable(finding);
+    const existing = map.get(comparable.identity);
+    if (!existing || compareComparableFindings(comparable, existing.comparable) < 0) {
+      map.set(comparable.identity, { finding, comparable });
+    }
+  }
+  return [...map.values()].sort(
+    (left, right) => compareComparableFindings(left.comparable, right.comparable)
+  );
+}
+function compareFindingRegressions(reference, current, options) {
+  const referenceEntries = dedupeByIdentity(reference, options.toReferenceComparable);
+  const currentEntries = dedupeByIdentity(current, options.toCurrentComparable);
+  const referenceIdentities = new Set(referenceEntries.map((entry) => entry.comparable.identity));
+  const currentIdentities = new Set(currentEntries.map((entry) => entry.comparable.identity));
+  return {
+    introduced: currentEntries.filter((entry) => !referenceIdentities.has(entry.comparable.identity)).map((entry) => entry.finding),
+    existing: currentEntries.filter((entry) => referenceIdentities.has(entry.comparable.identity)).map((entry) => entry.finding),
+    resolved: referenceEntries.filter((entry) => !currentIdentities.has(entry.comparable.identity)).map((entry) => entry.finding)
+  };
+}
+
+// ../core/src/architectureGovernanceBaseline.ts
 function sortUnique9(values) {
   return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
@@ -238442,13 +238710,51 @@ function baselineFindingKey(entry) {
   ].join("|");
 }
 function toBaselineFinding(entry) {
+  const regressionIdentity = entry.regressionIdentity ?? buildFindingRegressionIdentity({
+    id: entry.id,
+    kind: entry.kind,
+    severity: entry.severity,
+    message: entry.message,
+    sourceFile: entry.sourceFile,
+    findingType: entry.findingType,
+    module: entry.module,
+    target: entry.target,
+    filePath: entry.filePath,
+    table: entry.table,
+    api: entry.api,
+    dependencyType: entry.dependencyType,
+    sourceComponentId: entry.sourceComponentId,
+    sourceComponentName: entry.sourceComponentName,
+    targetComponentId: entry.targetComponentId,
+    targetComponentName: entry.targetComponentName,
+    importSpecifier: entry.importSpecifier,
+    resolvedTargetPath: entry.resolvedTargetPath,
+    isExternal: entry.isExternal
+  }).identity;
   return {
     key: baselineFindingKey(entry),
+    regressionIdentity,
     id: entry.id,
     severity: entry.severity,
     kind: entry.kind,
     message: entry.message,
-    ...entry.sourceFile ? { sourceFile: normalizePath18(entry.sourceFile) } : {}
+    ...entry.sourceFile ? { sourceFile: normalizePath18(entry.sourceFile) } : {},
+    ...typeof entry.sourceLine === "number" && Number.isFinite(entry.sourceLine) ? { sourceLine: Math.max(1, Math.floor(entry.sourceLine)) } : {},
+    ...typeof entry.sourceColumn === "number" && Number.isFinite(entry.sourceColumn) ? { sourceColumn: Math.max(1, Math.floor(entry.sourceColumn)) } : {},
+    ...entry.findingType ? { findingType: entry.findingType } : {},
+    ...entry.module ? { module: entry.module } : {},
+    ...entry.target ? { target: entry.target } : {},
+    ...entry.filePath ? { filePath: normalizePath18(entry.filePath) } : {},
+    ...entry.table ? { table: entry.table } : {},
+    ...entry.api ? { api: entry.api } : {},
+    ...entry.dependencyType ? { dependencyType: entry.dependencyType } : {},
+    ...entry.sourceComponentId ? { sourceComponentId: entry.sourceComponentId } : {},
+    ...entry.sourceComponentName ? { sourceComponentName: entry.sourceComponentName } : {},
+    ...entry.targetComponentId !== void 0 ? { targetComponentId: entry.targetComponentId } : {},
+    ...entry.targetComponentName !== void 0 ? { targetComponentName: entry.targetComponentName } : {},
+    ...entry.importSpecifier ? { importSpecifier: entry.importSpecifier } : {},
+    ...entry.resolvedTargetPath !== void 0 ? { resolvedTargetPath: entry.resolvedTargetPath } : {},
+    ...entry.isExternal !== void 0 ? { isExternal: entry.isExternal } : {}
   };
 }
 function compareFindings(left, right) {
@@ -238484,7 +238790,28 @@ function parseSummaryArtifact(value) {
     severity: entry.severity,
     kind: entry.kind,
     message: entry.message,
-    ...typeof entry.sourceFile === "string" ? { sourceFile: entry.sourceFile } : {}
+    ...typeof entry.regressionIdentity === "string" ? { regressionIdentity: entry.regressionIdentity } : {},
+    ...typeof entry.sourceFile === "string" ? { sourceFile: entry.sourceFile } : {},
+    ...typeof entry.sourceLine === "number" && Number.isFinite(entry.sourceLine) ? { sourceLine: entry.sourceLine } : {},
+    ...typeof entry.sourceColumn === "number" && Number.isFinite(entry.sourceColumn) ? { sourceColumn: entry.sourceColumn } : {},
+    ...typeof entry.findingType === "string" ? {
+      findingType: entry.findingType
+    } : {},
+    ...typeof entry.module === "string" ? { module: entry.module } : {},
+    ...typeof entry.target === "string" ? { target: entry.target } : {},
+    ...typeof entry.filePath === "string" ? { filePath: entry.filePath } : {},
+    ...typeof entry.table === "string" ? { table: entry.table } : {},
+    ...typeof entry.api === "string" ? { api: entry.api } : {},
+    ...typeof entry.dependencyType === "string" ? {
+      dependencyType: entry.dependencyType
+    } : {},
+    ...typeof entry.sourceComponentId === "string" ? { sourceComponentId: entry.sourceComponentId } : {},
+    ...typeof entry.sourceComponentName === "string" ? { sourceComponentName: entry.sourceComponentName } : {},
+    ...typeof entry.targetComponentId === "string" || entry.targetComponentId === null ? { targetComponentId: entry.targetComponentId } : {},
+    ...typeof entry.targetComponentName === "string" || entry.targetComponentName === null ? { targetComponentName: entry.targetComponentName } : {},
+    ...typeof entry.importSpecifier === "string" ? { importSpecifier: entry.importSpecifier } : {},
+    ...typeof entry.resolvedTargetPath === "string" || entry.resolvedTargetPath === null ? { resolvedTargetPath: entry.resolvedTargetPath } : {},
+    ...typeof entry.isExternal === "boolean" ? { isExternal: entry.isExternal } : {}
   }));
   const suppressionRaw = typed.suppressionSummary && typeof typed.suppressionSummary === "object" ? typed.suppressionSummary : void 0;
   const suppressionSummary = suppressionRaw && typeof suppressionRaw.configuredSuppressions === "number" && typeof suppressionRaw.activeSuppressions === "number" && typeof suppressionRaw.expiredSuppressions === "number" && typeof suppressionRaw.unusedSuppressions === "number" && typeof suppressionRaw.findingsSuppressed === "number" ? {
@@ -238553,6 +238880,57 @@ function buildBaselineFromSummaryArtifact(artifact, nowUtcIso2) {
     ...artifact.impactAnalysis ? { impactAnalysis: artifact.impactAnalysis } : {}
   };
 }
+function buildGovernanceBaselineFromReviewSummary(summary, nowUtcIso2) {
+  return {
+    reportVersion: 1,
+    projectName: summary.projectName,
+    capturedAtUtc: nowUtcIso2 ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sourceSummaryGeneratedAtUtc: summary.generatedAtUtc,
+    healthScore: summary.healthScore,
+    readinessScore: summary.readinessScore,
+    categoryScores: summary.categoryScores,
+    readinessCategoryScores: summary.readinessCategoryScores,
+    counts: {
+      errors: summary.counts.errors,
+      warnings: summary.counts.warnings,
+      info: summary.counts.info,
+      passed: summary.counts.passed
+    },
+    findingCount: summary.findings.length,
+    remainingViolationsCount: summary.findings.filter((finding) => finding.kind === "violation").length,
+    findings: summary.findings.map(
+      (entry) => toBaselineFinding({
+        id: entry.id,
+        severity: entry.severity,
+        kind: entry.kind,
+        message: entry.message,
+        ...entry.sourceFile ? { sourceFile: entry.sourceFile } : {},
+        ...entry.sourceLine !== void 0 ? { sourceLine: entry.sourceLine } : {},
+        ...entry.sourceColumn !== void 0 ? { sourceColumn: entry.sourceColumn } : {},
+        ...entry.findingType ? { findingType: entry.findingType } : {},
+        ...entry.module ? { module: entry.module } : {},
+        ...entry.target ? { target: entry.target } : {},
+        ...entry.filePath ? { filePath: entry.filePath } : {},
+        ...entry.table ? { table: entry.table } : {},
+        ...entry.api ? { api: entry.api } : {},
+        ...entry.dependencyType ? { dependencyType: entry.dependencyType } : {},
+        ...entry.sourceComponentId ? { sourceComponentId: entry.sourceComponentId } : {},
+        ...entry.sourceComponentName ? { sourceComponentName: entry.sourceComponentName } : {},
+        ...entry.targetComponentId !== void 0 ? { targetComponentId: entry.targetComponentId } : {},
+        ...entry.targetComponentName !== void 0 ? { targetComponentName: entry.targetComponentName } : {},
+        ...entry.importSpecifier ? { importSpecifier: entry.importSpecifier } : {},
+        ...entry.resolvedTargetPath !== void 0 ? { resolvedTargetPath: entry.resolvedTargetPath } : {},
+        ...entry.isExternal !== void 0 ? { isExternal: entry.isExternal } : {}
+      })
+    ).sort(compareFindings),
+    changeRisk: {
+      riskLevel: summary.changeRisk.riskLevel,
+      score: summary.changeRisk.score,
+      summary: summary.changeRisk.summary
+    },
+    ...summary.impactAnalysis ? { impactAnalysis: summary.impactAnalysis } : {}
+  };
+}
 function getGovernanceBaselinePath(workspaceRoot) {
   return path42.join(workspaceRoot, ".archpilot", "baseline", "baseline.json");
 }
@@ -238636,13 +239014,43 @@ async function readGovernanceBaseline(workspaceRoot) {
   }
 }
 function compareFindingsByKey(current, baseline) {
-  const currentMap = new Map(current.map((entry) => [entry.key, entry]));
-  const baselineMap = new Map(baseline.map((entry) => [entry.key, entry]));
-  const newlyIntroducedFindings = [...currentMap.entries()].filter(([key]) => !baselineMap.has(key)).map(([, entry]) => entry).sort(compareFindings);
-  const resolvedFindings = [...baselineMap.entries()].filter(([key]) => !currentMap.has(key)).map(([, entry]) => entry).sort(compareFindings);
-  const unchangedFindings = [...currentMap.entries()].filter(([key]) => baselineMap.has(key)).map(([, entry]) => entry).sort(compareFindings);
+  const comparison = compareFindingRegressions(baseline, current, {
+    toReferenceComparable: toComparableBaselineFinding,
+    toCurrentComparable: toComparableBaselineFinding
+  });
+  const newlyIntroducedFindings = comparison.introduced.sort(compareFindings);
+  const resolvedFindings = comparison.resolved.sort(compareFindings);
+  const unchangedFindings = comparison.existing.sort(compareFindings);
   return { newlyIntroducedFindings, resolvedFindings, unchangedFindings };
 }
+function toRegressionInput(entry) {
+  return {
+    id: entry.id,
+    kind: entry.kind,
+    severity: entry.severity,
+    message: entry.message,
+    regressionIdentity: entry.regressionIdentity,
+    key: entry.key,
+    sourceFile: entry.sourceFile,
+    findingType: entry.findingType,
+    module: entry.module,
+    target: entry.target,
+    filePath: entry.filePath,
+    table: entry.table,
+    api: entry.api,
+    dependencyType: entry.dependencyType,
+    sourceComponentId: entry.sourceComponentId,
+    sourceComponentName: entry.sourceComponentName,
+    targetComponentId: entry.targetComponentId,
+    targetComponentName: entry.targetComponentName,
+    importSpecifier: entry.importSpecifier,
+    resolvedTargetPath: entry.resolvedTargetPath,
+    isExternal: entry.isExternal
+  };
+}
+function toComparableBaselineFinding(entry) {
+  return toComparableFindingRegression(toRegressionInput(entry));
+}
 function compareWithGovernanceBaseline(currentSummary, baselineLoad) {
   const currentFindings = currentSummary.findings.map(
     (entry) => toBaselineFinding({
@@ -238650,7 +239058,23 @@ function compareWithGovernanceBaseline(currentSummary, baselineLoad) {
       severity: entry.severity,
       kind: entry.kind,
       message: entry.message,
-      ...entry.sourceFile ? { sourceFile: entry.sourceFile } : {}
+      ...entry.sourceFile ? { sourceFile: entry.sourceFile } : {},
+      ...entry.sourceLine !== void 0 ? { sourceLine: entry.sourceLine } : {},
+      ...entry.sourceColumn !== void 0 ? { sourceColumn: entry.sourceColumn } : {},
+      ...entry.findingType ? { findingType: entry.findingType } : {},
+      ...entry.module ? { module: entry.module } : {},
+      ...entry.target ? { target: entry.target } : {},
+      ...entry.filePath ? { filePath: entry.filePath } : {},
+      ...entry.table ? { table: entry.table } : {},
+      ...entry.api ? { api: entry.api } : {},
+      ...entry.dependencyType ? { dependencyType: entry.dependencyType } : {},
+      ...entry.sourceComponentId ? { sourceComponentId: entry.sourceComponentId } : {},
+      ...entry.sourceComponentName ? { sourceComponentName: entry.sourceComponentName } : {},
+      ...entry.targetComponentId !== void 0 ? { targetComponentId: entry.targetComponentId } : {},
+      ...entry.targetComponentName !== void 0 ? { targetComponentName: entry.targetComponentName } : {},
+      ...entry.importSpecifier ? { importSpecifier: entry.importSpecifier } : {},
+      ...entry.resolvedTargetPath !== void 0 ? { resolvedTargetPath: entry.resolvedTargetPath } : {},
+      ...entry.isExternal !== void 0 ? { isExternal: entry.isExternal } : {}
     })
   ).sort(compareFindings);
   const currentRemainingViolations = currentSummary.findings.filter(
@@ -238811,6 +239235,43 @@ function renderList(values) {
   }
   return values.map((value) => `- ${value}`).join("\n");
 }
+function formatRegressionFinding(finding) {
+  const pieces = [`[${finding.id}]`, `(${finding.severity})`];
+  const scope = finding.module && finding.target ? `${finding.module} -> ${finding.target}` : finding.sourceComponentName && finding.targetComponentName ? `${finding.sourceComponentName} -> ${finding.targetComponentName}` : finding.module ?? finding.target ?? finding.table ?? finding.api ?? finding.filePath;
+  if (scope) {
+    pieces.push(scope);
+  }
+  if (finding.sourceFile) {
+    pieces.push(
+      finding.sourceLine !== void 0 ? `${finding.sourceFile}:${finding.sourceLine}` : finding.sourceFile
+    );
+  }
+  if (finding.message) {
+    pieces.push(finding.message);
+  }
+  return pieces.join(" | ");
+}
+function renderRegressionFindingList(findings, limit) {
+  if (findings.length === 0) {
+    return "- (none)";
+  }
+  const sorted = [...findings].sort((left, right) => {
+    const idCompare = left.id.localeCompare(right.id);
+    if (idCompare !== 0) {
+      return idCompare;
+    }
+    const sourceCompare = (left.sourceFile ?? "").localeCompare(right.sourceFile ?? "");
+    if (sourceCompare !== 0) {
+      return sourceCompare;
+    }
+    return (left.message ?? "").localeCompare(right.message ?? "");
+  });
+  const rendered = sorted.slice(0, limit).map((finding) => `- ${formatRegressionFinding(finding)}`);
+  if (sorted.length > limit) {
+    rendered.push(`- ... ${sorted.length - limit} more`);
+  }
+  return rendered.join("\n");
+}
 function renderStatusLine(input2) {
   const validationHasIssues = input2.validation.kind === "ok" && (input2.validation.data.counts.errors > 0 || input2.validation.data.counts.warnings > 0 || input2.validation.data.counts.info > 0);
   const driftHasChanges = input2.drift.kind === "ok" && (input2.drift.data.summaryCounts.totalChanges ?? input2.drift.data.summaryCounts.modulesAdded + input2.drift.data.summaryCounts.modulesRemoved + input2.drift.data.summaryCounts.dependenciesAdded + input2.drift.data.summaryCounts.dependenciesRemoved + input2.drift.data.summaryCounts.cyclesAdded + input2.drift.data.summaryCounts.cyclesRemoved) > 0;
@@ -238960,14 +239421,43 @@ function renderArchitecturePrReviewMarkdown(input2) {
   }
   if (input2.validation.kind === "ok" && input2.validation.data.baselineComparison) {
     const baseline = input2.validation.data.baselineComparison;
-    lines.push("## Baseline Comparison");
-    lines.push(`- Baseline status: ${baseline.status}`);
-    lines.push(`- Health score delta: ${baseline.deltas.healthScoreDelta}`);
-    lines.push(`- Readiness score delta: ${baseline.deltas.readinessScoreDelta}`);
-    lines.push(`- New findings: ${baseline.newlyIntroducedFindings.length}`);
-    lines.push(`- Resolved findings: ${baseline.resolvedFindings.length}`);
-    lines.push(`- Summary: ${baseline.summary}`);
-    lines.push("");
+    const comparisonAvailable = baseline.baselineAvailable !== false && baseline.status !== "NO_BASELINE";
+    lines.push("## Architecture Regression Summary");
+    if (!comparisonAvailable) {
+      lines.push("- Architecture regression comparison is unavailable.");
+      if (baseline.summary.toLowerCase().includes("no baseline")) {
+        lines.push("- No governance baseline exists.");
+        lines.push("- Create or refresh the governance baseline with `archpilot baseline refresh`.");
+      }
+      lines.push(`- Summary: ${baseline.summary}`);
+      lines.push("");
+    } else {
+      const introducedCount = baseline.newlyIntroducedFindings.length;
+      const resolvedCount = baseline.resolvedFindings.length;
+      const existingCount = baseline.unchangedFindings?.length ?? 0;
+      lines.push("| | Count |");
+      lines.push("| --- | ---: |");
+      lines.push(`| Introduced | ${introducedCount} |`);
+      lines.push(`| Resolved | ${resolvedCount} |`);
+      lines.push(`| Existing | ${existingCount} |`);
+      lines.push("");
+      lines.push(
+        `Existing means current findings already represented by the accepted governance baseline.`
+      );
+      lines.push("");
+      if (introducedCount === 0) {
+        lines.push("No new architecture regressions detected.");
+      } else {
+        lines.push("### New architecture regressions");
+        lines.push(renderRegressionFindingList(baseline.newlyIntroducedFindings, 10));
+      }
+      if (resolvedCount > 0) {
+        lines.push("");
+        lines.push("### Resolved architecture findings");
+        lines.push(renderRegressionFindingList(baseline.resolvedFindings, 8));
+      }
+      lines.push("");
+    }
   }
   if (input2.validation.kind === "ok" && input2.validation.data.risk) {
     const governanceRisk = input2.validation.data.risk;
@@ -239058,23 +239548,32 @@ function renderArchitecturePrReviewMarkdown(input2) {
     }
   }
   if (input2.validation.kind === "ok") {
-    const topFindings = [...input2.validation.data.findings].sort((left, right) => {
-      const severityCompare = severityRank(left.severity) - severityRank(right.severity);
-      if (severityCompare !== 0) {
-        return severityCompare;
-      }
-      const idCompare = left.id.localeCompare(right.id);
-      if (idCompare !== 0) {
-        return idCompare;
-      }
-      return left.message.localeCompare(right.message);
-    }).slice(0, 8);
     lines.push("## Validation Findings");
-    lines.push(
-      topFindings.length === 0 ? "- (none)" : topFindings.map(
-        (finding) => `- [${finding.id}] (${finding.severity}) ${finding.title} | ${finding.message}`
-      ).join("\n")
-    );
+    const baseline = input2.validation.data.baselineComparison;
+    const comparisonAvailable = baseline && baseline.baselineAvailable !== false && baseline.status !== "NO_BASELINE";
+    if (comparisonAvailable) {
+      lines.push(`- Current canonical findings: ${input2.validation.data.findings.length}`);
+      lines.push(
+        "- Regression details above prioritize introduced and resolved findings; complete current findings remain in the validation artifacts."
+      );
+    } else {
+      const topFindings = [...input2.validation.data.findings].sort((left, right) => {
+        const severityCompare = severityRank(left.severity) - severityRank(right.severity);
+        if (severityCompare !== 0) {
+          return severityCompare;
+        }
+        const idCompare = left.id.localeCompare(right.id);
+        if (idCompare !== 0) {
+          return idCompare;
+        }
+        return left.message.localeCompare(right.message);
+      }).slice(0, 8);
+      lines.push(
+        topFindings.length === 0 ? "- (none)" : topFindings.map(
+          (finding) => `- [${finding.id}] (${finding.severity}) ${finding.title} | ${finding.message}`
+        ).join("\n")
+      );
+    }
     lines.push("");
   }
   if (input2.drift.kind === "ok") {
@@ -239201,7 +239700,7 @@ function toAnnotatableFinding(workspaceRoot, finding) {
   if (finding.severity !== "error" && finding.severity !== "warning") {
     return void 0;
   }
-  if (typeof finding.title !== "string" || typeof finding.message !== "string") {
+  if (typeof finding.message !== "string") {
     return void 0;
   }
   if (typeof finding.sourceFile !== "string") {
@@ -239218,7 +239717,7 @@ function toAnnotatableFinding(workspaceRoot, finding) {
   const column = typeof finding.sourceColumn === "number" && Number.isFinite(finding.sourceColumn) ? Math.max(1, Math.floor(finding.sourceColumn)) : void 0;
   return {
     id: finding.id,
-    title: finding.title,
+    title: typeof finding.title === "string" ? finding.title : finding.id,
     message: finding.message,
     severity: finding.severity,
     file,
@@ -239338,9 +239837,47 @@ async function loadFromSummaryReport(workspaceRoot, maxAgeMinutes) {
     findings: findings.filter((entry) => !!entry && typeof entry === "object")
   };
 }
+async function loadFromBaselineComparisonReport(workspaceRoot, maxAgeMinutes) {
+  const comparisonPath = path43.join(
+    workspaceRoot,
+    ".archpilot",
+    "reports",
+    "baseline-comparison.json"
+  );
+  let raw;
+  try {
+    raw = await import_node_fs37.promises.readFile(comparisonPath, { encoding: "utf8" });
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.log("ArchPilot inline annotations: unable to read baseline-comparison.json.");
+    }
+    return void 0;
+  }
+  if (!await isFreshArtifact(comparisonPath, maxAgeMinutes)) {
+    console.log(
+      `ArchPilot inline annotations: baseline-comparison.json is stale (older than ${maxAgeMinutes} minutes).`
+    );
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    console.log("ArchPilot inline annotations: baseline-comparison.json is invalid JSON.");
+    return void 0;
+  }
+  if (parsed.baselineAvailable !== true) {
+    return void 0;
+  }
+  const findings = Array.isArray(parsed.newlyIntroducedFindings) ? parsed.newlyIntroducedFindings : [];
+  return {
+    sourceLabel: ".archpilot/reports/baseline-comparison.json",
+    findings: findings.filter((entry) => !!entry && typeof entry === "object")
+  };
+}
 async function emitGithubInlineArchitectureAnnotations(workspaceRoot) {
   const maxAgeMinutes = readMaxArtifactAgeMinutes();
-  const loaded = await loadFromValidationStatus(workspaceRoot, maxAgeMinutes) ?? await loadFromSummaryReport(workspaceRoot, maxAgeMinutes);
+  const loaded = await loadFromBaselineComparisonReport(workspaceRoot, maxAgeMinutes) ?? await loadFromValidationStatus(workspaceRoot, maxAgeMinutes) ?? await loadFromSummaryReport(workspaceRoot, maxAgeMinutes);
   if (!loaded) {
     const now = formatUtcDate(/* @__PURE__ */ new Date());
     console.log(
@@ -246548,7 +247085,7 @@ function hasNestRuntimeApplicationEvidence(workspaceRoot, componentPath, package
   ].filter(Boolean).length;
   return hasBootstrapEntrypoint || hasRuntimePlatform && structuralEvidenceCount >= 2 || hasRunnableScript && hasRuntimeSourceShape && structuralEvidenceCount >= 3;
 }
-function resolveKind(workspaceRoot, candidate, localProjectKinds) {
+function resolveKind2(workspaceRoot, candidate, localProjectKinds) {
   const lowerPath = candidate.path.toLowerCase();
   const packageJson = readPackageJson(workspaceRoot, candidate.path);
   const projectJson = readProjectJson(workspaceRoot, candidate.path);
@@ -246961,7 +247498,7 @@ function detectComponents(input2) {
     }
     const localProjectKinds = input2.runContext?.detectProjectKinds(absoluteRoot) ?? detectProjectKinds(absoluteRoot);
     const stackDetection = input2.runContext?.detectStacks(absoluteRoot) ?? detectStacks(absoluteRoot);
-    const kind = resolveKind(input2.workspaceRoot, candidate, localProjectKinds);
+    const kind = resolveKind2(input2.workspaceRoot, candidate, localProjectKinds);
     const stack = resolveStack(kind, stackDetection);
     const evidence = [...candidate.evidence];
     if (candidate.architectureRoot?.classification && candidate.architectureRoot.classification !== "unknown") {
@@ -250227,7 +250764,30 @@ async function runStandardValidationWorkflowForWorkspace(input2) {
     "Loading governance baseline",
     () => readGovernanceBaseline(input2.workspaceRoot)
   );
-  const baselineComparison = compareWithGovernanceBaseline(reviewSummary, governanceBaseline);
+  applyCanonicalValidationSummary(reviewSummary, runResult.status.summary);
+  let effectiveGovernanceBaseline = governanceBaseline;
+  let initialGovernanceBaselinePath;
+  if (governanceBaseline.kind === "missing" && !input2.ciMode) {
+    const baseline = buildGovernanceBaselineFromReviewSummary(reviewSummary);
+    initialGovernanceBaselinePath = await phase(
+      "Creating initial governance baseline",
+      () => writeGovernanceBaseline(input2.workspaceRoot, baseline)
+    );
+    effectiveGovernanceBaseline = {
+      kind: "ok",
+      baseline,
+      baselinePath: initialGovernanceBaselinePath
+    };
+    emitOperationalMessage(
+      input2.onOperationalMessage,
+      "info",
+      "Governance baseline created from initial validation. Future validations will highlight new architecture regressions."
+    );
+  }
+  const baselineComparison = compareWithGovernanceBaseline(
+    reviewSummary,
+    effectiveGovernanceBaseline
+  );
   reviewSummary.enforcement = buildEnforcementResult(
     reviewSummary.risk,
     riskPolicyLoad.config,
@@ -250248,7 +250808,6 @@ async function runStandardValidationWorkflowForWorkspace(input2) {
     })
   );
   reviewSummary.baselineComparison = baselineComparison;
-  applyCanonicalValidationSummary(reviewSummary, runResult.status.summary);
   let baselineComparisonPath;
   try {
     baselineComparisonPath = await writeBaselineComparisonReport(
@@ -250313,6 +250872,7 @@ async function runStandardValidationWorkflowForWorkspace(input2) {
     impactAnalysisPath,
     baselineComparison,
     ...baselineComparisonPath ? { baselineComparisonPath } : {},
+    ...initialGovernanceBaselinePath ? { initialGovernanceBaselinePath } : {},
     ...prCommentPath ? { prCommentPath } : {}
   };
 }
@@ -250498,6 +251058,7 @@ function parseValidateFlags(args) {
     json: args.includes("--json"),
     changed: args.includes("--changed"),
     diff: args.includes("--diff"),
+    regressions: args.includes("--regressions"),
     base: base.length > 0 ? base : "main"
   };
 }
@@ -250544,8 +251105,8 @@ function readFlagValue(args, flag) {
   return value && value.length > 0 ? value : void 0;
 }
 async function readCliPackageVersion() {
-  if ("0.2.6".trim().length > 0) {
-    return "0.2.6".trim();
+  if ("0.2.7".trim().length > 0) {
+    return "0.2.7".trim();
   }
   const candidatePackageJsonPaths = [
     path73.join(__dirname, "..", "package.json"),
@@ -250602,7 +251163,7 @@ function printUsage() {
   console.error("Usage: archpilot init [--yes]");
   console.error("       archpilot init refresh --preview");
   console.error("       archpilot init refresh --apply");
-  console.error("Usage: archpilot validate [--ci] [--json] [--changed] [--diff] [--base <branch>]");
+  console.error("Usage: archpilot validate [--ci] [--json] [--regressions] [--changed] [--diff] [--base <branch>]");
   console.error("       archpilot impact <file-or-module> [--json] [--stdout] [--module] [--force]");
   console.error("       archpilot fix <RULE_ID>");
   console.error("       archpilot fix");
@@ -250689,11 +251250,12 @@ var cliHelpTopics = [
   {
     commandPath: ["validate"],
     lines: [
-      "Usage: archpilot validate [--ci] [--json] [--changed] [--diff] [--base <branch>]",
+      "Usage: archpilot validate [--ci] [--json] [--regressions] [--changed] [--diff] [--base <branch>]",
       "",
       "Options:",
       "  --ci                  CI mode",
       "  --json                JSON output",
+      "  --regressions         show findings introduced or resolved since the governance baseline",
       "  --changed             validate changed files only",
       "  --diff                compare with baseline",
       "  --base <branch>       compare against branch"
@@ -252770,12 +253332,136 @@ function applyCanonicalValidationSummary2(reviewSummary, validationSummary) {
   reviewSummary.guidanceFindings = validationSummary.guidanceFindings;
   reviewSummary.qualityFindings = validationSummary.qualityFindings;
 }
+function getRegressionComparisonUnavailableReason(comparison) {
+  if (comparison.baselineAvailable) {
+    return void 0;
+  }
+  return comparison.summary.startsWith("Baseline unavailable:") ? "INVALID_BASELINE" : "NO_BASELINE";
+}
+function formatRegressionFindingLine2(finding) {
+  const location = finding.module && finding.target ? `${finding.module} -> ${finding.target}` : finding.module ?? finding.target ?? finding.sourceFile ?? finding.filePath ?? finding.table ?? finding.api;
+  const header = `${finding.id}  ${finding.severity}`;
+  return [
+    location ? `${header}
+${location}` : header,
+    finding.message
+  ].join("\n");
+}
+function renderRegressionFindingSection(title, findings) {
+  const lines = [];
+  lines.push(title);
+  lines.push("-".repeat(title.length));
+  lines.push("");
+  if (findings.length === 0) {
+    lines.push("- (none)");
+    return lines;
+  }
+  for (const finding of findings) {
+    lines.push(formatRegressionFindingLine2(finding));
+    lines.push("");
+  }
+  while (lines.at(-1) === "") {
+    lines.pop();
+  }
+  return lines;
+}
+function renderValidationRegressionConsole(comparison) {
+  const unavailableReason = getRegressionComparisonUnavailableReason(comparison);
+  const lines = [];
+  lines.push("Regression Summary");
+  lines.push("------------------");
+  if (unavailableReason) {
+    lines.push("Regression comparison unavailable.");
+    lines.push("");
+    if (unavailableReason === "NO_BASELINE") {
+      lines.push("No governance baseline was found.");
+      lines.push("");
+      lines.push("Create a governance baseline first:");
+      lines.push("  archpilot baseline refresh");
+    } else {
+      lines.push(comparison.summary);
+    }
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push(`Introduced: ${comparison.newlyIntroducedFindings.length}`);
+  lines.push(`Resolved:   ${comparison.resolvedFindings.length}`);
+  lines.push(`Existing:   ${comparison.unchangedFindings.length}`);
+  lines.push("");
+  if (comparison.newlyIntroducedFindings.length === 0) {
+    lines.push("No new architecture regressions detected.");
+  } else {
+    lines.push(
+      ...renderRegressionFindingSection(
+        "Introduced architecture findings",
+        comparison.newlyIntroducedFindings
+      )
+    );
+  }
+  if (comparison.resolvedFindings.length > 0) {
+    lines.push("");
+    lines.push(...renderRegressionFindingSection("Resolved", comparison.resolvedFindings));
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function buildRegressionComparisonJson(comparison) {
+  const unavailableReason = getRegressionComparisonUnavailableReason(comparison);
+  if (unavailableReason) {
+    return {
+      available: false,
+      reason: unavailableReason,
+      introducedCount: 0,
+      resolvedCount: 0,
+      existingCount: 0,
+      introduced: [],
+      resolved: []
+    };
+  }
+  return {
+    available: true,
+    introducedCount: comparison.newlyIntroducedFindings.length,
+    resolvedCount: comparison.resolvedFindings.length,
+    existingCount: comparison.unchangedFindings.length,
+    introduced: comparison.newlyIntroducedFindings,
+    resolved: comparison.resolvedFindings
+  };
+}
+function buildScopedRegressionComparisonUnavailable(summary, scopeMode) {
+  return {
+    reportVersion: 1,
+    baselineAvailable: false,
+    status: "NO_BASELINE",
+    summary: `Regression comparison unavailable for ${scopeMode} validation scope. Full governance baselines cannot be compared safely against scoped current findings.`,
+    current: {
+      projectName: summary.projectName,
+      generatedAtUtc: summary.generatedAtUtc,
+      healthScore: summary.healthScore,
+      readinessScore: summary.readinessScore
+    },
+    deltas: {
+      healthScoreDelta: 0,
+      readinessScoreDelta: 0,
+      errorDelta: 0,
+      warningDelta: 0,
+      findingDelta: 0,
+      remainingViolationsDelta: 0
+    },
+    newlyIntroducedFindings: [],
+    resolvedFindings: [],
+    unchangedFindings: []
+  };
+}
 async function runValidateCommand(args) {
   const flags = parseValidateFlags(args);
   if (flags.changed && flags.diff) {
     console.error("Choose one scope mode: --changed or --diff.");
     return 1;
   }
+  if (flags.regressions && (flags.changed || flags.diff)) {
+    console.error("--regressions cannot currently be combined with --changed/--diff.");
+    return 1;
+  }
   if (args.includes("--base") && !flags.diff) {
     console.error("--base can only be used with --diff.");
     return 1;
@@ -252932,8 +253618,7 @@ async function runValidateCommand(args) {
         }
       }
     });
-    const governanceBaseline = await readGovernanceBaseline(workspaceRoot);
-    baselineComparison = compareWithGovernanceBaseline(reviewSummary, governanceBaseline);
+    baselineComparison = buildScopedRegressionComparisonUnavailable(reviewSummary, scopeMode);
     reviewSummary.enforcement = buildEnforcementResult2(
       reviewSummary.risk,
       riskPolicyLoad.config,
@@ -253032,6 +253717,7 @@ async function runValidateCommand(args) {
           impactAnalysis: reviewSummary.impactAnalysis,
           impactAnalysisPath: toWorkspaceRelativePath(workspaceRoot, impactAnalysisPath),
           baselineComparison,
+          ...flags.regressions ? { regressionComparison: buildRegressionComparisonJson(baselineComparison) } : {},
           ...baselineComparisonPath ? {
             baselineComparisonPath: toWorkspaceRelativePath(
               workspaceRoot,
@@ -253076,24 +253762,36 @@ async function runValidateCommand(args) {
 `
       );
     }
-    process.stdout.write(
-      renderArchitectureReviewConsole(reviewSummary, {
-        ...reportArtifacts.reportWriteError ? { reportWriteError: reportArtifacts.reportWriteError } : {
-          reportPaths: {
-            markdownPath: reportArtifacts.reviewMarkdownPath,
-            jsonPath: reportArtifacts.reviewJsonPath,
-            compactMarkdownPath: reportArtifacts.reviewCompactMarkdownPath
-          }
-        },
-        remediation,
-        discoveredAdrs,
-        healthTrend: runResult.status.summary.healthTrend,
-        driftComparison: runResult.status.driftComparison,
-        adrSummary: runResult.status.adrSummary,
-        suppressionSummary: runResult.status.suppressionSummary,
-        baselineComparison
-      })
-    );
+    if (flags.regressions) {
+      process.stdout.write("ArchPilot Architecture Review\n\n");
+      process.stdout.write(`Architecture Health Score: ${reviewSummary.healthScore} / 100
+`);
+      process.stdout.write(`Setup Readiness Score: ${reviewSummary.readinessScore} / 100
+`);
+      process.stdout.write(`Current findings: ${reviewSummary.findings.length}
+
+`);
+      process.stdout.write(renderValidationRegressionConsole(baselineComparison));
+    } else {
+      process.stdout.write(
+        renderArchitectureReviewConsole(reviewSummary, {
+          ...reportArtifacts.reportWriteError ? { reportWriteError: reportArtifacts.reportWriteError } : {
+            reportPaths: {
+              markdownPath: reportArtifacts.reviewMarkdownPath,
+              jsonPath: reportArtifacts.reviewJsonPath,
+              compactMarkdownPath: reportArtifacts.reviewCompactMarkdownPath
+            }
+          },
+          remediation,
+          discoveredAdrs,
+          healthTrend: runResult.status.summary.healthTrend,
+          driftComparison: runResult.status.driftComparison,
+          adrSummary: runResult.status.adrSummary,
+          suppressionSummary: runResult.status.suppressionSummary,
+          baselineComparison
+        })
+      );
+    }
     process.stdout.write("\n");
     process.stdout.write(renderSetupNextStepsConsole(nextSteps));
     process.stdout.write(`${setupNextStepsReportPointerLine}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archpilotlabs/archpilot",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Executable architecture governance CLI for Smart Init, validation, drift detection, and CI.",
   "homepage": "https://archpilot.org",
   "bugs": {