Minimize D&D NPC extraction contracts

2026-07-22 18:51:26 +00:00
parent 14991cf58b
commit a263a0840c
43 changed files with 486 additions and 1395 deletions
--- a/internal/modules/dnd/codec/npcs/assets/schemas/dnd_npcs.v1.json
+++ b/internal/modules/dnd/codec/npcs/assets/schemas/dnd_npcs.v1.json
@@ -13,9 +13,6 @@
        "required": [
          "id",
          "name",
-          "aliases",
-          "description",
-          "relationships",
          "source_refs"
        ],
        "properties": {
@@ -27,35 +24,6 @@
            "type": "string",
            "minLength": 1
          },
-          "aliases": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "minLength": 1
-            }
-          },
-          "description": {
-            "type": "string",
-            "minLength": 1
-          },
-          "relationships": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "additionalProperties": false,
-              "required": ["target", "relationship"],
-              "properties": {
-                "target": {
-                  "type": "string",
-                  "minLength": 1
-                },
-                "relationship": {
-                  "type": "string",
-                  "minLength": 1
-                }
-              }
-            }
-          },
          "source_refs": {
            "type": "array",
            "minItems": 1,
--- a/internal/modules/dnd/codec/npcs/codec.go
+++ b/internal/modules/dnd/codec/npcs/codec.go
@@ -106,29 +106,6 @@ func validate(value dnd.NPCList) error {
 		if strings.TrimSpace(npc.Name) == "" {
 			return fmt.Errorf("%s.name must not be empty", prefix)
 		}
-		if npc.Aliases == nil {
-			return fmt.Errorf("%s.aliases must be present", prefix)
-		}
-		for aliasIndex, alias := range npc.Aliases {
-			if strings.TrimSpace(alias) == "" {
-				return fmt.Errorf("%s.aliases[%d] must not be empty", prefix, aliasIndex)
-			}
-		}
-		if strings.TrimSpace(npc.Description) == "" {
-			return fmt.Errorf("%s.description must not be empty", prefix)
-		}
-		if npc.Relationships == nil {
-			return fmt.Errorf("%s.relationships must be present", prefix)
-		}
-		for relationshipIndex, relationship := range npc.Relationships {
-			relationshipPrefix := fmt.Sprintf("%s.relationships[%d]", prefix, relationshipIndex)
-			if strings.TrimSpace(relationship.Target) == "" {
-				return fmt.Errorf("%s.target must not be empty", relationshipPrefix)
-			}
-			if strings.TrimSpace(relationship.Relationship) == "" {
-				return fmt.Errorf("%s.relationship must not be empty", relationshipPrefix)
-			}
-		}
 		if len(npc.SourceRefs) == 0 {
 			return fmt.Errorf("%s.source_refs must not be empty", prefix)
 		}
--- a/internal/modules/dnd/codec/npcs/codec_test.go
+++ b/internal/modules/dnd/codec/npcs/codec_test.go
@@ -17,13 +17,8 @@ import (

 func validList() dnd.NPCList {
 	return dnd.NPCList{NPCs: []dnd.NPC{{
-		ID:          identity.DeriveID("Mira Thorn"),
-		Name:        "Mira Thorn",
-		Aliases:     []string{"The Greencloak"},
-		Description: "A guarded ranger who watches the northern road.",
-		Relationships: []dnd.NPCRelationship{{
-			Target: "Captain Vale", Relationship: "reports to",
-		}},
+		ID:         identity.DeriveID("Mira Thorn"),
+		Name:       "Mira Thorn",
 		SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 1, EndUnitID: 2}},
 	}}}
 }
@@ -86,10 +81,11 @@ func TestCodecStrictlyRejectsMalformedOrUnknownJSON(t *testing.T) {
 		want string
 	}{
 		{name: "unknown top-level", raw: `{"npcs":[],"unexpected":true}`, want: "unknown field"},
-		{name: "unknown nested", raw: `{"npcs":[{"id":"x","name":"Mira","aliases":[],"description":"desc","relationships":[],"source_refs":[{"source_id":"s","start_unit_id":1,"end_unit_id":1}],"unexpected":true}]}`, want: "unknown field"},
+		{name: "unknown nested", raw: `{"npcs":[{"id":"x","name":"Mira","source_refs":[{"source_id":"s","start_unit_id":1,"end_unit_id":1}],"unexpected":true}]}`, want: "unknown field"},
+		{name: "removed enrichment", raw: `{"npcs":[{"id":"x","name":"Mira","aliases":[],"source_refs":[{"source_id":"s","start_unit_id":1,"end_unit_id":1}]}]}`, want: "unknown field"},
 		{name: "trailing", raw: `{"npcs":[]} {}`, want: "multiple JSON values"},
 		{name: "missing array", raw: `{}`, want: "npcs must be present"},
-		{name: "invalid reference", raw: `{"npcs":[{"id":"npc:sha256:0000000000000000000000000000000000000000000000000000000000000000","name":"Mira","aliases":[],"description":"desc","relationships":[],"source_refs":[{"source_id":"s","start_unit_id":0,"end_unit_id":1}]}]}`, want: "start_unit_id"},
+		{name: "invalid reference", raw: `{"npcs":[{"id":"npc:sha256:0000000000000000000000000000000000000000000000000000000000000000","name":"Mira","source_refs":[{"source_id":"s","start_unit_id":0,"end_unit_id":1}]}]}`, want: "start_unit_id"},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
@@ -103,7 +99,7 @@ func TestCodecStrictlyRejectsMalformedOrUnknownJSON(t *testing.T) {

 func TestCodecCandidatePreservesInvalidTypedValues(t *testing.T) {
 	codec := New()
-	candidate := dnd.NPCList{NPCs: []dnd.NPC{{Name: "Mira Thorn", Aliases: []string{}, Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{}}}}
+	candidate := dnd.NPCList{NPCs: []dnd.NPC{{Name: "Mira Thorn", SourceRefs: []source.SourceRef{}}}}
 	content, err := codec.EncodeCandidate(candidate)
 	if err != nil || !json.Valid(content) {
 		t.Fatalf("EncodeCandidate() = %s, %v; want JSON", content, err)
@@ -124,11 +120,8 @@ func TestCodecRejectsEveryRequiredShapeBoundary(t *testing.T) {
 		value dnd.NPCList
 		want  string
 	}{
-		{name: "nil aliases", value: dnd.NPCList{NPCs: []dnd.NPC{{ID: base.ID, Name: base.Name, Description: base.Description, Relationships: []dnd.NPCRelationship{}, SourceRefs: base.SourceRefs}}}, want: "aliases must be present"},
-		{name: "empty alias", value: dnd.NPCList{NPCs: []dnd.NPC{{ID: base.ID, Name: base.Name, Aliases: []string{" "}, Description: base.Description, Relationships: []dnd.NPCRelationship{}, SourceRefs: base.SourceRefs}}}, want: "aliases[0] must not be empty"},
-		{name: "nil relationships", value: dnd.NPCList{NPCs: []dnd.NPC{{ID: base.ID, Name: base.Name, Aliases: []string{}, Description: base.Description, SourceRefs: base.SourceRefs}}}, want: "relationships must be present"},
-		{name: "empty relationship target", value: dnd.NPCList{NPCs: []dnd.NPC{{ID: base.ID, Name: base.Name, Aliases: []string{}, Description: base.Description, Relationships: []dnd.NPCRelationship{{Relationship: "knows"}}, SourceRefs: base.SourceRefs}}}, want: "target must not be empty"},
-		{name: "empty source refs", value: dnd.NPCList{NPCs: []dnd.NPC{{ID: base.ID, Name: base.Name, Aliases: []string{}, Description: base.Description, Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{}}}}, want: "source_refs must not be empty"},
+		{name: "blank name", value: dnd.NPCList{NPCs: []dnd.NPC{{ID: base.ID, Name: " ", SourceRefs: base.SourceRefs}}}, want: "name must not be empty"},
+		{name: "empty source refs", value: dnd.NPCList{NPCs: []dnd.NPC{{ID: base.ID, Name: base.Name, SourceRefs: []source.SourceRef{}}}}, want: "source_refs must not be empty"},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
--- a/internal/modules/dnd/codec/npcs/testdata/dnd_npcs.v1.json
+++ b/internal/modules/dnd/codec/npcs/testdata/dnd_npcs.v1.json
@@ -3,9 +3,6 @@
    {
      "id": "npc:sha256:99a16589618a04f535a7d21fdcc71a0b1c05d22f752cd492065b1086d97bc3d7",
      "name": "Mira Thorn",
-      "aliases": ["The Greencloak"],
-      "description": "A guarded ranger who watches the northern road.",
-      "relationships": [{"target": "Captain Vale", "relationship": "reports to"}],
      "source_refs": [{"source_id": "session-alpha", "start_unit_id": 1, "end_unit_id": 2}]
    }
  ]
--- a/internal/modules/dnd/extract/combatturns/extractor.go
+++ b/internal/modules/dnd/extract/combatturns/extractor.go
@@ -133,9 +133,7 @@ func (e *Extractor) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
 		{Name: "mapping_policy", Value: mappingPolicy},
 	}
 	seeded := e.npcResolver.Seeded()
-	if seeded.Bound() {
-		fingerprints = append(fingerprints, pipeline.CheckpointFingerprint{Name: "npc_registry", Value: seeded.Digest()})
-	}
+	fingerprints = append(fingerprints, pipeline.CheckpointFingerprint{Name: "npc_registry", Value: seeded.ProjectionDigest()})
 	return fingerprints
 }

--- a/internal/modules/dnd/extract/combatturns/extractor_test.go
+++ b/internal/modules/dnd/extract/combatturns/extractor_test.go
@@ -146,17 +146,15 @@ func TestExtractUnboundRegistryUsesExactEmptyPromptAndOmitsIdentity(t *testing.T
 		t.Fatalf("Extract() error = %v, want nil", err)
 	}
 	input := client.requests[0].Inputs[NPCRegistryReferenceSlot]
-	if string(input.Content) != `{"npcs":[]}` || input.Digest != "" || input.OriginURI != "" {
+	if string(input.Content) != `{"npcs":[]}` || input.Digest == "" || input.OriginURI != "" {
 		t.Fatalf("unbound registry input = %#v, want exact empty prompt without identity", input)
 	}
 	metadata := extractor.ManifestMetadata()
 	if _, ok := metadata["npc_registry_digest"]; ok {
 		t.Fatalf("unbound metadata has registry digest: %#v", metadata)
 	}
-	for _, fingerprint := range extractor.CheckpointFingerprints() {
-		if fingerprint.Name == "npc_registry" {
-			t.Fatalf("unbound fingerprints include registry identity: %#v", extractor.CheckpointFingerprints())
-		}
+	if fingerprints := extractor.CheckpointFingerprints(); len(fingerprints) != 4 || fingerprints[3].Name != "npc_registry" || fingerprints[3].Value != input.Digest {
+		t.Fatalf("unbound fingerprints = %#v, want empty-projection identity", fingerprints)
 	}
 }

@@ -175,7 +173,7 @@ func TestExtractorResolvesOperationNPCOverrideWithoutSingletonMetadata(t *testin
 		t.Fatalf("Extract() error = %v", err)
 	}
 	input := client.requests[0].Inputs[NPCRegistryReferenceSlot]
-	if input.Digest == "" || string(input.Content) != string(content) || input.OriginURI != "" {
+	if input.Digest == "" || string(input.Content) != `{"npcs":[{"name":"Mira Thorn"}]}` || input.OriginURI != "" {
 		t.Fatalf("operation NPC input = %#v, want generated canonical grounding without provenance", input)
 	}
 	if metadata := extractor.ManifestMetadata(); metadata["npc_registry_digest"] != nil || metadata["npc_count"] != nil {
@@ -252,7 +250,7 @@ func TestExtractorManifestMetadataAndFingerprints(t *testing.T) {
 			t.Fatalf("metadata[%q] = %#v, want digest", key, metadata[key])
 		}
 	}
-	wantNames := map[string]struct{}{"prompt": {}, "response_schema": {}, "mapping_policy": {}}
+	wantNames := map[string]struct{}{"prompt": {}, "response_schema": {}, "mapping_policy": {}, "npc_registry": {}}
 	for _, fingerprint := range extractor.CheckpointFingerprints() {
 		if _, ok := wantNames[fingerprint.Name]; !ok {
 			t.Fatalf("unexpected fingerprint = %#v", fingerprint)
@@ -340,10 +338,7 @@ func newExtractor(t *testing.T, client contracts.StructuredLLMClient, references

 func npcRegistryJSON(t *testing.T) []byte {
 	t.Helper()
-	value := dnd.NPCList{NPCs: []dnd.NPC{{
-		ID: identity.DeriveID("Mira Thorn"), Name: "Mira Thorn", Aliases: []string{"The Greencloak"},
-		Description: "A ranger.", Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{{SourceID: "other-session", StartUnitID: 1, EndUnitID: 1}},
-	}}}
+	value := dnd.NPCList{NPCs: []dnd.NPC{{ID: identity.DeriveID("Mira Thorn"), Name: "Mira Thorn", SourceRefs: []source.SourceRef{{SourceID: "other-session", StartUnitID: 1, EndUnitID: 1}}}}}
 	content, err := npccodec.New().Encode(value)
 	if err != nil {
 		t.Fatalf("encode NPC registry: %v", err)
--- a/internal/modules/dnd/extract/npcs/assets/prompts/instructions.md
+++ b/internal/modules/dnd/extract/npcs/assets/prompts/instructions.md
@@ -1,11 +1,10 @@
-For every NPC record, cite transcript units that support the canonical name,
-every alias, the description, and every relationship.
+For every NPC record, return only the observed display name and transcript
+units that support that identity.

-Descriptions must be short session records, not biographies, statistics,
-alignment, motivations, or lore inferred from general D&D knowledge. Do not
-summarize every action or follow a participant through unrelated scenes.
-Relationships must be stated or directly demonstrated by cited transcript
-units, not inferred from game lore.
+Do not return descriptions, aliases, relationships, biographies, statistics,
+alignment, motivations, encounter summaries, or lore inferred from general
+D&D knowledge. Do not invent a label for an anonymous creature, crowd, or
+generic role.

-Return aliases and relationships as arrays, including empty arrays when there
-are none. Preserve observed display spelling.
+Preserve observed display spelling. Return at least one narrow source range for
+every record.
--- a/internal/modules/dnd/extract/npcs/assets/prompts/task.md
+++ b/internal/modules/dnd/extract/npcs/assets/prompts/task.md
@@ -1,15 +1,12 @@
-Extract a concise Dungeons & Dragons non-player-character registry from the
-provided transcript.
+Extract the individually identifiable Dungeons & Dragons non-player characters
+established by the provided transcript and cite where each identity appears.

-Include an in-world non-PC participant when the transcript establishes that it
-appears, acts, speaks, or is materially discussed and gives it a proper name,
-a stable alias or title, or an individually useful distinguishing description.
+Include an in-world non-PC participant only when the transcript gives it a
+proper name or a stable, individually distinguishing title or alias.

 Exclude human players, transcript speakers, and the GM as out-of-world people,
 player characters identified by the player or party references, incidental or
-hypothetical name drops, corrected transcription mistakes, indistinguishable
-crowds or groups, and temporary summoned creatures or spell effects without a
-persistent individual identity.
-
-Keep each description concise and limited to facts established by the
-transcript. Include only explicitly supported aliases and relationships.
+hypothetical name drops, corrected transcription mistakes, anonymous or
+generic roles, indistinguishable crowds or groups, invented descriptive labels,
+and temporary summoned creatures or spell effects without a persistent
+individual identity.
--- a/internal/modules/dnd/extract/npcs/assets/schemas/dnd_npcs_llm.v1.json
+++ b/internal/modules/dnd/extract/npcs/assets/schemas/dnd_npcs_llm.v1.json
@@ -12,40 +12,12 @@
        "additionalProperties": false,
        "required": [
          "name",
-          "aliases",
-          "description",
-          "relationships",
          "source_refs"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
-          "aliases": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "description": {
-            "type": "string"
-          },
-          "relationships": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "additionalProperties": false,
-              "required": ["target", "relationship"],
-              "properties": {
-                "target": {
-                  "type": "string"
-                },
-                "relationship": {
-                  "type": "string"
-                }
-              }
-            }
-          },
          "source_refs": {
            "type": "array",
            "items": {
--- a/internal/modules/dnd/extract/npcs/canonicalize.go
+++ b/internal/modules/dnd/extract/npcs/canonicalize.go
@@ -98,35 +98,14 @@ func canonicalNPCList(response extractionResponse, sourceID string) dnd.NPCList
 	npcs := make([]dnd.NPC, len(response.NPCs))
 	for index, npc := range response.NPCs {
 		npcs[index] = dnd.NPC{
-			ID:            identity.DeriveID(npc.Name),
-			Name:          npc.Name,
-			Aliases:       cloneStrings(npc.Aliases),
-			Description:   npc.Description,
-			Relationships: cloneRelationships(npc.Relationships),
-			SourceRefs:    canonicalSourceRefs(npc.SourceRefs, sourceID),
+			ID:         identity.DeriveID(npc.Name),
+			Name:       npc.Name,
+			SourceRefs: canonicalSourceRefs(npc.SourceRefs, sourceID),
 		}
 	}
 	return dnd.NPCList{NPCs: npcs}
 }

-func cloneStrings(values []string) []string {
-	if values == nil {
-		return nil
-	}
-	return append([]string{}, values...)
-}
-
-func cloneRelationships(values []npcRelationshipResponse) []dnd.NPCRelationship {
-	if values == nil {
-		return nil
-	}
-	out := make([]dnd.NPCRelationship, len(values))
-	for index, value := range values {
-		out[index] = dnd.NPCRelationship{Target: value.Target, Relationship: value.Relationship}
-	}
-	return out
-}
-
 func canonicalSourceRefs(values []npcSourceRefResponse, sourceID string) []source.SourceRef {
 	if values == nil {
 		return nil
--- a/internal/modules/dnd/extract/npcs/extractor_test.go
+++ b/internal/modules/dnd/extract/npcs/extractor_test.go
@@ -16,13 +16,10 @@ import (
 func TestExtractReturnsCanonicalNPCListFromPrivateResponse(t *testing.T) {
 	client := &fakeNPCsLLMClient{response: extractionResponse{NPCs: []npcResponse{
 		{
-			Name: "Captain Vale", Aliases: []string{"The Captain"}, Description: "A road captain.",
-			Relationships: []npcRelationshipResponse{{Target: "Mira Thorn", Relationship: "reports to"}},
-			SourceRefs:    responseSourceRefs(3, 3),
+			Name: "Captain Vale", SourceRefs: responseSourceRefs(3, 3),
 		},
 		{
-			Name: "Mira Thorn", Aliases: []string{"The Greencloak"}, Description: "A guarded ranger.",
-			Relationships: []npcRelationshipResponse{{Target: "Captain Vale", Relationship: "commands"}},
+			Name: "Mira Thorn",
 			SourceRefs: []npcSourceRefResponse{
 				{StartUnitID: 2, EndUnitID: 2},
 				{StartUnitID: 1, EndUnitID: 2},
@@ -36,8 +33,8 @@ func TestExtractReturnsCanonicalNPCListFromPrivateResponse(t *testing.T) {
 		t.Fatalf("Extract() error = %v, want nil", err)
 	}
 	want := dnd.NPCList{NPCs: []dnd.NPC{
-		{ID: identity.DeriveID("Mira Thorn"), Name: "Mira Thorn", Aliases: []string{"The Greencloak"}, Description: "A guarded ranger.", Relationships: []dnd.NPCRelationship{{Target: "Captain Vale", Relationship: "commands"}}, SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 1, EndUnitID: 2}, {SourceID: "session-alpha", StartUnitID: 2, EndUnitID: 2}}},
-		{ID: identity.DeriveID("Captain Vale"), Name: "Captain Vale", Aliases: []string{"The Captain"}, Description: "A road captain.", Relationships: []dnd.NPCRelationship{{Target: "Mira Thorn", Relationship: "reports to"}}, SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 3, EndUnitID: 3}}},
+		{ID: identity.DeriveID("Mira Thorn"), Name: "Mira Thorn", SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 1, EndUnitID: 2}, {SourceID: "session-alpha", StartUnitID: 2, EndUnitID: 2}}},
+		{ID: identity.DeriveID("Captain Vale"), Name: "Captain Vale", SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 3, EndUnitID: 3}}},
 	}}
 	if !reflect.DeepEqual(result.Value, want) {
 		t.Fatalf("Value = %#v, want %#v", result.Value, want)
@@ -58,11 +55,11 @@ func TestExtractReturnsCanonicalNPCListFromPrivateResponse(t *testing.T) {
 func TestExtractOrdersNPCsBySourcePositionRatherThanUnitID(t *testing.T) {
 	client := &fakeNPCsLLMClient{response: extractionResponse{NPCs: []npcResponse{
 		{
-			Name: "Later NPC", Aliases: []string{}, Description: "Appears later.", Relationships: []npcRelationshipResponse{},
+			Name:       "Later NPC",
 			SourceRefs: responseSourceRefs(10, 10),
 		},
 		{
-			Name: "Earlier NPC", Aliases: []string{}, Description: "Appears first.", Relationships: []npcRelationshipResponse{},
+			Name: "Earlier NPC",
 			SourceRefs: []npcSourceRefResponse{
 				{StartUnitID: 50, EndUnitID: 50},
 				{StartUnitID: 100, EndUnitID: 100},
@@ -109,14 +106,14 @@ func TestExtractPassesCampaignReferencesAsPromptInputs(t *testing.T) {

 func TestExtractPreservesMalformedCandidatesForValidators(t *testing.T) {
 	client := &fakeNPCsLLMClient{response: extractionResponse{NPCs: []npcResponse{{
-		Name: "", Aliases: nil, Description: "", Relationships: nil,
+		Name:       "",
 		SourceRefs: []npcSourceRefResponse{{StartUnitID: 99, EndUnitID: 0}},
 	}}}}
 	result, err := newExtractor(t, client).Extract(context.Background(), extractionRequest())
 	if err != nil {
 		t.Fatalf("Extract() error = %v, want nil", err)
 	}
-	if len(result.Value.NPCs) != 1 || result.Value.NPCs[0].ID != "" || result.Value.NPCs[0].Name != "" || result.Value.NPCs[0].Aliases != nil || result.Value.NPCs[0].Relationships != nil {
+	if len(result.Value.NPCs) != 1 || result.Value.NPCs[0].ID != "" || result.Value.NPCs[0].Name != "" {
 		t.Fatalf("malformed candidate = %#v, want invalid values preserved", result.Value)
 	}
 	if refs := result.Value.NPCs[0].SourceRefs; len(refs) != 1 || refs[0].SourceID != "session-alpha" || refs[0].StartUnitID != 99 || refs[0].EndUnitID != 0 {
@@ -125,13 +122,13 @@ func TestExtractPreservesMalformedCandidatesForValidators(t *testing.T) {
 }

 func TestExtractMapsRawSemanticCandidatesWithoutRepair(t *testing.T) {
-	client := &fakeNPCsLLMClient{content: []byte(`{"npcs":[{"name":"","aliases":[],"description":"","relationships":[],"source_refs":[{"start_unit_id":0,"end_unit_id":-1}]}]}`)}
+	client := &fakeNPCsLLMClient{content: []byte(`{"npcs":[{"name":"","source_refs":[{"start_unit_id":0,"end_unit_id":-1}]}]}`)}
 	result, err := newExtractor(t, client).Extract(context.Background(), extractionRequest())
 	if err != nil {
 		t.Fatalf("Extract() error = %v, want nil", err)
 	}
 	npc := result.Value.NPCs[0]
-	if npc.ID != "" || npc.Name != "" || npc.Description != "" {
+	if npc.ID != "" || npc.Name != "" {
 		t.Fatalf("NPC = %#v, want blank semantic values preserved", npc)
 	}
 	if refs := npc.SourceRefs; len(refs) != 1 || refs[0] != (source.SourceRef{SourceID: "session-alpha", StartUnitID: 0, EndUnitID: -1}) {
--- a/internal/modules/dnd/extract/npcs/model.go
+++ b/internal/modules/dnd/extract/npcs/model.go
@@ -5,16 +5,8 @@ type extractionResponse struct {
 }

 type npcResponse struct {
-	Name          string                    `json:"name"`
-	Aliases       []string                  `json:"aliases"`
-	Description   string                    `json:"description"`
-	Relationships []npcRelationshipResponse `json:"relationships"`
-	SourceRefs    []npcSourceRefResponse    `json:"source_refs"`
-}
-
-type npcRelationshipResponse struct {
-	Target       string `json:"target"`
-	Relationship string `json:"relationship"`
+	Name       string                 `json:"name"`
+	SourceRefs []npcSourceRefResponse `json:"source_refs"`
 }

 type npcSourceRefResponse struct {
--- a/internal/modules/dnd/extract/npcs/schema_test.go
+++ b/internal/modules/dnd/extract/npcs/schema_test.go
@@ -18,7 +18,7 @@ func TestLoadResponseSchemaUsesPrivateNPCSchema(t *testing.T) {
 		t.Fatalf("schema = %#v, want private NPC schema identity", schema)
 	}
 	valid := map[string]any{"npcs": []any{map[string]any{
-		"name": "Mira Thorn", "aliases": []any{}, "description": "A ranger.", "relationships": []any{},
+		"name":        "Mira Thorn",
 		"source_refs": []any{map[string]any{"start_unit_id": 1, "end_unit_id": 2}},
 	}}}
 	validJSON, err := json.Marshal(valid)
@@ -36,14 +36,14 @@ func TestLoadResponseSchemaUsesPrivateNPCSchema(t *testing.T) {
 		{
 			name: "semantic blanks and empty collections",
 			response: map[string]any{"npcs": []any{map[string]any{
-				"name": "", "aliases": []any{""}, "description": "", "relationships": []any{map[string]any{"target": "", "relationship": ""}}, "source_refs": []any{},
+				"name": "", "source_refs": []any{},
 			}}},
 			valid: true,
 		},
 		{
 			name: "nonpositive unit candidates",
 			response: map[string]any{"npcs": []any{map[string]any{
-				"name": "Mira Thorn", "aliases": []any{}, "description": "A ranger.", "relationships": []any{},
+				"name":        "Mira Thorn",
 				"source_refs": []any{map[string]any{"start_unit_id": 0, "end_unit_id": -1}},
 			}}},
 			valid: true,
@@ -51,25 +51,25 @@ func TestLoadResponseSchemaUsesPrivateNPCSchema(t *testing.T) {
 		{
 			name: "missing required field",
 			response: map[string]any{"npcs": []any{map[string]any{
-				"aliases": []any{}, "description": "A ranger.", "relationships": []any{}, "source_refs": []any{},
+				"source_refs": []any{},
 			}}},
 		},
 		{
 			name: "unknown field",
 			response: map[string]any{"npcs": []any{map[string]any{
-				"name": "Mira Thorn", "aliases": []any{}, "description": "A ranger.", "relationships": []any{}, "source_refs": []any{}, "id": "assigned later",
+				"name": "Mira Thorn", "source_refs": []any{}, "id": "assigned later",
 			}}},
 		},
 		{
 			name: "wrong field type",
 			response: map[string]any{"npcs": []any{map[string]any{
-				"name": 7, "aliases": []any{}, "description": "A ranger.", "relationships": []any{}, "source_refs": []any{},
+				"name": 7, "source_refs": []any{},
 			}}},
 		},
 		{
 			name: "noninteger source identifier",
 			response: map[string]any{"npcs": []any{map[string]any{
-				"name": "Mira Thorn", "aliases": []any{}, "description": "A ranger.", "relationships": []any{},
+				"name":        "Mira Thorn",
 				"source_refs": []any{map[string]any{"start_unit_id": 1.5, "end_unit_id": 2}},
 			}}},
 		},
@@ -89,7 +89,7 @@ func TestLoadResponseSchemaUsesPrivateNPCSchema(t *testing.T) {
 		t.Fatal("validateJSONSchema() error = nil, want malformed JSON rejected")
 	}
 	withID := map[string]any{"npcs": []any{map[string]any{
-		"name": "Mira Thorn", "id": "assigned-later", "aliases": []any{}, "description": "A ranger.", "relationships": []any{},
+		"name": "Mira Thorn", "id": "assigned-later",
 		"source_refs": []any{map[string]any{"start_unit_id": 1, "end_unit_id": 2}},
 	}}}
 	withIDJSON, err := json.Marshal(withID)
--- a/internal/modules/dnd/extract/spells/extractor.go
+++ b/internal/modules/dnd/extract/spells/extractor.go
@@ -151,9 +151,7 @@ func (e *Extractor) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
 		{Name: "response_schema", Value: e.responseSchemaSHA},
 	}
 	seeded := e.npcResolver.Seeded()
-	if seeded.Bound() {
-		fingerprints = append(fingerprints, pipeline.CheckpointFingerprint{Name: "npc_registry", Value: seeded.Digest()})
-	}
+	fingerprints = append(fingerprints, pipeline.CheckpointFingerprint{Name: "npc_registry", Value: seeded.ProjectionDigest()})
 	return fingerprints
 }

--- a/internal/modules/dnd/extract/spells/extractor_test.go
+++ b/internal/modules/dnd/extract/spells/extractor_test.go
@@ -122,9 +122,10 @@ func TestExtractPromptUsesCanonicalOverlayNamesWithoutAliasesOrMetadata(t *testi
 		"effective_catalog": metadata["catalog_digest"],
 		"prompt":            metadata["prompt_sha256"],
 		"response_schema":   metadata["response_schema_sha256"],
+		"npc_registry":      checkpointFingerprintMap(newExtractor(t, &fakeSpellsLLMClient{}).CheckpointFingerprints())["npc_registry"],
 	}
 	if len(fingerprints) != len(wantFingerprints) {
-		t.Fatalf("checkpoint fingerprints = %#v, want prompt, response schema, and catalog identities", fingerprints)
+		t.Fatalf("checkpoint fingerprints = %#v, want prompt, response schema, catalog, and NPC projection identities", fingerprints)
 	}
 	for _, fingerprint := range fingerprints {
 		if want, ok := wantFingerprints[fingerprint.Name]; !ok || fingerprint.Value != want {
--- a/internal/modules/dnd/extract/spells/npc_registry_wiring_test.go
+++ b/internal/modules/dnd/extract/spells/npc_registry_wiring_test.go
@@ -22,10 +22,9 @@ func TestSpellExtractorUsesExactUnboundNPCPromptAndOmitsRegistryIdentity(t *test
 	if metadata["npc_registry_digest"] != nil || metadata["npc_count"] != nil {
 		t.Fatalf("unbound extractor metadata = %#v, want no NPC registry fields", metadata)
 	}
-	for _, fingerprint := range extractor.CheckpointFingerprints() {
-		if fingerprint.Name == "npc_registry" {
-			t.Fatalf("unbound checkpoint fingerprints = %#v, want no NPC registry fingerprint", extractor.CheckpointFingerprints())
-		}
+	fingerprints := checkpointFingerprintMap(extractor.CheckpointFingerprints())
+	if fingerprints["npc_registry"] == "" {
+		t.Fatalf("unbound checkpoint fingerprints = %#v, want empty-projection identity", fingerprints)
 	}

 	client := &fakeSpellsLLMClient{response: extractionResponse{SpellCasts: []spellCastResponse{}}}
@@ -34,7 +33,7 @@ func TestSpellExtractorUsesExactUnboundNPCPromptAndOmitsRegistryIdentity(t *test
 		t.Fatalf("Extract() error = %v, want nil", err)
 	}
 	input := client.requests[0].Inputs[NPCRegistryReferenceSlot]
-	if input.Name != NPCRegistryReferenceSlot || input.MediaType != npccodec.MediaType || input.Digest != "" || input.OriginURI != "" || string(input.Content) != `{"npcs":[]}` {
+	if input.Name != NPCRegistryReferenceSlot || input.MediaType != npccodec.MediaType || input.Digest != fingerprints["npc_registry"] || input.OriginURI != "" || string(input.Content) != `{"npcs":[]}` {
 		t.Fatalf("NPC prompt input = %#v, want exact empty registry material", input)
 	}
 }
@@ -57,7 +56,7 @@ func TestSpellExtractorPreservesSemanticNPCRegistryFingerprintAndPromptWiring(t
 		t.Fatalf("semantic NPC fingerprints = %#v and %#v, want same npc_registry value", firstFingerprints, secondFingerprints)
 	}
 	metadata := first.ManifestMetadata()
-	if metadata["npc_registry_digest"] != firstFingerprints["npc_registry"] || metadata["npc_count"] != 1 {
+	if metadata["npc_registry_digest"] == "" || metadata["npc_registry_digest"] == firstFingerprints["npc_registry"] || metadata["npc_count"] != 1 {
 		t.Fatalf("NPC registry metadata = %#v, want digest and count only", metadata)
 	}

@@ -70,8 +69,8 @@ func TestSpellExtractorPreservesSemanticNPCRegistryFingerprintAndPromptWiring(t
 	if input.Name != NPCRegistryReferenceSlot || input.MediaType != npccodec.MediaType || input.Digest != firstFingerprints["npc_registry"] || input.OriginURI != "" {
 		t.Fatalf("NPC prompt input metadata = %#v, want semantic metadata without provenance", input)
 	}
-	if !bytes.Equal(input.Content, canonical) {
-		t.Fatalf("NPC prompt input = %s, want canonical JSON %s", input.Content, canonical)
+	if !bytes.Equal(input.Content, []byte(`{"npcs":[{"name":"Mira Thorn"}]}`)) {
+		t.Fatalf("NPC prompt input = %s, want names-only projection", input.Content)
 	}
 	encoded, err := json.Marshal(map[string]any{"metadata": metadata, "fingerprints": firstFingerprints})
 	if err != nil {
@@ -97,28 +96,21 @@ func TestSpellExtractorResolvesOperationNPCOverrideWithoutSingletonMetadata(t *t
 		t.Fatalf("Extract() error = %v", err)
 	}
 	input := client.requests[0].Inputs[NPCRegistryReferenceSlot]
-	if input.Digest == "" || string(input.Content) != string(canonical) || input.OriginURI != "" {
+	if input.Digest == "" || string(input.Content) != `{"npcs":[{"name":"Mira Thorn"}]}` || input.OriginURI != "" {
 		t.Fatalf("operation NPC input = %#v, want generated canonical grounding without provenance", input)
 	}
 	if metadata := extractor.ManifestMetadata(); metadata["npc_registry_digest"] != nil || metadata["npc_count"] != nil {
 		t.Fatalf("singleton metadata = %#v, want no operation-varying NPC identity", metadata)
 	}
-	for _, fingerprint := range extractor.CheckpointFingerprints() {
-		if fingerprint.Name == "npc_registry" {
-			t.Fatalf("singleton fingerprints = %#v, want no operation-varying NPC identity", extractor.CheckpointFingerprints())
-		}
+	if checkpointFingerprintMap(extractor.CheckpointFingerprints())["npc_registry"] == "" {
+		t.Fatalf("singleton fingerprints = %#v, want empty-projection identity", extractor.CheckpointFingerprints())
 	}
 }

 func registryFixture() dnd.NPCList {
 	return dnd.NPCList{NPCs: []dnd.NPC{{
-		ID:          identity.DeriveID("Mira Thorn"),
-		Name:        "Mira Thorn",
-		Aliases:     []string{"The Greencloak"},
-		Description: "A guarded ranger who watches the northern road.",
-		Relationships: []dnd.NPCRelationship{{
-			Target: "Captain Vale", Relationship: "reports to",
-		}},
+		ID:         identity.DeriveID("Mira Thorn"),
+		Name:       "Mira Thorn",
 		SourceRefs: []source.SourceRef{{SourceID: "npc-session", StartUnitID: 41, EndUnitID: 43}},
 	}}}
 }
--- a/internal/modules/dnd/normalize/combatturns/normalizer.go
+++ b/internal/modules/dnd/normalize/combatturns/normalizer.go
@@ -92,9 +92,7 @@ func (n *Normalizer) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
 		{Name: "identity_policy", Value: identity.Policy},
 	}
 	seeded := n.npcResolver.Seeded()
-	if seeded.Bound() {
-		fingerprints = append(fingerprints, pipeline.CheckpointFingerprint{Name: "npc_registry", Value: seeded.Digest()})
-	}
+	fingerprints = append(fingerprints, pipeline.CheckpointFingerprint{Name: "npc_registry", Value: seeded.ProjectionDigest()})
 	return fingerprints
 }

--- a/internal/modules/dnd/normalize/combatturns/normalizer_test.go
+++ b/internal/modules/dnd/normalize/combatturns/normalizer_test.go
@@ -26,12 +26,12 @@ func TestNormalizeCanonicalizesFieldsAndRegistryIdentities(t *testing.T) {
 	}
 	resolution := "  the  target  is hit  "
 	input := dnd.CombatTurnList{CombatTurns: []dnd.CombatTurn{{
-		Actor:    "  storm  ",
+		Actor:    "  aria  ",
 		TurnKind: dnd.CombatTurnKindTurn,
 		Actions: []dnd.CombatAction{{
 			Category:    dnd.CombatActionCategoryAttack,
 			Declaration: "  attacks\n with  a sword ",
-			Targets:     []string{"  minion ", "goblin", " unknown combatant "},
+			Targets:     []string{"  goblin ", "goblin", " unknown combatant "},
 			Resolution:  &resolution,
 		}},
 		Summary:    "  Aria\n attacks  ",
@@ -77,10 +77,10 @@ func TestNormalizeResolvesOperationNPCOverrideWithoutSingletonMetadata(t *testin
 		t.Fatalf("New() error = %v", err)
 	}
 	input := dnd.CombatTurnList{CombatTurns: []dnd.CombatTurn{{
-		Actor:      "Storm",
+		Actor:      "aria",
 		TurnKind:   dnd.CombatTurnKindTurn,
-		Actions:    []dnd.CombatAction{{Category: dnd.CombatActionCategoryAttack, Declaration: "attacks", Targets: []string{"Minion"}}},
-		Summary:    "Storm attacks",
+		Actions:    []dnd.CombatAction{{Category: dnd.CombatActionCategoryAttack, Declaration: "attacks", Targets: []string{"goblin"}}},
+		Summary:    "Aria attacks",
 		SourceRefs: []source.SourceRef{{SourceID: doc.ID, StartUnitID: 10, EndUnitID: 10}},
 	}}}
 	result, err := normalizer.Normalize(context.Background(), contracts.TypedNormalizeRequest[dnd.CombatTurnList]{
@@ -222,7 +222,7 @@ func TestNormalizerPreparationMetadataFingerprintsAndModuleContract(t *testing.T
 	if metadata := unbound.ManifestMetadata(); metadata["npc_registry_digest"] != nil || metadata["npc_count"] != nil || metadata["normalization_policy"] != normalizationPolicy || metadata["identity_policy"] != identity.Policy {
 		t.Fatalf("unbound metadata = %#v", metadata)
 	}
-	if got := unbound.CheckpointFingerprints(); len(got) != 2 || got[0].Name != "normalization_policy" || got[1].Name != "identity_policy" {
+	if got := unbound.CheckpointFingerprints(); len(got) != 3 || got[0].Name != "normalization_policy" || got[1].Name != "identity_policy" || got[2].Name != "npc_registry" || got[2].Value == "" {
 		t.Fatalf("unbound fingerprints = %#v", got)
 	}

@@ -305,8 +305,8 @@ func testDocument() *source.SourceDocument {
 func npcReferences(t *testing.T) contracts.ReferenceSet {
 	t.Helper()
 	npcs := dnd.NPCList{NPCs: []dnd.NPC{
-		{ID: identity.DeriveID("Aria"), Name: "Aria", Aliases: []string{"Storm"}, Description: "a fighter", Relationships: []dnd.NPCRelationship{{Target: "Goblin", Relationship: "fights"}}, SourceRefs: []source.SourceRef{{SourceID: "npc-run", StartUnitID: 1, EndUnitID: 1}}},
-		{ID: identity.DeriveID("Goblin"), Name: "Goblin", Aliases: []string{"Minion"}, Description: "a goblin", Relationships: []dnd.NPCRelationship{{Target: "Aria", Relationship: "fights"}}, SourceRefs: []source.SourceRef{{SourceID: "npc-run", StartUnitID: 1, EndUnitID: 1}}},
+		{ID: identity.DeriveID("Aria"), Name: "Aria", SourceRefs: []source.SourceRef{{SourceID: "npc-run", StartUnitID: 1, EndUnitID: 1}}},
+		{ID: identity.DeriveID("Goblin"), Name: "Goblin", SourceRefs: []source.SourceRef{{SourceID: "npc-run", StartUnitID: 1, EndUnitID: 1}}},
 	}}
 	content, err := npccodec.New().Encode(npcs)
 	if err != nil {
--- a/internal/modules/dnd/normalize/npcs/normalizer.go
+++ b/internal/modules/dnd/normalize/npcs/normalizer.go
@@ -22,11 +22,10 @@ const (
 	normalizationPolicy = "dnd.npcs.normalize.v1"
 	NormalizationPolicy = normalizationPolicy

-	ReasonCodeNPCFieldsNormalized             = "npc_fields_normalized"
-	ReasonCodeNPCIDRecomputed                 = "npc_id_recomputed"
-	ReasonCodeSourceReferencesNormalized      = "source_references_normalized"
-	ReasonCodeDuplicateNPCCollapsed           = "duplicate_npc_collapsed"
-	ReasonCodeRelationshipTargetCanonicalized = "relationship_target_canonicalized"
+	ReasonCodeNPCFieldsNormalized        = "npc_fields_normalized"
+	ReasonCodeNPCIDRecomputed            = "npc_id_recomputed"
+	ReasonCodeSourceReferencesNormalized = "source_references_normalized"
+	ReasonCodeDuplicateNPCCollapsed      = "duplicate_npc_collapsed"
 )

 var requiredCapabilities = []string{"merged"}
@@ -37,23 +36,17 @@ var _ contracts.ManifestMetadataProvider = (*Normalizer)(nil)
 var _ pipeline.CheckpointFingerprintProvider = (*Normalizer)(nil)

 type Options struct{}
-
 type Normalizer struct{}

-func New(Options) *Normalizer { return &Normalizer{} }
-
-func (n *Normalizer) Key() string { return Key }
-
+func New(Options) *Normalizer                                   { return &Normalizer{} }
+func (n *Normalizer) Key() string                               { return Key }
 func (n *Normalizer) ReferenceSlots() []contracts.ReferenceSlot { return nil }

 func (n *Normalizer) ManifestMetadata() map[string]any {
 	if n == nil {
 		return nil
 	}
-	return map[string]any{
-		"identity_policy":      identity.Policy,
-		"normalization_policy": normalizationPolicy,
-	}
+	return map[string]any{"identity_policy": identity.Policy, "normalization_policy": normalizationPolicy}
 }

 func (n *Normalizer) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
@@ -76,193 +69,106 @@ func (n *Normalizer) Normalize(ctx context.Context, req contracts.TypedNormalize
 	if err := ctx.Err(); err != nil {
 		return contracts.TypedNormalizeResult[dnd.NPCList]{}, normalizerErrorf("context error before normalize: %w", err)
 	}
-
 	value, warnings := normalizeList(req.MergeOutput.Value)
 	return contracts.TypedNormalizeResult[dnd.NPCList]{Value: value, Warnings: warnings}, nil
 }

 type normalizedRecord struct {
-	npc               dnd.NPC
-	fieldsChanged     bool
-	referencesChanged bool
+	npc dnd.NPC
 }

 func normalizeList(input dnd.NPCList) (dnd.NPCList, []contracts.Warning) {
 	if input.NPCs == nil {
 		return dnd.NPCList{}, nil
 	}
-
 	records := make([]normalizedRecord, len(input.NPCs))
 	warnings := make([]contracts.Warning, 0)
 	for index, inputNPC := range input.NPCs {
 		npc, fieldsChanged, referencesChanged := normalizeRecord(inputNPC)
-		records[index] = normalizedRecord{
-			npc:               npc,
-			fieldsChanged:     fieldsChanged,
-			referencesChanged: referencesChanged,
-		}
+		records[index] = normalizedRecord{npc: npc}
 		if fieldsChanged {
-			warnings = append(warnings, contracts.Warning{
-				Scope:      npcScope(index),
-				ReasonCode: ReasonCodeNPCFieldsNormalized,
-				Message: fmt.Sprintf("input index %d: NPC fields normalized for %s",
-					index, diagnostics.Quote(inputNPC.Name)),
-			})
+			warnings = append(warnings, contracts.Warning{Scope: npcScope(index), ReasonCode: ReasonCodeNPCFieldsNormalized, Message: fmt.Sprintf("input index %d: NPC name normalized for %s", index, diagnostics.Quote(inputNPC.Name))})
 		}
 		if referencesChanged {
-			warnings = append(warnings, contracts.Warning{
-				Scope:      npcScope(index),
-				ReasonCode: ReasonCodeSourceReferencesNormalized,
-				Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)",
-					index, len(inputNPC.SourceRefs), len(npc.SourceRefs)),
-			})
+			warnings = append(warnings, contracts.Warning{Scope: npcScope(index), ReasonCode: ReasonCodeSourceReferencesNormalized, Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)", index, len(inputNPC.SourceRefs), len(npc.SourceRefs))})
 		}
 		if inputNPC.ID != npc.ID {
-			warnings = append(warnings, contracts.Warning{
-				Scope:      npcScope(index),
-				ReasonCode: ReasonCodeNPCIDRecomputed,
-				Message: fmt.Sprintf("input index %d: NPC ID recomputed from %s",
-					index, diagnostics.Quote(npc.Name)),
-			})
+			warnings = append(warnings, contracts.Warning{Scope: npcScope(index), ReasonCode: ReasonCodeNPCIDRecomputed, Message: fmt.Sprintf("input index %d: NPC ID recomputed from %s", index, diagnostics.Quote(npc.Name))})
 		}
 	}

-	components := identityComponents(records)
-	output := dnd.NPCList{NPCs: make([]dnd.NPC, 0, len(components))}
-	retainedIndexes := make([]int, 0, len(components))
-	for _, members := range components {
-		consolidated, sourceChanged := consolidate(records, members)
+	groups := canonicalNameGroups(records)
+	output := dnd.NPCList{NPCs: make([]dnd.NPC, 0, len(groups))}
+	for _, members := range groups {
+		consolidated, referencesChanged := consolidate(records, members)
 		retainedIndex := members[0]
 		output.NPCs = append(output.NPCs, consolidated)
-		retainedIndexes = append(retainedIndexes, retainedIndex)
-
-		if sourceChanged {
-			warnings = append(warnings, contracts.Warning{
-				Scope:      npcScope(retainedIndex),
-				ReasonCode: ReasonCodeSourceReferencesNormalized,
-				Message: fmt.Sprintf("input index %d: source references normalized during identity consolidation (final count %d)",
-					retainedIndex, len(consolidated.SourceRefs)),
-			})
+		if referencesChanged {
+			warnings = append(warnings, contracts.Warning{Scope: npcScope(retainedIndex), ReasonCode: ReasonCodeSourceReferencesNormalized, Message: fmt.Sprintf("input index %d: source references normalized during identity consolidation (final count %d)", retainedIndex, len(consolidated.SourceRefs))})
 		}
 		if len(members) > 1 {
 			warnings = append(warnings, duplicateWarning(retainedIndex, members[1:]))
 		}
 	}
-
-	warnings = append(warnings, canonicalizeRelationshipTargets(&output, retainedIndexes)...)
 	return output, warnings
 }

 func normalizeRecord(input dnd.NPC) (dnd.NPC, bool, bool) {
 	output := cloneNPC(input)
 	output.Name = identity.NormalizeDisplay(input.Name)
-	output.Aliases = normalizeAliases(input.Aliases, output.Name)
-	output.Description = strings.TrimSpace(input.Description)
-	output.Relationships = normalizeRelationships(input.Relationships)
 	output.SourceRefs, _, _ = canonicalizeSourceRefs(input.SourceRefs)
 	output.ID = identity.DeriveID(output.Name)
-
-	fieldsChanged := input.Name != output.Name ||
-		!reflect.DeepEqual(input.Aliases, output.Aliases) ||
-		input.Description != output.Description ||
-		!reflect.DeepEqual(input.Relationships, output.Relationships)
-	referencesChanged := !reflect.DeepEqual(input.SourceRefs, output.SourceRefs)
-	return output, fieldsChanged, referencesChanged
+	return output, input.Name != output.Name, !reflect.DeepEqual(input.SourceRefs, output.SourceRefs)
 }

 func cloneNPC(input dnd.NPC) dnd.NPC {
-	output := input
-	if input.Aliases != nil {
-		output.Aliases = make([]string, len(input.Aliases))
-		copy(output.Aliases, input.Aliases)
-	}
-	if input.Relationships != nil {
-		output.Relationships = make([]dnd.NPCRelationship, len(input.Relationships))
-		copy(output.Relationships, input.Relationships)
-	}
-	if input.SourceRefs != nil {
-		output.SourceRefs = make([]source.SourceRef, len(input.SourceRefs))
-		copy(output.SourceRefs, input.SourceRefs)
-	}
-	return output
+	input.SourceRefs = cloneSourceRefs(input.SourceRefs)
+	return input
 }

-func normalizeAliases(input []string, canonicalName string) []string {
-	if input == nil {
-		return nil
-	}
-
-	canonicalKey := identity.ComparisonKey(canonicalName)
-	output := make([]string, 0, len(input))
-	seen := make(map[string]struct{}, len(input))
-	for _, alias := range input {
-		normalized := identity.NormalizeDisplay(alias)
-		key := identity.ComparisonKey(normalized)
-		if canonicalKey != "" && key == canonicalKey {
-			continue
+func canonicalNameGroups(records []normalizedRecord) [][]int {
+	groups := make([][]int, 0, len(records))
+	ownerByKey := make(map[string]int, len(records))
+	for index, record := range records {
+		key := identity.ComparisonKey(record.npc.Name)
+		if key != "" {
+			if groupIndex, ok := ownerByKey[key]; ok {
+				groups[groupIndex] = append(groups[groupIndex], index)
+				continue
+			}
+			ownerByKey[key] = len(groups)
 		}
-		if _, exists := seen[key]; exists {
-			continue
-		}
-		seen[key] = struct{}{}
-		output = append(output, normalized)
+		groups = append(groups, []int{index})
 	}
-	return output
+	return groups
 }

-func normalizeRelationships(input []dnd.NPCRelationship) []dnd.NPCRelationship {
-	if input == nil {
-		return nil
-	}
-
-	output := make([]dnd.NPCRelationship, 0, len(input))
-	seen := make(map[relationshipIdentity]struct{}, len(input))
-	for _, relationship := range input {
-		normalized := dnd.NPCRelationship{
-			Target:       identity.NormalizeDisplay(relationship.Target),
-			Relationship: strings.TrimSpace(relationship.Relationship),
-		}
-		key := relationshipKey(normalized)
-		if _, exists := seen[key]; exists {
-			continue
-		}
-		seen[key] = struct{}{}
-		output = append(output, normalized)
-	}
-	return output
-}
-
-type relationshipIdentity struct {
-	target       string
-	relationship string
-}
-
-func relationshipKey(relationship dnd.NPCRelationship) relationshipIdentity {
-	return relationshipIdentity{
-		target:       identity.ComparisonKey(relationship.Target),
-		relationship: identity.ComparisonKey(relationship.Relationship),
+func consolidate(records []normalizedRecord, members []int) (dnd.NPC, bool) {
+	output := cloneNPC(records[members[0]].npc)
+	originalRefs := cloneSourceRefs(output.SourceRefs)
+	for _, member := range members[1:] {
+		output.SourceRefs = append(output.SourceRefs, records[member].npc.SourceRefs...)
 	}
+	output.SourceRefs, _, _ = canonicalizeSourceRefs(output.SourceRefs)
+	output.ID = identity.DeriveID(output.Name)
+	return output, !reflect.DeepEqual(originalRefs, output.SourceRefs)
 }

 func canonicalizeSourceRefs(input []source.SourceRef) ([]source.SourceRef, bool, int) {
 	if input == nil {
 		return nil, false, 0
 	}
-
-	canonical := make([]source.SourceRef, len(input))
-	copy(canonical, input)
+	canonical := cloneSourceRefs(input)
 	sort.SliceStable(canonical, func(left, right int) bool {
-		return sourceRefLess(canonical[left], canonical[right])
-	})
-
-	orderChanged := false
-	for index := range input {
-		if input[index] != canonical[index] {
-			orderChanged = true
-			break
+		if canonical[left].SourceID != canonical[right].SourceID {
+			return canonical[left].SourceID < canonical[right].SourceID
 		}
-	}
-
+		if canonical[left].StartUnitID != canonical[right].StartUnitID {
+			return canonical[left].StartUnitID < canonical[right].StartUnitID
+		}
+		return canonical[left].EndUnitID < canonical[right].EndUnitID
+	})
+	orderChanged := !reflect.DeepEqual(input, canonical)
 	unique := make([]source.SourceRef, 0, len(canonical))
 	for _, ref := range canonical {
 		if len(unique) == 0 || unique[len(unique)-1] != ref {
@@ -272,219 +178,11 @@ func canonicalizeSourceRefs(input []source.SourceRef) ([]source.SourceRef, bool,
 	return unique, orderChanged, len(input) - len(unique)
 }

-func sourceRefLess(left, right source.SourceRef) bool {
-	if left.SourceID != right.SourceID {
-		return left.SourceID < right.SourceID
-	}
-	if left.StartUnitID != right.StartUnitID {
-		return left.StartUnitID < right.StartUnitID
-	}
-	return left.EndUnitID < right.EndUnitID
-}
-
-func identityComponents(records []normalizedRecord) [][]int {
-	parent := make([]int, len(records))
-	for index := range parent {
-		parent[index] = index
-	}
-
-	for left := 0; left < len(records); left++ {
-		for right := left + 1; right < len(records); right++ {
-			if recordsCanMerge(records[left].npc, records[right].npc) {
-				union(parent, left, right)
-			}
-		}
-	}
-
-	byRoot := make(map[int][]int, len(records))
-	for index := range records {
-		root := find(parent, index)
-		byRoot[root] = append(byRoot[root], index)
-	}
-	roots := make([]int, 0, len(byRoot))
-	for root := range byRoot {
-		roots = append(roots, root)
-	}
-	sort.Slice(roots, func(left, right int) bool {
-		return byRoot[roots[left]][0] < byRoot[roots[right]][0]
-	})
-
-	components := make([][]int, 0, len(roots))
-	for _, root := range roots {
-		components = append(components, byRoot[root])
-	}
-	return components
-}
-
-func recordsCanMerge(left, right dnd.NPC) bool {
-	leftCanonical := identity.ComparisonKey(left.Name)
-	rightCanonical := identity.ComparisonKey(right.Name)
-	return leftCanonical == rightCanonical ||
-		containsAliasKey(right.Aliases, leftCanonical) ||
-		containsAliasKey(left.Aliases, rightCanonical)
-}
-
-func containsAliasKey(aliases []string, wanted string) bool {
-	for _, alias := range aliases {
-		if identity.ComparisonKey(alias) == wanted {
-			return true
-		}
-	}
-	return false
-}
-
-func find(parent []int, index int) int {
-	for parent[index] != index {
-		parent[index] = parent[parent[index]]
-		index = parent[index]
-	}
-	return index
-}
-
-func union(parent []int, left, right int) {
-	leftRoot := find(parent, left)
-	rightRoot := find(parent, right)
-	if leftRoot == rightRoot {
-		return
-	}
-	if leftRoot < rightRoot {
-		parent[rightRoot] = leftRoot
-	} else {
-		parent[leftRoot] = rightRoot
-	}
-}
-
-func consolidate(records []normalizedRecord, members []int) (dnd.NPC, bool) {
-	output := cloneNPC(records[members[0]].npc)
-	originalRefs := cloneSourceRefs(output.SourceRefs)
-	canonicalKey := identity.ComparisonKey(output.Name)
-
-	for _, member := range members[1:] {
-		candidate := records[member].npc
-		appendAlias(&output.Aliases, candidate.Name, canonicalKey)
-		for _, alias := range candidate.Aliases {
-			appendAlias(&output.Aliases, alias, canonicalKey)
-		}
-		for _, relationship := range candidate.Relationships {
-			appendRelationship(&output.Relationships, relationship)
-		}
-		output.SourceRefs = append(output.SourceRefs, candidate.SourceRefs...)
-	}
-
-	output.SourceRefs, _, _ = canonicalizeSourceRefs(output.SourceRefs)
-	output.ID = identity.DeriveID(output.Name)
-	return output, !reflect.DeepEqual(originalRefs, output.SourceRefs)
-}
-
 func cloneSourceRefs(input []source.SourceRef) []source.SourceRef {
 	if input == nil {
 		return nil
 	}
-	output := make([]source.SourceRef, len(input))
-	copy(output, input)
-	return output
-}
-
-func appendAlias(aliases *[]string, value, canonicalKey string) {
-	key := identity.ComparisonKey(value)
-	if canonicalKey != "" && key == canonicalKey {
-		return
-	}
-	for _, existing := range *aliases {
-		if identity.ComparisonKey(existing) == key {
-			return
-		}
-	}
-	*aliases = append(*aliases, value)
-}
-
-func appendRelationship(relationships *[]dnd.NPCRelationship, relationship dnd.NPCRelationship) {
-	key := relationshipKey(relationship)
-	for _, existing := range *relationships {
-		if relationshipKey(existing) == key {
-			return
-		}
-	}
-	*relationships = append(*relationships, relationship)
-}
-
-func canonicalizeRelationshipTargets(list *dnd.NPCList, retainedIndexes []int) []contracts.Warning {
-	if list == nil || len(list.NPCs) == 0 {
-		return nil
-	}
-
-	owners := make(map[string][]int)
-	for index, npc := range list.NPCs {
-		if key := identity.ComparisonKey(npc.Name); key != "" {
-			owners[key] = append(owners[key], index)
-		}
-		for _, alias := range npc.Aliases {
-			if key := identity.ComparisonKey(alias); key != "" {
-				owners[key] = appendUniqueIndex(owners[key], index)
-			}
-		}
-	}
-
-	warnings := make([]contracts.Warning, 0)
-	for outputIndex := range list.NPCs {
-		npc := &list.NPCs[outputIndex]
-		originalRelationshipCount := len(npc.Relationships)
-		for relationshipIndex := range npc.Relationships {
-			relationship := &npc.Relationships[relationshipIndex]
-			key := identity.ComparisonKey(relationship.Target)
-			if key == "" || len(owners[key]) != 1 {
-				continue
-			}
-			target := list.NPCs[owners[key][0]].Name
-			if relationship.Target == target {
-				continue
-			}
-			oldTarget := relationship.Target
-			relationship.Target = target
-			warnings = append(warnings, contracts.Warning{
-				Scope:      npcScope(retainedIndexes[outputIndex]),
-				ReasonCode: ReasonCodeRelationshipTargetCanonicalized,
-				Message: fmt.Sprintf("input index %d: relationship target canonicalized from %s to %s",
-					retainedIndexes[outputIndex], diagnostics.Quote(oldTarget), diagnostics.Quote(target)),
-			})
-		}
-		npc.Relationships = deduplicateRelationships(npc.Relationships)
-		if len(npc.Relationships) != originalRelationshipCount {
-			warnings = append(warnings, contracts.Warning{
-				Scope:      npcScope(retainedIndexes[outputIndex]),
-				ReasonCode: ReasonCodeNPCFieldsNormalized,
-				Message: fmt.Sprintf("input index %d: duplicate relationships removed after target canonicalization",
-					retainedIndexes[outputIndex]),
-			})
-		}
-	}
-	return warnings
-}
-
-func deduplicateRelationships(input []dnd.NPCRelationship) []dnd.NPCRelationship {
-	if input == nil {
-		return nil
-	}
-	output := make([]dnd.NPCRelationship, 0, len(input))
-	seen := make(map[relationshipIdentity]struct{}, len(input))
-	for _, relationship := range input {
-		key := relationshipKey(relationship)
-		if _, exists := seen[key]; exists {
-			continue
-		}
-		seen[key] = struct{}{}
-		output = append(output, relationship)
-	}
-	return output
-}
-
-func appendUniqueIndex(values []int, wanted int) []int {
-	for _, value := range values {
-		if value == wanted {
-			return values
-		}
-	}
-	return append(values, wanted)
+	return append([]source.SourceRef(nil), input...)
 }

 func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
@@ -497,28 +195,17 @@ func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
 	for index, removedIndex := range displayed {
 		indices[index] = strconv.Itoa(removedIndex)
 	}
-
 	message := fmt.Sprintf("retained input index %d; removed input indices [%s]", retainedIndex, strings.Join(indices, ", "))
 	if omitted := len(removed) - len(displayed); omitted > 0 {
 		message += fmt.Sprintf("; %d additional removed input indices omitted", omitted)
 	}
-	return contracts.Warning{
-		Scope:      npcScope(retainedIndex),
-		ReasonCode: ReasonCodeDuplicateNPCCollapsed,
-		Message:    message,
-	}
+	return contracts.Warning{Scope: npcScope(retainedIndex), ReasonCode: ReasonCodeDuplicateNPCCollapsed, Message: message}
 }

 func npcScope(index int) string { return fmt.Sprintf("npcs[%d]", index) }

 func ModuleSpec() pipeline.ModuleSpec {
-	return pipeline.ModuleSpec{
-		Key:          Key,
-		Stage:        pipeline.StageNormalize,
-		Requires:     append([]string(nil), requiredCapabilities...),
-		Provides:     append([]string(nil), providedCapabilities...),
-		ArtifactKind: dnd.NPCListKind,
-	}
+	return pipeline.ModuleSpec{Key: Key, Stage: pipeline.StageNormalize, Requires: append([]string(nil), requiredCapabilities...), Provides: append([]string(nil), providedCapabilities...), ArtifactKind: dnd.NPCListKind}
 }

 func Register(registry *pipeline.NormalizerRegistry) error {
@@ -531,10 +218,7 @@ func Register(registry *pipeline.NormalizerRegistry) error {
 	})
 }

-func validateOptions(options map[string]any) error {
-	_, err := DecodeOptions(options)
-	return err
-}
+func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }

 func DecodeOptions(options map[string]any) (Options, error) {
 	if err := pipeline.RejectUnknownOptions(options); err != nil {
--- a/internal/modules/dnd/normalize/npcs/normalizer_test.go
+++ b/internal/modules/dnd/normalize/npcs/normalizer_test.go
@@ -10,223 +10,91 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
-	identity "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
 )

 func TestModuleContractAndIdentity(t *testing.T) {
 	if _, err := DecodeOptions(nil); err != nil {
 		t.Fatalf("DecodeOptions(nil) error = %v, want nil", err)
 	}
-	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil || !strings.Contains(err.Error(), "unknown option") {
-		t.Fatalf("DecodeOptions() error = %v, want unknown option error", err)
-	}
-
-	want := pipeline.ModuleSpec{
-		Key:          Key,
-		Stage:        pipeline.StageNormalize,
-		Requires:     []string{"merged"},
-		Provides:     []string{"normalized"},
-		ArtifactKind: dnd.NPCListKind,
+	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil {
+		t.Fatal("DecodeOptions() accepted unknown option")
 	}
+	want := pipeline.ModuleSpec{Key: Key, Stage: pipeline.StageNormalize, Requires: []string{"merged"}, Provides: []string{"normalized"}, ArtifactKind: dnd.NPCListKind}
 	if got := ModuleSpec(); !reflect.DeepEqual(got, want) {
 		t.Fatalf("ModuleSpec() = %#v, want %#v", got, want)
 	}
-	if slots := New(Options{}).ReferenceSlots(); slots != nil {
-		t.Fatalf("ReferenceSlots() = %#v, want nil", slots)
-	}
-
 	registry := pipeline.NewNormalizerRegistry()
 	if err := Register(registry); err != nil {
-		t.Fatalf("Register() error = %v, want nil", err)
+		t.Fatalf("Register() error = %v", err)
 	}
-	if registered, ok := registry.SpecForArtifact(Key, dnd.NPCListKind); !ok || !reflect.DeepEqual(registered, want) {
-		t.Fatalf("registered spec = %#v, ok = %t, want %#v", registered, ok, want)
-	}
-	if err := Register(nil); err == nil || !strings.Contains(err.Error(), "normalizer registry") {
-		t.Fatalf("Register(nil) error = %v, want registry error", err)
-	}
-
 	normalizer := New(Options{})
-	metadata := normalizer.ManifestMetadata()
-	if metadata["identity_policy"] != identity.Policy || metadata["normalization_policy"] != normalizationPolicy {
-		t.Fatalf("metadata = %#v, want identity and normalization policies", metadata)
+	if metadata := normalizer.ManifestMetadata(); metadata["identity_policy"] != identity.Policy || metadata["normalization_policy"] != normalizationPolicy {
+		t.Fatalf("metadata = %#v", metadata)
 	}
-	fingerprints := normalizer.CheckpointFingerprints()
-	wantFingerprints := []pipeline.CheckpointFingerprint{
-		{Name: "identity_policy", Value: identity.Policy},
-		{Name: "normalization_policy", Value: normalizationPolicy},
-	}
-	if !reflect.DeepEqual(fingerprints, wantFingerprints) {
-		t.Fatalf("fingerprints = %#v, want %#v", fingerprints, wantFingerprints)
-	}
-	fingerprints[0].Value = "changed"
+	wantFingerprints := []pipeline.CheckpointFingerprint{{Name: "identity_policy", Value: identity.Policy}, {Name: "normalization_policy", Value: normalizationPolicy}}
 	if got := normalizer.CheckpointFingerprints(); !reflect.DeepEqual(got, wantFingerprints) {
-		t.Fatalf("fingerprints were not defensive: %#v", got)
+		t.Fatalf("fingerprints = %#v, want %#v", got, wantFingerprints)
 	}
 }

-func TestNormalizePerRecordFieldsAndEvidence(t *testing.T) {
+func TestNormalizeNamesEvidenceAndIDs(t *testing.T) {
 	input := dnd.NPCList{NPCs: []dnd.NPC{{
-		ID:          "wrong",
-		Name:        "  Lady\tAsh  ",
-		Aliases:     []string{" Ash ", "  L.A. ", "l.a.", "  Lady Ash  "},
-		Description: "  first description\n",
-		Relationships: []dnd.NPCRelationship{
-			{Target: "  Lord\nOak ", Relationship: " friend "},
-			{Target: "lord oak", Relationship: "friend"},
-		},
-		SourceRefs: []source.SourceRef{
+		ID: "wrong", Name: "  Lady\tAsh  ", SourceRefs: []source.SourceRef{
 			{SourceID: "b", StartUnitID: 2, EndUnitID: 3},
 			{SourceID: "a", StartUnitID: 4, EndUnitID: 4},
 			{SourceID: "b", StartUnitID: 2, EndUnitID: 3},
 		},
 	}}}
-
 	result, err := New(Options{}).Normalize(context.Background(), normalizeRequest(input))
 	if err != nil {
-		t.Fatalf("Normalize() error = %v, want nil", err)
+		t.Fatalf("Normalize() error = %v", err)
 	}
-	got := result.Value.NPCs[0]
-	if got.Name != "Lady Ash" || got.Description != "first description" {
-		t.Fatalf("normalized fields = %#v, want normalized display and description", got)
+	want := dnd.NPC{ID: identity.DeriveID("Lady Ash"), Name: "Lady Ash", SourceRefs: []source.SourceRef{{SourceID: "a", StartUnitID: 4, EndUnitID: 4}, {SourceID: "b", StartUnitID: 2, EndUnitID: 3}}}
+	if !reflect.DeepEqual(result.Value.NPCs[0], want) {
+		t.Fatalf("NPC = %#v, want %#v", result.Value.NPCs[0], want)
 	}
-	if !reflect.DeepEqual(got.Aliases, []string{"Ash", "L.A."}) {
-		t.Fatalf("aliases = %#v, want canonical alias removal and deduplication", got.Aliases)
-	}
-	wantRelationships := []dnd.NPCRelationship{{Target: "Lord Oak", Relationship: "friend"}}
-	if !reflect.DeepEqual(got.Relationships, wantRelationships) {
-		t.Fatalf("relationships = %#v, want %#v", got.Relationships, wantRelationships)
-	}
-	wantRefs := []source.SourceRef{
-		{SourceID: "a", StartUnitID: 4, EndUnitID: 4},
-		{SourceID: "b", StartUnitID: 2, EndUnitID: 3},
-	}
-	if !reflect.DeepEqual(got.SourceRefs, wantRefs) {
-		t.Fatalf("source refs = %#v, want %#v", got.SourceRefs, wantRefs)
-	}
-	if got.ID != identity.DeriveID("Lady Ash") {
-		t.Fatalf("ID = %q, want derived ID", got.ID)
-	}
-	if !hasWarning(result.Warnings, ReasonCodeNPCFieldsNormalized, "npcs[0]") ||
-		!hasWarning(result.Warnings, ReasonCodeSourceReferencesNormalized, "npcs[0]") ||
-		!hasWarning(result.Warnings, ReasonCodeNPCIDRecomputed, "npcs[0]") {
-		t.Fatalf("warnings = %#v, want field, source, and ID warnings", result.Warnings)
+	for _, reason := range []string{ReasonCodeNPCFieldsNormalized, ReasonCodeSourceReferencesNormalized, ReasonCodeNPCIDRecomputed} {
+		if !hasWarning(result.Warnings, reason, "npcs[0]") {
+			t.Fatalf("warnings = %#v, want %s", result.Warnings, reason)
+		}
 	}
 }

-func TestNormalizeConsolidatesIdentityComponentsInStableOrder(t *testing.T) {
+func TestNormalizeConsolidatesCanonicalNamesOnlyAndUnionsEvidence(t *testing.T) {
 	input := dnd.NPCList{NPCs: []dnd.NPC{
-		{
-			Name:          " Captain Vale ",
-			Description:   "first description",
-			Aliases:       []string{"Vale"},
-			Relationships: []dnd.NPCRelationship{{Target: "Archivist", Relationship: "knows"}},
-			SourceRefs:    []source.SourceRef{{SourceID: "a", StartUnitID: 1, EndUnitID: 1}},
-		},
-		{
-			Name:        "Captain Vale",
-			Description: "second description",
-			Aliases:     []string{"CV"},
-			SourceRefs:  []source.SourceRef{{SourceID: "b", StartUnitID: 1, EndUnitID: 1}},
-		},
-		{
-			Name:        "The Sage",
-			Description: "sage description",
-			Aliases:     []string{"Archivist"},
-			SourceRefs:  []source.SourceRef{{SourceID: "c", StartUnitID: 1, EndUnitID: 1}},
-		},
-		{
-			Name:        "Archivist",
-			Description: "later sage description",
-			Aliases:     []string{"Chronicler"},
-			SourceRefs:  []source.SourceRef{{SourceID: "d", StartUnitID: 1, EndUnitID: 1}},
-		},
-		{
-			Name:        "North",
-			Description: "north description",
-			SourceRefs:  []source.SourceRef{{SourceID: "e", StartUnitID: 1, EndUnitID: 1}},
-		},
-		{
-			Name:        "North Old",
-			Description: "old north description",
-			Aliases:     []string{"North"},
-			SourceRefs:  []source.SourceRef{{SourceID: "f", StartUnitID: 1, EndUnitID: 1}},
-		},
-		{
-			Name:        "North Renamed",
-			Description: "renamed north description",
-			Aliases:     []string{"North Old"},
-			SourceRefs:  []source.SourceRef{{SourceID: "g", StartUnitID: 1, EndUnitID: 1}},
-		},
-		{Name: "Red", Description: "red", Aliases: []string{"Shared"}, SourceRefs: []source.SourceRef{{SourceID: "h", StartUnitID: 1, EndUnitID: 1}}},
-		{Name: "Blue", Description: "blue", Aliases: []string{"Shared"}, SourceRefs: []source.SourceRef{{SourceID: "i", StartUnitID: 1, EndUnitID: 1}}},
+		{Name: " Captain Vale ", SourceRefs: []source.SourceRef{{SourceID: "a", StartUnitID: 1, EndUnitID: 1}}},
+		{Name: "captain vale", SourceRefs: []source.SourceRef{{SourceID: "b", StartUnitID: 2, EndUnitID: 2}}},
+		{Name: "The Captain", SourceRefs: []source.SourceRef{{SourceID: "c", StartUnitID: 3, EndUnitID: 3}}},
 	}}
-
 	result, err := New(Options{}).Normalize(context.Background(), normalizeRequest(input))
 	if err != nil {
-		t.Fatalf("Normalize() error = %v, want nil", err)
+		t.Fatalf("Normalize() error = %v", err)
 	}
-	if got := len(result.Value.NPCs); got != 5 {
-		t.Fatalf("normalized NPC count = %d, want five components", got)
+	if len(result.Value.NPCs) != 2 || result.Value.NPCs[0].Name != "Captain Vale" || result.Value.NPCs[1].Name != "The Captain" {
+		t.Fatalf("NPCs = %#v, want name-only stable consolidation", result.Value.NPCs)
 	}
-
-	first := result.Value.NPCs[0]
-	if first.Name != "Captain Vale" || first.Description != "first description" || !reflect.DeepEqual(first.Aliases, []string{"Vale", "CV"}) {
-		t.Fatalf("first component = %#v, want first description and ordered aliases", first)
+	if refs := result.Value.NPCs[0].SourceRefs; len(refs) != 2 || refs[0].SourceID != "a" || refs[1].SourceID != "b" {
+		t.Fatalf("source refs = %#v, want evidence union", refs)
 	}
-	if !reflect.DeepEqual(first.SourceRefs, []source.SourceRef{
-		{SourceID: "a", StartUnitID: 1, EndUnitID: 1},
-		{SourceID: "b", StartUnitID: 1, EndUnitID: 1},
-	}) {
-		t.Fatalf("first provenance = %#v, want unioned refs", first.SourceRefs)
-	}
-
-	second := result.Value.NPCs[1]
-	if second.Name != "The Sage" || !reflect.DeepEqual(second.Aliases, []string{"Archivist", "Chronicler"}) || second.Description != "sage description" {
-		t.Fatalf("canonical-to-alias component = %#v, want consolidated sage", second)
-	}
-	if first.Relationships[0].Target != "The Sage" {
-		t.Fatalf("relationship target = %q, want The Sage", first.Relationships[0].Target)
-	}
-	if !hasWarning(result.Warnings, ReasonCodeRelationshipTargetCanonicalized, "npcs[0]") ||
-		!hasWarning(result.Warnings, ReasonCodeDuplicateNPCCollapsed, "npcs[0]") ||
-		!hasWarning(result.Warnings, ReasonCodeDuplicateNPCCollapsed, "npcs[2]") {
-		t.Fatalf("warnings = %#v, want collapse and target warnings", result.Warnings)
-	}
-
-	if got := result.Value.NPCs[2].Aliases; !reflect.DeepEqual(got, []string{"North Old", "North Renamed"}) {
-		t.Fatalf("transitive aliases = %#v, want ordered canonical members", got)
-	}
-	if result.Value.NPCs[3].Name != "Red" || result.Value.NPCs[4].Name != "Blue" {
-		t.Fatalf("shared-alias ordering = %#v, want Red then Blue", result.Value.NPCs[3:])
+	if !hasWarning(result.Warnings, ReasonCodeDuplicateNPCCollapsed, "npcs[0]") {
+		t.Fatalf("warnings = %#v, want duplicate collapse", result.Warnings)
 	}
 }

-func TestNormalizePreservesInvalidEvidenceAndDoesNotAliasInput(t *testing.T) {
-	invalid := dnd.NPCList{NPCs: []dnd.NPC{{
-		Name:          " ",
-		Aliases:       []string{""},
-		Description:   " ",
-		Relationships: []dnd.NPCRelationship{{Target: " ", Relationship: " "}},
-		SourceRefs:    []source.SourceRef{{SourceID: "source", StartUnitID: 9, EndUnitID: 9}},
-	}}}
-	original := cloneNPCListForTest(invalid)
-	result, err := New(Options{}).Normalize(context.Background(), normalizeRequest(invalid))
-	if err != nil {
-		t.Fatalf("Normalize() error = %v, want nil", err)
+func TestNormalizePreservesInvalidCandidatesAndDoesNotAliasInput(t *testing.T) {
+	input := dnd.NPCList{NPCs: []dnd.NPC{{Name: " ", SourceRefs: []source.SourceRef{{SourceID: "source", StartUnitID: 0, EndUnitID: -1}}}}}
+	before := dnd.NPCList{NPCs: []dnd.NPC{{Name: " ", SourceRefs: []source.SourceRef{{SourceID: "source", StartUnitID: 0, EndUnitID: -1}}}}}
+	result, err := New(Options{}).Normalize(context.Background(), normalizeRequest(input))
+	if err != nil || !reflect.DeepEqual(input, before) {
+		t.Fatalf("Normalize() = %#v, %v; input mutated to %#v", result, err, input)
 	}
-	if !reflect.DeepEqual(invalid, original) {
-		t.Fatalf("normalizer mutated input: got %#v, want %#v", invalid, original)
+	if result.Value.NPCs[0].Name != "" || result.Value.NPCs[0].SourceRefs[0].EndUnitID != -1 {
+		t.Fatalf("candidate = %#v, want invalid semantics preserved", result.Value.NPCs[0])
 	}
-	if result.Value.NPCs[0].Name != "" || result.Value.NPCs[0].Aliases[0] != "" || result.Value.NPCs[0].Relationships[0].Target != "" {
-		t.Fatalf("invalid evidence was unexpectedly removed: %#v", result.Value.NPCs[0])
-	}
-
-	result.Value.NPCs[0].Aliases[0] = "changed"
-	result.Value.NPCs[0].Relationships[0].Target = "changed"
 	result.Value.NPCs[0].SourceRefs[0].SourceID = "changed"
-	if invalid.NPCs[0].Aliases[0] != "" || invalid.NPCs[0].Relationships[0].Target != " " || invalid.NPCs[0].SourceRefs[0].SourceID != "source" {
-		t.Fatalf("output aliases input storage: input = %#v", invalid)
+	if input.NPCs[0].SourceRefs[0].SourceID != "source" {
+		t.Fatal("output aliases input evidence")
 	}
 }

@@ -234,52 +102,17 @@ func TestNormalizeHandlesNilAndCanceledCalls(t *testing.T) {
 	normalizer := New(Options{})
 	result, err := normalizer.Normalize(context.Background(), normalizeRequest(dnd.NPCList{NPCs: nil}))
 	if err != nil || result.Value.NPCs != nil {
-		t.Fatalf("nil list result = %#v, error = %v, want nil NPC slice", result.Value, err)
+		t.Fatalf("nil list result = %#v, error = %v", result.Value, err)
 	}
 	canceled, cancel := context.WithCancel(context.Background())
 	cancel()
 	if _, err := normalizer.Normalize(canceled, normalizeRequest(dnd.NPCList{})); err == nil || !strings.Contains(err.Error(), "context error") {
-		t.Fatalf("canceled Normalize() error = %v, want context error", err)
-	}
-	if _, err := normalizer.Normalize(nil, normalizeRequest(dnd.NPCList{})); err == nil || !strings.Contains(err.Error(), "context must not be nil") {
-		t.Fatalf("nil context Normalize() error = %v, want context error", err)
-	}
-	var nilNormalizer *Normalizer
-	if _, err := nilNormalizer.Normalize(context.Background(), normalizeRequest(dnd.NPCList{})); err == nil {
-		t.Fatal("nil normalizer Normalize() error = nil, want error")
-	}
-}
-
-func TestNormalizePreservesPresentEmptyAliases(t *testing.T) {
-	result, err := New(Options{}).Normalize(context.Background(), normalizeRequest(dnd.NPCList{NPCs: []dnd.NPC{{
-		Name:        "Hooded Guard",
-		Aliases:     []string{},
-		Description: "A distinguishable sentry.",
-		SourceRefs:  []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}},
-	}}}))
-	if err != nil {
-		t.Fatalf("Normalize() error = %v, want nil", err)
-	}
-	if result.Value.NPCs[0].Aliases == nil || len(result.Value.NPCs[0].Aliases) != 0 {
-		t.Fatalf("aliases = %#v, want present empty array", result.Value.NPCs[0].Aliases)
+		t.Fatalf("canceled Normalize() error = %v", err)
 	}
 }

 func normalizeRequest(value dnd.NPCList) contracts.TypedNormalizeRequest[dnd.NPCList] {
-	return contracts.TypedNormalizeRequest[dnd.NPCList]{
-		MergeOutput: contracts.MergeArtifact[dnd.NPCList]{Value: value},
-	}
-}
-
-func cloneNPCListForTest(input dnd.NPCList) dnd.NPCList {
-	output := dnd.NPCList{}
-	if input.NPCs != nil {
-		output.NPCs = make([]dnd.NPC, len(input.NPCs))
-		for index, npc := range input.NPCs {
-			output.NPCs[index] = cloneNPC(npc)
-		}
-	}
-	return output
+	return contracts.TypedNormalizeRequest[dnd.NPCList]{MergeOutput: contracts.MergeArtifact[dnd.NPCList]{Value: value}}
 }

 func hasWarning(warnings []contracts.Warning, reason, scope string) bool {
--- a/internal/modules/dnd/npcs/identity/identity.go
+++ b/internal/modules/dnd/npcs/identity/identity.go
@@ -29,24 +29,17 @@ const idPrefix = "npc:sha256:"
 type IssueCode string

 const (
-	IssueEmptyCanonicalName      IssueCode = "empty_canonical_name"
-	IssueEmptyAlias              IssueCode = "empty_alias"
-	IssueInvalidID               IssueCode = "invalid_id"
-	IssueIDMismatch              IssueCode = "id_mismatch"
-	IssueDuplicateCanonical      IssueCode = "duplicate_canonical_identity"
-	IssueDuplicateID             IssueCode = "duplicate_id"
-	IssueDuplicateAlias          IssueCode = "duplicate_alias"
-	IssueOwnCanonicalAlias       IssueCode = "alias_matches_canonical_name"
-	IssueAliasCanonicalCollision IssueCode = "alias_canonical_collision"
-	IssueAliasOwnershipCollision IssueCode = "alias_owned_by_multiple_records"
+	IssueEmptyCanonicalName IssueCode = "empty_canonical_name"
+	IssueInvalidID          IssueCode = "invalid_id"
+	IssueIDMismatch         IssueCode = "id_mismatch"
+	IssueDuplicateCanonical IssueCode = "duplicate_canonical_identity"
+	IssueDuplicateID        IssueCode = "duplicate_id"
 )

-// Issue is an inspectable identity validation problem. AliasIndex is -1 when
-// the issue applies to an NPC as a whole rather than a particular alias.
+// Issue is an inspectable identity validation problem.
 type Issue struct {
 	Code        IssueCode
 	RecordIndex int
-	AliasIndex  int
 	Value       string
 }

@@ -107,88 +100,35 @@ func ValidID(value string) bool { return IsValidID(value) }
 // It accepts the NPC slice used by typed pipeline artifacts. Use ValidateList
 // when the enclosing NPCList is more convenient at the call site.
 func ValidateRegistry(npcs []dnd.NPC) []Issue {
-	type record struct {
-		canonical string
-		aliases   []string
-	}
-
-	records := make([]record, len(npcs))
 	issues := make([]Issue, 0)
 	canonicalOwners := make(map[string][]int)
 	idOwners := make(map[string][]int)
-	aliasOwners := make(map[string][]int)

 	for recordIndex, npc := range npcs {
 		canonical := ComparisonKey(npc.Name)
-		records[recordIndex].canonical = canonical
 		if canonical == "" {
-			issues = append(issues, Issue{Code: IssueEmptyCanonicalName, RecordIndex: recordIndex, AliasIndex: -1, Value: npc.Name})
+			issues = append(issues, Issue{Code: IssueEmptyCanonicalName, RecordIndex: recordIndex, Value: npc.Name})
 		} else {
 			canonicalOwners[canonical] = append(canonicalOwners[canonical], recordIndex)
 		}

 		if !IsValidID(npc.ID) {
-			issues = append(issues, Issue{Code: IssueInvalidID, RecordIndex: recordIndex, AliasIndex: -1, Value: npc.ID})
+			issues = append(issues, Issue{Code: IssueInvalidID, RecordIndex: recordIndex, Value: npc.ID})
 		} else if expected := DeriveID(npc.Name); npc.ID != expected {
-			issues = append(issues, Issue{Code: IssueIDMismatch, RecordIndex: recordIndex, AliasIndex: -1, Value: npc.ID})
+			issues = append(issues, Issue{Code: IssueIDMismatch, RecordIndex: recordIndex, Value: npc.ID})
 		}
 		if npc.ID != "" {
 			idOwners[npc.ID] = append(idOwners[npc.ID], recordIndex)
 		}
-
-		seenAliases := make(map[string]int, len(npc.Aliases))
-		for aliasIndex, alias := range npc.Aliases {
-			key := ComparisonKey(alias)
-			records[recordIndex].aliases = append(records[recordIndex].aliases, key)
-			if key == "" {
-				issues = append(issues, Issue{Code: IssueEmptyAlias, RecordIndex: recordIndex, AliasIndex: aliasIndex, Value: alias})
-				continue
-			}
-			if _, ok := seenAliases[key]; ok {
-				issues = append(issues, Issue{Code: IssueDuplicateAlias, RecordIndex: recordIndex, AliasIndex: aliasIndex, Value: alias})
-			} else {
-				seenAliases[key] = aliasIndex
-			}
-			if key == canonical {
-				issues = append(issues, Issue{Code: IssueOwnCanonicalAlias, RecordIndex: recordIndex, AliasIndex: aliasIndex, Value: alias})
-			}
-			aliasOwners[key] = append(aliasOwners[key], recordIndex)
-		}
 	}

-	for recordIndex, record := range records {
-		if record.canonical != "" && len(canonicalOwners[record.canonical]) > 1 && canonicalOwners[record.canonical][0] != recordIndex {
-			issues = append(issues, Issue{Code: IssueDuplicateCanonical, RecordIndex: recordIndex, AliasIndex: -1, Value: npcs[recordIndex].Name})
+	for recordIndex, npc := range npcs {
+		canonical := ComparisonKey(npc.Name)
+		if canonical != "" && len(canonicalOwners[canonical]) > 1 && canonicalOwners[canonical][0] != recordIndex {
+			issues = append(issues, Issue{Code: IssueDuplicateCanonical, RecordIndex: recordIndex, Value: npc.Name})
 		}
-		if id := npcs[recordIndex].ID; id != "" && len(idOwners[id]) > 1 && idOwners[id][0] != recordIndex {
-			issues = append(issues, Issue{Code: IssueDuplicateID, RecordIndex: recordIndex, AliasIndex: -1, Value: id})
-		}
-	}
-
-	seenAliasKeys := make(map[string]struct{})
-	for _, record := range records {
-		for _, alias := range record.aliases {
-			if alias == "" {
-				continue
-			}
-			if _, alreadyProcessed := seenAliasKeys[alias]; alreadyProcessed {
-				continue
-			}
-			seenAliasKeys[alias] = struct{}{}
-			owners := uniqueIndexes(aliasOwners[alias])
-			if len(owners) > 1 {
-				for _, recordIndex := range owners {
-					issues = append(issues, Issue{Code: IssueAliasOwnershipCollision, RecordIndex: recordIndex, AliasIndex: aliasIndexFor(records[recordIndex].aliases, alias), Value: alias})
-				}
-			}
-			for _, recordIndex := range owners {
-				for _, canonicalOwner := range canonicalOwners[alias] {
-					if canonicalOwner != recordIndex {
-						issues = append(issues, Issue{Code: IssueAliasCanonicalCollision, RecordIndex: recordIndex, AliasIndex: aliasIndexFor(records[recordIndex].aliases, alias), Value: alias})
-						break
-					}
-				}
-			}
+		if npc.ID != "" && len(idOwners[npc.ID]) > 1 && idOwners[npc.ID][0] != recordIndex {
+			issues = append(issues, Issue{Code: IssueDuplicateID, RecordIndex: recordIndex, Value: npc.ID})
 		}
 	}

@@ -201,28 +141,6 @@ func ValidateList(list dnd.NPCList) []Issue { return ValidateRegistry(list.NPCs)
 // Validate is a convenience alias for ValidateList.
 func Validate(list dnd.NPCList) []Issue { return ValidateList(list) }

-func uniqueIndexes(values []int) []int {
-	seen := make(map[int]struct{}, len(values))
-	unique := make([]int, 0, len(values))
-	for _, value := range values {
-		if _, ok := seen[value]; ok {
-			continue
-		}
-		seen[value] = struct{}{}
-		unique = append(unique, value)
-	}
-	return unique
-}
-
-func aliasIndexFor(aliases []string, key string) int {
-	for index, alias := range aliases {
-		if alias == key {
-			return index
-		}
-	}
-	return -1
-}
-
 // Error makes an issue useful in simple callers while preserving its
 // structured fields for aggregate diagnostics.
 func (i Issue) Error() string {
--- a/internal/modules/dnd/npcs/identity/identity_test.go
+++ b/internal/modules/dnd/npcs/identity/identity_test.go
@@ -77,18 +77,13 @@ func TestIdentityFunctionsAreSafeForConcurrentUse(t *testing.T) {
 func TestValidateRegistryReportsIdentityCollisionCategories(t *testing.T) {
 	validID := DeriveID("Mira Thorn")
 	npcs := []dnd.NPC{
-		{ID: validID, Name: "Mira Thorn", Aliases: []string{"The Greencloak", "the greencloak", "Mira Thorn"}},
-		{ID: validID, Name: "Mira Thorn", Aliases: []string{"The Greencloak"}},
-		{ID: DeriveID("Captain Vale"), Name: "Captain Vale", Aliases: []string{"Mira Thorn"}},
+		{ID: validID, Name: "Mira Thorn"},
+		{ID: validID, Name: "Mira Thorn"},
 	}
 	issues := ValidateRegistry(npcs)
 	want := map[IssueCode]bool{
-		IssueDuplicateAlias:          false,
-		IssueOwnCanonicalAlias:       false,
-		IssueDuplicateCanonical:      false,
-		IssueDuplicateID:             false,
-		IssueAliasOwnershipCollision: false,
-		IssueAliasCanonicalCollision: false,
+		IssueDuplicateCanonical: false,
+		IssueDuplicateID:        false,
 	}
 	for _, issue := range issues {
 		if _, ok := want[issue.Code]; ok {
--- a/internal/modules/dnd/npcs/registry/registry.go
+++ b/internal/modules/dnd/npcs/registry/registry.go
@@ -5,6 +5,7 @@ package registry
 import (
 	"crypto/sha256"
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"mime"
 	"strings"
@@ -27,12 +28,13 @@ const (
 // Registry is an immutable, validated NPC registry prepared for prompt
 // grounding. All accessors return defensive copies.
 type Registry struct {
-	bound       bool
-	list        dnd.NPCList
-	canonical   []byte
-	digest      string
-	promptInput contracts.LLMInputMaterial
-	lookupByKey map[string]int
+	bound            bool
+	list             dnd.NPCList
+	canonical        []byte
+	digest           string
+	projectionDigest string
+	promptInput      contracts.LLMInputMaterial
+	lookupByKey      map[string]int
 }

 // Resolver retains only the validated construction-time registry and immutable
@@ -141,11 +143,13 @@ func Resolve(references contracts.ReferenceSet) (*Registry, error) {
 	slot, ok := references.Slots[ReferenceSlot]
 	if !ok {
 		content := []byte(emptyPrompt)
+		projectionDigest := semanticDigest(content)
 		return &Registry{
-			list:        dnd.NPCList{NPCs: []dnd.NPC{}},
-			canonical:   append([]byte(nil), content...),
-			promptInput: contracts.NewLLMInputMaterial(ReferenceSlot, npccodec.MediaType, content, "", ""),
-			lookupByKey: map[string]int{},
+			list:             dnd.NPCList{NPCs: []dnd.NPC{}},
+			canonical:        append([]byte(nil), content...),
+			projectionDigest: projectionDigest,
+			promptInput:      contracts.NewLLMInputMaterial(ReferenceSlot, npccodec.MediaType, content, projectionDigest, ""),
+			lookupByKey:      map[string]int{},
 		}, nil
 	}
 	if len(slot.Items) != 1 {
@@ -178,21 +182,24 @@ func Resolve(references contracts.ReferenceSet) (*Registry, error) {
 	}

 	list := cloneNPCList(value)
-	lookupByKey := make(map[string]int, len(list.NPCs)*2)
+	lookupByKey := make(map[string]int, len(list.NPCs))
 	for index, npc := range list.NPCs {
 		lookupByKey[identity.ComparisonKey(npc.Name)] = index
-		for _, alias := range npc.Aliases {
-			lookupByKey[identity.ComparisonKey(alias)] = index
-		}
 	}
 	digest := semanticDigest(content)
+	projection, err := nameProjection(list)
+	if err != nil {
+		return nil, fmt.Errorf("encode NPC name projection: %w", err)
+	}
+	projectionDigest := semanticDigest(projection)
 	return &Registry{
-		bound:       true,
-		list:        list,
-		canonical:   append([]byte(nil), content...),
-		digest:      digest,
-		promptInput: contracts.NewLLMInputMaterial(ReferenceSlot, npccodec.MediaType, content, digest, ""),
-		lookupByKey: lookupByKey,
+		bound:            true,
+		list:             list,
+		canonical:        append([]byte(nil), content...),
+		digest:           digest,
+		projectionDigest: projectionDigest,
+		promptInput:      contracts.NewLLMInputMaterial(ReferenceSlot, npccodec.MediaType, projection, projectionDigest, ""),
+		lookupByKey:      lookupByKey,
 	}, nil
 }

@@ -235,6 +242,15 @@ func (r *Registry) Digest() string {
 	return r.digest
 }

+// ProjectionDigest returns the SHA-256 digest of the exact names-only prompt
+// projection, including for an unbound or empty registry.
+func (r *Registry) ProjectionDigest() string {
+	if r == nil {
+		return ""
+	}
+	return r.projectionDigest
+}
+
 // Count returns the number of validated NPC records.
 func (r *Registry) Count() int {
 	if r == nil {
@@ -243,8 +259,8 @@ func (r *Registry) Count() int {
 	return len(r.list.NPCs)
 }

-// PromptInput returns the canonical registry as a content-safe prompt input.
-// Reference provenance is deliberately omitted.
+// PromptInput returns the names-only registry projection as a content-safe
+// prompt input. Durable IDs, evidence, and reference provenance are omitted.
 func (r *Registry) PromptInput() contracts.LLMInputMaterial {
 	if r == nil {
 		return contracts.LLMInputMaterial{}
@@ -252,8 +268,8 @@ func (r *Registry) PromptInput() contracts.LLMInputMaterial {
 	return r.promptInput.Clone()
 }

-// Lookup returns the canonical NPC for an exact canonical-name or alias match
-// under the NPC identity comparison policy.
+// Lookup returns the canonical NPC for an exact canonical-name match under the
+// NPC identity comparison policy.
 func (r *Registry) Lookup(value string) (dnd.NPC, bool) {
 	if r == nil {
 		return dnd.NPC{}, false
@@ -270,13 +286,26 @@ func semanticDigest(content []byte) string {
 	return "sha256:" + hex.EncodeToString(sum[:])
 }

+type projectedNPC struct {
+	Name string `json:"name"`
+}
+
+type projectedNPCList struct {
+	NPCs []projectedNPC `json:"npcs"`
+}
+
+func nameProjection(list dnd.NPCList) ([]byte, error) {
+	projection := projectedNPCList{NPCs: make([]projectedNPC, len(list.NPCs))}
+	for index, npc := range list.NPCs {
+		projection.NPCs[index] = projectedNPC{Name: npc.Name}
+	}
+	return json.Marshal(projection)
+}
+
 func formatIdentityIssues(issues []identity.Issue) string {
 	parts := make([]string, len(issues))
 	for index, issue := range issues {
 		location := fmt.Sprintf("record %d", issue.RecordIndex)
-		if issue.AliasIndex >= 0 {
-			location += fmt.Sprintf(" alias %d", issue.AliasIndex)
-		}
 		parts[index] = fmt.Sprintf("%s at %s", issue.Code, location)
 	}
 	return diagnostics.Aggregate("validate NPC registry identity", parts)
@@ -298,8 +327,6 @@ func cloneNPCs(values []dnd.NPC) []dnd.NPC {
 }

 func cloneNPC(value dnd.NPC) dnd.NPC {
-	value.Aliases = append([]string(nil), value.Aliases...)
-	value.Relationships = append([]dnd.NPCRelationship(nil), value.Relationships...)
 	value.SourceRefs = append([]source.SourceRef(nil), value.SourceRefs...)
 	return value
 }
--- a/internal/modules/dnd/npcs/registry/registry_test.go
+++ b/internal/modules/dnd/npcs/registry/registry_test.go
@@ -2,313 +2,162 @@ package registry

 import (
 	"bytes"
-	"encoding/json"
-	"fmt"
+	"reflect"
 	"strings"
-	"sync"
 	"testing"
-	"unicode/utf8"

 	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcs"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
-	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
 )

-func TestResolveAbsentRegistryUsesExactEmptyPrompt(t *testing.T) {
-	resolved, err := Resolve(contracts.ReferenceSet{})
+func TestResolveUnboundRegistryHasExactEmptyProjection(t *testing.T) {
+	registry, err := Resolve(contracts.ReferenceSet{})
 	if err != nil {
-		t.Fatalf("Resolve() error = %v, want nil", err)
+		t.Fatalf("Resolve() error = %v", err)
 	}
-	if resolved.Bound() || resolved.Digest() != "" || resolved.Count() != 0 {
-		t.Fatalf("resolved unbound registry = %#v, want no semantic metadata", resolved)
+	input := registry.PromptInput()
+	if registry.Bound() || registry.Digest() != "" || registry.Count() != 0 || string(input.Content) != emptyPrompt {
+		t.Fatalf("registry = %#v input = %#v, want unbound empty registry", registry, input)
 	}
-	input := resolved.PromptInput()
-	if input.Name != ReferenceSlot || input.MediaType != npccodec.MediaType || input.Digest != "" || input.OriginURI != "" {
-		t.Fatalf("unbound prompt input metadata = %#v, want name/media type only", input)
-	}
-	if got := string(input.Content); got != emptyPrompt {
-		t.Fatalf("unbound prompt input = %q, want exact empty registry", got)
-	}
-	if got := string(resolved.CanonicalBytes()); got != emptyPrompt {
-		t.Fatalf("unbound canonical bytes = %q, want exact empty registry", got)
+	if registry.ProjectionDigest() == "" || input.Digest != registry.ProjectionDigest() || input.OriginURI != "" {
+		t.Fatalf("projection digest/input = %q/%#v", registry.ProjectionDigest(), input)
 	}
 }

-func TestResolveCanonicalizesAndProvidesSemanticIdentity(t *testing.T) {
-	value := validRegistryList()
-	canonical := encodeRegistry(t, value)
-	raw := append([]byte(" \n"), canonical...)
-	raw = append(raw, []byte("\n ")...)
-
-	resolved, err := Resolve(registryReference(raw, "file:///another-session/npcs.json"))
-	if err != nil {
-		t.Fatalf("Resolve() error = %v, want nil", err)
+func TestResolveKeepsDurableProvenanceAndProjectsOnlyOrderedNames(t *testing.T) {
+	list := registryFixture()
+	registry := resolveList(t, list)
+	if !registry.Bound() || registry.Digest() == "" || registry.Count() != 2 {
+		t.Fatalf("registry identity = bound %t digest %q count %d", registry.Bound(), registry.Digest(), registry.Count())
 	}
-	if !resolved.Bound() || resolved.Count() != len(value.NPCs) {
-		t.Fatalf("resolved registry = %#v, want bound registry with %d NPC", resolved, len(value.NPCs))
+	if got := string(registry.PromptInput().Content); got != `{"npcs":[{"name":"Mira Thorn"},{"name":"Captain Vale"}]}` {
+		t.Fatalf("prompt projection = %s", got)
 	}
-	if !bytes.Equal(resolved.CanonicalBytes(), canonical) || !bytes.Equal(resolved.PromptInput().Content, canonical) {
-		t.Fatalf("canonical content = %s, want %s", resolved.CanonicalBytes(), canonical)
-	}
-	if resolved.PromptInput().Digest != resolved.Digest() || !strings.HasPrefix(resolved.Digest(), "sha256:") {
-		t.Fatalf("semantic digest = %q, want SHA-256 digest", resolved.Digest())
-	}
-	if resolved.PromptInput().OriginURI != "" {
-		t.Fatalf("prompt input origin = %q, want no provenance path", resolved.PromptInput().OriginURI)
-	}
-}
-
-func TestResolveRejectsInvalidBoundaryValuesWithoutContent(t *testing.T) {
-	valid := validRegistryList()
-	second := valid.NPCs[0]
-	second.ID = identity.DeriveID("Captain Vale")
-	second.Name = "Captain Vale"
-	second.Aliases = []string{"The Greencloak"}
-	valueWithAliasCollision := dnd.NPCList{NPCs: []dnd.NPC{valid.NPCs[0], second}}
-	invalidID := valid
-	invalidID.NPCs[0].ID = "not-an-npc-id"
-
-	tests := []struct {
-		name      string
-		reference contracts.ReferenceSet
-		wantError string
-		forbidden []string
-	}{
-		{name: "zero items", reference: contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ReferenceSlot: {Items: []contracts.ReferenceItem{}}}}, wantError: "exactly one"},
-		{name: "multiple", reference: contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ReferenceSlot: {Items: []contracts.ReferenceItem{{Content: []byte(emptyPrompt)}, {Content: []byte(emptyPrompt)}}}}}, wantError: "exactly one"},
-		{name: "wrong media type", reference: registryReferenceWithMedia([]byte(emptyPrompt), "text/plain"), wantError: "must be application/json"},
-		{name: "malformed JSON", reference: registryReference([]byte(`{"npcs":[],"MALFORMED_REGISTRY_SECRET":`), "file:///private.json"), wantError: "invalid approved NPC JSON", forbidden: []string{"MALFORMED_REGISTRY_SECRET"}},
-		{name: "unknown field", reference: registryReference([]byte(`{"npcs":[],"UNKNOWN_FIELD_SECRET":true}`), "file:///private.json"), wantError: "invalid approved NPC JSON", forbidden: []string{"UNKNOWN_FIELD_SECRET"}},
-		{name: "invalid ID", reference: registryReference(marshalRegistry(t, invalidID), "file:///private.json"), wantError: "decode NPC registry"},
-		{name: "alias collision", reference: registryReference(encodeRegistry(t, valueWithAliasCollision), "file:///private.json"), wantError: string(identity.IssueAliasOwnershipCollision)},
-		{name: "byte limit", reference: registryReference(bytes.Repeat([]byte("x"), MaxBytes+1), "file:///private.json"), wantError: "limit"},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			_, err := Resolve(test.reference)
-			if err == nil || !strings.Contains(err.Error(), test.wantError) {
-				t.Fatalf("Resolve() error = %v, want %q", err, test.wantError)
-			}
-			for _, forbidden := range append(test.forbidden, "Mira Thorn", "The Greencloak", "private.json") {
-				if strings.Contains(err.Error(), forbidden) {
-					t.Fatalf("error leaked registry content or provenance %q: %v", forbidden, err)
-				}
-			}
-		})
-	}
-}
-
-func TestResolveBoundsIdentityDiagnosticsWithoutContent(t *testing.T) {
-	const recordCount = 30
-	value := dnd.NPCList{NPCs: make([]dnd.NPC, recordCount)}
-	for index := range value.NPCs {
-		value.NPCs[index] = dnd.NPC{
-			ID:            "npc:sha256:0000000000000000000000000000000000000000000000000000000000000000",
-			Name:          fmt.Sprintf("PRIVATE NPC %d", index),
-			Aliases:       []string{"PRIVATE SHARED ALIAS"},
-			Description:   "PRIVATE DESCRIPTION",
-			Relationships: []dnd.NPCRelationship{},
-			SourceRefs:    []source.SourceRef{{SourceID: "private-source", StartUnitID: 1, EndUnitID: 1}},
+	for _, forbidden := range []string{"npc:sha256:", "source_refs", "source_id", "session-alpha"} {
+		if strings.Contains(string(registry.PromptInput().Content), forbidden) {
+			t.Fatalf("projection leaked %q: %s", forbidden, registry.PromptInput().Content)
 		}
 	}
-	issues := identity.ValidateList(value)
-	if len(issues) <= diagnostics.MaxIssues {
-		t.Fatalf("identity issues = %d, want more than display limit", len(issues))
-	}
-
-	_, err := Resolve(registryReference(marshalRegistry(t, value), "file:///private-registry.json"))
-	if err == nil {
-		t.Fatal("Resolve() error = nil, want bounded identity rejection")
-	}
-	message := err.Error()
-	if !utf8.ValidString(message) || len([]byte(message)) > diagnostics.MaxMessageBytes {
-		t.Fatalf("identity error has invalid encoding or size: bytes=%d message=%q", len([]byte(message)), message)
-	}
-	wantOmitted := fmt.Sprintf("%d additional issue(s) omitted", len(issues)-diagnostics.MaxIssues)
-	if !strings.Contains(message, wantOmitted) {
-		t.Fatalf("identity error = %q, want %q", message, wantOmitted)
-	}
-	for _, forbidden := range []string{"PRIVATE NPC", "PRIVATE SHARED ALIAS", "PRIVATE DESCRIPTION", "private-source", "private-registry.json"} {
-		if strings.Contains(message, forbidden) {
-			t.Fatalf("identity error leaked %q: %s", forbidden, message)
-		}
+	if registry.PromptInput().Digest != registry.ProjectionDigest() || registry.Digest() == registry.ProjectionDigest() {
+		t.Fatalf("full/projection digests = %q/%q", registry.Digest(), registry.ProjectionDigest())
 	}
 }

-func TestRegistryAccessorsAndLookupAreDefensive(t *testing.T) {
-	resolved, err := Resolve(registryReference(encodeRegistry(t, validRegistryList()), "file:///npc-registry.json"))
+func TestNameProjectionDigestTracksOnlyNamesAndOrder(t *testing.T) {
+	base := registryFixture()
+	evidenceChanged := registryFixture()
+	evidenceChanged.NPCs[0].ID = "different application id"
+	evidenceChanged.NPCs[0].SourceRefs = []source.SourceRef{{SourceID: "other", StartUnitID: 40, EndUnitID: 41}}
+	baseBytes, err := nameProjection(base)
 	if err != nil {
-		t.Fatalf("Resolve() error = %v, want nil", err)
+		t.Fatal(err)
+	}
+	changedBytes, err := nameProjection(evidenceChanged)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(baseBytes, changedBytes) || semanticDigest(baseBytes) != semanticDigest(changedBytes) {
+		t.Fatalf("equivalent name projections differ: %s / %s", baseBytes, changedBytes)
 	}

-	npcs := resolved.NPCs()
+	nameChanged := registryFixture()
+	nameChanged.NPCs[0].Name = "The Greencloak"
+	nameBytes, _ := nameProjection(nameChanged)
+	orderChanged := registryFixture()
+	orderChanged.NPCs[0], orderChanged.NPCs[1] = orderChanged.NPCs[1], orderChanged.NPCs[0]
+	orderBytes, _ := nameProjection(orderChanged)
+	if bytes.Equal(baseBytes, nameBytes) || bytes.Equal(baseBytes, orderBytes) {
+		t.Fatalf("name/order changes did not change projection: %s %s %s", baseBytes, nameBytes, orderBytes)
+	}
+}
+
+func TestRegistryLookupAndAccessorsAreImmutable(t *testing.T) {
+	registry := resolveList(t, registryFixture())
+	if npc, ok := registry.Lookup("  mIRA\u2003thorn "); !ok || npc.Name != "Mira Thorn" {
+		t.Fatalf("Lookup() = %#v, %t", npc, ok)
+	}
+	if _, ok := registry.Lookup("The Greencloak"); ok {
+		t.Fatal("Lookup() accepted a non-canonical name")
+	}
+
+	npcs := registry.NPCs()
 	npcs[0].Name = "changed"
-	npcs[0].Aliases[0] = "changed alias"
-	npcs[0].Relationships[0].Target = "changed target"
-	npcs[0].SourceRefs[0].SourceID = "changed source"
-	if got, ok := resolved.Lookup("The Greencloak"); !ok || got.Name != "Mira Thorn" {
-		t.Fatalf("Lookup() after NPC mutation = %#v, %v, want original NPC", got, ok)
+	npcs[0].SourceRefs[0].SourceID = "changed"
+	content := registry.CanonicalBytes()
+	content[0] = '['
+	input := registry.PromptInput()
+	input.Content[0] = '['
+	if next := registry.NPCs()[0]; next.Name != "Mira Thorn" || next.SourceRefs[0].SourceID != "session-alpha" {
+		t.Fatalf("registry mutated through accessor: %#v", next)
 	}
-
-	wantCanonical := string(resolved.CanonicalBytes())
-	content := resolved.CanonicalBytes()
-	content[0] = 'X'
-	input := resolved.PromptInput()
-	input.Content[0] = 'X'
-	if string(resolved.CanonicalBytes()) != wantCanonical || string(resolved.PromptInput().Content) != wantCanonical {
-		t.Fatal("registry content accessors share mutable state")
-	}
-	if got, ok := resolved.Lookup("  MIRA\u00a0THORN "); !ok || got.Name != "Mira Thorn" {
-		t.Fatalf("Lookup() canonical identity = %#v, %v, want Mira Thorn", got, ok)
-	}
-	if _, ok := resolved.Lookup("unknown NPC"); ok {
-		t.Fatal("Lookup() found unknown NPC")
+	if registry.CanonicalBytes()[0] != '{' || registry.PromptInput().Content[0] != '{' {
+		t.Fatal("registry bytes mutated through accessor")
 	}
 }

-func TestResolverUsesSeededFallbackAndCachesGeneratedCanonicalRegistry(t *testing.T) {
-	staticContent := encodeRegistry(t, validRegistryList())
-	resolver, err := NewResolver(registryReference(staticContent, "file:///static.json"))
-	if err != nil {
-		t.Fatalf("NewResolver() error = %v", err)
-	}
-	if got, err := resolver.Resolve(contracts.ReferenceSet{}); err != nil || got != resolver.Seeded() {
-		t.Fatalf("Resolve(absent) = %p, %v, want seeded %p", got, err, resolver.Seeded())
-	}
-
-	generated := registryReference(append([]byte("\n"), staticContent...), "file:///generated.json")
-	first, err := resolver.Resolve(generated)
-	if err != nil {
-		t.Fatalf("Resolve(generated) error = %v", err)
-	}
-	second, err := resolver.Resolve(generated)
-	if err != nil {
-		t.Fatalf("Resolve(generated second) error = %v", err)
-	}
-	if first != resolver.Seeded() || second != first {
-		t.Fatalf("resolved registries = %p, %p, seeded %p; want seeded reuse", first, second, resolver.Seeded())
-	}
-
-	changed := validRegistryList()
-	changed.NPCs[0].Description = "A changed generated description."
-	changedContent := encodeRegistry(t, changed)
-	changedReferences := registryReference(changedContent, "file:///changed.json")
-	resolved, err := resolver.Resolve(changedReferences)
-	if err != nil {
-		t.Fatalf("Resolve(changed) error = %v", err)
-	}
-	changedReferences.Slots[ReferenceSlot].Items[0].Content[0] = 'X'
-	if resolved == first || string(resolved.CanonicalBytes()) != string(changedContent) {
-		t.Fatalf("changed registry = %p/%s, want independent canonical cache entry", resolved, resolved.CanonicalBytes())
-	}
-}
-
-func TestResolverSharesOneCachedRegistryAcrossConcurrentOperations(t *testing.T) {
-	content := encodeRegistry(t, validRegistryList())
-	resolver, err := NewResolver(contracts.ReferenceSet{})
-	if err != nil {
-		t.Fatalf("NewResolver() error = %v", err)
-	}
-	references := registryReference(content, "file:///generated.json")
-	const callers = 32
-	results := make(chan *Registry, callers)
-	errors := make(chan error, callers)
-	var wait sync.WaitGroup
-	for index := 0; index < callers; index++ {
-		wait.Add(1)
-		go func() {
-			defer wait.Done()
-			resolved, resolveErr := resolver.Resolve(references)
-			if resolveErr != nil {
-				errors <- resolveErr
-				return
-			}
-			results <- resolved
-		}()
-	}
-	wait.Wait()
-	close(results)
-	close(errors)
-	for err := range errors {
-		t.Fatalf("concurrent Resolve() error = %v", err)
-	}
-	var first *Registry
-	for resolved := range results {
-		if first == nil {
-			first = resolved
-		} else if resolved != first {
-			t.Fatalf("concurrent resolved registry %p differs from cached %p", resolved, first)
+func TestResolveRejectsRichOrInvalidRegistryJSON(t *testing.T) {
+	rich := []byte(`{"npcs":[{"id":"npc:sha256:99a16589618a04f535a7d21fdcc71a0b1c05d22f752cd492065b1086d97bc3d7","name":"Mira Thorn","aliases":[],"source_refs":[{"source_id":"session-alpha","start_unit_id":1,"end_unit_id":1}]}]}`)
+	for _, item := range []contracts.ReferenceItem{
+		{MediaType: "application/json", Content: rich},
+		{MediaType: "text/plain", Content: []byte(`{"npcs":[]}`)},
+	} {
+		_, err := Resolve(referenceSet(item))
+		if err == nil {
+			t.Fatalf("Resolve(%s) error = nil", item.Content)
 		}
 	}
 }

-func TestNewResolverAllowsGeneratedDeclarationButRejectsMalformedStaticItem(t *testing.T) {
-	placeholder := contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{
-		ReferenceSlot: {Slot: contracts.ReferenceSlot{Name: ReferenceSlot, AcceptedArtifactKinds: []contracts.ArtifactKind{dnd.NPCListKind}}},
-	}}
-	if _, err := NewResolver(placeholder); err != nil {
-		t.Fatalf("NewResolver(generated declaration) error = %v, want nil", err)
-	}
-	malformed := registryReference([]byte(`{"npcs":[`), "file:///runtime.json")
-	if _, err := NewResolver(malformed); err == nil || !strings.Contains(err.Error(), "invalid approved NPC JSON") {
-		t.Fatalf("NewResolver(malformed) error = %v, want bounded decode failure", err)
-	}
-}
-
-func validRegistryList() dnd.NPCList {
-	return dnd.NPCList{NPCs: []dnd.NPC{{
-		ID:          identity.DeriveID("Mira Thorn"),
-		Name:        "Mira Thorn",
-		Aliases:     []string{"The Greencloak"},
-		Description: "A guarded ranger who watches the northern road.",
-		Relationships: []dnd.NPCRelationship{{
-			Target: "Captain Vale", Relationship: "reports to",
-		}},
-		SourceRefs: []source.SourceRef{{SourceID: "npc-session", StartUnitID: 41, EndUnitID: 43}},
-	}}}
-}
-
-func encodeRegistry(t *testing.T, value dnd.NPCList) []byte {
-	t.Helper()
-	content, err := npccodec.New().Encode(value)
+func TestResolverReusesEquivalentCanonicalRegistries(t *testing.T) {
+	set := listReferenceSet(t, registryFixture())
+	resolver, err := NewResolver(set)
 	if err != nil {
-		t.Fatalf("encode NPC registry: %v", err)
+		t.Fatal(err)
 	}
-	return content
-}
-
-func marshalRegistry(t *testing.T, value dnd.NPCList) []byte {
-	t.Helper()
-	content, err := json.Marshal(value)
-	if err != nil {
-		t.Fatalf("marshal NPC registry: %v", err)
+	resolved, err := resolver.Resolve(set)
+	if err != nil || resolved != resolver.Seeded() {
+		t.Fatalf("Resolve() = %p, %v; seeded %p", resolved, err, resolver.Seeded())
 	}
-	return content
 }

-func registryReference(content []byte, origin string) contracts.ReferenceSet {
-	references := registryReferenceWithMedia(content, "application/json; charset=utf-8")
-	item := references.Slots[ReferenceSlot].Items[0]
-	item.Origin.URI = origin
-	slot := references.Slots[ReferenceSlot]
-	slot.Items[0] = item
-	references.Slots[ReferenceSlot] = slot
-	return references
-}
-
-func registryReferenceWithMedia(content []byte, mediaType string) contracts.ReferenceSet {
-	return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{
-		ReferenceSlot: {
-			Slot: contracts.ReferenceSlot{Name: ReferenceSlot, AcceptedMediaTypes: []string{npccodec.MediaType}, MaxBytes: MaxBytes},
-			Items: []contracts.ReferenceItem{{
-				SlotName:  ReferenceSlot,
-				MediaType: mediaType,
-				Content:   append([]byte(nil), content...),
-				Origin:    contracts.ReferenceOrigin{Type: "file", URI: "file:///npc-registry.json"},
-			}},
-		},
+func registryFixture() dnd.NPCList {
+	return dnd.NPCList{NPCs: []dnd.NPC{
+		{ID: identity.DeriveID("Mira Thorn"), Name: "Mira Thorn", SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 1, EndUnitID: 2}}},
+		{ID: identity.DeriveID("Captain Vale"), Name: "Captain Vale", SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 3, EndUnitID: 3}}},
 	}}
 }
+
+func resolveList(t *testing.T, list dnd.NPCList) *Registry {
+	t.Helper()
+	registry, err := Resolve(listReferenceSet(t, list))
+	if err != nil {
+		t.Fatalf("Resolve() error = %v", err)
+	}
+	return registry
+}
+
+func listReferenceSet(t *testing.T, list dnd.NPCList) contracts.ReferenceSet {
+	t.Helper()
+	content, err := npccodec.New().Encode(list)
+	if err != nil {
+		t.Fatalf("Encode() error = %v", err)
+	}
+	return referenceSet(contracts.ReferenceItem{SlotName: ReferenceSlot, MediaType: npccodec.MediaType, Content: content})
+}
+
+func referenceSet(item contracts.ReferenceItem) contracts.ReferenceSet {
+	return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ReferenceSlot: {Items: []contracts.ReferenceItem{item}}}}
+}
+
+func TestProjectionIsStableForEquivalentNormalizedRegistries(t *testing.T) {
+	first := resolveList(t, registryFixture())
+	secondList := registryFixture()
+	secondList.NPCs[0].SourceRefs = append(secondList.NPCs[0].SourceRefs, source.SourceRef{SourceID: "session-beta", StartUnitID: 8, EndUnitID: 8})
+	second := resolveList(t, secondList)
+	if !reflect.DeepEqual(first.PromptInput().Content, second.PromptInput().Content) || first.ProjectionDigest() != second.ProjectionDigest() || first.Digest() == second.Digest() {
+		t.Fatalf("projection/full identity mismatch: %#v %#v", first, second)
+	}
+}
--- a/internal/modules/dnd/types.go
+++ b/internal/modules/dnd/types.go
@@ -29,17 +29,9 @@ type NPCList struct {
 }

 type NPC struct {
-	ID            string             `json:"id"`
-	Name          string             `json:"name"`
-	Aliases       []string           `json:"aliases"`
-	Description   string             `json:"description"`
-	Relationships []NPCRelationship  `json:"relationships"`
-	SourceRefs    []source.SourceRef `json:"source_refs"`
-}
-
-type NPCRelationship struct {
-	Target       string `json:"target"`
-	Relationship string `json:"relationship"`
+	ID         string             `json:"id"`
+	Name       string             `json:"name"`
+	SourceRefs []source.SourceRef `json:"source_refs"`
 }

 type CombatTurnList struct {
--- a/internal/modules/dnd/validate/npcs/identity/validator.go
+++ b/internal/modules/dnd/validate/npcs/identity/validator.go
@@ -48,9 +48,6 @@ func (v *Validator) Validate(_ context.Context, req contracts.TypedValidationReq
 	issues := make([]string, len(identityIssues))
 	for index, issue := range identityIssues {
 		location := fmt.Sprintf("npcs[%d]", issue.RecordIndex)
-		if issue.AliasIndex >= 0 {
-			location += fmt.Sprintf(".aliases[%d]", issue.AliasIndex)
-		}
 		issues[index] = fmt.Sprintf("%s %s: %s", location, issue.Code, diagnostics.Quote(issue.Value))
 	}
 	return contracts.ValidationResult{
--- a/internal/modules/dnd/validate/npcs/identity/validator_test.go
+++ b/internal/modules/dnd/validate/npcs/identity/validator_test.go
@@ -43,7 +43,7 @@ func TestValidatorContractAndRegistration(t *testing.T) {

 func TestValidatorDefersShapeAndRejectsIdentityIssues(t *testing.T) {
 	validator := New(Options{})
-	shapeInvalid := dnd.NPCList{NPCs: []dnd.NPC{{Name: "missing description"}}}
+	shapeInvalid := dnd.NPCList{NPCs: []dnd.NPC{{Name: "missing evidence"}}}
 	result, err := validator.Validate(context.Background(), validationRequest(shapeInvalid))
 	if err != nil || !result.Approved {
 		t.Fatalf("shape-invalid result = %#v, error = %v, want deferred approval", result, err)
@@ -51,13 +51,13 @@ func TestValidatorDefersShapeAndRejectsIdentityIssues(t *testing.T) {

 	value := validNPCList(2)
 	value.NPCs[0].ID = "not-an-id"
-	value.NPCs[1].Aliases = []string{"Shared Alias"}
-	value.NPCs[0].Aliases = []string{"Shared Alias"}
+	value.NPCs[1].Name = value.NPCs[0].Name
+	value.NPCs[1].ID = value.NPCs[0].ID
 	result, err = validator.Validate(context.Background(), validationRequest(value))
 	if err != nil || result.Approved || result.ReasonCode != ReasonCode {
 		t.Fatalf("identity result = %#v, error = %v, want rejection", result, err)
 	}
-	for _, want := range []string{"invalid_id", "alias_owned_by_multiple_records", "npcs[0]", "npcs[1]"} {
+	for _, want := range []string{"invalid_id", "duplicate_canonical_identity", "duplicate_id", "npcs[0]", "npcs[1]"} {
 		if !strings.Contains(result.Message, want) {
 			t.Fatalf("identity message %q missing %q", result.Message, want)
 		}
@@ -90,14 +90,7 @@ func validNPCList(count int) dnd.NPCList {
 	value := dnd.NPCList{NPCs: make([]dnd.NPC, count)}
 	for index := range value.NPCs {
 		name := fmt.Sprintf("NPC %d", index)
-		value.NPCs[index] = dnd.NPC{
-			ID:            "npc:sha256:0000000000000000000000000000000000000000000000000000000000000000",
-			Name:          name,
-			Aliases:       []string{},
-			Description:   "description",
-			Relationships: []dnd.NPCRelationship{},
-			SourceRefs:    []source.SourceRef{sourceRefForTest()},
-		}
+		value.NPCs[index] = dnd.NPC{ID: "npc:sha256:0000000000000000000000000000000000000000000000000000000000000000", Name: name, SourceRefs: []source.SourceRef{sourceRefForTest()}}
 	}
 	return value
 }
--- a/internal/modules/dnd/validate/npcs/shape/validator.go
+++ b/internal/modules/dnd/validate/npcs/shape/validator.go
@@ -61,31 +61,6 @@ func issuesFor(value dnd.NPCList) []string {
 		if strings.TrimSpace(npc.Name) == "" {
 			issues = append(issues, prefix+".name must not be empty")
 		}
-		if npc.Aliases == nil {
-			issues = append(issues, prefix+".aliases must be present")
-		} else {
-			for aliasIndex, alias := range npc.Aliases {
-				if strings.TrimSpace(alias) == "" {
-					issues = append(issues, fmt.Sprintf("%s.aliases[%d] must not be empty: %s", prefix, aliasIndex, diagnostics.Quote(alias)))
-				}
-			}
-		}
-		if strings.TrimSpace(npc.Description) == "" {
-			issues = append(issues, prefix+".description must not be empty")
-		}
-		if npc.Relationships == nil {
-			issues = append(issues, prefix+".relationships must be present")
-		} else {
-			for relationshipIndex, relationship := range npc.Relationships {
-				relationshipPrefix := fmt.Sprintf("%s.relationships[%d]", prefix, relationshipIndex)
-				if strings.TrimSpace(relationship.Target) == "" {
-					issues = append(issues, relationshipPrefix+".target must not be empty: "+diagnostics.Quote(relationship.Target))
-				}
-				if strings.TrimSpace(relationship.Relationship) == "" {
-					issues = append(issues, relationshipPrefix+".relationship must not be empty: "+diagnostics.Quote(relationship.Relationship))
-				}
-			}
-		}
 		if len(npc.SourceRefs) == 0 {
 			issues = append(issues, prefix+".source_refs must not be empty")
 		}
--- a/internal/modules/dnd/validate/npcs/shape/validator_test.go
+++ b/internal/modules/dnd/validate/npcs/shape/validator_test.go
@@ -21,9 +21,9 @@ func TestValidatorApprovesWellFormedNPCPayload(t *testing.T) {

 func TestValidatorRejectsRequiredShapeValues(t *testing.T) {
 	value := validNPCList()
-	value.NPCs[0].Aliases = nil
+	value.NPCs[0].Name = ""
 	result, err := New(Options{}).Validate(context.Background(), requestWithValue(value))
-	if err != nil || result.Approved || result.ReasonCode != ReasonCode || !strings.Contains(result.Message, "aliases must be present") {
+	if err != nil || result.Approved || result.ReasonCode != ReasonCode || !strings.Contains(result.Message, "name must not be empty") {
 		t.Fatalf("Validate() = %#v, %v; want bounded shape rejection", result, err)
 	}

@@ -38,13 +38,13 @@ func TestValidatorBoundsDiagnosticsAndQuotesUnicode(t *testing.T) {
 	value := dnd.NPCList{NPCs: make([]dnd.NPC, 24)}
 	long := strings.Repeat("火", 220) + "\n\t"
 	for index := range value.NPCs {
-		value.NPCs[index] = dnd.NPC{ID: "candidate", Name: long, Aliases: []string{"\n\t"}, Description: "", Relationships: []dnd.NPCRelationship{{Target: " ", Relationship: " "}}, SourceRefs: []source.SourceRef{}}
+		value.NPCs[index] = dnd.NPC{ID: "", Name: long, SourceRefs: []source.SourceRef{}}
 	}
 	result, err := New(Options{}).Validate(context.Background(), requestWithValue(value))
 	if err != nil || result.Approved || len([]byte(result.Message)) > diagnosticsMaxMessageBytes || !utf8.ValidString(result.Message) {
 		t.Fatalf("Validate() = %#v, %v; want bounded valid UTF-8 rejection", result, err)
 	}
-	if strings.Count(result.Message, "npcs[") > diagnosticsMaxIssues || !strings.Contains(result.Message, "additional issue(s) omitted") || !strings.Contains(result.Message, `\n\t`) {
+	if strings.Count(result.Message, "npcs[") > diagnosticsMaxIssues || !strings.Contains(result.Message, "additional issue(s) omitted") {
 		t.Fatalf("message = %q, want bounded quoted diagnostics", result.Message)
 	}
 }
@@ -69,7 +69,7 @@ func TestValidatorDoesNotMutateValue(t *testing.T) {
 	value := validNPCList()
 	before := value
 	_, err := New(Options{}).Validate(context.Background(), requestWithValue(value))
-	if err != nil || value.NPCs[0].Aliases[0] != before.NPCs[0].Aliases[0] {
+	if err != nil || value.NPCs[0].Name != before.NPCs[0].Name {
 		t.Fatalf("Validate() mutated value: %#v", value)
 	}
 }
@@ -80,9 +80,8 @@ func requestWithValue(value dnd.NPCList) contracts.TypedValidationRequest[dnd.NP

 func validNPCList() dnd.NPCList {
 	return dnd.NPCList{NPCs: []dnd.NPC{{
-		ID: "candidate", Name: "Mira Thorn", Aliases: []string{"The Greencloak"}, Description: "A guarded ranger.",
-		Relationships: []dnd.NPCRelationship{{Target: "Captain Vale", Relationship: "reports to"}},
-		SourceRefs:    []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}},
+		ID: "candidate", Name: "Mira Thorn",
+		SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}},
 	}}}
 }

--- a/internal/modules/dnd/validate/npcs/source_refs/validator_test.go
+++ b/internal/modules/dnd/validate/npcs/source_refs/validator_test.go
@@ -84,5 +84,5 @@ func validDocument() *source.SourceDocument {
 }

 func validNPCList() dnd.NPCList {
-	return dnd.NPCList{NPCs: []dnd.NPC{{ID: "candidate", Name: "Mira Thorn", Aliases: []string{"The Greencloak"}, Description: "A ranger.", Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 2}}}}}
+	return dnd.NPCList{NPCs: []dnd.NPC{{ID: "candidate", Name: "Mira Thorn", SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 2}}}}}
 }
--- a/internal/modules/dnd/validate/npcs/source_relatedness/validator.go
+++ b/internal/modules/dnd/validate/npcs/source_relatedness/validator.go
@@ -60,15 +60,7 @@ func (v *Validator) Validate(_ context.Context, req contracts.TypedValidationReq
 }

 func npcAppearsInCitedText(citedText string, npc dnd.NPC) bool {
-	if shared.ContainsTokenSequence(citedText, npc.Name) {
-		return true
-	}
-	for _, alias := range npc.Aliases {
-		if shared.ContainsTokenSequence(citedText, alias) {
-			return true
-		}
-	}
-	return false
+	return shared.ContainsTokenSequence(citedText, npc.Name)
 }

 func Spec() pipeline.ValidatorSpec {
--- a/internal/modules/dnd/validate/npcs/source_relatedness/validator_test.go
+++ b/internal/modules/dnd/validate/npcs/source_relatedness/validator_test.go
@@ -12,14 +12,14 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 )

-func TestValidatorMatchesCanonicalNamesAndAliasesWithUnicodeVariants(t *testing.T) {
+func TestValidatorMatchesCanonicalNamesWithUnicodeVariants(t *testing.T) {
 	value := dnd.NPCList{NPCs: []dnd.NPC{
-		{ID: "one", Name: "O'Rin Thorn", Aliases: []string{}, Description: "A ranger.", Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{
+		{ID: "one", Name: "O'Rin Thorn", SourceRefs: []source.SourceRef{
 			{SourceID: "session", StartUnitID: 2, EndUnitID: 2},
 			{SourceID: "session", StartUnitID: 1, EndUnitID: 2},
 			{SourceID: "session", StartUnitID: 1, EndUnitID: 2},
 		}},
-		{ID: "two", Name: "Missing Name", Aliases: []string{"The Greencloak"}, Description: "A guard.", Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 2, EndUnitID: 2}}},
+		{ID: "two", Name: "The Greencloak", SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 2, EndUnitID: 2}}},
 	}}
 	doc := &source.SourceDocument{ID: "session", Kind: "transcript", Format: "application/json", Digest: "sha256:session", Units: []source.SourceUnit{
 		{ID: 1, Kind: "message", Text: "  o’rin\u2003thorn appears."},
@@ -27,13 +27,13 @@ func TestValidatorMatchesCanonicalNamesAndAliasesWithUnicodeVariants(t *testing.
 	}}
 	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.NPCList]{Source: doc, Value: value})
 	if err != nil || !result.Approved || len(result.Warnings) != 0 {
-		t.Fatalf("Validate() = %#v, %v; want alias/canonical relatedness approval", result, err)
+		t.Fatalf("Validate() = %#v, %v; want canonical-name relatedness approval", result, err)
 	}
 }

 func TestValidatorWarnsAtMostOncePerNPCForUnrelatedCitations(t *testing.T) {
 	value := dnd.NPCList{NPCs: []dnd.NPC{
-		{ID: "one", Name: "Missing\nName", Aliases: []string{"Also Missing"}, Description: "A guard.", Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}, {SourceID: "session", StartUnitID: 1, EndUnitID: 1}}},
+		{ID: "one", Name: "Missing\nName", SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}, {SourceID: "session", StartUnitID: 1, EndUnitID: 1}}},
 	}}
 	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.NPCList]{Source: relatednessDocument(), Value: value})
 	if err != nil || !result.Approved || len(result.Warnings) != 1 {
@@ -47,7 +47,7 @@ func TestValidatorWarnsAtMostOncePerNPCForUnrelatedCitations(t *testing.T) {

 func TestValidatorDoesNotMatchShortNameSubstring(t *testing.T) {
 	value := dnd.NPCList{NPCs: []dnd.NPC{{
-		ID: "one", Name: "Art", Aliases: []string{}, Description: "A guard.", Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}},
+		ID: "one", Name: "Art", SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}},
 	}}}
 	doc := &source.SourceDocument{ID: "session", Kind: "transcript", Format: "application/json", Digest: "sha256:session", Units: []source.SourceUnit{{ID: 1, Kind: "message", Text: "A cart rolls past."}}}
 	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.NPCList]{Source: doc, Value: value})
@@ -62,7 +62,7 @@ func TestValidatorDefersMalformedShapeAndInvalidRangesDoNotPanic(t *testing.T) {
 	if err != nil || !result.Approved || len(result.Warnings) != 0 {
 		t.Fatalf("shape deferral = %#v, %v; want approval without warning", result, err)
 	}
-	invalidRange := dnd.NPCList{NPCs: []dnd.NPC{{ID: "one", Name: "Mira Thorn", Aliases: []string{}, Description: "A ranger.", Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 99, EndUnitID: 99}}}}}
+	invalidRange := dnd.NPCList{NPCs: []dnd.NPC{{ID: "one", Name: "Mira Thorn", SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 99, EndUnitID: 99}}}}}
 	result, err = New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.NPCList]{Source: relatednessDocument(), Value: invalidRange})
 	if err != nil || !result.Approved || len(result.Warnings) != 0 {
 		t.Fatalf("invalid-range relatedness = %#v, %v; want approval without warning", result, err)
@@ -70,7 +70,7 @@ func TestValidatorDefersMalformedShapeAndInvalidRangesDoNotPanic(t *testing.T) {
 }

 func TestValidatorUsesOnlyTranscriptEvidenceAndRegistersPolicy(t *testing.T) {
-	value := dnd.NPCList{NPCs: []dnd.NPC{{ID: "one", Name: "Opaque NPC", Aliases: []string{}, Description: "A guard.", Relationships: []dnd.NPCRelationship{}, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}}}}}
+	value := dnd.NPCList{NPCs: []dnd.NPC{{ID: "one", Name: "Opaque NPC", SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}}}}}
 	references := contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{"glossary": {Items: []contracts.ReferenceItem{{Content: []byte("Opaque NPC")}}}}}
 	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.NPCList]{Source: relatednessDocument(), References: references, Value: value})
 	if err != nil || len(result.Warnings) != 1 {