@ttsc/evidence 0.28.5 → 0.29.0

package/lib/structures/ITtscEvidenceGraphClaimBase.d.ts

@@ -1,3 +1,4 @@
+import type { TtscLintSeverity } from "@ttsc/lint";
 import type { ITtscEvidenceGraphReference } from "./ITtscEvidenceGraphReference";
 /**
  * What every claim declares: which artifact kind makes the claim, where its
@@ -21,6 +22,12 @@ export interface ITtscEvidenceGraphClaimBase<Type extends string> {
      * configuration entries.
      */
     name?: string;
+    /**
+     * Diagnostic level for this claim. Omit it or use `undefined` to inherit the
+     * outer `evidence/graph` rule level. A reference may override this level
+     * again. `"off"` disables the entire claim, including its references.
+     */
+    severity?: TtscLintSeverity | undefined;
     /**
      * Excludes this claim from graph loading and evaluation.
      *

package/lib/structures/ITtscEvidenceGraphReferenceBase.d.ts

@@ -1,3 +1,4 @@
+import type { TtscLintSeverity } from "@ttsc/lint";
 /**
  * What every evidence population declares: which artifact kind it materializes,
  * and how strictly the owning claim must acknowledge it.
@@ -25,6 +26,12 @@
 export interface ITtscEvidenceGraphReferenceBase<Type extends string> {
     /** Identifies the artifact kind this population materializes. */
     type: Type;
+    /**
+     * Diagnostic level for this reference's obligation. Omit it or use
+     * `undefined` to inherit the claim level, then the outer `evidence/graph`
+     * rule level. `"off"` disables this reference's population and obligation.
+     */
+    severity?: TtscLintSeverity | undefined;
     /**
      * Whether this reference refuses `@evidenceExclude` as an acknowledgement.
      *

package/native/config.go

@@ -8,6 +8,8 @@ import (
   "path"
   "sort"
   "strings"
+
+  "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 func decodeGraphConfig(raw json.RawMessage) (graphConfig, []string) {
@@ -54,7 +56,7 @@ func decodeClaim(raw json.RawMessage, index int) (claimSpec, []string) {
   }
   problems := rejectUnknownFields(
     object,
-    []string{"type", "name", "disabled", "root", "files", "evidenceExcludeCarriers", "symbol", "reference"},
+    []string{"type", "name", "severity", "disabled", "root", "files", "evidenceExcludeCarriers", "symbol", "reference"},
     graphRuleName,
     path,
   )
@@ -78,6 +80,8 @@ func decodeClaim(raw json.RawMessage, index int) (claimSpec, []string) {
       problems = append(problems, "Invalid evidence/graph configuration at "+path+".disabled: expected a boolean.")
     }
   }
+  severity, severityProblems := decodeGraphSeverity(object["severity"], path+".severity")
+  problems = append(problems, severityProblems...)
   root, rootProblems := decodeClaimRoot(object["root"], kind, path+".root")
   problems = append(problems, rootProblems...)
   files, fileProblems := decodeFiles(object["files"], path+".files")
@@ -98,6 +102,7 @@ func decodeClaim(raw json.RawMessage, index int) (claimSpec, []string) {
   }
   return claimSpec{
     Index:             index,
+    Severity:          severity,
     Type:              kind,
     Name:              name,
     Disabled:          disabled,
@@ -109,16 +114,26 @@ func decodeClaim(raw json.RawMessage, index int) (claimSpec, []string) {
   }, nil
 }
 
-// enabledGraphConfig removes explicitly staged claims after their public
+// enabledGraphConfig removes disabled claims and references after their public
 // configuration has been validated. Keeping the filter separate from decoding
-// preserves original claim indexes and prevents disabled entries from hiding a
+// preserves original indexes and prevents disabled entries from hiding a
 // malformed shape.
 func enabledGraphConfig(config graphConfig) graphConfig {
   claims := make([]claimSpec, 0, len(config.Claims))
   for _, claim := range config.Claims {
-    if claim.Disabled {
+    if claim.Disabled || claim.Severity != nil && *claim.Severity == rule.SeverityOff {
+      continue
+    }
+    references := make([]referenceSpec, 0, len(claim.References))
+    for _, reference := range claim.References {
+      if reference.Severity == nil || *reference.Severity != rule.SeverityOff {
+        references = append(references, reference)
+      }
+    }
+    if len(references) == 0 {
       continue
     }
+    claim.References = references
     claims = append(claims, claim)
   }
   config.Claims = claims
@@ -183,6 +198,7 @@ func decodeReference(
     object,
     []string{
       "type",
+      "severity",
       "noEvidenceExclude",
       "uniqueEvidence",
       "singleEvidencePerSymbol",
@@ -204,6 +220,8 @@ func decodeReference(
   if problem := rejectForeignTypeScriptReference(claimKind, kind, path); problem != "" {
     problems = append(problems, problem)
   }
+  severity, severityProblems := decodeGraphSeverity(object["severity"], path+".severity")
+  problems = append(problems, severityProblems...)
   root, rootProblems := decodeRoot(object["root"], kind, path+".root")
   problems = append(problems, rootProblems...)
   policy, policyProblems := decodeReferencePolicy(object, kind, path)
@@ -265,14 +283,15 @@ func decodeReference(
     return referenceSpec{}, problems
   }
   return referenceSpec{
-    Index:   index,
-    Type:    kind,
-    Policy:  policy,
-    Root:    root,
-    Files:   files,
-    Source:  source,
-    Package: packageName,
-    Symbols: symbols,
+    Severity: severity,
+    Index:    index,
+    Type:     kind,
+    Policy:   policy,
+    Root:     root,
+    Files:    files,
+    Source:   source,
+    Package:  packageName,
+    Symbols:  symbols,
   }, nil
 }
 

package/native/graph.go

@@ -31,6 +31,7 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
     reportProblems(ctx, problems)
     return
   }
+  resolveGraphSeverities(&config, ctx.Severity)
   config = enabledGraphConfig(config)
   if len(config.Claims) == 0 {
     cycle.Corpus = graphCorpus{Config: config}
@@ -46,6 +47,7 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
     ctx.Report("Evidence graph project root '" + root + "' is not a readable directory. Fix the ttsc project identity before evaluating evidence globs.")
     return
   }
+  diagnostics := graphDiagnostics{}
   // Every population is anchored before anything is read, so a loader, a
   // diagnostic, and the corpus the editor receives all speak of one resolved
   // base rather than each re-deriving it from the author's spelling.
@@ -68,15 +70,15 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
     root,
     claimPopulationConfig(config, artifactPrisma),
   )
-  problems = append(
-    problems,
+  diagnostics = append(
+    diagnostics,
     typeScriptBaseProblems(
       claimPopulationConfig(config, artifactTypeScript),
       typescript,
     )...,
   )
-  problems = append(problems, markdownClaimProblems...)
-  problems = append(problems, prismaClaimProblems...)
+  diagnostics = append(diagnostics, markdownClaimProblems...)
+  diagnostics = append(diagnostics, prismaClaimProblems...)
   // Governance is judged against the configuration as declared, before
   // activation drops a claim whose population materialized no unit of its
   // symbol kind. The question is whether an author put this file in a
@@ -91,10 +93,10 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
   markdown, markdownProblems := loadMarkdownInventories(root, config)
   prisma, prismaProblems := loadPrismaInventories(root, config)
   swagger, swaggerProblems := loadSwaggerInventories(root, config)
-  problems = append(problems, markdownProblems...)
-  problems = append(problems, prismaProblems...)
-  problems = append(problems, swaggerProblems...)
-  problems = append(problems, unreadableTypeScriptTags(typescript, governed)...)
+  diagnostics = append(diagnostics, markdownProblems...)
+  diagnostics = append(diagnostics, prismaProblems...)
+  diagnostics = append(diagnostics, swaggerProblems...)
+  diagnostics = append(diagnostics, unreadableTypeScriptTags(typescript, governed, declared)...)
   loader := newTypeScriptLoader(root, typescript)
   states, stateProblems := materializeClaimStates(
     config,
@@ -104,10 +106,10 @@ func (graphRule) Check(ctx *rule.ProjectContext) {
     typescript,
     loader,
   )
-  problems = append(problems, stateProblems...)
-  problems = append(problems, evaluateEvidenceGraph(states, loader)...)
-  reportProblems(ctx, problems)
-  if len(problems) == 0 {
+  diagnostics = append(diagnostics, stateProblems...)
+  diagnostics = append(diagnostics, evaluateEvidenceGraph(states, loader)...)
+  diagnostics.report(ctx)
+  if len(diagnostics) == 0 {
     // Published only on a clean evaluation, because the host reads state
     // from a rule that passed and reporting anything marks this one failed
     // (`linthost/hints.go:147-149`, `linthost/project_engine.go:68-77`).
@@ -238,10 +240,11 @@ func materializeClaimStates(
   swagger map[string]*artifactInventory,
   typescript map[string]*artifactInventory,
   loader *typeScriptLoader,
-) ([]claimState, []string) {
+) ([]claimState, graphDiagnostics) {
   states := make([]claimState, 0, len(config.Claims))
-  problems := []string{}
+  problems := graphDiagnostics{}
   for _, claim := range config.Claims {
+    severity := claim.Level
     inventories := inventoriesOf(claim.Type, markdown, prisma, swagger, typescript)
     paths := matchingInventoryPaths(inventories, claim.Base, claim.Files)
     state := claimState{
@@ -268,8 +271,8 @@ func materializeClaimStates(
       // exclusion the claim writes, so the misspelling is reported where
       // it was made rather than as a placement finding on each tag.
       if len(carrierPaths) == 0 && len(paths) != 0 {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           claimLabel(claim)+" declares evidenceExcludeCarriers "+describePopulation(claim.Base, claim.ExclusionCarriers)+", which selects none of its "+decimal(len(paths))+" claim file(s). Point the patterns at a file this claim already selects, or drop the property to accept an exclusion anywhere in the population.",
         )
       }
@@ -346,6 +349,7 @@ func materializeClaimStates(
     }
     sortUnits(state.Hosts)
     for _, reference := range claim.References {
+      severity := reference.Level
       referenceInventories := inventoriesOf(
         reference.Type,
         markdown,
@@ -359,7 +363,7 @@ func materializeClaimStates(
           reference,
           loader,
         )
-        problems = append(problems, entryProblems...)
+        problems = problems.add(severity, entryProblems...)
         state.References = append(state.References, entryState)
         continue
       }
@@ -369,7 +373,7 @@ func materializeClaimStates(
           reference,
           loader,
         )
-        problems = append(problems, packageProblems...)
+        problems = problems.add(severity, packageProblems...)
         state.References = append(state.References, packageState)
         continue
       }
@@ -380,7 +384,7 @@ func materializeClaimStates(
           referenceInventories,
           loader,
         )
-        problems = append(problems, localProblems...)
+        problems = problems.add(severity, localProblems...)
         state.References = append(state.References, localState)
         continue
       }
@@ -396,13 +400,13 @@ func materializeClaimStates(
       }
       if len(referencePaths) == 0 && referenceState.Healthy {
         if reference.Type == artifactSwagger {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             claimLabel(claim)+" "+referenceLabel(reference)+" matched no swagger source for "+describeReferenceSources(reference)+". Fix the reference location; this obligation cannot materialize evidence units without a source.",
           )
         } else {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             claimLabel(claim)+" "+referenceLabel(reference)+" matched no "+string(reference.Type)+" files for "+describePopulation(reference.Base, reference.Files)+". Fix the reference globs or the root they resolve against; this obligation cannot materialize evidence units without files.",
           )
         }
@@ -477,8 +481,8 @@ func materializeClaimStates(
         len(referenceState.Units) == 0 &&
         referenceState.Healthy &&
         !selectedInventoryProblem {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           claimLabel(claim)+" "+referenceLabel(reference)+" matched "+decimal(len(referencePaths))+" file(s) but found no selected evidence units ("+reference.Symbols.names()+"). Select symbol kinds present in those files or correct the reference globs.",
         )
       }
@@ -492,8 +496,8 @@ func materializeClaimStates(
 func evaluateEvidenceGraph(
   states []claimState,
   loader *typeScriptLoader,
-) []string {
-  problems := []string{}
+) graphDiagnostics {
+  problems := graphDiagnostics{}
   targets := map[string]map[string]*evidenceUnit{}
   markdownTargets := map[string]map[string]*evidenceUnit{}
   // Scoped targets are keyed by owning file as well as name, which is what
@@ -604,11 +608,12 @@ func evaluateEvidenceGraph(
 
   resolved := map[string]string{}
   for _, id := range declarationIDs {
+    severity := ownerSeverity(owners[id])
     declaration := declarations[id]
     context := declarationObligationContext(owners[id])
     if !declaration.valid() {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Malformed @"+string(declaration.Tag)+" declaration at "+declaration.location()+" for "+context+": target and non-empty reason are mandatory. Write '@"+string(declaration.Tag)+" <target> <reason>'."+untrueTagWarning,
       )
       continue
@@ -622,7 +627,7 @@ func evaluateEvidenceGraph(
         context,
       )
       if problem != "" {
-        problems = append(problems, problem)
+        problems = problems.add(severity, problem)
         continue
       }
       resolved[id] = unitID
@@ -630,8 +635,8 @@ func evaluateEvidenceGraph(
     }
     if declaration.Type == artifactTypeScript &&
       looksLikeTypeScriptTarget(declaration.Target, targets, markdownTargets) {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Unbraced TypeScript evidence target '"+declaration.Target+"' at "+declaration.location()+" for "+context+": a target naming a symbol is now written as an inline link, so the citing module's import is what resolves it. Write '@"+string(declaration.Tag)+" {@link "+declaration.Target+"} <reason>' and import the symbol; 'import type' is enough.",
       )
       continue
@@ -648,8 +653,8 @@ func evaluateEvidenceGraph(
     if declaration.Type != artifactTypeScript {
       addressable, code := splitCodeCandidates(candidates)
       if len(addressable) == 0 && len(code) != 0 {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Code evidence target '"+declaration.Target+"' at "+declaration.location()+" for "+context+": a "+string(declaration.Type)+" claim cannot cite a TypeScript symbol, because a symbol citation resolves through the citing module's imports and this artifact has none. Invert the obligation so the code cites this artifact, or move the citation into TypeScript.",
         )
         continue
@@ -667,14 +672,11 @@ func evaluateEvidenceGraph(
         continue
       }
       if hidden := hiddenTargets[declaration.Target]; hidden != nil {
-        problems = append(
-          problems,
-          hiddenTargetProblem(declaration, hidden, context),
-        )
+        problems = problems.add(severity, hiddenTargetProblem(declaration, hidden, context))
         continue
       }
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Unresolved evidence target '"+declaration.Target+"' at "+declaration.location()+" for "+context+": no configured source materializes that evidence unit. Correct the target, make one of the named references select the source unit this claim actually uses, or remove the tag when this host does not answer for that target."+untrueTagWarning,
       )
     case 1:
@@ -687,8 +689,8 @@ func evaluateEvidenceGraph(
         descriptions = append(descriptions, unit.Readable+" at "+unit.location())
       }
       sort.Strings(descriptions)
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Ambiguous evidence target '"+declaration.Target+"' at "+declaration.location()+" for "+context+": it matches "+strings.Join(descriptions, "; ")+". Rename or qualify the source symbols so the target has exactly one meaning.",
       )
     }
@@ -697,11 +699,13 @@ func evaluateEvidenceGraph(
   participates := map[string]bool{}
   uncertain := map[string]bool{}
   outOfScope := map[string][]string{}
+  outOfScopeLevels := map[string]rule.Severity{}
   outOfScopeSelections := map[string]symbolSet{}
   // An exclusion outside its claim's declared carriers is a placement
   // finding, not a host-kind one, so it carries its own obligations and the
   // carrier globs its message must name.
   outsideCarrier := map[string][]string{}
+  outsideCarrierLevels := map[string]rule.Severity{}
   outsideCarrierGlobs := map[string]string{}
   // A checklist tag speaking for no selected host is a non-participation
   // finding: within its reference it answers nothing, and whether that earns a
@@ -711,6 +715,7 @@ func evaluateEvidenceGraph(
   // elsewhere — so the finding is recorded here and judged after the walk,
   // when `answers` can say whether anything consumed the tag.
   unhosted := map[string][]string{}
+  unhostedLevels := map[string]rule.Severity{}
   unhostedSelections := map[string]symbolSet{}
   // answers marks a declaration that wrote at least one acknowledgement
   // ledger, or was refused as an aggregate, which is that citation's own
@@ -732,6 +737,7 @@ func evaluateEvidenceGraph(
     // reviewing reference pays nothing.
     var reviewLedgerForClaim *reviewLedger
     for _, reference := range state.References {
+      severity := reference.Spec.Level
       if !reference.Healthy {
         for _, declaration := range state.Declarations {
           uncertain[declaration.ID] = true
@@ -819,6 +825,7 @@ func evaluateEvidenceGraph(
           continue
         }
         if declaration.Tag == tagExclude && state.OutsideCarrier[declaration.ID] {
+          outsideCarrierLevels[declaration.ID] = max(outsideCarrierLevels[declaration.ID], severity)
           outsideCarrier[declaration.ID] = appendUniqueString(
             outsideCarrier[declaration.ID],
             claimLabel(state.Spec)+" "+referenceLabel(reference.Spec),
@@ -827,6 +834,7 @@ func evaluateEvidenceGraph(
           continue
         }
         if !declarationEligibleForClaim(declaration, state.Spec) {
+          outOfScopeLevels[declaration.ID] = max(outOfScopeLevels[declaration.ID], severity)
           outOfScope[declaration.ID] = appendUniqueString(
             outOfScope[declaration.ID],
             claimLabel(state.Spec)+" "+referenceLabel(reference.Spec),
@@ -849,8 +857,8 @@ func evaluateEvidenceGraph(
           continue
         }
         if declaration.Tag == tagExclude && reference.Spec.Policy.NoExclude {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Forbidden @evidenceExclude for '"+scopesByID[scopeID].Target+"' at "+declaration.location()+" in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+": noEvidenceExclude requires positive @evidence for this reference. Remove the exclusion and cite the target from a selected "+string(state.Spec.Type)+" host that answers for it."+untrueTagWarning,
           )
           continue
@@ -889,6 +897,7 @@ func evaluateEvidenceGraph(
             // answer, and a hard diagnostic here left that valid configuration
             // no placement to exist in. The end-of-run block reports the tag
             // once nothing has consumed it.
+            unhostedLevels[declaration.ID] = max(unhostedLevels[declaration.ID], severity)
             unhosted[declaration.ID] = appendUniqueString(
               unhosted[declaration.ID],
               claimLabel(state.Spec)+" "+referenceLabel(reference.Spec),
@@ -910,8 +919,8 @@ func evaluateEvidenceGraph(
           for _, unit := range covered {
             targets = append(targets, "'"+unit.Target+"'")
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Aggregate @evidence target '"+scopesByID[scopeID].Target+"' at "+declaration.location()+" in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+": this reference is a checklist, so a citation answers for the item it names, and this target names a scope containing "+decimal(len(covered))+" item(s) ("+strings.Join(targets, ", ")+") rather than one of them. Cite each item this host answers for, or write @evidenceExclude on this scope when none of it applies here."+untrueTagWarning,
           )
           for _, unit := range covered {
@@ -936,7 +945,7 @@ func evaluateEvidenceGraph(
           if reviewLedgerForClaim == nil {
             reviewLedgerForClaim = newReviewLedger(state.Reviews)
           }
-          problems = append(problems, reviewProblems(
+          problems = problems.add(severity, reviewProblems(
             declaration,
             scopesByID[scopeID],
             reference,
@@ -952,8 +961,8 @@ func evaluateEvidenceGraph(
             evidenceByHostAndScope[declaration.HostID] = byScope
           }
           if first := byScope[scopeID]; first != nil {
-            problems = append(
-              problems,
+            problems = problems.add(
+              severity,
               "Duplicate @evidence for '"+scopesByID[scopeID].Target+"' on the same host at "+declaration.location()+"; first declared at "+first.location()+".",
             )
           } else {
@@ -1060,14 +1069,14 @@ func evaluateEvidenceGraph(
             evidence = conflictingDeclaration
             exclusion = declaration
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Conflicting acknowledgements for '"+conflictingUnit.Target+"' in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+": @evidence at "+evidence.location()+" overlaps @evidenceExclude at "+exclusion.location()+". Delete whichever is untrue of this host."+untrueTagWarning,
           )
         }
         if duplicateExclusionUnit != nil {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Duplicate @evidenceExclude for '"+duplicateExclusionUnit.Target+"' in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+": exclusion at "+declaration.location()+" overlaps exclusion at "+firstExclusion.location()+".",
           )
         }
@@ -1084,8 +1093,8 @@ func evaluateEvidenceGraph(
           if count == 1 {
             continue
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Evidence host "+host.Readable+" at "+host.location()+" in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+" cites "+decimal(count)+" distinct selected evidence unit(s); singleEvidencePerSymbol requires exactly 1. Split this host so each unit has one that owns it, or keep positive @evidence citations on this semantic host to exactly one distinct unit.",
           )
         }
@@ -1116,8 +1125,8 @@ func evaluateEvidenceGraph(
           if reference.Spec.Policy.NoExclude {
             repair = "Do what each item requires and cite it with @evidence on this host; this reference forbids @evidenceExclude." + untrueTagWarning
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Evidence host "+host.Readable+" at "+host.location()+" in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+" has not acknowledged "+decimal(len(missing))+" of "+decimal(len(reference.Units))+" checklist item(s): "+strings.Join(missing, ", ")+". "+repair,
           )
         }
@@ -1131,8 +1140,8 @@ func evaluateEvidenceGraph(
           if reference.Spec.Policy.NoExclude {
             repair = "Cite the artifact that answers for this unit with @evidence on a selected " + string(state.Spec.Type) + " host, building that artifact first when none does; this reference forbids @evidenceExclude." + untrueTagWarning
           }
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "Missing acknowledgement for '"+unit.Target+"' ("+unit.Readable+" at "+unit.location()+") in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+". "+repair,
           )
         }
@@ -1140,14 +1149,15 @@ func evaluateEvidenceGraph(
         if !unique || hostCount <= 1 {
           continue
         }
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence unit '"+unit.Target+"' ("+unit.Readable+" at "+unit.location()+") in "+claimLabel(state.Spec)+" "+referenceLabel(reference.Spec)+" has "+decimal(hostCount)+" distinct positive evidence host(s); uniqueEvidence allows at most 1. Keep the one selected "+string(state.Spec.Type)+" host that owns this unit and remove the other citation(s).",
         )
       }
     }
   }
   for _, id := range declarationIDs {
+    severity := ownerSeverity(owners[id])
     if resolved[id] == "" {
       continue
     }
@@ -1161,8 +1171,8 @@ func evaluateEvidenceGraph(
     // withholds its own.
     if obligations := unhosted[id]; len(obligations) != 0 &&
       !answers[id] && !uncertain[id] {
-      problems = append(
-        problems,
+      problems = problems.add(
+        unhostedLevels[id],
         "Unhosted @"+string(declaration.Tag)+" at "+declaration.location()+" for "+strings.Join(obligations, "; ")+", target '"+displayTarget(declaration.Target)+"': a checklist acknowledgement answers for one selected host of its claim, and this declaration sits on no selected host and discharges no other obligation. Move the tag onto a host of a selected kind ("+unhostedSelections[id].names()+") in a claim that owes it."+untrueTagWarning,
       )
     }
@@ -1171,8 +1181,8 @@ func evaluateEvidenceGraph(
     }
     context := declarationObligationContext(owners[id])
     if obligations := outsideCarrier[id]; len(obligations) != 0 {
-      problems = append(
-        problems,
+      problems = problems.add(
+        outsideCarrierLevels[id],
         "Misplaced @evidenceExclude at "+declaration.location()+" for "+strings.Join(obligations, "; ")+", target '"+displayTarget(declaration.Target)+"': evidenceExcludeCarriers confines this claim's exclusions to "+outsideCarrierGlobs[id]+". Move the tag there, or delete it and build what the target requires of this claim."+untrueTagWarning,
       )
       continue
@@ -1183,14 +1193,14 @@ func evaluateEvidenceGraph(
         host = "unsupported or non-exported declaration"
       }
       if declaration.Tag == tagExclude {
-        problems = append(
-          problems,
+        problems = problems.add(
+          outOfScopeLevels[id],
           "Out-of-scope @evidenceExclude carrier at "+declaration.location()+" for "+strings.Join(obligations, "; ")+", target '"+displayTarget(declaration.Target)+"': '"+host+"' is not an eligible exclusion carrier in these matching claim files. Move the exclusion to a supported public export or selected declaration host, or use a top-level unattached Prisma documentation comment.",
         )
         continue
       }
-      problems = append(
-        problems,
+      problems = problems.add(
+        outOfScopeLevels[id],
         "Out-of-scope @"+string(declaration.Tag)+" host at "+declaration.location()+" for "+strings.Join(obligations, "; ")+", target '"+displayTarget(declaration.Target)+"': host kind '"+host+"' is not selected ("+outOfScopeSelections[id].names()+") by any of these claim obligations. Move the declaration to a selected host, or widen the claim symbol selector only when it genuinely owns this target."+untrueTagWarning,
       )
       continue
@@ -1201,8 +1211,8 @@ func evaluateEvidenceGraph(
       // derive a second claim from an incomplete graph.
       continue
     }
-    problems = append(
-      problems,
+    problems = problems.add(
+      severity,
       "Non-participating @"+string(declaration.Tag)+" target '"+displayTarget(declaration.Target)+"' at "+declaration.location()+" for "+context+": the target resolves, but none of this declaration's configured references selects it. Correct the target or reference, or move the tag to an eligible host or exclusion carrier in the claim that owes it; a resolving tag must discharge at least one obligation."+untrueTagWarning,
     )
   }

package/native/markdown.go

@@ -23,9 +23,9 @@ var explicitAnchorPattern = regexp.MustCompile(`\s*\{#([A-Za-z0-9][A-Za-z0-9._:-
 func loadMarkdownInventories(
   root string,
   config graphConfig,
-) (map[string]*artifactInventory, []string) {
+) (map[string]*artifactInventory, graphDiagnostics) {
   inventories := map[string]*artifactInventory{}
-  problems := []string{}
+  problems := graphDiagnostics{}
   for _, base := range configuredBases(config, artifactMarkdown) {
     problems = append(
       problems,
@@ -39,16 +39,17 @@ func loadMarkdownBase(
   base populationBase,
   config graphConfig,
   inventories map[string]*artifactInventory,
-) []string {
-  problems := []string{}
+) graphDiagnostics {
+  problems := graphDiagnostics{}
+  severity := populationSeverity(config, artifactMarkdown, base, "", "*", false)
   if problem := baseDirectoryProblem(base, artifactMarkdown); problem != "" {
     recordPopulationFailure(inventories, artifactMarkdown, base)
-    return []string{problem}
+    return problems.add(severity, problem)
   }
   from, resolved := resolvedBaseDirectory(base)
   if !resolved {
     recordPopulationFailure(inventories, artifactMarkdown, base)
-    return []string{unresolvedBaseProblem(base, artifactMarkdown)}
+    return problems.add(severity, unresolvedBaseProblem(base, artifactMarkdown))
   }
   err := filepath.WalkDir(from, func(current string, entry fs.DirEntry, walkErr error) error {
     if walkErr != nil {
@@ -82,7 +83,8 @@ func loadMarkdownBase(
       )
       if relevant {
         recordPopulationFailure(inventories, artifactMarkdown, base)
-        problems = append(problems, problem)
+        relative, _ := relativeProjectPath(from, current)
+        problems = problems.add(populationSeverity(config, artifactMarkdown, base, relative, "*", true), problem)
       }
       // `WalkDir` passes a nil entry only for its root, which the guard above
       // answers, so this error belongs to a directory whose listing failed and
@@ -105,6 +107,7 @@ func loadMarkdownBase(
     if !matchesConfiguredMarkdownFile(config, base, relative) {
       return nil
     }
+    severity := populationSeverity(config, artifactMarkdown, base, relative, "*", false)
     address := base.addressOf(relative)
     content, readErr := os.ReadFile(current)
     if readErr != nil {
@@ -113,26 +116,29 @@ func loadMarkdownBase(
         Type:       artifactMarkdown,
         LoadFailed: true,
       }
-      problems = append(problems, "Evidence graph could not read Markdown file '"+address.Display+"': "+causeText(readErr)+". Fix filesystem access or exclude the file from configured globs.")
+      problems = problems.add(
+        severity,
+        "Evidence graph could not read Markdown file '"+address.Display+"': "+causeText(readErr)+". Fix filesystem access or exclude the file from configured globs.",
+      )
       return nil
     }
     inventory, _ := scanMarkdownInventory(address, string(content))
     inventories[address.Key] = inventory
     for _, inventoryProblem := range inventory.Problems {
       if selectedByMarkdownPopulation(config, base, relative, inventoryProblem.Symbol) {
-        problems = append(problems, inventoryProblem.Message)
+        problems = problems.add(populationSeverity(config, artifactMarkdown, base, relative, inventoryProblem.Symbol, false), inventoryProblem.Message)
       }
     }
     // An unreadable tag is not a health question and not a symbol question
     // either: the file loaded, its units are complete, and the tag reaches no
     // host whichever symbol a reference selects. The walk already refuses a
     // path no configured glob takes, so reaching here is enough to report.
-    problems = append(problems, inventory.Unreadable...)
+    problems = problems.add(severity, inventory.Unreadable...)
     return nil
   })
   if err != nil {
     recordPopulationFailure(inventories, artifactMarkdown, base)
-    problems = append(problems, unlistableBaseProblem(base, "Markdown", err))
+    problems = problems.add(severity, unlistableBaseProblem(base, "Markdown", err))
   }
   return problems
 }

package/native/model.go

@@ -5,6 +5,7 @@ import (
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 const graphRuleName = "evidence/graph"
@@ -57,6 +58,8 @@ type graphConfig struct {
 }
 
 type claimSpec struct {
+  Severity *rule.Severity
+  Level    rule.Severity
   Index    int
   Type     artifactKind
   Name     string
@@ -84,13 +87,15 @@ type claimSpec struct {
 }
 
 type referenceSpec struct {
-  Index  int
-  Type   artifactKind
-  Policy referencePolicy
-  Root   string
-  Base   populationBase
-  Files  globSet
-  Source string
+  Severity *rule.Severity
+  Level    rule.Severity
+  Index    int
+  Type     artifactKind
+  Policy   referencePolicy
+  Root     string
+  Base     populationBase
+  Files    globSet
+  Source   string
   // Package moves the base that Files resolves against from the project to an
   // installed package. With no globs it also becomes the selection itself: the
   // package's declaration entry defines the population by reachability, while

package/native/prisma.go

@@ -12,6 +12,8 @@ import (
   "sort"
   "strings"
   "time"
+
+  "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 const prismaBridgeTimeout = 60 * time.Second
@@ -127,7 +129,7 @@ type prismaField struct {
 func loadPrismaInventories(
   root string,
   config graphConfig,
-) (map[string]*artifactInventory, []string) {
+) (map[string]*artifactInventory, graphDiagnostics) {
   // A graph that names no Prisma glob never pays for one. The walk below is
   // cheap on such a project — every directory fails the descendant test and is
   // skipped at once — but "cheap" is still a full listing of the project root
@@ -160,27 +162,28 @@ func loadPrismaInventories(
   // ten-model schema and a two-hundred-model one pay nearly the same. A
   // resident host repeats this every cycle, so an unchanged schema would
   // otherwise be re-parsed on every TypeScript keystroke that rebuilds.
+  severity := prismaSetSeverity(config, inventories)
   digest := prismaContentDigest(root, set.Sources)
   if outcome, hit := prismaSchemas.lookup(digest); hit {
     return inventories, append(
       problems,
-      prismaUnitsFromOutcome(root, set, inventories, outcome)...,
+      prismaUnitsFromOutcome(root, set, inventories, outcome, config)...,
     )
   }
 
   result, err := normalizePrismaSet(root, set.Sources)
   if err != nil {
     message := "Evidence graph could not run its Prisma schema loader: " + causeText(err) + ". Prisma references require Node.js and a resolvable @prisma/prisma-schema-wasm."
-    return inventories, append(problems, failPrismaSet(inventories, set, message))
+    return inventories, problems.add(severity, failPrismaSet(inventories, set, message))
   }
 
   outcome, problem := prismaOutcomeOf(result)
   if problem != "" {
-    return inventories, append(problems, failPrismaSet(inventories, set, problem))
+    return inventories, problems.add(severity, failPrismaSet(inventories, set, problem))
   }
   problems = append(
     problems,
-    prismaUnitsFromOutcome(root, set, inventories, outcome)...,
+    prismaUnitsFromOutcome(root, set, inventories, outcome, config)...,
   )
   rememberPrismaSchema(outcome.digest, outcome)
   return inventories, problems
@@ -223,27 +226,28 @@ func prismaOutcomeOf(result prismaNormalizationResult) (prismaSetOutcome, string
 // Order is the digest's, so it must not depend on filesystem enumeration.
 func configuredPrismaAddresses(
   config graphConfig,
-) ([]artifactAddress, []string) {
+) ([]artifactAddress, graphDiagnostics) {
   addresses, _, problems := configuredPrismaAddressesWithHealth(config)
   return addresses, problems
 }
 
 func configuredPrismaAddressesWithHealth(
   config graphConfig,
-) ([]artifactAddress, []populationBase, []string) {
+) ([]artifactAddress, []populationBase, graphDiagnostics) {
   addresses := []artifactAddress{}
   failedBases := []populationBase{}
-  problems := []string{}
+  problems := graphDiagnostics{}
   for _, base := range configuredBases(config, artifactPrisma) {
+    severity := populationSeverity(config, artifactPrisma, base, "", "*", false)
     if problem := baseDirectoryProblem(base, artifactPrisma); problem != "" {
-      problems = append(problems, problem)
+      problems = problems.add(severity, problem)
       failedBases = append(failedBases, base)
       continue
     }
     baseFailed := false
     from, resolved := resolvedBaseDirectory(base)
     if !resolved {
-      problems = append(problems, unresolvedBaseProblem(base, artifactPrisma))
+      problems = problems.add(severity, unresolvedBaseProblem(base, artifactPrisma))
       failedBases = append(failedBases, base)
       continue
     }
@@ -272,7 +276,8 @@ func configuredPrismaAddressesWithHealth(
         )
         if relevant {
           baseFailed = true
-          problems = append(problems, problem)
+          relative, _ := relativeProjectPath(from, current)
+          problems = problems.add(populationSeverity(config, artifactPrisma, base, relative, "*", true), problem)
         }
         return filepath.SkipDir
       }
@@ -295,7 +300,7 @@ func configuredPrismaAddressesWithHealth(
     })
     if err != nil {
       baseFailed = true
-      problems = append(problems, unlistableBaseProblem(base, "Prisma", err))
+      problems = problems.add(severity, unlistableBaseProblem(base, "Prisma", err))
     }
     if baseFailed {
       failedBases = append(failedBases, base)
@@ -647,15 +652,17 @@ func prismaDeclarationsFromComments(
   comments []prismaCommentRun,
   hosts map[string]*evidenceUnit,
   inventories map[string][]*artifactInventory,
-) []string {
-  problems := []string{}
+  levels map[string]rule.Severity,
+) graphDiagnostics {
+  problems := graphDiagnostics{}
   sequence := 0
   for _, run := range comments {
+    severity := levels[run.Path]
     location := run.Path + ":" + decimal(run.Line)
     if run.Form != prismaDocComment {
       if prismaCommentCarriesTag(run.Body) {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence tag at "+location+" sits in a '//' line comment, which Prisma discards rather than attaching to the declaration below it. Write the citation on a '///' or '/* */' documentation comment directly above the model, column, or relation it grounds.",
         )
       }
@@ -667,8 +674,8 @@ func prismaDeclarationsFromComments(
         continue
       }
       for _, offset := range prismaBuriedTagLines(run.Body) {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence tag at "+run.Path+":"+decimal(run.Line+offset)+" is buried behind an extra slash. Prisma reads a fourth slash as content, so the tag no longer opens its documentation line and nothing resolves it. Write exactly three slashes.",
         )
       }
@@ -676,8 +683,8 @@ func prismaDeclarationsFromComments(
         sequence++
         line := run.Line + parsed.LineOffset
         if parsed.Tag == tagEvidence {
-          problems = append(
-            problems,
+          problems = problems.add(
+            severity,
             "@evidence at "+run.Path+":"+decimal(line)+" is on a file-level Prisma exclusion carrier. Move ownership evidence directly above the selected model, column, or relation it grounds; only @evidenceExclude may be unattached at file level.",
           )
           continue
@@ -724,8 +731,8 @@ func prismaDeclarationsFromComments(
     }
     if run.Key == "" {
       if prismaCommentCarriesTag(run.Body) {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence tag at "+location+" documents no declaration. Prisma attaches a '///' comment to the declaration that immediately follows it, so a blank line before a top-level block, a block attribute, or a closing brace leaves the comment documenting nothing. Move the citation directly above the model, column, or relation it grounds.",
         )
       }
@@ -734,8 +741,8 @@ func prismaDeclarationsFromComments(
     host := hosts[run.Key]
     if host == nil {
       if prismaCommentCarriesTag(run.Body) {
-        problems = append(
-          problems,
+        problems = problems.add(
+          severity,
           "Evidence tag at "+location+" documents '"+run.Key+"', which is not a model, column, or relation. A model or a view and their members host an evidence citation; an enum, a composite type, and a datasource or generator setting do not.",
         )
       }
@@ -746,8 +753,8 @@ func prismaDeclarationsFromComments(
       continue
     }
     for _, offset := range prismaBuriedTagLines(run.Body) {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Evidence tag at "+run.Path+":"+decimal(run.Line+offset)+" is buried behind an extra slash. Prisma reads a fourth slash as content, so the tag no longer opens its documentation line and nothing resolves it. Write exactly three slashes.",
       )
     }

package/native/prisma_cache.go

@@ -6,6 +6,8 @@ import (
   "os"
   "strings"
   "sync"
+
+  "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 // prismaCacheLimit bounds the cache so a resident host cannot grow without end.
@@ -176,13 +178,14 @@ func prismaUnitsFromOutcome(
   set prismaSourceSet,
   inventories map[string]*artifactInventory,
   outcome prismaSetOutcome,
-) []string {
+  config graphConfig,
+) graphDiagnostics {
   if outcome.Rejected {
-    return []string{failPrismaSet(
+    return graphDiagnostics{}.add(prismaSetSeverity(config, inventories), failPrismaSet(
       inventories,
       set,
       prismaNormalizationFailure(outcome.Problem),
-    )}
+    ))
   }
   locations, comments := locatePrismaDeclarations(root, set.Sources)
   fallback := ""
@@ -230,7 +233,16 @@ func prismaUnitsFromOutcome(
   for _, inventory := range inventories {
     sortUnits(inventory.Units)
   }
-  return prismaDeclarationsFromComments(comments, hosts, indexed)
+  levels := map[string]rule.Severity{}
+  for key, inventory := range inventories {
+    levels[inventory.Path] = max(levels[inventory.Path], inventorySeverity(config, artifactPrisma, key, "*"))
+  }
+  for _, source := range set.Sources {
+    for _, spelling := range set.Spellings[source] {
+      levels[source] = max(levels[source], levels[spelling])
+    }
+  }
+  return prismaDeclarationsFromComments(comments, hosts, indexed, levels)
 }
 
 // joinPrismaIdentity renders a unit's identity the way the locator keys one.

package/native/severity.go

@@ -0,0 +1,156 @@
+package evidence
+
+import (
+  "encoding/json"
+  "sort"
+
+  "github.com/samchon/ttsc/packages/lint/rule"
+)
+
+func decodeGraphSeverity(raw json.RawMessage, path string) (*rule.Severity, []string) {
+  if len(raw) == 0 {
+    return nil, nil
+  }
+  var severity rule.Severity
+  var value any
+  if err := json.Unmarshal(raw, &value); err != nil {
+    return nil, []string{"Invalid evidence/graph configuration at " + path + ": expected a lint severity value."}
+  }
+  switch value {
+  case "off", float64(0):
+    severity = rule.SeverityOff
+  case "warning", "warn", float64(1):
+    severity = rule.SeverityWarn
+  case "error", float64(2):
+    severity = rule.SeverityError
+  default:
+    return nil, []string{"Invalid evidence/graph configuration at " + path + ": expected 'off', 'warning', 'warn', 'error', 0, 1, or 2; omit severity or use undefined to inherit the enclosing level."}
+  }
+  return &severity, nil
+}
+
+// Resolve inheritance once, before populations are loaded. A nil severity is
+// unset; an explicit zero disables its population.
+func resolveGraphSeverities(config *graphConfig, severity rule.Severity) {
+  for i := range config.Claims {
+    claim := &config.Claims[i]
+    claim.Level = severity
+    if claim.Severity != nil {
+      claim.Level = *claim.Severity
+    }
+    for j := range claim.References {
+      reference := &claim.References[j]
+      reference.Level = claim.Level
+      if reference.Severity != nil {
+        reference.Level = *reference.Severity
+      }
+    }
+  }
+}
+
+type graphDiagnostic struct {
+  Message  string
+  Severity rule.Severity
+}
+
+type graphDiagnostics []graphDiagnostic
+
+func (problems graphDiagnostics) add(severity rule.Severity, messages ...string) graphDiagnostics {
+  for _, message := range messages {
+    problems = append(problems, graphDiagnostic{Message: message, Severity: severity})
+  }
+  return problems
+}
+
+func (problems graphDiagnostics) report(ctx *rule.ProjectContext) {
+  levels := map[string]rule.Severity{}
+  for _, problem := range problems {
+    levels[problem.Message] = max(levels[problem.Message], problem.Severity)
+  }
+  messages := make([]string, 0, len(levels))
+  for message := range levels {
+    messages = append(messages, message)
+  }
+  sort.Strings(messages)
+  for _, message := range messages {
+    ctx.ReportSeverity(levels[message], message)
+  }
+}
+
+// A shared source problem belongs to every population that reads it. Keep the
+// strongest owning level without pooling independent coverage obligations.
+func populationSeverity(config graphConfig, kind artifactKind, base populationBase, path string, symbol string, descendants bool) rule.Severity {
+  var severity rule.Severity
+  matches := func(candidate populationBase, files globSet, symbols symbolSet) bool {
+    return candidate.Absolute == base.Absolute &&
+      (path == "" || files.matches(path) || descendants && files.couldMatchDescendant(path)) &&
+      (symbol == "*" || symbols.contains(symbol))
+  }
+  for _, claim := range config.Claims {
+    if claim.Type == kind && matches(claim.Base, claim.Files, claim.Symbols) {
+      severity = max(severity, claim.Level)
+    }
+    for _, reference := range claim.References {
+      if reference.Type == kind && reference.Package == "" && matches(reference.Base, reference.Files, reference.Symbols) {
+        severity = max(severity, reference.Level)
+      }
+    }
+  }
+  return severity
+}
+
+func artifactSeverity(config graphConfig, kind artifactKind) rule.Severity {
+  var severity rule.Severity
+  for _, claim := range config.Claims {
+    if claim.Type == kind {
+      severity = max(severity, claim.Level)
+    }
+    for _, reference := range claim.References {
+      if reference.Type == kind {
+        severity = max(severity, reference.Level)
+      }
+    }
+  }
+  return severity
+}
+
+func swaggerSeverity(config graphConfig, source string) rule.Severity {
+  var severity rule.Severity
+  for _, claim := range config.Claims {
+    for _, reference := range claim.References {
+      if reference.Type == artifactSwagger && reference.Source == source {
+        severity = max(severity, reference.Level)
+      }
+    }
+  }
+  return severity
+}
+
+func ownerSeverity(owners []claimState) rule.Severity {
+  var severity rule.Severity
+  for _, owner := range owners {
+    severity = max(severity, owner.Spec.Level)
+  }
+  return severity
+}
+
+func inventorySeverity(config graphConfig, kind artifactKind, address string, symbol string) rule.Severity {
+  var severity rule.Severity
+  for _, base := range configuredBases(config, kind) {
+    if relative, ok := base.relativeOf(address); ok {
+      severity = max(severity, populationSeverity(config, kind, base, relative, symbol, false))
+    }
+  }
+  return severity
+}
+
+// Empty or failed populations contribute no file to the shared Prisma parse.
+func prismaSetSeverity(config graphConfig, inventories map[string]*artifactInventory) rule.Severity {
+  var severity rule.Severity
+  for address, inventory := range inventories {
+    if inventory != nil && inventory.FailureBase == "" {
+      severity = max(severity, inventorySeverity(config, artifactPrisma, address, "*"))
+    }
+  }
+  return severity
+}

package/native/swagger.go

@@ -11,6 +11,8 @@ import (
   "sort"
   "strings"
   "time"
+
+  "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 const swaggerBridgeTimeout = 60 * time.Second
@@ -94,7 +96,7 @@ type swaggerOperation struct {
 func loadSwaggerInventories(
   root string,
   config graphConfig,
-) (map[string]*artifactInventory, []string) {
+) (map[string]*artifactInventory, graphDiagnostics) {
   sources := configuredSwaggerSources(config)
   inventories := map[string]*artifactInventory{}
   for _, source := range sources {
@@ -114,15 +116,16 @@ func loadSwaggerInventories(
   // TypeScript keystroke that triggers a rebuild.
   digests := swaggerContentDigests(root, sources)
   pending := []string{}
-  problems := []string{}
+  problems := graphDiagnostics{}
+  severity := artifactSeverity(config, artifactSwagger)
   for _, source := range sources {
     outcome, hit := lookupSwaggerDocument(source, digests[source])
     if !hit {
       pending = append(pending, source)
       continue
     }
-    problems = append(
-      problems,
+    problems = problems.add(
+      swaggerSeverity(config, source),
       swaggerUnitsFromOutcome(source, inventories[source], outcome)...,
     )
   }
@@ -140,30 +143,34 @@ func loadSwaggerInventories(
         inventoryProblem{Symbol: "operation", Message: message},
       )
     }
-    return inventories, append(problems, message)
+    var pendingSeverity rule.Severity
+    for _, source := range pending {
+      pendingSeverity = max(pendingSeverity, swaggerSeverity(config, source))
+    }
+    return inventories, problems.add(pendingSeverity, message)
   }
 
   seen := map[string]bool{}
   for _, document := range result.Documents {
     inventory := inventories[document.Source]
     if inventory == nil {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Evidence graph Swagger normalizer returned an unconfigured source '"+displaySwaggerSource(document.Source)+"'. Reinstall @ttsc/evidence; the native and JavaScript bridge contracts disagree.",
       )
       continue
     }
     if seen[document.Source] {
-      problems = append(
-        problems,
+      problems = problems.add(
+        swaggerSeverity(config, document.Source),
         "Evidence graph Swagger normalizer returned source '"+displaySwaggerSource(document.Source)+"' more than once. Reinstall @ttsc/evidence; the native and JavaScript bridge contracts disagree.",
       )
       continue
     }
     seen[document.Source] = true
     outcome := swaggerDocumentOutcome{Operations: document.Operations}
-    problems = append(
-      problems,
+    problems = problems.add(
+      swaggerSeverity(config, document.Source),
       swaggerUnitsFromOutcome(document.Source, inventory, outcome)...,
     )
     rememberSwaggerDocument(document.Source, document.Digest, outcome)
@@ -171,8 +178,8 @@ func loadSwaggerInventories(
   for _, problem := range result.Problems {
     inventory := inventories[problem.Source]
     if inventory == nil {
-      problems = append(
-        problems,
+      problems = problems.add(
+        severity,
         "Evidence graph Swagger normalizer rejected an unconfigured source '"+displaySwaggerSource(problem.Source)+"'. Reinstall @ttsc/evidence; the native and JavaScript bridge contracts disagree.",
       )
       continue
@@ -182,8 +189,8 @@ func loadSwaggerInventories(
       Rejected: true,
       Problem:  problem.Message,
     }
-    problems = append(
-      problems,
+    problems = problems.add(
+      swaggerSeverity(config, problem.Source),
       swaggerUnitsFromOutcome(problem.Source, inventory, outcome)...,
     )
     rememberSwaggerDocument(problem.Source, problem.Digest, outcome)
@@ -198,7 +205,7 @@ func loadSwaggerInventories(
       inventories[source].Problems,
       inventoryProblem{Symbol: "operation", Message: message},
     )
-    problems = append(problems, message)
+    problems = problems.add(swaggerSeverity(config, source), message)
   }
   return inventories, problems
 }

package/native/typescript.go

@@ -79,8 +79,8 @@ func extendTypeScriptInventories(
 func typeScriptBaseProblems(
   config graphConfig,
   inventories map[string]*artifactInventory,
-) []string {
-  problems := []string{}
+) graphDiagnostics {
+  problems := graphDiagnostics{}
   for _, base := range configuredBases(config, artifactTypeScript) {
     problem := baseDirectoryProblem(base, artifactTypeScript)
     // The stat accepts a chain of links the resolver will not finish, and this
@@ -111,7 +111,7 @@ func typeScriptBaseProblems(
       continue
     }
     recordPopulationFailure(inventories, artifactTypeScript, base)
-    problems = append(problems, problem)
+    problems = problems.add(populationSeverity(config, artifactTypeScript, base, "", "*", false), problem)
   }
   return problems
 }

package/native/unreadable.go

@@ -1,7 +1,6 @@
 package evidence
 
 import (
-  "sort"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -142,14 +141,14 @@ func readableCommentBody(comment string) string {
 func unreadableTypeScriptTags(
   inventories map[string]*artifactInventory,
   governed map[string]bool,
-) []string {
-  reported := []string{}
+  config graphConfig,
+) graphDiagnostics {
+  reported := graphDiagnostics{}
   for address, inventory := range inventories {
-    if inventory == nil || !governed[address] {
+    if inventory == nil || len(inventory.Unreadable) == 0 || !governed[address] {
       continue
     }
-    reported = append(reported, inventory.Unreadable...)
+    reported = reported.add(inventorySeverity(config, artifactTypeScript, address, "*"), inventory.Unreadable...)
   }
-  sort.Strings(reported)
   return reported
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/evidence",
-  "version": "0.28.5",
+  "version": "0.29.0",
   "description": "Evidence-graph lint contributor for @ttsc/lint: declare provenance with a JSDoc @evidence tag and fail the build when it is missing or dangling.",
   "main": "lib/index.js",
   "exports": {
@@ -42,14 +42,14 @@
     "url": "https://github.com/samchon/ttsc/issues"
   },
   "peerDependencies": {
-    "@ttsc/lint": ">=0.24.0"
+    "@ttsc/lint": ">0.28.6"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "@ttsc/lint": "0.28.5",
-    "ttsc": "0.28.5"
+    "ttsc": "0.29.0",
+    "@ttsc/lint": "0.29.0"
   },
   "dependencies": {
     "@prisma/prisma-schema-wasm": "7.10.0-2.d0368e25c88e68caa4d283b5f2d88d1b76ed9356",