@kaddo/mcp 3.124.2 → 3.124.4

package/dist/index.js

@@ -10404,6 +10404,29 @@ function buildGuardHistory(dir) {
 }
 
 // ../cli/src/core/reporting-evidence.ts
+function graphHintFinding(hint) {
+  const affected = [hint.artifact_id, ...hint.path ? [hint.path] : []];
+  const semantics = {
+    "work-item": { classification: "coverage_gap", priority: "medium", action: "Review whether the active Work Item needs the missing declared relationship." },
+    decision: { classification: "coverage_gap", priority: "low", action: "Review whether this decision should declare governed code paths." },
+    capability: { classification: "coverage_gap", priority: "low", action: "Review whether this capability should connect to existing Work Items; the relationship is optional." },
+    "knowledge-capsule": { classification: "review_hint", priority: "low", action: "Confirm whether this capsule is intended for direct contextual use or Work Item relationships." }
+  };
+  const semantic = semantics[hint.artifact_type];
+  return {
+    id: `graph-hint:${hint.artifact_id}:${hint.missing.join(",")}`,
+    category: "topology",
+    classification: semantic.classification,
+    resolution_status: "open",
+    source: "graph-hints",
+    affected_artifacts: affected,
+    // Graph Hints are intentionally non-blocking; their type determines priority and meaning.
+    priority: semantic.priority,
+    evidence: hint.reason,
+    explanation: hint.message,
+    suggested_action: semantic.action
+  };
+}
 function reportingProjectContext(dir) {
   const config = loadConfig(dir);
   if (!config) return { state: "unknown", mode: "unknown", repository_structure: "unknown" };
@@ -10458,7 +10481,11 @@ function buildImpactReport(dir, opts = {}, now = /* @__PURE__ */ new Date()) {
   const projectContext = reportingProjectContext(dir);
   const wis = discoverWorkItems(dir);
   const total = wis.length;
-  const verifiedWorkItems = wis.filter((wi) => wi.validationStatus === "passed").length;
+  const completedWis = wis.filter((wi) => wi.lifecycle === "completed");
+  const verifiedWorkItems = completedWis.filter((wi) => wi.validationStatus === "passed").length;
+  const failedValidationWorkItems = completedWis.filter((wi) => wi.validationStatus === "failed").length;
+  const pendingValidationWorkItems = completedWis.filter((wi) => Boolean(wi.validationStatus) && !["passed", "failed"].includes(wi.validationStatus)).length;
+  const notRecordedValidationWorkItems = completedWis.length - verifiedWorkItems - failedValidationWorkItems - pendingValidationWorkItems;
   let withOwnership = 0;
   let withSource = 0;
   let withInitiative = 0;
@@ -10531,10 +10558,12 @@ function buildImpactReport(dir, opts = {}, now = /* @__PURE__ */ new Date()) {
   }
   const ownershipOverlaps = gaps.ownership_overlaps.length;
   let g;
+  let graphHintEntries = [];
   const config = loadConfig(dir);
   if (config) {
     const graph = buildGraph(dir, config, { scope: resolvedScope }, now);
     const hints = buildGraphHints(dir, graph, now);
+    graphHintEntries = hints.hints;
     g = { available: true, scope: graph.scope, scopeReason: graph.scope_reason, nodes: graph.nodes.length, edges: graph.edges.length, quality: hints.quality, hints: hints.summary.hints, generatedAt: graph.generated_at };
   } else {
     g = { available: false, scope: resolvedScope, scopeReason: "", nodes: 0, edges: 0, quality: "unknown", hints: 0, generatedAt: "" };
@@ -10607,6 +10636,56 @@ function buildImpactReport(dir, opts = {}, now = /* @__PURE__ */ new Date()) {
     ai_context_readiness: aiReady,
     maintenance_readiness: levelFromRatio((coverageRatio(withOwnership) + (deliveryTraceable ? 1 : 0)) / 2)
   };
+  const baselineLayers = projectContext.mode === "poc" ? ["Tech", "Delivery"] : ["Business", "Product", "Tech", "Delivery"];
+  const findings = [];
+  for (const layer2 of baselineLayers) {
+    const status = layerStatus(layer2);
+    if (status !== "Weak" && status !== "Missing") continue;
+    findings.push({
+      id: `knowledge-health:${layer2.toLowerCase()}`,
+      category: "knowledge",
+      classification: "coverage_gap",
+      resolution_status: "open",
+      source: "knowledge-health",
+      affected_artifacts: [layer2],
+      priority: status === "Missing" ? "medium" : "low",
+      evidence: `${layer2} knowledge maturity is ${status}.`,
+      explanation: `This assesses documented ${layer2} knowledge, not the quality of the product or implementation.`,
+      suggested_action: `Review ${layer2} knowledge coverage and the artifacts or relationships available for it.`
+    });
+  }
+  for (const gap of gaps.missing_code_ownership) {
+    findings.push({
+      id: `ownership:${gap.id}`,
+      category: "delivery",
+      classification: "coverage_gap",
+      resolution_status: "open",
+      source: "work-item-ownership",
+      affected_artifacts: [gap.id, gap.path],
+      priority: "medium",
+      evidence: "A corrective Work Item has no declared code ownership.",
+      explanation: gap.title,
+      suggested_action: "Review and add relevant code ownership declarations."
+    });
+  }
+  for (const wi of completedWis) {
+    if (!wi.validationStatus || !["not-started", "in-progress", "partial", "failed", "blocked"].includes(wi.validationStatus)) continue;
+    findings.push({
+      id: `completion-validation:${wi.id || wi.title}`,
+      category: "delivery",
+      classification: "review_hint",
+      resolution_status: "open",
+      source: "work-item-lifecycle",
+      affected_artifacts: [wi.id || wi.title, wi.relPath],
+      priority: "medium",
+      evidence: `Lifecycle is completed while persisted validation is ${wi.validationStatus}.`,
+      explanation: "This requires review against the Work Item completion contract; it is not automatically a failed or invalid completion.",
+      suggested_action: "Review the validation evidence and confirm whether the completed lifecycle state is consistent with the Work Item completion contract."
+    });
+  }
+  findings.push(...graphHintEntries.map(graphHintFinding));
+  const priorityOrder = { high: 0, medium: 1, low: 2, unknown: 3 };
+  findings.sort((a2, b2) => priorityOrder[a2.priority] - priorityOrder[b2.priority] || a2.id.localeCompare(b2.id));
   let score = null;
   let score_breakdown = null;
   if (total > 0) {
@@ -10644,17 +10723,18 @@ function buildImpactReport(dir, opts = {}, now = /* @__PURE__ */ new Date()) {
   else if (g.scope === "active" && g.quality === "empty") actions.push("Run `kaddo impact --scope all` to measure accumulated knowledge impact.");
   if (exp.roadmap.remaining > 0) actions.push(`Materialize the ${exp.roadmap.remaining} remaining roadmap candidate(s) with \`kaddo create --from roadmap\`.`);
   for (const a2 of [
-    groupedAction(gaps.missing_code_ownership, "Add `code:` ownership to"),
-    groupedAction(gaps.missing_source, "Add `source`/`source_id` to"),
-    groupedAction(gaps.missing_acceptance_criteria, "Add Acceptance Criteria to"),
-    groupedAction(gaps.missing_definition_of_done, "Add a Definition of Done to"),
-    groupedAction(gaps.missing_validation, "Add a validation (How to test it) section to")
+    groupedAction(gaps.missing_source, "Add `source`/`source_id` to")
   ]) if (a2) actions.push(a2);
   if (gaps.broad_ownership_globs.length > 0) actions.push(`Narrow ${gaps.broad_ownership_globs.length} broad ownership glob(s) into specific paths.`);
-  if (g.available && g.hints > 0) actions.push("Review graph hints (`kaddo://graph-hints` or `.kaddo/graph-hints.md`).");
+  for (const finding of findings) {
+    if (!actions.includes(finding.suggested_action)) actions.push(finding.suggested_action);
+  }
   if (skills.length === 0) actions.push("Install reusable skills with `kaddo add skills`.");
   actions.push("Run `kaddo guard` before committing to catch knowledge drift.");
   const summary = [];
+  if (completedWis.length > 0) {
+    summary.push(`Delivery evidence: ${completedWis.length} completed; ${verifiedWorkItems} validation passed; ${notRecordedValidationWorkItems} not confirmed by persisted validation.`);
+  }
   if (total > 0) summary.push(`${withOwnership}/${total} Work Items include code ownership.`);
   if (g.available) summary.push(`The knowledge graph is ${g.quality} with ${g.nodes} nodes and ${g.edges} edges (${g.scope} scope).`);
   else summary.push("The knowledge graph has not been exported yet.");
@@ -10676,6 +10756,15 @@ function buildImpactReport(dir, opts = {}, now = /* @__PURE__ */ new Date()) {
     default_scope: "all",
     scope_source: scopeSource,
     executive_summary: summary,
+    delivery_evidence: {
+      completed: completedWis.length,
+      validation_passed: verifiedWorkItems,
+      validation_failed: failedValidationWorkItems,
+      validation_pending: pendingValidationWorkItems,
+      validation_not_recorded: notRecordedValidationWorkItems,
+      completion_with_passed_validation_percent: completedWis.length > 0 ? Math.round(verifiedWorkItems / completedWis.length * 1e3) / 10 : null
+    },
+    findings,
     knowledge_health,
     knowledge_coverage,
     ownership_coverage: {
@@ -10721,7 +10810,7 @@ function buildImpactReport(dir, opts = {}, now = /* @__PURE__ */ new Date()) {
 function ratio(have, total) {
   return `${have}/${total}`;
 }
-function renderImpactMarkdown(r2) {
+function renderImpactMarkdown(r2, opts = {}) {
   const L = [];
   L.push("# Kaddo Knowledge Impact Report", "");
   L.push(`Generated at: ${r2.generated_at}`);
@@ -10739,6 +10828,27 @@ function renderImpactMarkdown(r2) {
   L.push("## Executive Summary", "");
   for (const s2 of r2.executive_summary) L.push(`- ${s2}`);
   L.push("");
+  L.push("## Key Findings", "");
+  if (r2.findings.length === 0) L.push("No current findings detected by the executed deterministic checks.");
+  if (r2.findings.length > 0) {
+    const cell = (value) => value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+    L.push("| Classification | Priority | Status | Source | Affected | Finding | Suggested action |");
+    L.push("|---|---|---|---|---|---|---|");
+    for (const finding of r2.findings) {
+      L.push(`| ${finding.classification} | ${finding.priority} | ${finding.resolution_status} | ${cell(finding.source)} | ${cell(finding.affected_artifacts.join(", ") || "not available")} | ${cell(finding.explanation)} Evidence: ${cell(finding.evidence)} | ${cell(finding.suggested_action)} |`);
+    }
+  }
+  L.push("");
+  L.push("## Delivery Evidence", "");
+  const de = r2.delivery_evidence;
+  L.push(`- Completed Work Items: ${de.completed}`);
+  L.push(`- Validation passed: ${de.validation_passed}`);
+  L.push(`- Validation failed: ${de.validation_failed}`);
+  L.push(`- Validation pending: ${de.validation_pending}`);
+  L.push(`- Validation not recorded: ${de.validation_not_recorded}`);
+  L.push(`- Completion with passed validation: ${de.completion_with_passed_validation_percent === null ? "not available" : `${de.completion_with_passed_validation_percent}%`}`);
+  L.push("- \u201CNot recorded\u201D means persisted evidence is absent; it does not prove validation never happened.");
+  L.push("");
   L.push("## Evidence and Applicability", "");
   for (const item of r2.evidence) L.push(`- ${item.label}: ${item.classification} \u2014 ${item.reason}`);
   L.push("");
@@ -10837,14 +10947,9 @@ function renderImpactMarkdown(r2) {
     }
     L.push("");
   };
-  gapSection("Work Items missing source", gp.missing_source);
-  gapSection("Work Items missing initiative", gp.missing_initiative);
-  gapSection("Work Items missing code ownership", gp.missing_code_ownership);
-  gapSection("Work Items missing knowledge level", gp.missing_knowledge_level);
-  gapSection("Work Items missing acceptance criteria", gp.missing_acceptance_criteria);
-  gapSection("Work Items missing Definition of Done", gp.missing_definition_of_done);
-  gapSection("Work Items missing validation", gp.missing_validation);
-  if (gp.broad_ownership_globs.length > 0) {
+  if (opts.details) gapSection("Work Items missing source", gp.missing_source);
+  if (opts.details) gapSection("Work Items missing code ownership", gp.missing_code_ownership);
+  if (opts.details && gp.broad_ownership_globs.length > 0) {
     L.push("### Broad ownership globs", "");
     for (const b2 of gp.broad_ownership_globs) {
       L.push(`- ${b2.id} \u2014 ${b2.title}`);
@@ -10855,17 +10960,43 @@ function renderImpactMarkdown(r2) {
   }
   if (gp.ownership_overlaps.length > 0) {
     L.push("### Shared code-path history (review only)", "");
-    for (const o2 of gp.ownership_overlaps) {
-      L.push(`- \`${o2.code_path}\``);
-      L.push(`  - Owned by: ${o2.work_items.join(", ")}`);
-      L.push(`  - Suggested action: ${o2.suggested_action}`);
+    if (opts.details) {
+      for (const o2 of gp.ownership_overlaps) {
+        L.push(`- \`${o2.code_path}\``);
+        L.push(`  - Owned by: ${o2.work_items.join(", ")}`);
+        L.push(`  - Suggested action: ${o2.suggested_action}`);
+      }
+    } else {
+      L.push(`- ${gp.ownership_overlaps.length} shared path declaration(s) detected. These are historical relationships, not necessarily ownership conflicts.`);
+      const areas = gp.ownership_overlaps.slice(0, 3).map((o2) => `\`${o2.code_path}\``);
+      if (areas.length > 0) L.push(`- Most involved paths: ${areas.join(", ")}.`);
+      L.push("- Run `kaddo impact --details` for the complete shared-path inventory.");
     }
     L.push("");
   }
-  const anyGaps = gp.missing_source.length + gp.missing_initiative.length + gp.missing_code_ownership.length + gp.missing_knowledge_level.length + gp.missing_acceptance_criteria.length + gp.missing_definition_of_done.length + gp.missing_validation.length + gp.broad_ownership_globs.length;
+  const anyGaps = gp.missing_source.length + gp.missing_code_ownership.length + gp.broad_ownership_globs.length;
   if (anyGaps === 0) {
     L.push("No actionable knowledge gaps detected. \u{1F389}", "");
+  } else if (!opts.details) {
+    L.push("- Current actionable items are listed in Key Findings. Run `kaddo impact --details` for the full artifact inventory.");
+    L.push("");
+  }
+  const historical = [
+    ["knowledge level", gp.missing_knowledge_level],
+    ["Acceptance Criteria", gp.missing_acceptance_criteria],
+    ["Definition of Done", gp.missing_definition_of_done],
+    ["validation section", gp.missing_validation]
+  ];
+  L.push("## Historical Documentation Completeness", "");
+  for (const [label, items] of historical) {
+    const completed = items.filter((item) => item.status === "completed");
+    if (completed.length > 0) L.push(`- Completed Work Items without detected ${label}: ${completed.length}`);
+  }
+  if (!historical.some(([, items]) => items.some((item) => item.status === "completed"))) {
+    L.push("No historical documentation completeness gaps were detected.");
   }
+  L.push("- This is an inventory for review, not a recommendation to rewrite historical Work Items merely to increase a metric.");
+  L.push("");
   if (r2.score_breakdown) {
     L.push("## Score Breakdown", "");
     const b2 = r2.score_breakdown;
@@ -11015,6 +11146,16 @@ function buildSavingsReport(dir, opts = {}, now = /* @__PURE__ */ new Date()) {
   } else {
     actions.push("Use drift history to calibrate `rework_hours_avoided_per_resolved_drift`.");
   }
+  const calibrationOpportunities = !a2.calibrated_at ? {
+    available: true,
+    reason: source3 === "default" ? "Default assumptions are uncalibrated estimates." : "Project assumptions are not marked as calibrated.",
+    opportunities: [
+      { area: "Context preparation", suggested_evidence: "Compare preparation effort on comparable tasks before and after using the knowledge artifacts." },
+      { area: "Review effort", suggested_evidence: "Record a baseline for comparable reviews with similar ownership coverage." },
+      { area: "Clarification reduction", suggested_evidence: "Estimate effort spent resolving repeated scope or context questions." },
+      { area: "Architecture discovery", suggested_evidence: "Compare discovery time for similar dependency or relationship analyses." }
+    ]
+  } : { available: false, reason: `Assumptions are marked as calibrated on ${a2.calibrated_at}.`, opportunities: [] };
   return {
     generated_at: now.toISOString(),
     project: impact.project,
@@ -11066,6 +11207,7 @@ function buildSavingsReport(dir, opts = {}, now = /* @__PURE__ */ new Date()) {
     },
     total: { estimated_hours_saved: observedHours, estimated_value: observedValue, currency: a2.currency },
     confidence: { level, reasons },
+    calibration_opportunities: calibrationOpportunities,
     suggested_actions: actions
   };
 }
@@ -11100,7 +11242,7 @@ function renderSavingsMarkdown(r2) {
   L.push("");
   L.push("## Evidence Used", "");
   const e = r2.evidence;
-  L.push(`- Knowledge Impact Score: ${e.knowledge_impact_score ?? "not available"}${e.knowledge_impact_score !== null ? "/100" : ""}`);
+  L.push(`- Legacy Knowledge Impact Score: ${e.knowledge_impact_score ?? "not available"}${e.knowledge_impact_score !== null ? "/100" : ""} (deprecated; informational only and not used for confidence)`);
   L.push(`- Completed Work Items: ${e.completed_work_items}`);
   L.push(`- Ownership coverage: ${e.ownership_coverage_percent}%`);
   L.push(`- Work Items with Acceptance Criteria: ${e.work_items_with_acceptance_criteria}`);
@@ -11147,6 +11289,17 @@ function renderSavingsMarkdown(r2) {
   L.push(`Confidence: ${r2.confidence.level}`, "", "Reason:");
   for (const reason of r2.confidence.reasons) L.push(`- ${reason}`);
   L.push("");
+  L.push("## Calibration Opportunities", "");
+  if (!r2.calibration_opportunities.available) {
+    L.push(`- ${r2.calibration_opportunities.reason}`);
+  } else {
+    L.push(`- ${r2.calibration_opportunities.reason}`);
+    L.push("- Use external, aggregate project observations; do not collect or store personal data.");
+    for (const opportunity of r2.calibration_opportunities.opportunities) {
+      L.push(`- ${opportunity.area}: ${opportunity.suggested_evidence}`);
+    }
+  }
+  L.push("");
   L.push("## Suggested Actions", "");
   r2.suggested_actions.forEach((act, i) => L.push(`${i + 1}. ${act}`));
   L.push("");
@@ -11164,13 +11317,49 @@ function buildDriftReport(dir, now = /* @__PURE__ */ new Date()) {
   const workItems = discoverWorkItems(dir);
   const verificationEvidence = workItems.filter((wi) => wi.validationStatus && wi.validationStatus !== "not-started");
   const plans = getDeprecationPlans(dir);
-  const deprecationFindings = plans.flatMap((plan) => getDeprecationPlan(dir, plan.id)?.targets.flatMap(validateTarget) ?? []);
+  const planDetails = plans.map((plan) => getDeprecationPlan(dir, plan.id)).filter((plan) => plan !== null);
+  const plansWithoutTargets = planDetails.filter((plan) => plan.targets.length === 0);
+  const plansWithTargets = planDetails.filter((plan) => plan.targets.length > 0);
+  const targetFindingsByPlan = new Map(plansWithTargets.map((plan) => [
+    plan.id,
+    plan.targets.flatMap(validateTarget)
+  ]));
+  const deprecationFindings = [...targetFindingsByPlan.values()].flat();
+  const plansWithoutStructuralFindings = plansWithTargets.filter((plan) => (targetFindingsByPlan.get(plan.id) ?? []).length === 0);
   const config = loadConfig(dir);
   const topology = config ? buildGraph(dir, config, { scope: "all" }, now) : null;
-  const topologyHints = topology ? buildGraphHints(dir, topology, now).summary.hints : null;
+  const graphHints = topology ? buildGraphHints(dir, topology, now) : null;
+  const topologyHints = graphHints?.summary.hints ?? null;
+  const currentConsistencyFindings = [
+    ...graphHints?.hints.map(graphHintFinding) ?? [],
+    ...deprecationFindings.map((finding, index) => ({
+      id: `deprecation-target:${index + 1}`,
+      category: "consistency",
+      classification: "consistency_violation",
+      resolution_status: "open",
+      source: "deprecation-target-validation",
+      affected_artifacts: finding.target ? [finding.target] : [],
+      priority: finding.severity === "error" ? "high" : "medium",
+      evidence: finding.message,
+      explanation: "A deterministic deprecation target consistency check reported a finding.",
+      suggested_action: "Review the affected deprecation target and its declared lifecycle evidence."
+    })),
+    ...h2.available && h2.total_runs >= 2 ? h2.threads.filter((thread) => thread.status === "open").map((thread) => ({
+      id: `guard-history:${thread.code_path}`,
+      category: "consistency",
+      classification: "historical_drift",
+      resolution_status: "open",
+      source: "guard-history",
+      affected_artifacts: [thread.code_path, ...thread.related_artifacts],
+      priority: "medium",
+      evidence: `Recorded Guard observations from ${thread.first_detected} through ${thread.last_seen} remain unresolved.`,
+      explanation: "Comparable Guard runs observed a possible code/knowledge drift thread over time.",
+      suggested_action: "Review the recorded drift thread and update the relevant knowledge or ownership evidence."
+    })) : []
+  ];
   const actions = [];
   if (!h2.available) {
-    actions.push("Run `kaddo guard --record` to start recording guard history.");
+    actions.push("Start recording Guard runs at relevant delivery checkpoints with `kaddo guard --record`; one run creates an observation, while multiple comparable runs are needed for a historical trend.");
   } else {
     if (h2.open > 0) actions.push("Review open drift warnings and update related Work Items or ownership.");
     actions.push("Run `kaddo guard --record` before important commits.");
@@ -11183,9 +11372,19 @@ function buildDriftReport(dir, now = /* @__PURE__ */ new Date()) {
     consistency_evidence: [
       { id: "guard-current-consistency", label: "Current Guard consistency", classification: h2.available ? "observed" : "unknown", reason: h2.available ? `${h2.total_runs} recorded Guard run(s) provide deterministic consistency evidence.` : "No recorded Guard history is available." },
       { id: "lifecycle-consistency", label: "Lifecycle evidence consistency", classification: verificationEvidence.length > 0 ? "observed" : "unknown", reason: verificationEvidence.length > 0 ? `${verificationEvidence.length} Work Item(s) persist an implementation validation status.` : "No persisted Work Item validation status is available." },
-      { id: "deprecation-consistency", label: "Deprecation consistency", classification: plans.length === 0 ? "not_applicable" : deprecationFindings.length === 0 ? "derived" : "observed", reason: plans.length === 0 ? "No deprecation plans exist in this project." : deprecationFindings.length === 0 ? `${plans.length} plan(s) passed deterministic target consistency checks.` : `${deprecationFindings.length} deterministic deprecation consistency finding(s) were detected.` },
+      { id: "deprecation-consistency", label: "Deprecation consistency", classification: plans.length === 0 ? "not_applicable" : plansWithTargets.length === 0 ? "unknown" : deprecationFindings.length === 0 ? "derived" : "observed", reason: plans.length === 0 ? "No deprecation plans exist in this project." : plansWithTargets.length === 0 ? `${plansWithoutTargets.length} plan(s) have no targets, so target consistency was not evaluated.` : deprecationFindings.length === 0 ? `${plansWithTargets.length} plan(s) with targets passed deterministic target consistency checks; ${plansWithoutTargets.length} plan(s) remain unevaluated because they have no targets.` : `${deprecationFindings.length} deterministic deprecation consistency finding(s) were detected.` },
       { id: "topology-consistency", label: "Knowledge topology consistency", classification: topology === null ? "unknown" : topologyHints === 0 ? "derived" : "observed", reason: topology === null ? "No project configuration is available to construct the topology." : topologyHints === 0 ? `The in-memory topology has ${topology.nodes.length} node(s) and no open deterministic hints.` : `The in-memory topology has ${topologyHints} open deterministic hint(s).` }
     ],
+    current_consistency_findings: currentConsistencyFindings,
+    structural_consistency: {
+      deprecation_target_checks: plans.length === 0 ? "not_applicable" : plansWithTargets.length === 0 ? "not_evaluated" : deprecationFindings.length === 0 ? "passed" : "findings_detected",
+      plans_discovered: plans.length,
+      plans_without_targets: plansWithoutTargets.length,
+      plans_with_targets_evaluated: plansWithTargets.length,
+      structural_findings: deprecationFindings.length,
+      plans_without_structural_findings: plansWithoutStructuralFindings.length,
+      note: plans.length === 0 ? "No deprecation plans exist in this project." : "Target consistency checks validate declared structural state only; they do not verify operational removal from infrastructure, production or external consumers."
+    },
     guard_history: {
       available: h2.available,
       total_runs: h2.total_runs,
@@ -11211,6 +11410,43 @@ function renderDriftMarkdown(r2) {
   L.push("## Consistency Evidence", "");
   for (const item of r2.consistency_evidence) L.push(`- ${item.label}: ${item.classification} \u2014 ${item.reason}`);
   L.push("");
+  const findingGroups = [
+    { classification: "consistency_violation", title: "Consistency Violations" },
+    { classification: "coverage_gap", title: "Coverage Gaps" },
+    { classification: "review_hint", title: "Review Hints" },
+    { classification: "historical_drift", title: "Historical Drift" }
+  ];
+  L.push("## Current Findings Summary", "");
+  for (const group of findingGroups) {
+    const count = r2.current_consistency_findings.filter((finding) => finding.classification === group.classification).length;
+    const unavailable = group.classification === "historical_drift" && !r2.guard_history.available;
+    L.push(`- ${group.title}: ${unavailable ? "not available \u2014 no recorded Guard runs" : count}`);
+  }
+  L.push("");
+  L.push("## Current Consistency Findings", "");
+  if (r2.current_consistency_findings.length === 0) L.push("No findings detected by the executed consistency checks.", "");
+  const cell = (value) => value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+  for (const group of findingGroups) {
+    const findings = r2.current_consistency_findings.filter((finding) => finding.classification === group.classification);
+    if (findings.length === 0) continue;
+    L.push(`### ${group.title}`, "");
+    L.push("| Classification | Priority | Status | Source | Affected | Finding | Suggested action |");
+    L.push("|---|---|---|---|---|---|---|");
+    for (const finding of findings) {
+      L.push(`| ${finding.classification} | ${finding.priority} | ${finding.resolution_status} | ${cell(finding.source)} | ${cell(finding.affected_artifacts.join(", ") || "not available")} | ${cell(finding.explanation)} Evidence: ${cell(finding.evidence)} | ${cell(finding.suggested_action)} |`);
+    }
+    L.push("");
+  }
+  L.push("## Structural Consistency Boundaries", "");
+  L.push(`- Deprecation target checks: ${r2.structural_consistency.deprecation_target_checks}`);
+  L.push(`- Plans discovered: ${r2.structural_consistency.plans_discovered}`);
+  L.push(`- Plans without targets: ${r2.structural_consistency.plans_without_targets}`);
+  L.push(`- Plans with targets evaluated: ${r2.structural_consistency.plans_with_targets_evaluated}`);
+  L.push(`- Structural findings: ${r2.structural_consistency.structural_findings}`);
+  L.push(`- Plans without structural findings: ${r2.structural_consistency.plans_without_structural_findings}`);
+  if (r2.structural_consistency.plans_without_targets > 0) L.push("- Target consistency for plans without targets: not evaluated \u2014 no targets defined.");
+  L.push(`- Note: ${r2.structural_consistency.note}`);
+  L.push("");
   if (!r2.guard_history.available) {
     L.push("## Guard History", "");
     L.push("No guard history recorded yet.");
@@ -11282,6 +11518,8 @@ function serializeDriftJson(r2) {
     project: r2.project,
     project_context: r2.project_context,
     consistency_evidence: r2.consistency_evidence,
+    current_consistency_findings: r2.current_consistency_findings,
+    structural_consistency: r2.structural_consistency,
     guard_history: r2.guard_history,
     drift_warnings: r2.drift_warnings,
     hotspots: r2.hotspots,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaddo/mcp",
-  "version": "3.124.2",
+  "version": "3.124.4",
   "description": "MCP server for Kaddo project knowledge: read-only resources/tools/prompts plus safe derived generation under .kaddo/.",
   "license": "MIT",
   "repository": {