Plan D&D location tracking

README.md

@@ -3,7 +3,7 @@
 Notarius is a Go CLI for turning source material into structured artifacts with
 configured extraction pipelines. The implemented D&D workflow reads Seriatim
 transcript JSON and can produce scene descriptions, item and currency events,
-NPC identities, combat turns, NPC interactions, and spell casts.
+NPC identities, combat turns, NPC interactions, enemy events, and spell casts.
 
 ## Quickstart
 

docs/cli.md

@@ -40,7 +40,7 @@ pipeline ID and **--input** are required.
 | **--debug-dir path** | Override the debug-bundle root. Requires **--debug**. |
 | **--only lane-a,lane-b** | Run only the selected comma-separated artifact lanes when that selection is valid for the configured pipeline. |
 | **--llm-profile id** | Highest-precedence configured profile for selected LLM-backed bindings and validators; it replaces binding and [pipeline](config.md#pipelines) defaults. |
-| **--session-id id** | Supply a non-empty prompt session identifier to LLM-backed module calls. |
+| **--session-id id** | Override the generated prompt session identifier with a non-empty value for LLM-backed module calls. |
 | **--reasoning-effort value** | Replace the selected PromptKit profile's reasoning effort for every LLM-backed call in this run. The value must be non-empty and the flag may be specified only once. |
 | **--clear-reasoning-effort** | Clear reasoning effort inherited from the selected PromptKit profile for every LLM-backed call in this run. |
 | **--reference selector=path** | Add or replace a file reference binding. Repeatable. |
@@ -57,6 +57,16 @@ Persistent reasoning settings remain a PromptKit profile concern.
 **--recompute-step** requires **--resume**; checkpoint requirements and reuse
 behavior are documented in [Operations](operations.md).
 
+Every run uses one effective prompt session. Without **--session-id**, Notarius
+generates a stable `notarius:v1:` identifier from the trimmed resolved input
+module key and the input file's exact raw bytes. The same module and bytes
+therefore produce the same identifier, regardless of pipeline, references,
+profile, retries, or run settings. An explicit non-empty value replaces that
+default. Session identifiers are visible to providers; they are non-secret
+correlation identifiers, not credential storage. See
+[Operations](operations.md#operational-limits) for privacy and workflow
+guidance.
+
 ### Reference selectors
 
 Use **--reference** only for a reference slot declared by the selected

docs/config.md

@@ -58,7 +58,7 @@ Built-in defaults are:
 
 | Field | Default |
 | --- | --- |
-| **concurrency.total_llm** | 1 |
+| **concurrency.total_llm** | 16 |
 | **concurrency.stage_workers.extract** | Effective **total_llm** |
 | **output.directory** | **./notarius-output** |
 | **cache.chunk_plans.mode** | **auto** |
@@ -370,14 +370,28 @@ selected target declares them:
 | **players** | Optional text player context. |
 | **glossary** | Optional text campaign glossary. |
 | **spell_catalog** | Optional JSON spell-catalog overlay for spell extraction and normalization. See [spell-catalog overlays](integrations/dnd-spell-catalog-overlays.md). |
-| **npcs** | Normalized NPC registry. Optional for spells and combat turns; required for NPC interactions. |
-| **scene_descriptions** | Required normalized scene-description artifact for combat-turn extraction. |
+| **npcs** | Normalized NPC registry. Optional for spells and combat turns; required for NPC interactions and enemy-event extraction and normalization. |
+| **scene_descriptions** | Required normalized scene-description artifact for combat-turn and enemy-event extraction. |
+| **combat_turns** | Required normalized combat-turn artifact for enemy-event extraction. |
+| **npc_interactions** | Required normalized NPC-interaction artifact for enemy-event extraction. |
+
+Enemy-event artifact slots have the following exact binding contract. Durable
+event semantics and wire shape remain in the
+[enemy-event artifact contract](integrations/dnd-enemy-event-artifacts.md).
+
+| Slot | Accepted artifact kind | Media type | Maximum size | Required stage |
+| --- | --- | --- | --- | --- |
+| `npcs` | `dnd/npc-list` | `application/json` | 1,048,576 bytes | extract and normalize |
+| `scene_descriptions` | `dnd/scene-description-list` | `application/json` | 1,048,576 bytes | extract only |
+| `combat_turns` | `dnd/combat-turn-list` | `application/json` | 1,048,576 bytes | extract only |
+| `npc_interactions` | `dnd/npc-interaction-list` | `application/json` | 1,048,576 bytes | extract only |
 
 Scene descriptions accept **party**, **players**, and **glossary**, but not
 **roster**. NPC interactions require **npcs** for both extraction and
 normalization. Combat turns require **scene_descriptions** for extraction; the
-normalized combat-turn module may use optional **npcs**. The complete example
-shows generated **npcs** and **scene_descriptions** bindings.
+normalized combat-turn module may use optional **npcs**. Enemy-event extraction
+requires all four JSON artifact slots; its normalizer requires **npcs**. The
+complete example shows the ordered generated bindings.
 
 ## Production Module Keys
 
@@ -385,9 +399,9 @@ shows generated **npcs** and **scene_descriptions** bindings.
 | --- | --- |
 | Input | **seriatim** |
 | Chunk | **generic**, **dnd/scenes** |
-| Extract | **dnd/spells**, **dnd/npcs**, **dnd/combat-turns**, **dnd/item-events**, **dnd/npc-interactions**, **dnd/scene-descriptions** |
+| Extract | **dnd/spells**, **dnd/npcs**, **dnd/combat-turns**, **dnd/item-events**, **dnd/npc-interactions**, **dnd/scene-descriptions**, **dnd/enemy-events** |
 | Merge | **appendorder** |
-| Normalize | **noop**, **dnd/spells**, **dnd/npcs**, **dnd/combat-turns**, **dnd/item-events**, **dnd/npc-interactions**, **dnd/scene-descriptions** |
+| Normalize | **noop**, **dnd/spells**, **dnd/npcs**, **dnd/combat-turns**, **dnd/item-events**, **dnd/npc-interactions**, **dnd/scene-descriptions**, **dnd/enemy-events** |
 | Output | **json** |
 
 The D&D artifact contracts define each emitted schema:
@@ -395,8 +409,9 @@ The D&D artifact contracts define each emitted schema:
 [NPCs](integrations/dnd-npc-artifacts.md),
 [NPC interactions](integrations/dnd-npc-interaction-artifacts.md),
 [combat turns](integrations/dnd-combat-turn-artifacts.md),
-[item events](integrations/dnd-item-event-artifacts.md), and
-[scene descriptions](integrations/dnd-scene-description-artifacts.md).
+[item events](integrations/dnd-item-event-artifacts.md),
+[scene descriptions](integrations/dnd-scene-description-artifacts.md), and
+[enemy events](integrations/dnd-enemy-event-artifacts.md).
 
 ## Production Validator Keys And Default Chains
 
@@ -411,6 +426,7 @@ Available validator keys are:
 | Item events | **extract/dnd/item-events/shape**, **extract/dnd/item-events/source_refs**, **extract/dnd/item-events/source_relatedness**, **normalize/dnd/item-events/invariants** |
 | NPC interactions | **extract/dnd/npc-interactions/shape**, **extract/dnd/npc-interactions/registry**, **extract/dnd/npc-interactions/source_refs**, **extract/dnd/npc-interactions/source_relatedness**, **normalize/dnd/npc-interactions/invariants** |
 | Scene descriptions | **extract/dnd/scene-descriptions/shape**, **extract/dnd/scene-descriptions/source_refs**, **extract/dnd/scene-descriptions/source_relatedness**, **normalize/dnd/scene-descriptions/invariants** |
+| Enemy events | **extract/dnd/enemy-events/shape**, **extract/dnd/enemy-events/engagements**, **extract/dnd/enemy-events/source_refs**, **extract/dnd/enemy-events/source_relatedness**, **normalize/dnd/enemy-events/invariants** |
 
 When no override is configured, production D&D bindings use the following
 ordered chains. Each row lists extract then normalize; spell chains are the
@@ -424,6 +440,7 @@ same at both stages.
 | Item events | generic/valid_json, extract/dnd/item-events/shape, extract/dnd/item-events/source_refs, generic/valid_json_schema, extract/dnd/item-events/source_relatedness | generic/valid_json, extract/dnd/item-events/shape, normalize/dnd/item-events/invariants, extract/dnd/item-events/source_refs, generic/valid_json_schema, extract/dnd/item-events/source_relatedness |
 | NPC interactions | generic/valid_json, extract/dnd/npc-interactions/shape, extract/dnd/npc-interactions/registry, extract/dnd/npc-interactions/source_refs, generic/valid_json_schema, extract/dnd/npc-interactions/source_relatedness | generic/valid_json, extract/dnd/npc-interactions/shape, extract/dnd/npc-interactions/registry, normalize/dnd/npc-interactions/invariants, extract/dnd/npc-interactions/source_refs, generic/valid_json_schema, extract/dnd/npc-interactions/source_relatedness |
 | Scene descriptions | generic/valid_json, extract/dnd/scene-descriptions/shape, extract/dnd/scene-descriptions/source_refs, generic/valid_json_schema, extract/dnd/scene-descriptions/source_relatedness | generic/valid_json, extract/dnd/scene-descriptions/shape, normalize/dnd/scene-descriptions/invariants, extract/dnd/scene-descriptions/source_refs, generic/valid_json_schema, extract/dnd/scene-descriptions/source_relatedness |
+| Enemy events | generic/valid_json, extract/dnd/enemy-events/shape, extract/dnd/enemy-events/engagements, extract/dnd/enemy-events/source_refs, generic/valid_json_schema, extract/dnd/enemy-events/source_relatedness | generic/valid_json, extract/dnd/enemy-events/shape, normalize/dnd/enemy-events/invariants, extract/dnd/enemy-events/source_refs, generic/valid_json_schema, extract/dnd/enemy-events/source_relatedness |
 
 Chains are only registered for the D&D extract and normalize modules shown
 above; select an explicit override when a different compatible chain is

docs/consumers/subprocess.md

@@ -27,10 +27,13 @@ notarius run pipeline-id \
 ```
 
 Use absolute paths for supplied input, configuration, output-root, and
-reference files. When a stable prompt session identifier or references are
-needed, pass the supported CLI flags. Supply credentials through Notarius's
-documented configuration and environment mechanisms, never as command-line
-arguments or generated secret-bearing configuration.
+reference files. Notarius generates a stable prompt session for the resolved
+input module and exact input bytes. Pass **--session-id** only when intentionally
+grouping different invocations under a different session. Supply credentials
+through Notarius's documented configuration and environment mechanisms, never
+as command-line arguments or generated secret-bearing configuration. In
+particular, a session identifier is provider-visible and is not a credential
+mechanism.
 
 Wait for the process before interpreting standard output. Only an exit status
 of 0 permits decoding the receipt. On a nonzero exit, retain standard error for

docs/integrations/dnd-combat-turn-artifacts.md

@@ -64,6 +64,8 @@ kind, and complete valid evidence. It does not infer turns, initiative, or
 actions from registry or scene data.
 
 The [NPC-interaction artifact](dnd-npc-interaction-artifacts.md) records
-broader NPC occurrences. The [JSON output contract](json-output.md) defines
-publication, and [D&D module internals](../internal/dnd.md) describes routing
-and validation mechanics.
+broader NPC occurrences. The [enemy-event artifact](dnd-enemy-event-artifacts.md)
+uses combat turns as grounding only; turns do not establish an enemy event or
+its outcome. The [JSON output contract](json-output.md) defines publication,
+and [D&D module internals](../internal/dnd.md) describes routing and validation
+mechanics.

docs/integrations/dnd-enemy-event-artifacts.md

@@ -0,0 +1,114 @@
+# D&D Enemy-Event Artifact
+
+This contract defines the durable, source-grounded enemy-event occurrence list.
+It records enemies directly established as opposing the party and explicitly
+observed combat outcomes. It is an ordered observation artifact from which a
+consumer may derive a ledger; it is not a ledger, encounter roster, or terminal
+state model.
+
+## Identity and compatibility
+
+| Property | Value |
+| --- | --- |
+| Artifact kind | `dnd/enemy-event-list` |
+| Schema ID | `notarius.dnd.enemy_events` |
+| Schema name | `notarius_dnd_enemy_events_v1` |
+| Schema version | `v1` |
+| Media type | `application/json` |
+
+`v1` is a strict JSON object with required `events`; the array may be empty.
+Event and source-reference objects reject unknown fields. An incompatible shape
+change requires a new schema version.
+
+## Wire shape
+
+Every event has these required fields:
+
+| Field | Contract |
+| --- | --- |
+| `name` | Non-empty display name or directly grounded collective subject label. |
+| `kind` | `engaged`, `killed`, `fled`, `captured`, or `incapacitated`. |
+| `source_refs` | One or more current-transcript evidence ranges. |
+
+Each source reference has exactly `source_id`, `start_unit_id`, and
+`end_unit_id`. It identifies an inclusive current-transcript range; unit IDs
+are positive and the start may not follow the end.
+
+```json
+{
+  "events": [
+    {
+      "name": "Ashfang",
+      "kind": "engaged",
+      "source_refs": [
+        {"source_id": "session-7", "start_unit_id": 41, "end_unit_id": 42}
+      ]
+    },
+    {
+      "name": "Ashfang",
+      "kind": "fled",
+      "source_refs": [
+        {"source_id": "session-7", "start_unit_id": 57, "end_unit_id": 58}
+      ]
+    }
+  ]
+}
+```
+
+## Event semantics and evidence
+
+| Kind | Required evidence |
+| --- | --- |
+| `engaged` | The subject is directly established as actively opposing the party in combat. At most one engagement is emitted for one subject in one combat scene. |
+| `killed` | The transcript explicitly establishes that the subject died or was killed. Damage, defeat, disappearance, or combat ending is insufficient. |
+| `fled` | The subject explicitly escapes, retreats, or otherwise leaves combat to avoid continued engagement. Movement or absence from later turns is insufficient. |
+| `captured` | The subject is explicitly taken prisoner or secured under the party's control. A grapple or temporary restraint alone is insufficient. |
+| `incapacitated` | The subject is explicitly rendered unable to continue acting without being established as killed or captured. A missed turn is insufficient. |
+
+The current transcript is the only event evidence. Campaign context and
+normalized NPC, scene-description, combat-turn, and NPC-interaction artifacts
+can ground names or control combat eligibility, but none may supply event
+evidence. An outcome may share evidence with an engagement, in which case both
+events are retained.
+
+Extraction is limited to chunks with an exact combat-scene classification. An
+exact non-combat classification produces an accepted empty list. Missing or
+mismatched classification also produces an accepted empty list and a
+`scene_classification_unavailable` warning.
+
+## Subjects, normalization, and order
+
+A subject matching the normalized NPC registry uses that registry's canonical
+display name. Unmatched hostile creatures, summoned entities, and directly
+grounded groups remain valid subjects. An unnamed homogeneous group uses the
+narrowest transcript-grounded label, such as `Orcs`, `One orc`, or `Remaining
+orcs`; the artifact never invents synthetic member identities or quantities.
+Party members, allies, neutral observers, mentioned-but-absent enemies, hazards,
+traps, and environmental effects are excluded.
+
+Normalization collapses surrounding and repeated internal whitespace in subject
+display values, canonicalizes recognized registry names, canonicalizes and
+deduplicates exact source ranges, then orders events by valid evidence
+chronology, normalized subject identity, display name, kind, and reference
+sequence. The deterministic kind tie order is `engaged`,
+`incapacitated`, `captured`, `fled`, then `killed`. Only entries with the same
+normalized name, kind, and complete canonical evidence sequence are collapsed.
+Different kinds, evidence, repeated engagement in separate scenes, and later
+outcomes remain separate. A later engagement for the same named subject is
+preserved after an earlier outcome because the artifact does not assert an
+irreversible state transition.
+
+## Non-goals
+
+The artifact has no NPC or scene ID, quantity, confidence, description,
+rationale, summary, current state, or inferred terminal outcome. It does not
+emit `active` or `unresolved`; consumers may derive an unresolved ledger view
+only when an engagement has no later explicit outcome. It never infers an
+outcome from turn absence, scene termination, initiative order, hit-point
+guesses, or other artifacts.
+
+The [JSON output contract](json-output.md) defines publication. Configuration
+keys, required generated-reference slots, and validator-chain selection are
+defined in the [configuration reference](../config.md). Implementation and
+prompt-grounding mechanics are described in the
+[D&D module internals](../internal/dnd.md).

docs/integrations/dnd-npc-artifacts.md

@@ -60,10 +60,13 @@ relationship fields.
 Only individually identifiable NPC names with transcript evidence belong in
 this artifact. Groups, generic roles, invented labels, and descriptive
 enrichment are excluded. Its source references prove registry provenance; they
-do not become evidence for a spell, interaction, or combat occurrence.
+do not become evidence for a spell, interaction, combat, or enemy-event
+occurrence.
 
 This registry can ground actor or caster names in the [spell](dnd-spell-artifacts.md)
 and [combat-turn](dnd-combat-turn-artifacts.md) artifacts. It is required to
 resolve the canonical `name` in an [NPC interaction](dnd-npc-interaction-artifacts.md).
+The [enemy-event artifact](dnd-enemy-event-artifacts.md) also uses it only for
+subject grounding and canonical display names.
 The [JSON output contract](json-output.md) defines publication, and
 [D&D module internals](../internal/dnd.md) owns pipeline mechanics.

docs/integrations/dnd-npc-interaction-artifacts.md

@@ -74,5 +74,8 @@ Only entries with the same canonical name, kind, and complete valid evidence
 sequence are collapsed; distinct categories or evidence remain separate.
 
 See the [combat-turn artifact](dnd-combat-turn-artifacts.md) for combat-action
-occurrences and the [JSON output contract](json-output.md) for publication.
-Pipeline mechanics are described in [D&D module internals](../internal/dnd.md).
+occurrences. The [enemy-event artifact](dnd-enemy-event-artifacts.md) consumes
+only `combat_opponent` interactions as grounding; they never establish an enemy
+event or outcome. The [JSON output contract](json-output.md) defines
+publication. Pipeline mechanics are described in
+[D&D module internals](../internal/dnd.md).

docs/integrations/dnd-scene-description-artifacts.md

@@ -62,8 +62,9 @@ durable fields, or the same source range with different kind, title, or
 summary, is invalid. It does not merge adjacent ranges, alter prose, or infer
 missing scenes.
 
-The [combat-turn artifact](dnd-combat-turn-artifacts.md) uses an exact matching
+The [combat-turn artifact](dnd-combat-turn-artifacts.md) and
+[enemy-event artifact](dnd-enemy-event-artifacts.md) use an exact matching
 `combat` scene only as eligibility control; scene title, summary, and source
-reference never become combat evidence. Publication is defined by the
+reference never become their evidence. Publication is defined by the
 [JSON output contract](json-output.md); implementation details live in
 [D&D module internals](../internal/dnd.md).

docs/integrations/json-output.md

@@ -74,8 +74,9 @@ than infer a lane schema from its name. The current D&D payload contracts are
 [spells](dnd-spell-artifacts.md), [NPCs](dnd-npc-artifacts.md),
 [NPC interactions](dnd-npc-interaction-artifacts.md),
 [combat turns](dnd-combat-turn-artifacts.md),
-[item events](dnd-item-event-artifacts.md), and
-[scene descriptions](dnd-scene-description-artifacts.md).
+[item events](dnd-item-event-artifacts.md),
+[scene descriptions](dnd-scene-description-artifacts.md), and
+[enemy events](dnd-enemy-event-artifacts.md).
 
 ## `manifest.json`
 
@@ -98,6 +99,11 @@ summarize results without embedding lane payload bytes. A chunk-plan summary is
 provenance for the plan used by this run; cache records, debug artifacts, and
 other operational state are not published as bundle files.
 
+When present, `metadata.session_id` is the effective non-secret routing
+correlation identifier used for the run. It can be visible to providers and is
+not a substitute for a cache or checkpoint identity. Its generation and
+override behavior are defined by the [CLI reference](../cli.md#run).
+
 Each `llm_profiles` entry identifies effective, non-secret LLM execution
 provenance:
 

docs/integrations/pkg-promptkit.md

@@ -48,11 +48,13 @@ adapter boundary. It also retains responsibility for pipeline retries,
 scheduling, debug persistence, redaction, profile provenance, and conversion
 from private model responses into durable domain artifacts.
 
-Notarius sends its trimmed run session through PromptKit's direct session
+Notarius sends one stable effective session through PromptKit's direct session
 field, which is authoritative for provider session behavior. It also retains
 the same value as the `session_id` prompt variable for maintained prompt
-compatibility. Session IDs are stable, non-secret correlation identifiers and
-may be exposed to providers and provider observability.
+compatibility. The generated identifier is 76 ASCII characters, within
+PromptKit v0.5.0's 256-code-point session limit. Session IDs are non-secret
+correlation identifiers and may be exposed to providers and provider
+observability. The CLI contract owns generation and override behavior.
 
 Notarius records PromptKit's selected backend ID and effective reasoning
 setting as optional run-manifest provenance. Endpoint-only profiles have no

docs/internal/cli.md

@@ -89,9 +89,11 @@ handoff:
    profiles;
 4. materialize external or generated references and record redacted invocation
    and resolution provenance when debug capture is enabled;
-5. construct registries, the scheduled LLM client, prepared modules, and the
-   requested cache/checkpoint collaborators;
-6. read the source input and invoke the framework runner; and
+5. construct registries, the scheduled LLM client, and prepared modules;
+6. read the source input once, resolve its effective session from the explicit
+   override or resolved input module and raw bytes, then construct requested
+   checkpoint collaborators and invoke the framework runner with that same
+   value; and
 7. write the runner's logical output files only after a successful run, then
    complete the command report and user-facing result.
 
@@ -102,6 +104,13 @@ final command result. Detailed state lifecycle, resume handling, and physical
 path confinement are maintained in [Run State Internals](state.md) and
 [Operations](../operations.md).
 
+The CLI owns the versioned generated-session policy and resolves the sole
+effective value before checkpoint construction. It records that value in the
+final debug invocation summary when capture is enabled and passes it unchanged
+to checkpoint identity and `pipeline.RunInput`. The public flag and stability
+contract are defined by the [CLI reference](../cli.md#run); framework and LLM
+packages only transport the supplied value.
+
 For `run --json`, the CLI constructs and encodes its private run-result receipt
 after a successful runner result is available, before it publishes logical
 output files. It writes the prepared receipt to standard output only after

docs/internal/dnd.md

@@ -7,7 +7,7 @@ selectable keys, bindings, reference syntax, and default validator chains.
 
 ## Durable Artifact Contracts
 
-The six lanes have separate durable wire contracts. This guide deliberately
+The seven lanes have separate durable wire contracts. This guide deliberately
 does not repeat their JSON shapes or schemas.
 
 | Lane | Durable contract |
@@ -18,6 +18,7 @@ does not repeat their JSON shapes or schemas.
 | Item events | [item-event artifacts](../integrations/dnd-item-event-artifacts.md) |
 | NPC interactions | [NPC-interaction artifacts](../integrations/dnd-npc-interaction-artifacts.md) |
 | Scene descriptions | [scene-description artifacts](../integrations/dnd-scene-description-artifacts.md) |
+| Enemy events | [enemy-event artifacts](../integrations/dnd-enemy-event-artifacts.md) |
 
 ## Family Composition
 
@@ -101,14 +102,19 @@ relatedness validators report advisory evidence concerns. The configured order
 is documented in
 [Configuration](../config.md#production-validator-keys-and-default-chains).
 
+Enemy-event extraction additionally rejects a second `engaged` observation for
+the same comparison identity within one scene-scoped result. Normalization may
+combine results from distinct scenes, so it intentionally does not apply that
+rule. Configuration owns the exact validator key and chain position.
+
 Normalizers are deterministic for spells, combat turns, item events, NPC
-interactions, and scene descriptions. They canonicalize display values and
-evidence, use source-document order for stable output, and issue bounded
-warnings for changes or collapsed duplicates. The NPC normalizer is the
-intentional exception: it first produces a deterministic candidate set, then
-uses a bounded structured-LLM proposal to reconcile identity groups. Invalid
-or unusable proposals retain the deterministic result and surface retry or
-fallback diagnostics; the model does not directly replace durable records.
+interactions, scene descriptions, and enemy events. They canonicalize display
+values and evidence, use source-document order for stable output, and issue
+bounded warnings for changes or collapsed duplicates. The NPC normalizer is
+the intentional exception: it first produces a deterministic candidate set,
+then uses a bounded structured-LLM proposal to reconcile identity groups.
+Invalid or unusable proposals retain the deterministic result and surface retry
+or fallback diagnostics; the model does not directly replace durable records.
 
 ## Generated References And Grounding
 
@@ -122,7 +128,10 @@ NPC registries are names-only grounding projections: they may canonicalize
 actors for spells and combat turns and are required for NPC interactions, but
 they do not supply evidence. Scene-description registries are eligibility-only
 projections: they retain the current chunk’s classification data, not scene
-prose or evidence, and exist to route combat extraction.
+prose or evidence, and exist to route combat extraction. Enemy-event extraction
+also projects combat turns to `actor` and `turn_kind` and filters NPC
+interactions to `combat_opponent` names and kinds. These compact projections,
+like NPC grounding, are source-free guidance and never event evidence.
 
 ## Lane-Specific Rules
 
@@ -137,11 +146,15 @@ shared helper changes.
 | Item events | Uses campaign context for disambiguation but has no NPC-registry or scene-description dependency. |
 | NPC interactions | Requires the normalized NPC registry at extraction and normalization, using it for canonical actor grounding only. |
 | Scene descriptions | Produces the classifications consumed by combat routing; it does not consume an NPC registry or provide evidence for combat artifacts. |
+| Enemy events | Requires NPC, scene-description, combat-turn, and NPC-interaction artifacts. It calls the LLM only for an exact `combat` classification, records ordered observations rather than terminal state, and normalizes recognized names through the NPC registry while preserving grounded collective labels. |
 
 The combat and scene-description contracts describe their exact handoff and
 empty-result behavior in more detail:
 [combat turns](../integrations/dnd-combat-turn-artifacts.md) and
 [scene descriptions](../integrations/dnd-scene-description-artifacts.md).
+The [enemy-event contract](../integrations/dnd-enemy-event-artifacts.md)
+defines its durable semantics; [Configuration](../config.md) owns its
+selectable bindings and validation chains.
 
 ## Focused Verification
 

docs/internal/llm.md

@@ -26,9 +26,10 @@ durable schemas. Those responsibilities remain with the module and its
 
 `PromptKitClient` validates the request target and prompt identity, maps each
 named material to a PromptKit inline artifact while preserving its origin URI,
-maps the trimmed request session to PromptKit's direct per-run session field,
-retains the same value as the `session_id` prompt variable for maintained
-prompt compatibility, and forwards profile selection. It then creates one
+passes the supplied request session through to PromptKit's direct per-run
+session field, retains the same value as the `session_id` prompt variable for
+maintained prompt compatibility, and forwards profile selection. It does not
+derive or replace session values; the CLI owns that policy. It then creates one
 frozen prepared execution, captures its caller-owned credential-redacted
 details for debug material, and executes that exact snapshot through
 PromptKit's prepared-execution boundary. The direct field

docs/internal/pipeline.md

@@ -10,11 +10,11 @@ own durable output shapes. Concrete production extensions are covered by
 ## Boundary
 
 The pipeline framework accepts a resolved composition, registries, shared
-dependencies, input bytes, and state/debug collaborators. It returns logical
-output files, normalized artifacts, recorded rejections and warnings, manifest
-provenance, and checkpoint decisions. The CLI owns process arguments,
-configuration discovery, physical roots, and placement of returned output
-files.
+dependencies, input bytes, a supplied prompt session, and state/debug
+collaborators. It returns logical output files, normalized artifacts, recorded
+rejections and warnings, manifest provenance, and checkpoint decisions. The
+CLI owns process arguments, configuration discovery, session resolution,
+physical roots, and placement of returned output files.
 
 The framework has one fixed shape:
 
@@ -84,6 +84,10 @@ incompatible producer prevents the consumer step from starting.
 
 The runner validates its input, installs no-op state collaborators when none
 were supplied, and serially performs source parsing and chunk-plan selection.
+It transports the supplied session unchanged to prompt-facing operations and
+run-manifest metadata; it neither derives a session nor substitutes a parsed
+source document identifier. The public session contract is owned by the
+[CLI reference](../cli.md#run).
 An accepted plan is materialized into source-addressed chunks and passes the
 configured chunk validators before any lane runs. A chunk rejection is a
 recorded pipeline outcome: lanes do not start, but the output stage can encode

docs/operations.md

@@ -266,16 +266,18 @@ transport-wide cap. Notarius does not add another timeout around PromptKit.
 The pinned upstream boundary and profile-format links are in
 [PromptKit Integration](integrations/pkg-promptkit.md).
 
-Concurrency has two independent layers. Notarius **total_llm** is the
-application-wide provider-call limit shared by all backends, modules, retries,
-and validators. PromptKit may impose a narrower admission limit for the
-selected backend. The effective active-generation bound is the intersection of
-both limits and can therefore be lower than **total_llm**. Built-in OpenRouter
-profiles use PromptKit's upstream backend limit; endpoint-only profiles have no
-PromptKit backend limit and remain bounded by Notarius. For the configured
-local backend, a zero **concurrency_limit** leaves only the Notarius scheduler
-as a call limit. A positive value makes the effective active local-generation
-bound the smaller of **total_llm** and that local limit.
+Concurrency has two independent layers. Notarius **total_llm** defaults to 16
+and is the application-wide provider-call limit shared by all backends,
+modules, retries, and validators. PromptKit may impose a narrower admission
+limit for the selected backend. The effective active-generation bound is the
+intersection of the Notarius limit, any PromptKit backend limit, and work made
+available by the pipeline. Built-in OpenRouter profiles use PromptKit's
+upstream backend limit; endpoint-only profiles have no PromptKit backend limit
+and remain bounded by Notarius. For the configured local backend, a zero
+**concurrency_limit** leaves only the Notarius scheduler as a call limit. A
+positive value makes the effective active local-generation bound the smaller
+of **total_llm** and that local limit, so a local limit of four permits no more
+than four active local generations.
 
 For a positive local limit, PromptKit owns its default waiting capacity and
 admission behavior. When a PromptKit backend has admitted all active and queued
@@ -289,3 +291,11 @@ under [PromptKit profiles](config.md#promptkit-profiles) and
 limits and actual provider-call limits are independent. Notarius writes local
 filesystem state only; remote storage, archival, and retention automation are
 outside the implemented CLI.
+
+Every run has an effective prompt session used for provider routing and run
+provenance. The generated default is stable for the same input module and raw
+input bytes; use [**--session-id**](cli.md#run) only when intentionally grouping
+different invocations. Both generated and explicit values can be visible to
+providers, manifests, checkpoints, and requested debug bundles. Do not put
+credentials or other secrets in an explicit session identifier; command-line
+values are not a credential mechanism.

docs/roadmap/future.md

@@ -7,24 +7,6 @@ not as committed release dates.
 
 ## Near-Term D&D Pipeline
 
-### Combat Enemy Ledger
-
-- Add a D&D artifact that identifies enemies faced during combat and supports
-  an end-of-session encounter ledger.
-- Track each enemy's observed state using a small controlled vocabulary such as
-  `active`, `killed`, `fled`, `captured`, or `incapacitated`, while preserving
-  an explicit unresolved state when the transcript does not establish an
-  outcome.
-- Preserve the evidence for enemy participation and state changes rather than
-  inferring a terminal outcome from combat ending or an enemy disappearing
-  from the conversation.
-- Define how repeated mentions, groups of unnamed enemies, summoned or allied
-  creatures, and the same enemy appearing in multiple combats affect identity
-  and ledger entries.
-- Evaluate whether the ledger should be extracted directly, derived from
-  combat-turn artifacts, or use a sequential pipeline that consumes combat
-  turns and the normalized NPC registry as grounding references.
-
 ### Location Extraction
 
 - Add a D&D artifact for locations visited by the party or otherwise mentioned
@@ -53,71 +35,6 @@ not as committed release dates.
   spell, combat, interaction, and scene-description lanes after real-world use.
   Add more complex chunking only in response to demonstrated failures.
 
-## Cross-Cutting LLM Runtime
-
-### Deterministic Prompt Session Identity
-
-- Replace the source-document-ID default for prompt sessions with one
-  predictable, procedurally generated session ID for the complete
-  source-processing workload.
-- Preserve an explicit non-empty `--session-id` as the highest-precedence
-  override. Otherwise, derive the default only from the effective input module
-  identity and the exact raw input bytes.
-- Use a versioned, bounded representation such as
-  `notarius:v1:<sha256(input-module + NUL + raw-input)>`. The exact encoding
-  must fit PromptKit's session length contract and must not embed source
-  content.
-- Keep the derived session stable across runs, pipelines, selected lanes,
-  ordered steps, retries, resume, recomputation, LLM profiles, reasoning
-  overrides, and output, debug, or cache settings.
-- Do not include file-backed references, generated references, reference
-  contents, or the composition of a reference bundle in session derivation.
-  References may change between prompt calls within one pipeline without
-  changing routing affinity.
-- Resolve the authoritative session before checkpoint construction and use the
-  same value for checkpoint runtime identity, every prompt-facing module,
-  PromptKit's direct session field, the compatibility `session_id` prompt
-  variable, run-manifest metadata, and debug metadata.
-- Keep routing identity separate from cache and checkpoint content identity.
-  Exact prompt prefixes, reference contents, model settings, and other
-  generation-affecting inputs must continue to participate in their existing
-  hashes and checkpoint fingerprints even though they do not change the
-  session.
-- Treat the generated value as a provider-visible, stable pseudonymous
-  correlation identifier. Do not introduce an installation-specific HMAC or
-  secret unless a concrete multi-tenant or privacy requirement justifies
-  sacrificing deterministic identity across installations.
-
-### Raise The Default Application-Wide LLM Limit
-
-- Raise the default `concurrency.total_llm` value from 1 to 16 so ordinary
-  single-backend runs can use PromptKit's expected OpenRouter capacity and
-  lower-capacity local backends without an unnecessarily narrower Notarius
-  limit.
-- Keep the Notarius application-wide scheduler mandatory and require
-  `total_llm` to remain a positive integer. Do not make the default unlimited:
-  endpoint-only profiles, an unrestricted local backend, injected clients, and
-  aggregate work across several backends may have no narrower PromptKit limit.
-- Continue defaulting `concurrency.stage_workers.extract` to the effective
-  `total_llm`, making its default 16 as part of the same change. Preserve an
-  explicit lower extract-worker setting when an operator wants less queued or
-  concurrent extraction work.
-- Define effective provider concurrency as the intersection of the Notarius
-  application-wide limit, the selected PromptKit backend limit when present,
-  and the work made available by stage execution. A Notarius limit of 16 does
-  not narrow a backend already limited to 16, while a local backend limited to
-  4 remains bounded at 4.
-- Treat the default as an application-wide safety ceiling across profiles,
-  backends, modules, retries, and validators. A run that intentionally needs
-  the combined capacity of several backends may configure a higher
-  `total_llm` and an appropriate extract-worker count explicitly.
-- Retain the existing configuration and environment override surfaces. Update
-  canonical configuration, operations, and internal documentation together
-  when the default changes.
-- Reconsider decoupling the extract-worker default from `total_llm` only after
-  mixed-backend workloads demonstrate a need for a high global emergency
-  ceiling with a lower default work-production rate.
-
 ## Shared Normalization And Quality Work
 
 ### Generic LLM-Assisted Deduplication

docs/roadmap/location.md

@@ -0,0 +1,337 @@
+# D&D Location Tracking
+
+## Purpose
+
+Add evidence-grounded D&D location tracking without turning a single extractor
+into both an entity registry and an event classifier. The target design follows
+the established NPC pattern: one lane identifies canonical location records and
+a later lane records how the party related to those locations in the transcript.
+
+This roadmap defines the desired end state and policy choices. The ordered work
+needed to reach that state is in [the implementation plan](implementation.md).
+
+## User Intent
+
+- Record locations the party visits or that the session otherwise discusses.
+- Distinguish current physical presence from plans, recollections, and ordinary
+  mentions.
+- Preserve transcript evidence for every durable record.
+- Reconcile aliases and repeated appearances conservatively.
+- Keep distinct places separate when they happen to share a generic name.
+- Keep the schemas minimal. Location description, hierarchy, participants, and
+  narrative analysis belong in other artifacts or deterministic joins.
+
+## Target Capability
+
+The D&D module family will have two new lanes:
+
+1. `dnd/locations` produces a session-scoped registry of physical places.
+2. `dnd/location-occurrences` consumes the normalized location registry and
+   produces an ordered list of source-grounded relationships between the party
+   and those places.
+
+The normalized location artifact is handed to the occurrence lane through a
+required generated reference named `locations`. The occurrence lane must use
+that registry for identity grounding, but the current transcript remains its
+only evidence source.
+
+## Durable Artifact Contracts
+
+Both contracts remain at `v1`; Notarius is pre-release and does not need a
+compatibility layer for these new artifacts.
+
+### Location registry
+
+The location lane uses:
+
+- artifact kind: `dnd/location-list`
+- module key: `dnd/locations`
+- schema ID: `notarius.dnd.locations`
+- schema name: `notarius_dnd_locations_v1`
+- media type: `application/json`
+- root member: `locations`
+
+Each location contains exactly:
+
+| Field | Type | Meaning |
+| --- | --- | --- |
+| `id` | string | Deterministic, session-scoped canonical location identity. |
+| `name` | string | Evidence-grounded display name or transcript-established label. |
+| `source_refs` | non-empty source-reference array | Current-transcript evidence that identifies the place. |
+
+Locations are physical or spatial places: planes, regions, settlements,
+districts, buildings, rooms, landmarks, routes, and geographic features. A
+generic label such as `the tavern` is permitted only when the transcript uses
+it for a specific place. The extractor must not invent a qualifier merely to
+distinguish that place from another place with the same label.
+
+The registry does not contain type, parent, description, summary, coordinates,
+participants, visit status, or occurrence data. Parent and child places are
+separate identities when the transcript identifies both; nesting alone is not
+a reason to merge them.
+
+### Location occurrences
+
+The occurrence lane uses:
+
+- artifact kind: `dnd/location-occurrence-list`
+- module key: `dnd/location-occurrences`
+- schema ID: `notarius.dnd.location_occurrences`
+- schema name: `notarius_dnd_location_occurrences_v1`
+- media type: `application/json`
+- root member: `occurrences`
+
+Each occurrence contains exactly:
+
+| Field | Type | Meaning |
+| --- | --- | --- |
+| `location_id` | string | An exact ID from the consumed normalized location registry. |
+| `name` | string | The canonical display name associated with `location_id`. |
+| `kind` | enum | `visited`, `planned`, `recalled`, or `mentioned`. |
+| `source_refs` | non-empty source-reference array | Current-transcript evidence for both the place and the classified occurrence. |
+
+`location_id` is required even though existing NPC interactions currently use
+name-only grounding. Locations can legitimately share the same display name,
+so a name alone cannot provide an unambiguous cross-artifact link. The name is
+retained for readable standalone output and must exactly match the registry
+record selected by the ID after normalization.
+
+## Identity Policy
+
+Location identity is conservative and scoped to one source document. It is not
+a campaign-wide or cross-session world identity.
+
+Display normalization trims surrounding whitespace and collapses internal
+Unicode whitespace. Comparison normalization uses the existing D&D entity
+rules: Unicode NFKC normalization, normalized apostrophes, collapsed
+whitespace, and Unicode case folding.
+
+The canonical ID is:
+
+~~~text
+location:sha256:<lowercase SHA-256 hex digest>
+~~~
+
+The digest input is the UTF-8 encoding of compact JSON for this five-element
+array:
+
+~~~text
+["dnd.locations.identity.v1", comparison_name, source_id, start_unit_id, end_unit_id]
+~~~
+
+The source values come from the earliest reference after canonical reference
+sorting and exact deduplication. Compact JSON array encoding is part of the
+identity contract: it avoids delimiter ambiguity and must not be replaced
+without changing the policy version. A blank comparison name or missing valid
+source reference produces no manufactured ID and remains a validation error.
+
+Including the evidence anchor prevents two unrelated places called `the
+tavern` from receiving the same ID. When semantic normalization safely groups
+aliases or repeated appearances, it first chooses an existing canonical display
+name and unions the evidence; it then derives the final ID from that name and
+the earliest unioned reference.
+
+The normalizer may merge records only when transcript evidence clearly shows
+that they denote the same physical place. It must not merge records solely
+because:
+
+- their comparison names are equal;
+- they are near one another in the transcript;
+- one is spatially nested inside the other; or
+- their labels are both generic.
+
+Distinct normalized records may therefore have the same comparison name, but
+their IDs must be unique and correctly derived. Exact duplicates with the same
+comparison name and canonical evidence may be collapsed deterministically.
+
+## Occurrence Semantics
+
+Each occurrence has one kind:
+
+- `visited`: current-session gameplay establishes that one or more party
+  members are physically present at the location, including an arrival,
+  continuing presence, or departure.
+- `planned`: the party explicitly proposes, intends, or agrees to future travel
+  to the location. Mere hypotheticals or speculation are not plans.
+- `recalled`: the transcript explicitly recounts or recaps the party being at
+  the location before the current session's live events.
+- `mentioned`: the location is explicitly referenced but the occurrence does
+  not meet a stronger definition. This includes lore, directions, third-party
+  activity, non-actionable speculation, and out-of-character discussion.
+
+An inferred but unstated place produces no location or occurrence. Uncertainty
+is handled by conservative omission rather than an `uncertain` enum value.
+
+For one occurrence supported by overlapping evidence, classification precedence
+is `visited`, then `planned`, then `recalled`, then `mentioned`; `mentioned` is
+the fallback. A passage may produce multiple records when it independently
+supports separate facts, such as recalling an earlier visit while planning a
+return. Exact duplicates with the same ID, kind, and canonical evidence are
+collapsed. Different kinds or independently supported evidence remain.
+
+Output is ordered by earliest evidence in source-document order, then by
+`location_id`, `name`, kind order (`visited`, `planned`, `recalled`,
+`mentioned`), and the remaining canonical reference sequence.
+
+## Extraction, Normalization, And Evidence
+
+### Location registry lane
+
+The extractor is LLM-backed and follows the shared D&D extraction prompt and
+input conventions. It emits names and source ranges through a private response
+schema; deterministic mapping supplies the current source ID and derives
+candidate IDs. Campaign references may disambiguate terminology but never
+become durable evidence.
+
+The merger uses the typed append-order convention. The normalizer is LLM-backed:
+it deterministically prepares names and evidence, then asks the model only for
+duplicate groups. The model may identify groups and choose a canonical member,
+but it may not create, delete, rewrite, or directly replace durable records.
+Code validates the proposal, applies non-overlapping safe groups, unions
+evidence, derives final IDs, orders output, and emits bounded warnings.
+
+Malformed, unknown, overlapping, or ambiguous proposal groups are rejected.
+The normalizer uses the existing bounded retry behavior and falls back to the
+safe deterministic candidate set if no usable proposal is obtained.
+
+### Location occurrence lane
+
+The extractor is LLM-backed and requires exactly one validated `locations`
+reference. The prompt projection contains only ordered `{id, name}` pairs; it
+omits registry evidence and reference provenance. The model must copy both
+values from one projected record and cite current-transcript source ranges for
+the occurrence.
+
+The occurrence normalizer is deterministic. It canonicalizes names by exact
+registry ID, normalizes evidence and ordering, and removes exact duplicates.
+Unknown IDs and mismatched ID/name pairs remain inspectable validation failures
+rather than being guessed or silently reassigned.
+
+The occurrence lane cannot add a missing location to the registry. If the
+location extractor omitted a place, the correct behavior is to omit its
+occurrence and improve the upstream extraction later.
+
+## Shared Entity Reconciliation
+
+Adding a second LLM-assisted entity registry demonstrates a concrete shared
+need in the D&D domain. The existing NPC normalization context-window and
+proposal-safety logic will move to
+`internal/modules/dnd/shared/entityreconcile` and serve both NPC and location
+normalizers.
+
+The shared package owns:
+
+- deterministic opaque candidate keys;
+- source-window construction and canonical prompt materials;
+- a common private duplicate-group response contract;
+- validation of unknown, repeated, overlapping, malformed, or ineligible
+  candidate keys; and
+- immutable assessment results identifying safe groups.
+
+It does not call the LLM, choose domain-specific canonical names, derive
+durable IDs, mutate domain artifacts, or format domain warnings. Those
+responsibilities remain in each normalizer.
+
+NPC normalization will migrate to the shared key-based proposal contract
+without changing its durable NPC behavior. Its prompt and private response
+schema fingerprints are expected to change, so stale NPC normalization
+checkpoints will invalidate normally.
+
+The two normalizers will reuse an exactly identical shared reconciliation
+instruction asset and private response schema. Module-owned task text will
+continue to define the different NPC and location identity rules. This keeps
+shared prompt content identical without pretending the two domains have the
+same semantic merge policy.
+
+This helper is intentionally D&D-specific. It does not implement the broader
+domain-neutral replacement-element normalizer still described in
+[future work](future.md).
+
+## Reference Contract And Pipeline Placement
+
+The generated reference slot is named `locations` and accepts exactly one JSON
+artifact of kind `dnd/location-list`, with the established 1 MiB limit. It is
+required by both extraction and normalization for
+`dnd/location-occurrences`. Static file bindings remain valid where the
+framework permits them, but the maintained complete example uses a generated
+same-run artifact.
+
+The complete D&D pipeline places `locations` in the first descriptive step
+alongside the independent NPC, item-event, and scene-description lanes. It
+places `location-occurrences` in the next step and binds the accepted normalized
+location artifact from the first step. The occurrence lane has no mandatory
+NPC or scene-description dependency.
+
+No current downstream lane is changed to consume location artifacts. Future
+narrative reports or joins may use the canonical IDs after defining their own
+contracts.
+
+## Validation And Production Defaults
+
+The location registry receives production validators for:
+
+- required shape and supported ID syntax;
+- current-document and current-chunk source ranges;
+- normalized identity derivation and ID uniqueness; and
+- advisory source relatedness.
+
+The location occurrence artifact receives production validators for:
+
+- required shape and the four supported kinds;
+- registry membership and exact ID/name correspondence;
+- normalized ordering and exact-duplicate invariants;
+- current-document and current-chunk source ranges; and
+- advisory source relatedness.
+
+Validators remain immutable and diagnostic. Durable JSON Schema validation
+stays in the production chains after semantic shape and source-reference
+checks, consistent with the existing D&D lanes.
+
+## Documentation End State
+
+Implementation will add canonical integration documents for both durable
+artifacts and update current-state documentation to cover:
+
+- both module and artifact keys;
+- the `locations` generated-reference slot;
+- production validators and default chains;
+- D&D family composition, reconciliation, identity, and grounding behavior;
+- the complete maintained pipeline example; and
+- JSON output and evidence-context support.
+
+After the feature is implemented, the fulfilled Location Extraction section is
+removed from `future.md`. Historical implementation narration remains in
+version control rather than current documentation.
+
+## Out Of Scope
+
+- Campaign-wide or cross-session canonical location IDs.
+- A location ontology, hierarchy, map, coordinates, or containment graph.
+- Location descriptions, summaries, participants, ownership, or encounter
+  analysis.
+- Inferring a location that the transcript does not identify.
+- Automatically creating registry records from occurrence output.
+- Changing NPC-interaction artifacts to use NPC IDs.
+- Making other lanes consume location references.
+- A generic domain-neutral LLM deduplication framework.
+- Long-term artifact-version migration machinery.
+
+## Acceptance Criteria
+
+- Both durable contracts are minimal, strict, versioned, and registered.
+- Location IDs are deterministic under the documented policy and do not force
+  same-named places to collapse.
+- Alias and repeat reconciliation is proposal-only, conservatively validated,
+  and safe on retry exhaustion.
+- Occurrences use one of the four defined kinds and carry an unambiguous
+  registry ID/name pair plus current-transcript evidence.
+- Missing, malformed, oversized, or incompatible `locations` references fail
+  through the established configuration or operation boundaries.
+- Both lanes have typed mergers, normalizers, evidence projectors, validators,
+  default chains, prompt/profile metadata, and registration coverage consistent
+  with the D&D family.
+- NPC normalization retains its durable behavior after adopting the shared
+  reconciliation helper.
+- The maintained complete example loads and exercises the generated handoff.
+- Focused D&D and integration tests pass offline, and current documentation
+  describes only implemented behavior once the work is complete.

docs/roadmap/promptkit.md

@@ -1,318 +0,0 @@
-# PromptKit v0.5 Integration And LLM Profile Policy
-
-## Purpose
-
-This roadmap defines the target state for upgrading Notarius from PromptKit
-v0.3.0 to v0.5.0 and adopting the upstream runtime and profile facilities that
-directly improve Notarius. It also defines the application policy for stable,
-domain-oriented LLM profile names, operator overrides, pipeline inheritance,
-profile validation, provider defaults, checkpoint identity, and documentation.
-
-The ordered work needed to reach this state belongs in
-[the implementation plan](implementation.md). Current behavior remains defined
-by the canonical documentation outside `docs/roadmap/` until the corresponding
-work is implemented.
-
-## Background
-
-Notarius currently pins PromptKit v0.3.0. Its adapter prepares a request once
-for debug material and then independently runs the original request, causing
-PromptKit to prepare the same logical call a second time. The CLI validates an
-explicit profile by preparing a synthetic prompt. PromptKit profile selection
-can be repeated on individual module bindings or replaced for one invocation
-with `--llm-profile`, but a configured pipeline cannot yet declare one inherited
-profile policy.
-
-PromptKit v0.4.0 and v0.5.0 add the upstream boundaries needed to improve these
-areas:
-
-- [v0.4.0](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.5.0/docs/releases/v0.4.0.md)
-  adds opaque prepared executions, exact profile and prompt inspection, and a
-  typed backend-capacity error;
-- [v0.5.0](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.5.0/docs/releases/v0.5.0.md)
-  adds application fallback profile filesystems and stops sending unset
-  optional sampling controls as framework-selected provider values; and
-- the [v0.5.0 format contract](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.5.0/docs/formats.md)
-  defines the resulting profile-source and execution-setting precedence.
-
-A source-compatibility test of the current Notarius repository against
-PromptKit v0.5.0 completed successfully. The work is therefore primarily an
-intentional runtime and configuration migration rather than a repair for a
-breaking Go API change.
-
-## Goals
-
-- Pin and document PromptKit v0.5.0 as Notarius's supported upstream contract.
-- Execute the exact prepared request snapshot whose safe details are recorded
-  in Notarius debug material.
-- Validate configured PromptKit profiles through the upstream inspection API
-  without synthetic prompts, provider calls, or credential-value access.
-- Give Notarius an application-owned, operator-overridable
-  `dnd-extraction` profile fallback.
-- Let a pipeline choose one default LLM profile without repeating that ID on
-  every LLM-backed binding.
-- Apply profile inheritance and run-wide overrides only where the resolved
-  module or validator can use an LLM.
-- Preserve accurate checkpoint invalidation, effective profile provenance,
-  redaction, cancellation, concurrency, and provider-neutral module contracts.
-- Provide operators with one clear deployment pattern for production,
-  development, and local profile definitions.
-
-## Target End State
-
-### PromptKit Runtime Boundary
-
-Notarius depends on PromptKit v0.5.0 and uses its public APIs rather than
-reimplementing source or execution resolution.
-
-For each structured completion, the adapter:
-
-1. builds one PromptKit run request from the provider-neutral Notarius request;
-2. calls `PrepareExecution` once;
-3. immediately arranges an idempotent `Discard` for every unexecuted handle;
-4. obtains credential-redacted `Details` for debug and response metadata; and
-5. calls `RunPrepared` so generation uses that exact frozen snapshot.
-
-The debug prompt and successful result therefore describe the same selected
-profile, rendered messages, input bytes, session, output contract, and effective
-settings even when a filesystem-backed source changes concurrently. PromptKit
-handle types remain private to `internal/framework/llm`.
-
-PromptKit admission failures continue to match Notarius's provider-neutral
-`ErrLLMCapacityExceeded` contract. When PromptKit supplies a `CapacityError`,
-the adapter obtains the normalized backend ID through `errors.As` and may add it
-to safe application-owned diagnostics without parsing upstream error wording.
-The backend ID does not become a provider-specific module contract.
-
-### Optional Provider Controls
-
-Notarius accepts PromptKit v0.5.0's new behavior for `temperature`,
-`max_tokens`, and `top_p`: an unset setting is omitted from compatible provider
-requests and the provider chooses its own default. Notarius does not restore
-PromptKit's former implicit `top_p: 1` value globally.
-
-An operator who requires a particular value specifies it in the selected
-PromptKit profile. The application fallback described below intentionally
-leaves these controls unset. A human-reviewed D&D extraction comparison should
-be performed after the upgrade, but paid or nondeterministic model output is
-not part of the default automated test suite.
-
-### Profile Inspection
-
-Pipeline-aware configuration validation uses `Engine.InspectProfile` for every
-effective explicit profile ID. It verifies that the profile exists, parses and
-validates, resolves its backend and target, and is compatible with the engine's
-registered backends. It does not create a synthetic prompt, load prompt inputs,
-contact a provider, or require credential values to exist in the validation
-process environment.
-
-Credential availability is execution-time state. PromptKit preparation still
-enforces the selected profile's credential contract before generation. This
-keeps `notarius config validate` useful in build and deployment validation
-environments where secrets are deliberately absent.
-
-PromptKit construction for inspection and execution uses one shared internal
-profile-source and backend-option path. The CLI does not expose PromptKit public
-types across the Notarius LLM boundary merely to perform inspection.
-
-`InspectPrompt` is not adopted merely because it exists. It remains available
-for a later, separately defined module-to-prompt interface preflight if a
-concrete validation requirement justifies that additional contract.
-
-### Application And Operator Profile Sources
-
-Notarius embeds one ordinary PromptKit YAML profile with the stable ID
-`dnd-extraction`. It is an application fallback registered through
-`WithFallbackProfileFS`, is owned by the D&D module family, and initially
-preserves the current effective D&D baseline:
-
-- backend: PromptKit's built-in `openrouter` backend;
-- model: `openai/gpt-5.6-luna`;
-- reasoning effort: unset, allowing OpenAI's backend to apply its default of
-  `medium`;
-- generation timeout: 240 seconds;
-- service tier: `flex`; and
-- no application-selected `temperature`, `max_tokens`, or `top_p`.
-
-All maintained D&D LLM prompt definitions use `dnd-extraction` as their
-`default_profile`. The ID communicates workload intent rather than a provider,
-model, or environment. Changing the embedded fallback is an intentional
-Notarius execution-policy change and participates in checkpoint identity.
-
-Effective profile definitions resolve in PromptKit's order:
-
-1. programmatic in-memory profiles used by tests or explicit consumers;
-2. the operator source configured by `promptkit.profile_file` or
-   `promptkit.profile_dir`;
-3. the Notarius application fallback source; and
-4. PromptKit's embedded built-in catalog.
-
-Only an absent ID falls through to the next source. A matching profile is a
-complete definition: fields are not merged with a lower-precedence definition,
-and a malformed matching operator profile fails rather than silently selecting
-the application fallback.
-
-Production, development, and local deployments should normally provide
-different complete definitions for the same `dnd-extraction` ID. An operator
-source is optional because the application fallback keeps the maintained D&D
-workflow usable, but a deployment that needs an intentional model or backend
-policy should configure its own definition.
-
-### Domain Ownership And Asset Assembly
-
-The D&D fallback profile remains under `internal/modules/dnd` and is registered
-by the D&D registrar, consistent with ADR-0004. Generic LLM plumbing knows how
-to collect and flatten application fallback profile filesystems but contains no
-D&D model or policy knowledge.
-
-The shared asset registry detects invalid roots, unreadable sources, and
-duplicate flattened paths. PromptKit remains responsible for strict profile
-YAML parsing, duplicate profile-ID detection, source precedence, and effective
-target resolution. The same assembled fallback source is supplied to runtime
-execution and CLI profile inspection.
-
-### Explicit Module Execution Metadata
-
-Every registered input, chunk, extract, merge, normalize, and output module
-declares one required execution class: `deterministic` or `llm_backed`.
-Validator registrations continue to declare the same distinction through their
-validator specifications.
-
-The registered specification is authoritative for configuration resolution.
-Current production classifications are:
-
-- the D&D scene chunker, all D&D extractors, and the D&D NPC normalizer are
-  LLM-backed;
-- the Seriatim input adapter, generic chunker, all current mergers, all other
-  current normalizers, and the JSON output encoder are deterministic; and
-- current validators retain their declared classifications.
-
-Missing or unsupported execution metadata is a registration error. Explicitly
-assigning `llm_profile` to a deterministic module or validator is a pipeline
-resolution error. The framework does not infer execution class by inspecting
-domain package names or concrete implementation types at runtime.
-
-The module specification replaces the chunk runner's special runtime
-execution-class probe. Effective resolved bindings already express the result:
-only LLM-backed bindings may retain a non-empty profile.
-
-### Pipeline-Level Profile Default
-
-Configuration version 4 gains one optional non-empty pipeline field:
-
-```yaml
-pipelines:
-  dnd-session:
-    llm_profile: dnd-extraction
-```
-
-No configuration-version increment is required because the field is additive
-and existing files remain valid. An explicitly present blank value is invalid.
-
-For every selected LLM-backed module and validator, the effective profile uses
-this precedence:
-
-1. non-empty run-wide `--llm-profile` override;
-2. binding-specific `llm_profile`;
-3. pipeline-level `llm_profile`; and
-4. the prompt definition's `default_profile`, represented by an empty effective
-   Notarius binding profile.
-
-The run-wide override and inherited pipeline default never attach to a
-deterministic binding. Binding-specific exceptions remain available when one
-operation needs a different cost, latency, quality, backend, or reasoning
-policy.
-
-Inheritance is resolved after module and validator selection, including
-`--only` lane filtering, but before effective-pipeline validation, digest
-construction, explicit-profile inspection, checkpoint construction,
-preparation, execution, or provenance capture. Only profiles used by selected
-LLM-backed bindings are inspected. An unused pipeline default in a pipeline
-with no selected LLM-backed work does not require an otherwise unused profile
-to exist.
-
-The resolved pipeline contains effective binding profiles rather than a second
-runtime inheritance mechanism. Two pipelines that differ only by spelling the
-same effective policy once as a pipeline default and once on every LLM-backed
-binding have the same semantic resolved digest. Changing an effective profile
-changes the digest and applicable checkpoint identity.
-
-### Provenance And Checkpoints
-
-The PromptKit profile-source checkpoint fingerprint covers:
-
-- the PromptKit v0.5.0 built-in profile catalog identity;
-- exact application fallback profile asset content; and
-- exact configured operator profile YAML content, when present.
-
-The existing local-backend target fingerprint remains separate and continues
-to exclude scheduling-only concurrency limits. Fingerprints contain hashes and
-stable markers, not profile contents, filesystem paths, endpoints, credentials,
-or other secrets.
-
-Changing the PromptKit version, application fallback, operator profile, or
-effective pipeline profile makes incompatible LLM checkpoints ineligible for
-reuse. The dependency upgrade is expected to invalidate checkpoints produced
-under v0.3.0.
-
-Successful run manifests continue to record only profiles actually selected by
-PromptKit, including their effective model, backend, and reasoning metadata.
-Debug output reports the same effective execution snapshot used for generation.
-
-### Operator Documentation And Examples
-
-Canonical documentation clearly distinguishes:
-
-- Notarius prompt and schema assets embedded in the application;
-- Notarius application fallback profiles embedded in the application;
-- PromptKit's own embedded built-in profiles; and
-- operator profile files on the deployment filesystem.
-
-The configuration reference owns the pipeline field, profile-source fields,
-validation rules, and precedence. Operations owns deployment layout, working
-directory behavior, credentials, and environment-specific profile management.
-The PromptKit integration document owns the pinned upstream contract and
-source-precedence boundary. Internal documents describe asset registration,
-resolution, inspection, prepared execution, fingerprinting, and tests without
-duplicating user-facing field definitions.
-
-The maintained examples continue to include only the minimal and complete D&D
-configurations. They use the stable `dnd-extraction` policy, and one maintained
-PromptKit profile file under `examples/` demonstrates an operator override.
-Examples remain secret-free and are validated without live provider calls.
-
-## Out Of Scope
-
-- Implementing the separate deterministic prompt-session identity roadmap
-  item.
-- Changing the default `concurrency.total_llm` value; PromptKit's retained
-  OpenRouter capacity of 16 remains relevant to that separate item.
-- Adding model evaluation as a deterministic or CI correctness gate.
-- Automatically selecting production, development, or local environments.
-  Deployment configuration chooses the operator profile source.
-- Profile inheritance, partial profile merging, or cross-profile aliases.
-- Exposing PromptKit types to modules, validators, durable output contracts, or
-  public configuration structures.
-- Adopting `InspectPrompt` without a separately justified prompt-interface
-  validation contract.
-
-## Acceptance Criteria
-
-- Notarius builds and its offline test suite passes with PromptKit v0.5.0.
-- Every structured completion executes the exact snapshot used for safe debug
-  prompt details.
-- Profile preflight uses profile inspection and no synthetic prompt.
-- The embedded `dnd-extraction` fallback resolves without an operator source,
-  and a matching valid operator profile replaces it completely.
-- Every production module has explicit, correct execution metadata.
-- Pipeline, binding, CLI, and prompt-default precedence behaves as defined for
-  modules and validators, while deterministic bindings remain profile-free.
-- Effective profiles participate in pipeline digests, profile inspection,
-  checkpoint identity, debug records, and run provenance at the appropriate
-  boundaries.
-- The dependency and application fallback changes invalidate incompatible old
-  checkpoints without exposing profile or credential content.
-- Canonical documentation and maintained examples accurately describe and
-  exercise the implemented operator workflow.
-- Default tests remain deterministic, offline, credential-free, and focused on
-  Notarius-owned behavior rather than duplicating PromptKit's upstream suite.

examples/dnd-complete.config.yml

@@ -40,6 +40,7 @@ pipelines:
             - spells
             - combat-turns
             - npc-interactions
+            - enemy-events
     steps:
       # Establish session-wide reference artifacts alongside independent item events.
       - id: describe-session
@@ -101,3 +102,28 @@ pipelines:
               retries: 2
             merge: appendorder
             normalize: dnd/npc-interactions
+      - id: track-enemies
+        references:
+          npcs:
+            artifact:
+              step: describe-session
+              lane: npcs
+          scene_descriptions:
+            artifact:
+              step: describe-session
+              lane: scene-descriptions
+          combat_turns:
+            artifact:
+              step: extract-events
+              lane: combat-turns
+          npc_interactions:
+            artifact:
+              step: extract-events
+              lane: npc-interactions
+        artifacts:
+          enemy-events:
+            extract:
+              module: dnd/enemy-events
+              retries: 2
+            merge: appendorder
+            normalize: dnd/enemy-events

internal/cli/cache_contract_test.go

@@ -249,10 +249,24 @@ func TestRunAutoReusesPlanWhenRunInputsChange(t *testing.T) {
 	}
 	harness.mu.Lock()
 	chunkCalls := harness.chunkCalls
+	sessions := append([]string(nil), harness.sessionIDs...)
 	harness.mu.Unlock()
 	if chunkCalls != 1 {
 		t.Fatalf("chunk calls across changed run inputs = %d, want 1", chunkCalls)
 	}
+	rawInput, err := os.ReadFile(roots.input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantSessionID, err := resolvePromptSessionID("", "test/input", rawInput)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, sessionID := range sessions {
+		if sessionID != wantSessionID {
+			t.Fatalf("session IDs across reference changes = %#v, want %q", sessions, wantSessionID)
+		}
+	}
 	assertFile(t, filepath.Join(roots.plans, strings.TrimPrefix(stateTestDigest, "sha256:"), "plan.json"))
 	assertAnyFile(t, roots.output)
 }

internal/cli/dnd_enemy_events_contract_test.go

@@ -0,0 +1,275 @@
+package cli
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/artifacts"
+	"gitea.maximumdirect.net/eric/notarius/internal/core/config"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/evidencecontext"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/chunk/scenes"
+	combat "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/combatturns"
+	enemyevents "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/enemyevents"
+	itemevents "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/itemevents"
+	npcinteractions "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcinteractions"
+	npcs "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcs"
+	scenedescriptions "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/scenedescriptions"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/spells"
+	enemyeventnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/enemyevents"
+	npcnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/npcs"
+)
+
+func TestProductionEnemyEventConfigurationResolvesGeneratedHandoffs(t *testing.T) {
+	components := productionTestComponents(t)
+	cfg := loadMaintainedExample(t, repositoryPath("examples", "dnd-complete.config.yml"))
+	effective, err := cfg.Resolve(resolveInputForMaintainedExample(components, "dnd-session"))
+	if err != nil {
+		t.Fatalf("Resolve() error = %v, want nil", err)
+	}
+	materialized, _, err := pipeline.MaterializeReferences(effective.ResolvedPipeline, catalogFromRegistries(components.registries), pipeline.ReferenceMaterializationOptions{
+		ConfigPath: repositoryPath("examples", "dnd-complete.config.yml"),
+		WorkingDir: repositoryPath("examples"),
+	})
+	if err != nil {
+		t.Fatalf("MaterializeReferences() error = %v, want nil", err)
+	}
+	lane := referenceContractLane(t, materialized, "enemy-events")
+	if lane.ArtifactKind != dnd.EnemyEventListKind || lane.Extract.Module != enemyevents.Key || lane.Extract.Retries != 2 || lane.Merge.Module != pipeline.DefaultMergeModule || lane.Normalize.Module != enemyeventnormalize.Key {
+		t.Fatalf("enemy event lane = %#v, want typed production composition", lane)
+	}
+	for slot, want := range map[string]struct{ step, lane string }{
+		"npcs":               {step: "describe-session", lane: "npcs"},
+		"scene_descriptions": {step: "describe-session", lane: "scene-descriptions"},
+		"combat_turns":       {step: "extract-events", lane: "combat-turns"},
+		"npc_interactions":   {step: "extract-events", lane: "npc-interactions"},
+	} {
+		binding, found := generatedReferenceBinding(lane.ExtractReferences.Bindings, slot)
+		if !found || binding.Artifact.Step != want.step || binding.Artifact.Lane != want.lane {
+			t.Fatalf("enemy event %s reference = %#v, want generated %s/%s artifact", slot, binding, want.step, want.lane)
+		}
+	}
+	if binding, found := generatedReferenceBinding(lane.NormalizeReferences.Bindings, "npcs"); !found || binding.Artifact.Step != "describe-session" || binding.Artifact.Lane != "npcs" {
+		t.Fatalf("enemy event normalizer NPC reference = %#v, want generated NPC artifact", binding)
+	}
+
+	catalog := catalogFromRegistries(components.registries)
+	extractSpec, ok := catalog.Extractors.Spec(enemyevents.Key)
+	if !ok || !reflect.DeepEqual(extractSpec.Requires, []string{"chunks", "source.transcript"}) || !reflect.DeepEqual(extractSpec.Provides, []string{"dnd.enemy_events"}) {
+		t.Fatalf("enemy event extractor spec = %#v, want source and artifact capabilities", extractSpec)
+	}
+	normalizeSpec, ok := catalog.Normalizers.SpecForArtifact(enemyeventnormalize.Key, dnd.EnemyEventListKind)
+	if !ok || !reflect.DeepEqual(normalizeSpec.Requires, []string{"merged"}) || !reflect.DeepEqual(normalizeSpec.Provides, []string{"normalized"}) {
+		t.Fatalf("enemy event normalizer spec = %#v, want merged/normalized capabilities", normalizeSpec)
+	}
+	for _, slot := range []string{"npcs", "scene_descriptions", "combat_turns", "npc_interactions"} {
+		if !hasReferenceSlot(extractSpec.ReferenceSlots, slot) {
+			t.Fatalf("enemy event extractor slots = %#v, want %q", extractSpec.ReferenceSlots, slot)
+		}
+	}
+	if !hasReferenceSlot(normalizeSpec.ReferenceSlots, "npcs") {
+		t.Fatalf("enemy event normalizer slots = %#v, want NPC registry", normalizeSpec.ReferenceSlots)
+	}
+
+	profile := cfg.Pipelines["dnd-session"]
+	profile.Steps[2].References["npcs"] = pipeline.GeneratedReference("track-enemies", "enemy-events")
+	cfg.Pipelines["dnd-session"] = profile
+	if _, err := cfg.Resolve(resolveInputForMaintainedExample(components, "dnd-session")); err == nil || !strings.Contains(err.Error(), "earlier step") {
+		t.Fatalf("Resolve() error = %v, want future generated-reference rejection", err)
+	}
+}
+
+func TestMaintainedCompleteExampleProducesEnemyEventsThroughGeneratedHandoffs(t *testing.T) {
+	t.Chdir(repositoryPath())
+	outputRoot := filepath.Join(t.TempDir(), "output")
+	configPath := completeExampleConfigWithTemporaryCache(t)
+	client := &enemyEventLLMClient{}
+	options := productionCLIOptions(t)
+	options.Now = func() time.Time { return time.Unix(1700000000, 0).UTC() }
+	options.RunIDGenerator = func(time.Time) (string, error) { return productionRunID, nil }
+	options.UserCacheDir = func() (string, error) { return "", errors.New("user cache must not be used") }
+	options.LLMClientFactory = func(context.Context, config.Config, string, LLMRuntimeOverrides) (contracts.StructuredLLMClient, []artifacts.LLMProfileManifest, error) {
+		return client, nil, nil
+	}
+
+	var stdout, stderr strings.Builder
+	code := RunWithOptions([]string{
+		"run", "dnd-session",
+		"--config", configPath,
+		"--input", repositoryPath("examples", "dnd-complete-transcript.json"),
+		"--chunk_cache", "bypass", "--output-dir", outputRoot, "--session-id", "enemy-event-session",
+	}, &stdout, &stderr, options)
+	if code != 0 {
+		t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
+	}
+
+	runRoot := filepath.Join(outputRoot, productionRunID)
+	index := readProductionJSON[exampleOutputIndex](t, filepath.Join(runRoot, "index.json"))
+	var enemyOutput exampleOutputIndexEntry
+	for _, entry := range index.OutputFiles {
+		if entry.LaneID == "enemy-events" {
+			enemyOutput = entry
+			break
+		}
+	}
+	if enemyOutput.File != "lanes/enemy-events.json" || enemyOutput.SchemaID != "notarius.dnd.enemy_events" || enemyOutput.SchemaVersion != "v1" {
+		t.Fatalf("enemy event output = %#v, want typed enemy-event JSON", enemyOutput)
+	}
+	value := readProductionJSON[dnd.EnemyEventList](t, filepath.Join(runRoot, enemyOutput.File))
+	if len(value.Events) != 1 || value.Events[0].Name != "Kesh" || value.Events[0].Kind != dnd.EnemyEventKindFled || len(value.Events[0].SourceRefs) != 1 || value.Events[0].SourceRefs[0].SourceID != "session-ravenfall" || value.Events[0].SourceRefs[0].StartUnitID != 10 {
+		t.Fatalf("enemy event artifact = %#v, want source-linked Kesh fleeing event", value)
+	}
+
+	evidence := readProductionJSON[evidencecontext.Document](t, filepath.Join(runRoot, "evidence-context.json"))
+	if !containsString(evidence.SelectedLanes, "enemy-events") || !evidenceHasLane(evidence, "enemy-events") {
+		t.Fatalf("evidence context = %#v, want direct enemy-event evidence", evidence)
+	}
+
+	requests := client.requestsFor(enemyevents.PromptID)
+	if len(requests) != 1 {
+		t.Fatalf("enemy event requests = %#v, want only the combat scene request", requests)
+	}
+	request := requests[0]
+	if request.SessionID != "enemy-event-session" {
+		t.Fatalf("enemy event session = %q, want shared session", request.SessionID)
+	}
+	for slot, required := range map[string]string{
+		"npcs":             "Kesh",
+		"combat_turns":     "Kesh",
+		"npc_interactions": "Kesh",
+	} {
+		input, ok := request.Inputs[slot]
+		if !ok || !strings.Contains(string(input.Content), required) || strings.Contains(string(input.Content), "source_refs") || strings.Contains(string(input.Content), "start_unit_id") {
+			t.Fatalf("enemy event %s prompt input = %q, want compact source-free grounding", slot, input.Content)
+		}
+	}
+}
+
+func completeExampleConfigWithTemporaryCache(t *testing.T) string {
+	t.Helper()
+	content, err := os.ReadFile(repositoryPath("examples", "dnd-complete.config.yml"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cacheRoot := t.TempDir()
+	updated := strings.Replace(string(content), "directory: ./notarius-cache/chunk-plans", fmt.Sprintf("directory: %q", filepath.Join(cacheRoot, "chunk-plans")), 1)
+	updated = strings.Replace(updated, "directory: ./notarius-cache/checkpoints", fmt.Sprintf("directory: %q", filepath.Join(cacheRoot, "checkpoints")), 1)
+	for relative, absolute := range map[string]string{
+		"./dnd-party.txt":          repositoryPath("examples", "dnd-party.txt"),
+		"./dnd-glossary.txt":       repositoryPath("examples", "dnd-glossary.txt"),
+		"./dnd-spell-catalog.json": repositoryPath("examples", "dnd-spell-catalog.json"),
+	} {
+		updated = strings.ReplaceAll(updated, relative, fmt.Sprintf("%q", absolute))
+	}
+	path := filepath.Join(t.TempDir(), "dnd-complete.config.yml")
+	if err := os.WriteFile(path, []byte(updated), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+type enemyEventLLMClient struct {
+	mu       sync.Mutex
+	requests []contracts.StructuredCompletionRequest
+}
+
+func (client *enemyEventLLMClient) CompleteStructured(ctx context.Context, request contracts.StructuredCompletionRequest, output any) (contracts.StructuredCompletionResponse, error) {
+	if err := ctx.Err(); err != nil {
+		return contracts.StructuredCompletionResponse{}, err
+	}
+	combatScene := strings.Contains(string(request.Inputs["transcript"].Content), "Roll initiative")
+	var content []byte
+	switch request.PromptID {
+	case scenes.PromptID:
+		content = []byte(`{"scenes":[{"start_unit_id":1,"end_unit_id":6},{"start_unit_id":7,"end_unit_id":11}]}`)
+	case npcs.PromptID:
+		if combatScene {
+			content = []byte(`{"npcs":[{"name":"Kesh","source_refs":[{"start_unit_id":7,"end_unit_id":7}]}]}`)
+		} else {
+			content = []byte(`{"npcs":[]}`)
+		}
+	case npcnormalize.PromptID:
+		content = []byte(`{"duplicate_groups":[]}`)
+	case scenedescriptions.PromptID:
+		kind, title := "narrative", "Arrival"
+		if combatScene {
+			kind, title = "combat", "Raiders attack"
+		}
+		content = []byte(fmt.Sprintf(`{"kind":%q,"title":%q,"summary":"session scene"}`, kind, title))
+	case spells.PromptID:
+		content = []byte(`{"spell_casts":[]}`)
+	case itemevents.PromptID:
+		content = []byte(`{"events":[]}`)
+	case combat.PromptID:
+		content = []byte(`{"combat_turns":[{"actor":"Kesh","turn_kind":"turn","source_refs":[{"start_unit_id":8,"end_unit_id":8}]}]}`)
+	case npcinteractions.PromptID:
+		if combatScene {
+			content = []byte(`{"interactions":[{"name":"Kesh","kind":"combat_opponent","source_refs":[{"start_unit_id":7,"end_unit_id":7}]}]}`)
+		} else {
+			content = []byte(`{"interactions":[]}`)
+		}
+	case enemyevents.PromptID:
+		content = []byte(`{"events":[{"name":"Kesh","kind":"fled","source_refs":[{"start_unit_id":10,"end_unit_id":10}]}]}`)
+	default:
+		return contracts.StructuredCompletionResponse{}, fmt.Errorf("unexpected prompt %q", request.PromptID)
+	}
+	if err := json.Unmarshal(content, output); err != nil {
+		return contracts.StructuredCompletionResponse{}, fmt.Errorf("populate fake structured target: %w", err)
+	}
+	client.mu.Lock()
+	client.requests = append(client.requests, request)
+	client.mu.Unlock()
+	return contracts.StructuredCompletionResponse{Content: content, Provider: "test", Model: "deterministic", ProfileID: request.ProfileID}, nil
+}
+
+func (client *enemyEventLLMClient) requestsFor(promptID string) []contracts.StructuredCompletionRequest {
+	client.mu.Lock()
+	defer client.mu.Unlock()
+	var requests []contracts.StructuredCompletionRequest
+	for _, request := range client.requests {
+		if request.PromptID == promptID {
+			requests = append(requests, request)
+		}
+	}
+	return requests
+}
+
+func containsString(values []string, want string) bool {
+	for _, value := range values {
+		if value == want {
+			return true
+		}
+	}
+	return false
+}
+
+func evidenceHasLane(value evidencecontext.Document, laneID string) bool {
+	for _, context := range value.Contexts {
+		for _, reference := range context.EvidenceRefs {
+			if reference.LaneID == laneID {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func generatedReferenceBinding(bindings []pipeline.ReferenceBinding, slotName string) (pipeline.ReferenceBinding, bool) {
+	for _, binding := range bindings {
+		if binding.SlotName == slotName && binding.Artifact != nil {
+			return binding, true
+		}
+	}
+	return pipeline.ReferenceBinding{}, false
+}

internal/cli/example_contract_test.go

@@ -24,6 +24,9 @@ func TestMaintainedExamplesLoadResolveAndList(t *testing.T) {
 	for _, example := range maintainedExampleFiles(t) {
 		t.Run(example.name, func(t *testing.T) {
 			cfg := loadMaintainedExample(t, example.path)
+			if example.name == "complete" && (cfg.Concurrency.TotalLLM != 2 || cfg.Concurrency.StageWorkers["extract"] != 2) {
+				t.Fatalf("complete example concurrency = %#v, want explicit limits of 2", cfg.Concurrency)
+			}
 			raw, err := os.ReadFile(example.transcriptPath)
 			if err != nil {
 				t.Fatalf("read maintained transcript %q: %v", example.transcriptPath, err)
@@ -51,8 +54,8 @@ func TestMaintainedExamplesLoadResolveAndList(t *testing.T) {
 					t.Fatalf("materialize maintained example references for %q: %v", pipelineID, err)
 				}
 				if example.name == "complete" {
-					if got := exampleStepLaneIDs(materialized); strings.Join(got, "|") != "describe-session:item-events,npcs,scene-descriptions|extract-events:combat-turns,npc-interactions,spells" {
-						t.Fatalf("complete example steps and lanes = %v, want every D&D extractor in the documented two-step composition", got)
+					if got := exampleStepLaneIDs(materialized); strings.Join(got, "|") != "describe-session:item-events,npcs,scene-descriptions|extract-events:combat-turns,npc-interactions,spells|track-enemies:enemy-events" {
+						t.Fatalf("complete example steps and lanes = %v, want the documented D&D extractor composition", got)
 					}
 					spellLane := referenceContractLane(t, materialized, "spells")
 					if len(spellLane.ExtractReferences.ReferenceSet.Slots["spell_catalog"].Items) != 1 ||
@@ -68,6 +71,18 @@ func TestMaintainedExamplesLoadResolveAndList(t *testing.T) {
 							t.Fatalf("item event lane unexpectedly depends on generated scene descriptions: %#v", itemEventLane)
 						}
 					}
+					enemyEventLane := referenceContractLane(t, materialized, "enemy-events")
+					for slot, want := range map[string]struct{ step, lane string }{
+						"npcs":               {step: "describe-session", lane: "npcs"},
+						"scene_descriptions": {step: "describe-session", lane: "scene-descriptions"},
+						"combat_turns":       {step: "extract-events", lane: "combat-turns"},
+						"npc_interactions":   {step: "extract-events", lane: "npc-interactions"},
+					} {
+						binding, found := generatedReferenceBinding(enemyEventLane.ExtractReferences.Bindings, slot)
+						if !found || binding.Artifact.Step != want.step || binding.Artifact.Lane != want.lane {
+							t.Fatalf("enemy event %s reference = %#v, want generated %s/%s artifact", slot, binding, want.step, want.lane)
+						}
+					}
 				}
 			}
 			var stdout, stderr strings.Builder
@@ -242,6 +257,12 @@ func TestMaintainedMalformedInputOnlyRecordsDebugFailureWhenRequested(t *testing
 			if report.Succeeded || report.PipelineID != "dnd-session" {
 				t.Fatalf("failure report = %#v, want failed dnd-session report", report)
 			}
+			invocation := readProductionJSON[debugbundle.Invocation](t, filepath.Join(bundle, "summary", "invocation.json"))
+			manifest := readProductionJSON[artifacts.RunManifest](t, filepath.Join(bundle, "summary", "run-manifest.json"))
+			manifestSession, found := manifest.Metadata["session_id"]
+			if invocation.SessionID == "" || !found || manifestSession != invocation.SessionID {
+				t.Fatalf("failed run sessions: invocation=%q manifest=%#v metadata=%#v", invocation.SessionID, manifestSession, manifest.Metadata)
+			}
 		})
 	}
 }

internal/cli/production_contract_test.go

@@ -29,12 +29,15 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/chunk/scenes"
 	combatcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/combatturns"
+	enemyeventcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/enemyevents"
 	itemeventcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/itemevents"
 	spellcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/spells"
 	combatextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/combatturns"
+	enemyeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/enemyevents"
 	itemeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/itemevents"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/spells"
 	combatnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/combatturns"
+	enemyeventnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/enemyevents"
 	itemeventnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/itemevents"
 	spellnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/spells"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/generic/normalize/noop"
@@ -47,9 +50,9 @@ func TestProductionCatalogCoversMaintainedConfigurations(t *testing.T) {
 
 	assertProductionContains(t, "inputs", registries.Inputs.RegisteredKeys(), []string{"seriatim"})
 	assertProductionContains(t, "chunkers", registries.Chunkers.RegisteredKeys(), []string{"dnd/scenes", "generic"})
-	assertProductionContains(t, "extractors", registries.Extractors.RegisteredKeys(), []string{"dnd/spells", "dnd/npcs", combatextract.Key, itemeventextract.Key})
+	assertProductionContains(t, "extractors", registries.Extractors.RegisteredKeys(), []string{"dnd/spells", "dnd/npcs", combatextract.Key, itemeventextract.Key, enemyeventextract.Key})
 	assertProductionContains(t, "mergers", registries.Mergers.RegisteredKeys(), []string{"appendorder"})
-	assertProductionContains(t, "normalizers", registries.Normalizers.RegisteredKeys(), []string{"noop", spellnormalize.Key, "dnd/npcs", combatnormalize.Key, itemeventnormalize.Key})
+	assertProductionContains(t, "normalizers", registries.Normalizers.RegisteredKeys(), []string{"noop", spellnormalize.Key, "dnd/npcs", combatnormalize.Key, itemeventnormalize.Key, enemyeventnormalize.Key})
 	assertProductionContains(t, "outputs", registries.Outputs.RegisteredKeys(), []string{"json"})
 	assertProductionContains(t, "validators", registries.Validators.RegisteredKeys(), []string{
 		"extract/dnd/spells/catalog",
@@ -64,17 +67,23 @@ func TestProductionCatalogCoversMaintainedConfigurations(t *testing.T) {
 		"extract/dnd/item-events/source_refs",
 		"extract/dnd/item-events/source_relatedness",
 		"normalize/dnd/item-events/invariants",
+		"extract/dnd/enemy-events/shape",
+		"extract/dnd/enemy-events/engagements",
+		"extract/dnd/enemy-events/source_refs",
+		"extract/dnd/enemy-events/source_relatedness",
+		"normalize/dnd/enemy-events/invariants",
 		"generic/always_accept",
 		"generic/always_reject",
 		"generic/valid_json",
 		"generic/valid_json_schema",
 	})
-	assertProductionContains(t, "artifact codec kinds", registries.ArtifactCodecs.RegisteredKinds(), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind})
-	assertProductionContains(t, "merger variants", registries.Mergers.RegisteredArtifactKinds(pipeline.DefaultMergeModule), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind})
-	assertProductionContains(t, "normalizer variants", registries.Normalizers.RegisteredArtifactKinds(pipeline.DefaultNormalizeModule), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind})
+	assertProductionContains(t, "artifact codec kinds", registries.ArtifactCodecs.RegisteredKinds(), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind, dnd.EnemyEventListKind})
+	assertProductionContains(t, "merger variants", registries.Mergers.RegisteredArtifactKinds(pipeline.DefaultMergeModule), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind, dnd.EnemyEventListKind})
+	assertProductionContains(t, "normalizer variants", registries.Normalizers.RegisteredArtifactKinds(pipeline.DefaultNormalizeModule), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind, dnd.EnemyEventListKind})
 	assertProductionContains(t, "spell normalizer variants", registries.Normalizers.RegisteredArtifactKinds(spellnormalize.Key), []contracts.ArtifactKind{dnd.SpellListKind})
 	assertProductionContains(t, "combat normalizer variants", registries.Normalizers.RegisteredArtifactKinds(combatnormalize.Key), []contracts.ArtifactKind{dnd.CombatTurnListKind})
 	assertProductionContains(t, "item event normalizer variants", registries.Normalizers.RegisteredArtifactKinds(itemeventnormalize.Key), []contracts.ArtifactKind{dnd.ItemEventListKind})
+	assertProductionContains(t, "enemy event normalizer variants", registries.Normalizers.RegisteredArtifactKinds(enemyeventnormalize.Key), []contracts.ArtifactKind{dnd.EnemyEventListKind})
 
 	wantChain := []pipeline.ModuleBinding{
 		pipeline.Binding("generic/valid_json"),
@@ -132,6 +141,17 @@ func TestProductionCatalogCoversMaintainedConfigurations(t *testing.T) {
 	if got := registries.ValidatorChains.Validators(pipeline.StageNormalize, itemeventnormalize.Key); !reflect.DeepEqual(got, itemEventNormalizeChain) {
 		t.Fatalf("item event normalize validator chain = %#v, want %#v", got, itemEventNormalizeChain)
 	}
+	enemyEventExtractChain := []pipeline.ModuleBinding{
+		pipeline.Binding("generic/valid_json"),
+		pipeline.Binding("extract/dnd/enemy-events/shape"),
+		pipeline.Binding("extract/dnd/enemy-events/engagements"),
+		pipeline.Binding("extract/dnd/enemy-events/source_refs"),
+		pipeline.Binding("generic/valid_json_schema"),
+		pipeline.Binding("extract/dnd/enemy-events/source_relatedness"),
+	}
+	if got := registries.ValidatorChains.Validators(pipeline.StageExtract, enemyeventextract.Key); !reflect.DeepEqual(got, enemyEventExtractChain) {
+		t.Fatalf("enemy event extract validator chain = %#v, want %#v", got, enemyEventExtractChain)
+	}
 
 	assetNames := productionAssetNames(t, components.assets.PromptFS)
 	requiredAssets := []string{
@@ -162,6 +182,10 @@ func TestProductionCatalogCoversMaintainedConfigurations(t *testing.T) {
 		"dnd.item_events/sharedassets/common-dnd-system.md",
 		"dnd.item_events/sharedassets/common-dnd-transcript.md",
 		"dnd.item_events/task.md",
+		"dnd.enemy_events/dnd.enemy_events.yaml",
+		"dnd.enemy_events/grounding.md",
+		"dnd.enemy_events/instructions.md",
+		"dnd.enemy_events/task.md",
 	}
 	assertProductionContains(t, "production prompt assets", assetNames, requiredAssets)
 
@@ -180,6 +204,7 @@ func TestProductionCatalogCoversMaintainedConfigurations(t *testing.T) {
 		{stage: pipeline.StageExtract, key: "dnd/item-events", want: contracts.ExecutionClassLLMBacked},
 		{stage: pipeline.StageExtract, key: "dnd/npc-interactions", want: contracts.ExecutionClassLLMBacked},
 		{stage: pipeline.StageExtract, key: "dnd/scene-descriptions", want: contracts.ExecutionClassLLMBacked},
+		{stage: pipeline.StageExtract, key: enemyeventextract.Key, want: contracts.ExecutionClassLLMBacked},
 		{stage: pipeline.StageMerge, key: "appendorder", want: contracts.ExecutionClassDeterministic},
 		{stage: pipeline.StageNormalize, key: "noop", want: contracts.ExecutionClassDeterministic},
 		{stage: pipeline.StageNormalize, key: "dnd/spells", want: contracts.ExecutionClassDeterministic},
@@ -188,6 +213,7 @@ func TestProductionCatalogCoversMaintainedConfigurations(t *testing.T) {
 		{stage: pipeline.StageNormalize, key: "dnd/item-events", want: contracts.ExecutionClassDeterministic},
 		{stage: pipeline.StageNormalize, key: "dnd/npc-interactions", want: contracts.ExecutionClassDeterministic},
 		{stage: pipeline.StageNormalize, key: "dnd/scene-descriptions", want: contracts.ExecutionClassDeterministic},
+		{stage: pipeline.StageNormalize, key: enemyeventnormalize.Key, want: contracts.ExecutionClassDeterministic},
 		{stage: pipeline.StageOutput, key: "json", want: contracts.ExecutionClassDeterministic},
 	} {
 		got, ok := catalog.ExecutionClass(test.stage, test.key)
@@ -211,6 +237,10 @@ func TestProductionCatalogCoversMaintainedConfigurations(t *testing.T) {
 	if !ok || itemEventCodecSpec.Kind != dnd.ItemEventListKind || itemEventCodecSpec.Schema.ID != itemeventcodec.SchemaID {
 		t.Fatalf("item event codec spec = %#v, ok=%t, want typed D&D item-event codec", itemEventCodecSpec, ok)
 	}
+	enemyEventCodecSpec, ok := catalog.ArtifactCodecs.Spec(dnd.EnemyEventListKind)
+	if !ok || enemyEventCodecSpec.Kind != dnd.EnemyEventListKind || enemyEventCodecSpec.Schema.ID != enemyeventcodec.SchemaID {
+		t.Fatalf("enemy event codec spec = %#v, ok=%t, want typed D&D enemy-event codec", enemyEventCodecSpec, ok)
+	}
 	if got := catalog.ValidatorChains.Validators(pipeline.StageExtract, spells.Key); !reflect.DeepEqual(got, wantChain) {
 		t.Fatalf("catalog validator chain = %#v, want %#v", got, wantChain)
 	}

internal/cli/run.go

@@ -153,10 +153,10 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i
 	resume := fs.Bool("resume", false, "reuse compatible recorded checkpoints")
 	recomputeStep := singleValueFlag{name: "--recompute-step"}
 	chunkCache := chunkCacheFlag{}
-	sessionID := sessionIDFlag{}
+	requestedSessionID := sessionIDFlag{}
 	referenceFlags := stringListFlag{}
 	withoutReferenceFlags := stringListFlag{}
-	fs.Var(&sessionID, "session-id", "prompt session identifier")
+	fs.Var(&requestedSessionID, "session-id", "prompt session identifier")
 	fs.Var(&reasoningEffort, "reasoning-effort", "reasoning effort override")
 	fs.Var(&chunkCache, "chunk_cache", "chunk plan cache mode: auto, bypass, or refresh")
 	fs.Var(&referenceFlags, "reference", "reference binding, as slot=path, chunk.slot=path, merge.slot=path, lane.slot=path, lane.extract.slot=path, lane.merge.slot=path, or lane.normalize.slot=path")
@@ -199,7 +199,7 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i
 		fmt.Fprintln(stderr, "notarius: --debug-dir must not be empty")
 		return 2
 	}
-	if sessionID.set && strings.TrimSpace(sessionID.value) == "" {
+	if requestedSessionID.set && strings.TrimSpace(requestedSessionID.value) == "" {
 		fmt.Fprintln(stderr, "notarius: --session-id must not be empty")
 		return 2
 	}
@@ -414,11 +414,19 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i
 	if err != nil {
 		return failPipelineCommand(stderr, commandState, terminalWriter, fmt.Errorf("read input %q: %w", strings.TrimSpace(*inputPath), err))
 	}
+	effectiveSessionID, err := resolvePromptSessionID(requestedSessionID.value, effective.ResolvedPipeline.Input.Module, rawInput)
+	if err != nil {
+		return failPipelineCommand(stderr, commandState, terminalWriter, err)
+	}
+	invocation.SessionID = effectiveSessionID
+	if err := writeSummary(summary, func() error { return summary.WriteInvocation(invocation) }); err != nil {
+		return failPipelineCommand(stderr, commandState, terminalWriter, fmt.Errorf("write debug invocation metadata: %w", err))
+	}
 	chunkPlans, err := chunkPlanStoreForRun(effective.Config.Cache.ChunkPlans, opts)
 	if err != nil {
 		return failPipelineCommand(stderr, commandState, terminalWriter, err)
 	}
-	checkpointRecorder, checkpointLoader, err := checkpointHandlersForRun(effective.Config.Cache.Checkpoints, opts, effective.ResolvedPipeline, prepared.CheckpointFingerprints(), llmFingerprints, rawInput, only, llmProfiles, strings.TrimSpace(*llmProfile), strings.TrimSpace(sessionID.value), runtimeOverrides, *resume)
+	checkpointRecorder, checkpointLoader, err := checkpointHandlersForRun(effective.Config.Cache.Checkpoints, opts, effective.ResolvedPipeline, prepared.CheckpointFingerprints(), llmFingerprints, rawInput, only, llmProfiles, strings.TrimSpace(*llmProfile), effectiveSessionID, runtimeOverrides, *resume)
 	if err != nil {
 		return failPipelineCommand(stderr, commandState, terminalWriter, err)
 	}
@@ -427,7 +435,7 @@ func runPipelineCommand(args []string, stdout, stderr io.Writer, opts Options) i
 		Prepared:         prepared,
 		Path:             strings.TrimSpace(*inputPath),
 		RawInput:         rawInput,
-		SessionID:        strings.TrimSpace(sessionID.value),
+		SessionID:        effectiveSessionID,
 		RunID:            runID,
 		StartedAt:        startedAt,
 		LLMProfiles:      llmProfiles,

internal/cli/run_contract_test.go

@@ -492,19 +492,30 @@ func TestEffectiveLLMProfileIDsAreSortedDeduplicatedAndLLMOnly(t *testing.T) {
 	}
 }
 
-func TestRunSessionIDUsesExplicitValueOrSourceDocumentID(t *testing.T) {
+func TestRunSessionIDUsesEffectiveValueForPromptRequests(t *testing.T) {
 	for _, tt := range []struct {
 		name string
 		args []string
 		want string
 	}{
-		{name: "source document", want: "source"},
+		{name: "derived default"},
 		{name: "explicit trimmed value", args: []string{"--session-id", " explicit-session "}, want: "explicit-session"},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
 			roots := newStateTestRoots(t)
+			want := tt.want
+			if want == "" {
+				rawInput, err := os.ReadFile(roots.input)
+				if err != nil {
+					t.Fatal(err)
+				}
+				want, err = resolvePromptSessionID("", "test/input", rawInput)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
 			harness := newStateTestHarness()
-			args := append([]string{"run", "sample", "--config", roots.config, "--input", roots.input, "--chunk_cache", "bypass"}, tt.args...)
+			args := append([]string{"run", "sample", "--config", roots.config, "--input", roots.input, "--chunk_cache", "bypass", "--debug"}, tt.args...)
 			var stdout, stderr bytes.Buffer
 			code := RunWithOptions(args, &stdout, &stderr, harness.options())
 			if code != 0 || stderr.Len() != 0 {
@@ -517,10 +528,15 @@ func TestRunSessionIDUsesExplicitValueOrSourceDocumentID(t *testing.T) {
 				t.Fatalf("session IDs = %#v, want all prompt-facing module requests", sessions)
 			}
 			for _, session := range sessions {
-				if session != tt.want {
-					t.Fatalf("session IDs = %#v, want %q", sessions, tt.want)
+				if session != want {
+					t.Fatalf("session IDs = %#v, want %q", sessions, want)
 				}
 			}
+			var manifest artifacts.RunManifest
+			readStateTestSummaryJSON(t, onlyChildDir(t, roots.debug), "run-manifest.json", &manifest)
+			if session, ok := manifest.Metadata["session_id"]; !ok || session != want {
+				t.Fatalf("manifest session = %#v, want %q; metadata = %#v", session, want, manifest.Metadata)
+			}
 		})
 	}
 }

internal/cli/session.go

@@ -0,0 +1,26 @@
+package cli
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"strings"
+)
+
+const generatedSessionIDPrefix = "notarius:v1:"
+
+func resolvePromptSessionID(explicitSessionID, inputModule string, rawInput []byte) (string, error) {
+	inputModule = strings.TrimSpace(inputModule)
+	if inputModule == "" {
+		return "", fmt.Errorf("resolve prompt session: input module key must not be empty")
+	}
+	if sessionID := strings.TrimSpace(explicitSessionID); sessionID != "" {
+		return sessionID, nil
+	}
+
+	hasher := sha256.New()
+	_, _ = hasher.Write([]byte(inputModule))
+	_, _ = hasher.Write([]byte{0})
+	_, _ = hasher.Write(rawInput)
+	return generatedSessionIDPrefix + hex.EncodeToString(hasher.Sum(nil)), nil
+}

internal/cli/session_test.go

@@ -0,0 +1,61 @@
+package cli
+
+import "testing"
+
+func TestResolvePromptSessionIDUsesVersionedInputIdentity(t *testing.T) {
+	got, err := resolvePromptSessionID("", " seriatim/input/transcript ", []byte("{\"entries\":[\"one\"]}\n"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	const want = "notarius:v1:e15fefdca48653e73248b4157900547be1fd34250c0138f8d3d1f2e89b43bb25"
+	if got != want {
+		t.Fatalf("resolved session = %q, want %q", got, want)
+	}
+}
+
+func TestResolvePromptSessionIDStabilityAndOverride(t *testing.T) {
+	rawInput := []byte("same input")
+	baseline, err := resolvePromptSessionID("", "input/transcript", rawInput)
+	if err != nil {
+		t.Fatal(err)
+	}
+	repeated, err := resolvePromptSessionID("", "input/transcript", rawInput)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if baseline != repeated {
+		t.Fatalf("resolved sessions = %q and %q, want stable value", baseline, repeated)
+	}
+
+	differentModule, err := resolvePromptSessionID("", "input/other", rawInput)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if baseline == differentModule {
+		t.Fatalf("resolved sessions = %q for distinct input modules", baseline)
+	}
+
+	differentInput, err := resolvePromptSessionID("", "input/transcript", []byte("same inpuu"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if baseline == differentInput {
+		t.Fatalf("resolved sessions = %q for distinct input bytes", baseline)
+	}
+
+	override, err := resolvePromptSessionID(" explicit-session ", "input/other", []byte("different input"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if override != "explicit-session" {
+		t.Fatalf("resolved override = %q, want %q", override, "explicit-session")
+	}
+}
+
+func TestResolvePromptSessionIDRejectsEmptyInputModule(t *testing.T) {
+	for _, explicitSessionID := range []string{"", "explicit-session"} {
+		if _, err := resolvePromptSessionID(explicitSessionID, " \t", []byte("input")); err == nil {
+			t.Fatalf("resolvePromptSessionID(%q) error = nil, want empty module failure", explicitSessionID)
+		}
+	}
+}

internal/cli/state_hardening_test.go

@@ -329,11 +329,25 @@ func TestRunUsesOneInjectedIdentityForDebugOutputAndManifest(t *testing.T) {
 	if manifest.StartedAt == nil || !manifest.StartedAt.Equal(wantStartedAt) {
 		t.Fatalf("manifest started at = %v, want %v", manifest.StartedAt, wantStartedAt)
 	}
+	rawInput, err := os.ReadFile(roots.input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantSessionID, err := resolvePromptSessionID("", "test/input", rawInput)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sessionID, ok := manifest.Metadata["session_id"]; !ok || sessionID != wantSessionID {
+		t.Fatalf("manifest session = %#v, want %q; metadata = %#v", sessionID, wantSessionID, manifest.Metadata)
+	}
 	var invocation debugbundle.Invocation
 	readStateTestSummaryJSON(t, debugPath, "invocation.json", &invocation)
 	if invocation.RunID != runID || !invocation.StartedAt.Equal(wantStartedAt) {
 		t.Fatalf("debug invocation identity = %#v, want run %q at %v", invocation, runID, wantStartedAt)
 	}
+	if invocation.SessionID != wantSessionID {
+		t.Fatalf("debug invocation session = %q, want %q", invocation.SessionID, wantSessionID)
+	}
 	report := readStateTestRunReport(t, debugPath)
 	if !report.Succeeded || report.RunID != runID || report.PipelineID != "sample" || report.OutputPath != outputPath || report.DebugPath != debugPath || report.OutputCount != 1 || report.RejectedCount != 0 || report.WarningCount != 0 || report.ValidationStatus != "approved" {
 		t.Fatalf("success report = %#v", report)
@@ -343,6 +357,45 @@ func TestRunUsesOneInjectedIdentityForDebugOutputAndManifest(t *testing.T) {
 	}
 }
 
+func TestRunCheckpointReuseRequiresSameEffectiveSession(t *testing.T) {
+	roots := newStateTestRoots(t)
+	harness := newStateTestHarness()
+	run := func(extra ...string) stateTestResult {
+		args := []string{"run", "sample", "--config", roots.config, "--input", roots.input, "--chunk_cache", "bypass"}
+		args = append(args, extra...)
+		var stdout, stderr bytes.Buffer
+		return stateTestResult{code: RunWithOptions(args, &stdout, &stderr, harness.options()), stdout: stdout.String(), stderr: stderr.String()}
+	}
+
+	if result := run(); result.code != 0 {
+		t.Fatalf("initial run code=%d stdout=%q stderr=%q", result.code, result.stdout, result.stderr)
+	}
+	harness.mu.Lock()
+	initialExtractCalls := harness.extractCalls
+	harness.mu.Unlock()
+	if initialExtractCalls != 1 {
+		t.Fatalf("initial extract calls = %d, want 1", initialExtractCalls)
+	}
+	if result := run("--resume"); result.code != 0 {
+		t.Fatalf("same-session resume code=%d stdout=%q stderr=%q", result.code, result.stdout, result.stderr)
+	}
+	harness.mu.Lock()
+	reusedExtractCalls := harness.extractCalls
+	harness.mu.Unlock()
+	if reusedExtractCalls != initialExtractCalls {
+		t.Fatalf("extract calls after same-session resume = %d, want %d", reusedExtractCalls, initialExtractCalls)
+	}
+	if result := run("--resume", "--session-id", "different-session"); result.code != 0 {
+		t.Fatalf("different-session resume code=%d stdout=%q stderr=%q", result.code, result.stdout, result.stderr)
+	}
+	harness.mu.Lock()
+	differentSessionExtractCalls := harness.extractCalls
+	harness.mu.Unlock()
+	if differentSessionExtractCalls != initialExtractCalls+1 {
+		t.Fatalf("extract calls after different-session resume = %d, want %d", differentSessionExtractCalls, initialExtractCalls+1)
+	}
+}
+
 func TestRunWritesTerminalArtifactsForResolutionPipelineAndOutputFailures(t *testing.T) {
 	for _, tc := range []struct {
 		name             string

internal/core/config/config.go

@@ -34,6 +34,8 @@ type ConcurrencyConfig struct {
 	defaultedExtractWorkers  int
 }
 
+const defaultLLMConcurrency = 16
+
 type OutputConfig struct {
 	Directory string `json:"directory"`
 }
@@ -60,9 +62,9 @@ func Default() Config {
 	return Config{
 		Pipelines: map[string]pipeline.PipelineProfile{},
 		Concurrency: ConcurrencyConfig{
-			TotalLLM:                1,
-			StageWorkers:            map[string]int{"extract": 1},
-			defaultedExtractWorkers: 1,
+			TotalLLM:                defaultLLMConcurrency,
+			StageWorkers:            map[string]int{"extract": defaultLLMConcurrency},
+			defaultedExtractWorkers: defaultLLMConcurrency,
 		},
 		Output: OutputConfig{Directory: "./notarius-output"},
 		Cache:  CacheConfig{ChunkPlans: ChunkPlanCacheConfig{Mode: pipeline.ChunkCacheAuto}},

internal/core/config/file_config_contract_test.go

@@ -14,7 +14,7 @@ import (
 
 func TestDefaultReturnsDocumentedValuesAndIndependentMaps(t *testing.T) {
 	first := Default()
-	if first.Concurrency.TotalLLM != 1 || first.Concurrency.StageWorkers["extract"] != 1 {
+	if first.Concurrency.TotalLLM != 16 || first.Concurrency.StageWorkers["extract"] != 16 {
 		t.Fatalf("concurrency defaults = %#v", first.Concurrency)
 	}
 	if first.Output.Directory != "./notarius-output" || first.Debug.Directory != "./notarius-debug" {
@@ -31,7 +31,7 @@ func TestDefaultReturnsDocumentedValuesAndIndependentMaps(t *testing.T) {
 	first.Concurrency.StageWorkers["other"] = 100
 	first.Pipelines["changed"] = pipeline.PipelineProfile{}
 	second := Default()
-	if second.Concurrency.StageWorkers["extract"] != 1 || len(second.Concurrency.StageWorkers) != 1 || len(second.Pipelines) != 0 {
+	if second.Concurrency.StageWorkers["extract"] != 16 || len(second.Concurrency.StageWorkers) != 1 || len(second.Pipelines) != 0 {
 		t.Fatalf("Default() returned state shared with an earlier result: %#v", second)
 	}
 }
@@ -45,7 +45,7 @@ func TestFileConfigMinimalVersion4AppliesOverDefaults(t *testing.T) {
 	if cfg.Output.Directory != "./notarius-output" || cfg.Debug.Directory != "./notarius-debug" || cfg.Cache.ChunkPlans.Mode != pipeline.ChunkCacheAuto {
 		t.Fatalf("minimal file changed unrelated defaults: %#v", cfg)
 	}
-	if cfg.Concurrency.TotalLLM != 1 || cfg.Concurrency.StageWorkers["extract"] != 1 || len(cfg.Pipelines) != 0 {
+	if cfg.Concurrency.TotalLLM != 16 || cfg.Concurrency.StageWorkers["extract"] != 16 || len(cfg.Pipelines) != 0 {
 		t.Fatalf("minimal file did not retain defaults: %#v", cfg)
 	}
 }

internal/core/debugbundle/bundle_test.go

@@ -179,6 +179,30 @@ func TestWriteInvocationPreservesReasoningEffortOverrideStates(t *testing.T) {
 		})
 	}
 }
+
+func TestWriteInvocationOmitsEmptySessionID(t *testing.T) {
+	for _, sessionID := range []string{"", "session-123"} {
+		bundle, err := Allocate(t.TempDir(), testBundleRunID, time.Unix(0, 42))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := bundle.Summary().WriteInvocation(Invocation{Operation: "run", SessionID: sessionID}); err != nil {
+			t.Fatal(err)
+		}
+		data, err := os.ReadFile(filepath.Join(bundle.SummaryRoot(), ArtifactInvocationMetadata))
+		if err != nil {
+			t.Fatal(err)
+		}
+		var payload map[string]any
+		if err := json.Unmarshal(data, &payload); err != nil {
+			t.Fatal(err)
+		}
+		value, found := payload["session_id"]
+		if found != (sessionID != "") || (found && value != sessionID) {
+			t.Fatalf("session found=%t value=%#v, want found=%t value=%q; JSON=%s", found, value, sessionID != "", sessionID, data)
+		}
+	}
+}
 func TestSummaryWriterInternalWritesConfineArtifacts(t *testing.T) {
 	bundle, err := Allocate(t.TempDir(), testBundleRunID, time.Unix(0, 42))
 	if err != nil {

internal/core/debugbundle/summary.go

@@ -40,6 +40,7 @@ type Invocation struct {
 	OnlyLanes               []string  `json:"only_lanes,omitempty"`
 	ChunkCacheOverride      string    `json:"chunk_cache_override,omitempty"`
 	ReasoningEffortOverride *string   `json:"reasoning_effort_override,omitempty"`
+	SessionID               string    `json:"session_id,omitempty"`
 	RunID                   string    `json:"run_id"`
 	StartedAt               time.Time `json:"started_at"`
 }

internal/framework/pipeline/runner.go

@@ -91,6 +91,11 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err
 	input.llmClient = input.Prepared.dependencies.LLM
 
 	output.Manifest = manifestFromPipeline(input)
+	sessionID := strings.TrimSpace(input.SessionID)
+	output.Manifest.Metadata, err = manifestMetadataWithSessionID(output.Manifest.Metadata, sessionID)
+	if err != nil {
+		return failOutput(output), err
+	}
 	output.ChunkPlan = &artifacts.ChunkPlanSummary{
 		Mode: string(effectiveChunkCacheMode(input.ChunkCacheMode)), RequestedModule: input.pipeline.Chunk.Module,
 		LookupStatus: "skipped", LookupReason: "chunk plan lookup skipped",
@@ -191,11 +196,6 @@ func (r *Runner) Run(ctx context.Context, input RunInput) (output RunOutput, err
 		return failOutput(output), fmt.Errorf("write source debug artifact: %w", err)
 	}
 	sourceInput := sourceInputMaterial(input.Path, input.RawInput)
-	sessionID := resolvedSessionID(input.SessionID, doc.ID)
-	output.Manifest.Metadata, err = manifestMetadataWithSessionID(output.Manifest.Metadata, sessionID)
-	if err != nil {
-		return failOutput(output), err
-	}
 	output.Manifest.SourceDigests = []string{doc.Digest}
 
 	chunker := input.Prepared.chunker
@@ -896,13 +896,6 @@ func sourceInputOriginURI(inputPath string) string {
 	return fileURI(inputPath)
 }
 
-func resolvedSessionID(explicit string, sourceDocumentID string) string {
-	if trimmed := strings.TrimSpace(explicit); trimmed != "" {
-		return trimmed
-	}
-	return strings.TrimSpace(sourceDocumentID)
-}
-
 func manifestMetadataWithSessionID(metadata map[string]any, sessionID string) (map[string]any, error) {
 	out, err := cloneMetadata(metadata)
 	if err != nil {

internal/framework/pipeline/runner_session_test.go

@@ -0,0 +1,37 @@
+package pipeline
+
+import (
+	"context"
+	"testing"
+)
+
+func TestRunnerUsesProvidedSessionWithoutSourceFallback(t *testing.T) {
+	for _, test := range []struct {
+		name    string
+		session string
+		wantSet bool
+		want    string
+	}{
+		{name: "provided", session: " supplied-session ", wantSet: true, want: "supplied-session"},
+		{name: "empty", wantSet: false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			prepared, _ := preparedTerminalDebugPipeline(t)
+			output, err := New().Run(context.Background(), RunInput{
+				Prepared:  prepared,
+				RawInput:  []byte("input"),
+				SessionID: test.session,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			value, found := output.Manifest.Metadata["session_id"]
+			if found != test.wantSet {
+				t.Fatalf("manifest session presence = %t, want %t; metadata = %#v", found, test.wantSet, output.Manifest.Metadata)
+			}
+			if found && value != test.want {
+				t.Fatalf("manifest session = %#v, want %q", value, test.want)
+			}
+		})
+	}
+}

internal/modules/dnd/codec/enemyevents/assets/schemas/dnd_enemy_events.v1.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "notarius.dnd.enemy_events",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["events"],
+  "properties": {
+    "events": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["name", "kind", "source_refs"],
+        "properties": {
+          "name": {"type": "string", "minLength": 1},
+          "kind": {"type": "string", "enum": ["engaged", "killed", "fled", "captured", "incapacitated"]},
+          "source_refs": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["source_id", "start_unit_id", "end_unit_id"],
+              "properties": {
+                "source_id": {"type": "string", "minLength": 1},
+                "start_unit_id": {"type": "integer", "minimum": 1},
+                "end_unit_id": {"type": "integer", "minimum": 1}
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

internal/modules/dnd/codec/enemyevents/codec.go

@@ -0,0 +1,182 @@
+// Package enemyevents encodes durable D&D enemy-event artifacts.
+package enemyevents
+
+import (
+	"embed"
+	"encoding/json"
+	"fmt"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/candidatejson"
+)
+
+const (
+	SchemaID      = "notarius.dnd.enemy_events"
+	SchemaName    = "notarius_dnd_enemy_events_v1"
+	SchemaVersion = "v1"
+	MediaType     = "application/json"
+)
+
+//go:embed assets/schemas/dnd_enemy_events.v1.json
+var schemaAssets embed.FS
+
+var _ contracts.ArtifactCodec[dnd.EnemyEventList] = (*Codec)(nil)
+
+type Codec struct{}
+
+func New() *Codec { return &Codec{} }
+
+func (c *Codec) Kind() contracts.ArtifactKind { return dnd.EnemyEventListKind }
+
+func (c *Codec) Schema() contracts.ArtifactSchema {
+	raw, err := schemaAssets.ReadFile("assets/schemas/dnd_enemy_events.v1.json")
+	if err != nil {
+		return contracts.ArtifactSchema{}
+	}
+	return contracts.ArtifactSchema{
+		ID:         SchemaID,
+		Name:       SchemaName,
+		Version:    SchemaVersion,
+		JSONSchema: append([]byte(nil), raw...),
+	}
+}
+
+func (c *Codec) MediaType() string { return MediaType }
+
+func (c *Codec) Metadata(value dnd.EnemyEventList) map[string]any {
+	return map[string]any{"event_count": len(value.Events)}
+}
+
+func (c *Codec) Encode(value dnd.EnemyEventList) ([]byte, error) {
+	if err := validateRequiredValueFields(value); err != nil {
+		return nil, fmt.Errorf("encode dnd enemy event list: %w", err)
+	}
+	return c.EncodeCandidate(value)
+}
+
+// EncodeCandidate provides the durable representation before semantic
+// validators have approved a value.
+func (c *Codec) EncodeCandidate(value dnd.EnemyEventList) ([]byte, error) {
+	return candidatejson.EncodeCandidate("dnd enemy event list", cloneList(value))
+}
+
+func (c *Codec) Decode(content []byte) (dnd.EnemyEventList, error) {
+	value, err := c.DecodeCandidate(content)
+	if err != nil {
+		return dnd.EnemyEventList{}, err
+	}
+	if err := validateRequiredJSONFields(content); err != nil {
+		return dnd.EnemyEventList{}, fmt.Errorf("decode dnd enemy event list: %w", err)
+	}
+	return value, nil
+}
+
+// DecodeCandidate reads one strict durable JSON value before semantic
+// validators have approved it.
+func (c *Codec) DecodeCandidate(content []byte) (dnd.EnemyEventList, error) {
+	value, err := candidatejson.DecodeCandidate[dnd.EnemyEventList]("dnd enemy event list", content)
+	if err != nil {
+		return dnd.EnemyEventList{}, err
+	}
+	return cloneList(value), nil
+}
+
+func validateRequiredValueFields(value dnd.EnemyEventList) error {
+	if value.Events == nil {
+		return fmt.Errorf("events must be present")
+	}
+	for index, event := range value.Events {
+		if event.SourceRefs == nil {
+			return fmt.Errorf("events[%d].source_refs must be present", index)
+		}
+	}
+	return nil
+}
+
+func validateRequiredJSONFields(content []byte) error {
+	var root map[string]json.RawMessage
+	if err := json.Unmarshal(content, &root); err != nil || root == nil {
+		return fmt.Errorf("must be a JSON object")
+	}
+	events, err := requiredArray(root, "events", "")
+	if err != nil {
+		return err
+	}
+	for eventIndex, rawEvent := range events {
+		path := fmt.Sprintf("events[%d]", eventIndex)
+		var event map[string]json.RawMessage
+		if err := json.Unmarshal(rawEvent, &event); err != nil || event == nil {
+			return fmt.Errorf("%s must be an object", path)
+		}
+		for _, field := range []string{"name", "kind"} {
+			if err := requireField(event, field, path); err != nil {
+				return err
+			}
+		}
+		refs, err := requiredArray(event, "source_refs", path)
+		if err != nil {
+			return err
+		}
+		for refIndex, rawRef := range refs {
+			refPath := fmt.Sprintf("%s.source_refs[%d]", path, refIndex)
+			var ref map[string]json.RawMessage
+			if err := json.Unmarshal(rawRef, &ref); err != nil || ref == nil {
+				return fmt.Errorf("%s must be an object", refPath)
+			}
+			for _, field := range []string{"source_id", "start_unit_id", "end_unit_id"} {
+				if err := requireField(ref, field, refPath); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func requiredArray(object map[string]json.RawMessage, field, path string) ([]json.RawMessage, error) {
+	raw, err := requiredField(object, field, path)
+	if err != nil {
+		return nil, err
+	}
+	var values []json.RawMessage
+	if err := json.Unmarshal(raw, &values); err != nil {
+		return nil, fmt.Errorf("%s must be an array", fieldPath(path, field))
+	}
+	return values, nil
+}
+
+func requireField(object map[string]json.RawMessage, field, path string) error {
+	_, err := requiredField(object, field, path)
+	return err
+}
+
+func requiredField(object map[string]json.RawMessage, field, path string) (json.RawMessage, error) {
+	raw, ok := object[field]
+	if !ok || string(raw) == "null" {
+		return nil, fmt.Errorf("%s must be present", fieldPath(path, field))
+	}
+	return raw, nil
+}
+
+func fieldPath(path, field string) string {
+	if path == "" {
+		return field
+	}
+	return path + "." + field
+}
+
+func cloneList(value dnd.EnemyEventList) dnd.EnemyEventList {
+	if value.Events == nil {
+		return dnd.EnemyEventList{}
+	}
+	cloned := dnd.EnemyEventList{Events: make([]dnd.EnemyEvent, len(value.Events))}
+	for index, event := range value.Events {
+		cloned.Events[index] = event
+		if event.SourceRefs != nil {
+			cloned.Events[index].SourceRefs = append([]source.SourceRef(nil), event.SourceRefs...)
+		}
+	}
+	return cloned
+}

internal/modules/dnd/codec/enemyevents/codec_test.go

@@ -0,0 +1,99 @@
+package enemyevents
+
+import (
+	"encoding/json"
+	"reflect"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+)
+
+func validList() dnd.EnemyEventList {
+	return dnd.EnemyEventList{Events: []dnd.EnemyEvent{
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindEngaged, SourceRefs: refs(1, 2)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindFled, SourceRefs: refs(5, 6)},
+	}}
+}
+
+func refs(start, end int) []source.SourceRef {
+	return []source.SourceRef{{SourceID: "session", StartUnitID: start, EndUnitID: end}}
+}
+
+func TestCodecRoundTripAndIdentity(t *testing.T) {
+	codec := New()
+	value := validList()
+	content, err := codec.Encode(value)
+	if err != nil {
+		t.Fatalf("Encode() error = %v", err)
+	}
+	decoded, err := codec.Decode(content)
+	if err != nil || !reflect.DeepEqual(decoded, value) {
+		t.Fatalf("Decode() = %#v, %v; want %#v", decoded, err, value)
+	}
+
+	schema := codec.Schema()
+	if codec.Kind() != dnd.EnemyEventListKind || codec.MediaType() != MediaType || schema.ID != SchemaID || schema.Name != SchemaName || schema.Version != SchemaVersion || !json.Valid(schema.JSONSchema) {
+		t.Fatalf("codec identity/schema = %q/%q %#v", codec.Kind(), codec.MediaType(), schema)
+	}
+	registry := pipeline.NewArtifactCodecRegistry()
+	if err := pipeline.RegisterArtifactCodec(registry, codec); err != nil {
+		t.Fatal(err)
+	}
+	spec, ok := registry.Spec(dnd.EnemyEventListKind)
+	if !ok || spec.SchemaDigest != contracts.DigestArtifactSchema(schema) {
+		t.Fatalf("registered spec = %#v, %t", spec, ok)
+	}
+}
+
+func TestCodecRejectsStrictJSONAndMissingRequiredFields(t *testing.T) {
+	validJSON := `{"events":[{"name":"Ashfang","kind":"engaged","source_refs":[{"source_id":"session","start_unit_id":1,"end_unit_id":1}]}]}`
+	tests := []struct {
+		name, raw, want string
+	}{
+		{"invalid JSON", `{`, "decode dnd enemy event list"},
+		{"unknown root field", `{"events":[],"unexpected":true}`, "unknown field"},
+		{"unknown event field", strings.Replace(validJSON, `"kind":"engaged"`, `"kind":"engaged","unexpected":true`, 1), "unknown field"},
+		{"missing events", `{}`, "events must be present"},
+		{"missing name", strings.Replace(validJSON, `"name":"Ashfang",`, "", 1), "events[0].name must be present"},
+		{"missing kind", strings.Replace(validJSON, `"kind":"engaged",`, "", 1), "events[0].kind must be present"},
+		{"missing refs", strings.Replace(validJSON, `,"source_refs":[{"source_id":"session","start_unit_id":1,"end_unit_id":1}]`, "", 1), "events[0].source_refs must be present"},
+		{"missing source ID", strings.Replace(validJSON, `"source_id":"session",`, "", 1), "source_refs[0].source_id must be present"},
+		{"trailing JSON", `{"events":[]} {}`, "multiple JSON values"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if _, err := New().Decode([]byte(test.raw)); err == nil || !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("Decode() error = %v, want %q", err, test.want)
+			}
+		})
+	}
+}
+
+func TestCodecDefensivelyOwnsValuesAndDefersSemanticValidation(t *testing.T) {
+	codec := New()
+	candidate := dnd.EnemyEventList{Events: []dnd.EnemyEvent{{
+		Name: " ", Kind: "unsupported", SourceRefs: []source.SourceRef{{SourceID: "", StartUnitID: 0, EndUnitID: -1}},
+	}}}
+	content, err := codec.EncodeCandidate(candidate)
+	if err != nil {
+		t.Fatal(err)
+	}
+	decoded, err := codec.Decode(content)
+	if err != nil || !reflect.DeepEqual(decoded, candidate) {
+		t.Fatalf("Decode() = %#v, %v; want semantic candidate preservation", decoded, err)
+	}
+	decoded.Events[0].SourceRefs[0].SourceID = "changed"
+	if candidate.Events[0].SourceRefs[0].SourceID != "" {
+		t.Fatal("Decode() retained caller-owned source references")
+	}
+
+	first := codec.Schema()
+	first.JSONSchema[0] = '['
+	if second := codec.Schema(); !json.Valid(second.JSONSchema) || second.JSONSchema[0] == '[' {
+		t.Fatal("Schema() returned shared bytes")
+	}
+}

internal/modules/dnd/enemyevents/enemyevents.go

@@ -0,0 +1,107 @@
+// Package enemyevents owns canonical ordering and identity policy for D&D
+// enemy-event artifacts.
+package enemyevents
+
+import (
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
+)
+
+// NormalizeDisplay returns the durable display form for an enemy subject.
+func NormalizeDisplay(value string) string { return identity.NormalizeDisplay(value) }
+
+// ComparisonKey returns the shared D&D identity key for an enemy subject.
+func ComparisonKey(value string) string { return identity.ComparisonKey(NormalizeDisplay(value)) }
+
+// SupportedKind reports whether kind belongs to the durable enemy-event vocabulary.
+func SupportedKind(kind dnd.EnemyEventKind) bool {
+	_, ok := KindRank(kind)
+	return ok
+}
+
+// KindRank returns the explicit chronological tie-break order for event kinds.
+func KindRank(kind dnd.EnemyEventKind) (int, bool) {
+	switch kind {
+	case dnd.EnemyEventKindEngaged:
+		return 0, true
+	case dnd.EnemyEventKindIncapacitated:
+		return 1, true
+	case dnd.EnemyEventKindCaptured:
+		return 2, true
+	case dnd.EnemyEventKindFled:
+		return 3, true
+	case dnd.EnemyEventKindKilled:
+		return 4, true
+	default:
+		return 0, false
+	}
+}
+
+// SourceRefsEqual reports whether two reference sequences are equal after
+// canonical ordering and exact duplicate removal.
+func SourceRefsEqual(order shared.SourceRefOrder, left, right []source.SourceRef) bool {
+	left = order.Canonicalize(left)
+	right = order.Canonicalize(right)
+	if (left == nil) != (right == nil) || len(left) != len(right) {
+		return false
+	}
+	for index := range left {
+		if left[index] != right[index] {
+			return false
+		}
+	}
+	return true
+}
+
+// ExactEqual reports whether events have the same subject identity, kind, and
+// complete canonical evidence sequence.
+func ExactEqual(order shared.SourceRefOrder, left, right dnd.EnemyEvent) bool {
+	return ComparisonKey(left.Name) == ComparisonKey(right.Name) &&
+		left.Kind == right.Kind &&
+		SourceRefsEqual(order, left.SourceRefs, right.SourceRefs)
+}
+
+// Less defines the canonical stable event order. Invalid source references
+// remain comparable through SourceRefOrder's literal fallback so malformed
+// candidates can still be sorted for later validation.
+func Less(order shared.SourceRefOrder, left, right dnd.EnemyEvent) bool {
+	leftPosition, leftHasEvidence := order.EarliestValid(left.SourceRefs)
+	rightPosition, rightHasEvidence := order.EarliestValid(right.SourceRefs)
+	if leftHasEvidence != rightHasEvidence {
+		return leftHasEvidence
+	}
+	if leftHasEvidence && leftPosition != rightPosition {
+		return leftPosition < rightPosition
+	}
+	if leftKey, rightKey := ComparisonKey(left.Name), ComparisonKey(right.Name); leftKey != rightKey {
+		return leftKey < rightKey
+	}
+	if leftName, rightName := NormalizeDisplay(left.Name), NormalizeDisplay(right.Name); leftName != rightName {
+		return leftName < rightName
+	}
+	if leftRank, leftKnown := KindRank(left.Kind); leftKnown {
+		if rightRank, rightKnown := KindRank(right.Kind); rightKnown && leftRank != rightRank {
+			return leftRank < rightRank
+		} else if !rightKnown {
+			return true
+		}
+	} else if _, rightKnown := KindRank(right.Kind); rightKnown {
+		return false
+	}
+	if left.Kind != right.Kind {
+		return left.Kind < right.Kind
+	}
+	return sourceRefsLess(order, order.Canonicalize(left.SourceRefs), order.Canonicalize(right.SourceRefs))
+}
+
+func sourceRefsLess(order shared.SourceRefOrder, left, right []source.SourceRef) bool {
+	for index := 0; index < len(left) && index < len(right); index++ {
+		if left[index] == right[index] {
+			continue
+		}
+		return order.Less(left[index], right[index])
+	}
+	return len(left) < len(right)
+}

internal/modules/dnd/enemyevents/enemyevents_test.go

@@ -0,0 +1,90 @@
+package enemyevents
+
+import (
+	"sort"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
+)
+
+func TestSupportedKindAndRank(t *testing.T) {
+	tests := []struct {
+		kind dnd.EnemyEventKind
+		rank int
+	}{
+		{dnd.EnemyEventKindEngaged, 0},
+		{dnd.EnemyEventKindIncapacitated, 1},
+		{dnd.EnemyEventKindCaptured, 2},
+		{dnd.EnemyEventKindFled, 3},
+		{dnd.EnemyEventKindKilled, 4},
+	}
+	for _, test := range tests {
+		if rank, ok := KindRank(test.kind); !ok || rank != test.rank || !SupportedKind(test.kind) {
+			t.Fatalf("kind %q = (%d, %t), supported %t", test.kind, rank, ok, SupportedKind(test.kind))
+		}
+	}
+	if _, ok := KindRank("unknown"); ok || SupportedKind("unknown") {
+		t.Fatal("unsupported kind was accepted")
+	}
+}
+
+func TestLessOrdersChronologyThenKind(t *testing.T) {
+	order := testOrder()
+	events := []dnd.EnemyEvent{
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindKilled, SourceRefs: refs(20)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindFled, SourceRefs: refs(20)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindCaptured, SourceRefs: refs(20)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindIncapacitated, SourceRefs: refs(20)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindEngaged, SourceRefs: refs(20)},
+		{Name: "Later", Kind: dnd.EnemyEventKindEngaged, SourceRefs: refs(30)},
+		{Name: "Earlier", Kind: dnd.EnemyEventKindKilled, SourceRefs: refs(10)},
+	}
+	sort.SliceStable(events, func(left, right int) bool { return Less(order, events[left], events[right]) })
+	want := []dnd.EnemyEventKind{
+		dnd.EnemyEventKindKilled,
+		dnd.EnemyEventKindEngaged,
+		dnd.EnemyEventKindIncapacitated,
+		dnd.EnemyEventKindCaptured,
+		dnd.EnemyEventKindFled,
+		dnd.EnemyEventKindKilled,
+		dnd.EnemyEventKindEngaged,
+	}
+	for index, kind := range want {
+		if events[index].Kind != kind {
+			t.Fatalf("event %d kind = %q, want %q", index, events[index].Kind, kind)
+		}
+	}
+}
+
+func TestExactEqualUsesSubjectIdentityAndCanonicalEvidence(t *testing.T) {
+	order := testOrder()
+	first := dnd.EnemyEvent{Name: "  ASHFANG ", Kind: dnd.EnemyEventKindFled, SourceRefs: []source.SourceRef{
+		{SourceID: "session", StartUnitID: 30, EndUnitID: 30},
+		{SourceID: "session", StartUnitID: 10, EndUnitID: 10},
+		{SourceID: "session", StartUnitID: 10, EndUnitID: 10},
+	}}
+	second := dnd.EnemyEvent{Name: "Ashfang", Kind: dnd.EnemyEventKindFled, SourceRefs: []source.SourceRef{
+		{SourceID: "session", StartUnitID: 10, EndUnitID: 10},
+		{SourceID: "session", StartUnitID: 30, EndUnitID: 30},
+	}}
+	if !ExactEqual(order, first, second) || !SourceRefsEqual(order, first.SourceRefs, second.SourceRefs) {
+		t.Fatal("canonical duplicate identity was not recognized")
+	}
+	differentKind := second
+	differentKind.Kind = dnd.EnemyEventKindKilled
+	differentEvidence := second
+	differentEvidence.SourceRefs = []source.SourceRef{{SourceID: "session", StartUnitID: 20, EndUnitID: 20}}
+	if ExactEqual(order, first, differentKind) || ExactEqual(order, first, differentEvidence) {
+		t.Fatal("distinct event was treated as an exact duplicate")
+	}
+}
+
+func refs(unitID int) []source.SourceRef {
+	return []source.SourceRef{{SourceID: "session", StartUnitID: unitID, EndUnitID: unitID}}
+}
+
+func testOrder() shared.SourceRefOrder {
+	return shared.NewSourceRefOrder(&source.SourceDocument{ID: "session", Units: []source.SourceUnit{{ID: 10}, {ID: 20}, {ID: 30}}})
+}

internal/modules/dnd/extract/enemyevents/assets.go

@@ -0,0 +1,6 @@
+package enemyevents
+
+import "embed"
+
+//go:embed assets/schemas/dnd_enemy_events_llm.v1.json assets/prompts/*.yaml assets/prompts/*.md
+var embeddedAssets embed.FS

internal/modules/dnd/extract/enemyevents/assets/prompts/dnd.enemy_events.yaml

@@ -0,0 +1,55 @@
+id: dnd.enemy_events
+version: "v1"
+default_profile: dnd-extraction
+inputs:
+  - name: transcript
+    required: true
+    content_type: application/json
+  - name: players
+    required: false
+    content_type: text/plain
+  - name: party
+    required: false
+    content_type: text/plain
+  - name: glossary
+    required: false
+    content_type: text/plain
+  - name: npcs
+    required: true
+    content_type: application/json
+  - name: combat_turns
+    required: true
+    content_type: application/json
+  - name: npc_interactions
+    required: true
+    content_type: application/json
+messages:
+  - role: system
+    content_file: ./sharedassets/common-dnd-system.md
+  - role: user
+    content_file: ./sharedassets/common-dnd-identity.md
+  - role: user
+    content_file: ./sharedassets/common-dnd-references.md
+    cache_control:
+      type: ephemeral
+  - role: user
+    content_file: ./sharedassets/common-dnd-transcript.md
+    cache_control:
+      type: ephemeral
+  - role: user
+    content_file: ./sharedassets/common-dnd-extraction-evidence.md
+  - role: user
+    content_file: ./sharedassets/common-dnd-npcs.md
+  - role: user
+    content_file: ./grounding.md
+  - role: user
+    content_file: ./task.md
+  - role: user
+    content_file: ./instructions.md
+    cache_control:
+      type: ephemeral
+output:
+  format: json
+  validation_mode: json_schema
+  schema_path: dnd_enemy_events_llm.v1.json
+  repair_attempts: 0

internal/modules/dnd/extract/enemyevents/assets/prompts/grounding.md

@@ -0,0 +1,12 @@
+Compact combat grounding is supplied below. It can guide attention and
+disambiguation, but it is not evidence. Do not derive an event, subject,
+outcome, or source range from either list. The current transcript alone must
+directly establish every returned event.
+
+Combat-turn grounding:
+
+{{ input "combat_turns" }}
+
+Named combat-opponent grounding:
+
+{{ input "npc_interactions" }}

internal/modules/dnd/extract/enemyevents/assets/prompts/instructions.md

@@ -0,0 +1,14 @@
+Exclude party members, allies, neutral observers, mentioned-but-absent enemies,
+hazards, traps, environmental effects, uncertain allegiance, table talk,
+planning, hypotheses, recaps outside this passage, and downstream inference.
+
+Do not infer an engagement or outcome from initiative, turn absence, damage,
+defeat, movement, a scene ending, combat-opponent grounding, or any auxiliary
+artifact. Auxiliary inputs can guide attention but cannot prove or supply an
+event. Cite only narrow current-transcript ranges that establish each event.
+
+Return the `events` array even when no enemy event is established. Every event
+must contain only `name`, `kind`, and `source_refs`. Use exactly one kind:
+`engaged`, `killed`, `fled`, `captured`, or `incapacitated`. Each source range
+uses integer `start_unit_id` and `end_unit_id`; omit `source_id` because
+Notarius assigns the current source identity.

internal/modules/dnd/extract/enemyevents/assets/prompts/task.md

@@ -0,0 +1,20 @@
+Extract Dungeons & Dragons enemy events from the supplied combat transcript.
+
+Return an `engaged` event only when the transcript directly establishes that a
+subject is actively opposing the party in combat. Return `killed`, `fled`,
+`captured`, or `incapacitated` only when the transcript explicitly establishes
+that outcome. An outcome may share evidence with an engagement, and a later
+engagement or outcome for the same subject remains a separate observation.
+Emit at most one engagement for the same subject in this combat scene.
+
+For `killed`, direct death or killing is required. For `fled`, the subject must
+explicitly escape, retreat, or leave combat to avoid continued engagement. For
+`captured`, the subject must be explicitly taken prisoner or secured under the
+party's control. For `incapacitated`, the subject must be explicitly unable to
+continue acting without being established as killed or captured.
+
+Use a normalized NPC registry spelling when the transcript identifies that
+named NPC. A hostile creature without a registry entry is allowed. For unnamed
+individuals or groups, use only the narrowest transcript-grounded label, such
+as `Orcs`, `One orc`, or `Remaining orcs`; never invent member names, IDs, or
+quantities.

internal/modules/dnd/extract/enemyevents/assets/schemas/dnd_enemy_events_llm.v1.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "notarius.dnd.enemy_events.llm",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["events"],
+  "properties": {
+    "events": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["name", "kind", "source_refs"],
+        "properties": {
+          "name": {"type": "string"},
+          "kind": {"type": "string"},
+          "source_refs": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["start_unit_id", "end_unit_id"],
+              "properties": {
+                "start_unit_id": {"type": "integer"},
+                "end_unit_id": {"type": "integer"}
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

internal/modules/dnd/extract/enemyevents/extractor.go

@@ -0,0 +1,210 @@
+package enemyevents
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	sceneregistry "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/scenedescriptions/registry"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
+)
+
+const (
+	Key             = "dnd/enemy-events"
+	mappingPolicy   = "dnd.enemy_events.extract_mapping.v1"
+	sceneGatePolicy = "dnd.enemy_events.scene_gate.v1"
+)
+
+var requiredCapabilities = []string{
+	"chunks",
+	"source.transcript",
+}
+
+var providedCapabilities = []string{
+	"dnd.enemy_events",
+}
+
+var _ contracts.Extractor[dnd.EnemyEventList] = (*Extractor)(nil)
+var _ contracts.ManifestMetadataProvider = (*Extractor)(nil)
+var _ pipeline.CheckpointFingerprintProvider = (*Extractor)(nil)
+
+type Options struct{}
+
+type Extractor struct {
+	llm       contracts.StructuredLLMClient
+	grounding *groundingResolver
+
+	promptSHA         string
+	responseSchemaSHA string
+}
+
+func New(llmClient contracts.StructuredLLMClient, _ Options, references ...contracts.ReferenceSet) (*Extractor, error) {
+	if llmClient == nil {
+		return nil, extractorErrorf("LLM client must not be nil")
+	}
+	if len(references) > 1 {
+		return nil, extractorErrorf("at most one reference set may be supplied")
+	}
+	var referenceSet contracts.ReferenceSet
+	if len(references) == 1 {
+		referenceSet = references[0]
+	}
+	grounding, err := newGroundingResolver(referenceSet)
+	if err != nil {
+		return nil, extractorErrorf("prepare grounding: %w", err)
+	}
+	promptSHA, err := promptAssetMetadata()
+	if err != nil {
+		return nil, extractorErrorf("load prompt metadata: %w", err)
+	}
+	responseSchema, err := loadResponseSchema()
+	if err != nil {
+		return nil, extractorErrorf("load response schema: %w", err)
+	}
+	return &Extractor{
+		llm:               llmClient,
+		grounding:         grounding,
+		promptSHA:         promptSHA,
+		responseSchemaSHA: responseSchema.SHA256,
+	}, nil
+}
+
+func (e *Extractor) Key() string { return Key }
+
+func (e *Extractor) ReferenceSlots() []contracts.ReferenceSlot { return referenceSlots() }
+
+func (e *Extractor) ManifestMetadata() map[string]any {
+	if e == nil {
+		return nil
+	}
+	return map[string]any{
+		"prompt_id":               PromptID,
+		"prompt_version":          SchemaVersion,
+		"prompt_sha256":           e.promptSHA,
+		"mapping_policy":          mappingPolicy,
+		"scene_gate_policy":       sceneGatePolicy,
+		"response_schema_key":     string(ResponseSchemaKey),
+		"response_schema_id":      ResponseSchemaID,
+		"response_schema_name":    ResponseSchemaName,
+		"response_schema_version": SchemaVersion,
+		"response_schema_sha256":  e.responseSchemaSHA,
+	}
+}
+
+func (e *Extractor) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
+	if e == nil {
+		return nil
+	}
+	return []pipeline.CheckpointFingerprint{
+		{Name: "prompt", Value: e.promptSHA},
+		{Name: "response_schema", Value: e.responseSchemaSHA},
+		{Name: "mapping_policy", Value: mappingPolicy},
+		{Name: "scene_gate_policy", Value: sceneGatePolicy},
+	}
+}
+
+func (e *Extractor) Extract(ctx context.Context, req contracts.TypedExtractionRequest) (contracts.TypedExtractionResult[dnd.EnemyEventList], error) {
+	if e == nil {
+		return contracts.TypedExtractionResult[dnd.EnemyEventList]{}, extractorErrorf("extractor must not be nil")
+	}
+	if e.llm == nil {
+		return contracts.TypedExtractionResult[dnd.EnemyEventList]{}, extractorErrorf("LLM client must not be nil")
+	}
+	if e.grounding == nil {
+		return contracts.TypedExtractionResult[dnd.EnemyEventList]{}, extractorErrorf("grounding resolver must not be nil")
+	}
+	sourceInput, err := shared.PrepareChunkExtraction(ctx, req)
+	if err != nil {
+		return contracts.TypedExtractionResult[dnd.EnemyEventList]{}, extractorErrorf("%w", err)
+	}
+	match, err := e.grounding.SceneMatch(req.References, req.Chunk)
+	if err != nil {
+		return contracts.TypedExtractionResult[dnd.EnemyEventList]{}, extractorErrorf("resolve scene eligibility: %w", err)
+	}
+	switch match.State {
+	case sceneregistry.MatchExact:
+		if match.Kind != dnd.SceneKindCombat {
+			return emptyResult(), nil
+		}
+	case sceneregistry.MatchMissing, sceneregistry.MatchMismatched:
+		return unavailableSceneResult(), nil
+	default:
+		return contracts.TypedExtractionResult[dnd.EnemyEventList]{}, extractorErrorf("unsupported scene eligibility match state %q", match.State)
+	}
+	grounding, err := e.grounding.Resolve(req.References)
+	if err != nil {
+		return contracts.TypedExtractionResult[dnd.EnemyEventList]{}, extractorErrorf("resolve enemy-event grounding: %w", err)
+	}
+	inputs := shared.PromptInputs(sourceInput, req.References)
+	for name, input := range grounding.PromptInputs() {
+		inputs[name] = input
+	}
+	var response extractionResponse
+	if _, err := e.llm.CompleteStructured(ctx, contracts.StructuredCompletionRequest{
+		StageName:     Key,
+		PromptID:      PromptID,
+		PromptVersion: SchemaVersion,
+		ProfileID:     req.LLMProfile,
+		SessionID:     req.SessionID,
+		Inputs:        inputs,
+	}, &response); err != nil {
+		return contracts.TypedExtractionResult[dnd.EnemyEventList]{}, extractorErrorf("complete structured output: %w", err)
+	}
+	return contracts.TypedExtractionResult[dnd.EnemyEventList]{
+		Value: canonicalEnemyEventList(response, shared.NewSourceRefOrder(req.Source), req.Source.ID),
+	}, nil
+}
+
+func emptyResult() contracts.TypedExtractionResult[dnd.EnemyEventList] {
+	return contracts.TypedExtractionResult[dnd.EnemyEventList]{Value: dnd.EnemyEventList{Events: []dnd.EnemyEvent{}}}
+}
+
+func unavailableSceneResult() contracts.TypedExtractionResult[dnd.EnemyEventList] {
+	result := emptyResult()
+	result.Warnings = []contracts.Warning{{
+		Scope:      SceneDescriptionReferenceSlot,
+		ReasonCode: "scene_classification_unavailable",
+		Message:    "No exact scene classification was available; enemy-event extraction was skipped.",
+	}}
+	return result
+}
+
+func ModuleSpec() pipeline.ModuleSpec {
+	return pipeline.ModuleSpec{
+		Key:            Key,
+		Stage:          pipeline.StageExtract,
+		ExecutionClass: contracts.ExecutionClassLLMBacked,
+		Requires:       append([]string(nil), requiredCapabilities...),
+		Provides:       append([]string(nil), providedCapabilities...),
+		ArtifactKind:   dnd.EnemyEventListKind,
+		ReferenceSlots: referenceSlots(),
+	}
+}
+
+func Register(registry *pipeline.ExtractorRegistry) error {
+	return pipeline.RegisterExtractorBuilder(registry, ModuleSpec(), validateOptions, func(request pipeline.BuildRequest) (contracts.Extractor[dnd.EnemyEventList], error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return New(request.Dependencies.LLM, options, request.References)
+	})
+}
+
+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 {
+		return Options{}, extractorErrorf("%w", err)
+	}
+	return Options{}, nil
+}
+
+func extractorErrorf(format string, args ...any) error {
+	return fmt.Errorf("dnd enemy events extractor: "+format, args...)
+}

internal/modules/dnd/extract/enemyevents/extractor_test.go

@@ -0,0 +1,229 @@
+package enemyevents
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+)
+
+func TestExtractMapsEnemyEventsInSourceOrder(t *testing.T) {
+	client := &fakeEnemyEventsLLMClient{response: extractionResponse{Events: []enemyEventResponse{
+		{Name: "Ashfang", Kind: "killed", SourceRefs: []enemySourceRefResponse{{StartUnitID: 4, EndUnitID: 4}}},
+		{Name: "Ashfang", Kind: "engaged", SourceRefs: []enemySourceRefResponse{{StartUnitID: 1, EndUnitID: 1}, {StartUnitID: 1, EndUnitID: 1}}},
+		{Name: "Orcs", Kind: "fled", SourceRefs: []enemySourceRefResponse{{StartUnitID: 3, EndUnitID: 3}}},
+		{Name: "One orc", Kind: "captured", SourceRefs: []enemySourceRefResponse{{StartUnitID: 2, EndUnitID: 2}}},
+		{Name: "Ashfang", Kind: "incapacitated", SourceRefs: []enemySourceRefResponse{{StartUnitID: 2, EndUnitID: 2}}},
+	}}}
+
+	result, err := newEnemyExtractor(t, client).Extract(context.Background(), enemyExtractionRequest(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := []dnd.EnemyEventKind{result.Value.Events[0].Kind, result.Value.Events[1].Kind, result.Value.Events[2].Kind, result.Value.Events[3].Kind, result.Value.Events[4].Kind}; !reflect.DeepEqual(got, []dnd.EnemyEventKind{
+		dnd.EnemyEventKindEngaged,
+		dnd.EnemyEventKindCaptured,
+		dnd.EnemyEventKindIncapacitated,
+		dnd.EnemyEventKindFled,
+		dnd.EnemyEventKindKilled,
+	}) {
+		t.Fatalf("event order = %#v", got)
+	}
+	if refs := result.Value.Events[0].SourceRefs; !reflect.DeepEqual(refs, []source.SourceRef{{SourceID: "combat-session", StartUnitID: 1, EndUnitID: 1}}) {
+		t.Fatalf("canonical source refs = %#v", refs)
+	}
+	if len(client.requests) != 1 {
+		t.Fatalf("LLM calls = %d, want 1", len(client.requests))
+	}
+	request := client.requests[0]
+	if request.StageName != Key || request.PromptID != PromptID || request.PromptVersion != SchemaVersion || request.ProfileID != "enemy-profile" || request.SessionID != "session-123" {
+		t.Fatalf("LLM request identity = %#v", request)
+	}
+	if got := string(request.Inputs[CombatTurnReferenceSlot].Content); !strings.Contains(got, `"actor":"Ashfang"`) || strings.Contains(got, "source_ref") {
+		t.Fatalf("combat grounding = %s", got)
+	}
+	if got := string(request.Inputs[NPCInteractionReferenceSlot].Content); !strings.Contains(got, `"kind":"combat_opponent"`) || strings.Contains(got, "Aria") {
+		t.Fatalf("interaction grounding = %s", got)
+	}
+}
+
+func TestExtractPreservesSemanticCandidatesAndResponseOwnership(t *testing.T) {
+	client := &fakeEnemyEventsLLMClient{response: extractionResponse{Events: []enemyEventResponse{{
+		Name: " ", Kind: "unsupported", SourceRefs: []enemySourceRefResponse{{StartUnitID: 99, EndUnitID: 0}},
+	}}}}
+	result, err := newEnemyExtractor(t, client).Extract(context.Background(), enemyExtractionRequest(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	event := result.Value.Events[0]
+	if event.Name != " " || event.Kind != "unsupported" || event.SourceRefs[0] != (source.SourceRef{SourceID: "combat-session", StartUnitID: 99}) {
+		t.Fatalf("semantic candidate = %#v", event)
+	}
+	result.Value.Events[0].SourceRefs[0].StartUnitID = 7
+	if client.response.Events[0].SourceRefs[0].StartUnitID != 99 {
+		t.Fatal("mapped event aliases model-owned source references")
+	}
+}
+
+func TestExtractSkipsModelForIneligibleScenes(t *testing.T) {
+	for _, test := range []struct {
+		name        string
+		kind        dnd.SceneKind
+		change      func(*source.Chunk)
+		wantWarning bool
+	}{
+		{name: "non-combat", kind: dnd.SceneKindNarrative},
+		{name: "missing", kind: dnd.SceneKindCombat, change: func(chunk *source.Chunk) { chunk.ID = "other" }, wantWarning: true},
+		{name: "mismatched", kind: dnd.SceneKindCombat, change: func(chunk *source.Chunk) { chunk.Ref.EndUnitID++ }, wantWarning: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			client := &fakeEnemyEventsLLMClient{}
+			request := enemyExtractionRequest(t)
+			request.References = groundingReferences(t, "Ashfang", test.kind)
+			if test.change != nil {
+				test.change(request.Chunk)
+			}
+			result, err := newEnemyExtractor(t, client).Extract(context.Background(), request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(client.requests) != 0 || result.Value.Events == nil || len(result.Value.Events) != 0 {
+				t.Fatalf("result = %#v, calls = %d", result, len(client.requests))
+			}
+			if test.wantWarning {
+				if len(result.Warnings) != 1 || result.Warnings[0].ReasonCode != "scene_classification_unavailable" || result.Warnings[0].Scope != SceneDescriptionReferenceSlot {
+					t.Fatalf("warnings = %#v", result.Warnings)
+				}
+			} else if len(result.Warnings) != 0 {
+				t.Fatalf("warnings = %#v", result.Warnings)
+			}
+		})
+	}
+}
+
+func TestExtractReportsRequiredGroundingAndProviderFailures(t *testing.T) {
+	client := &fakeEnemyEventsLLMClient{}
+	request := enemyExtractionRequest(t)
+	request.References = withoutSlot(request.References, NPCRegistryReferenceSlot)
+	if _, err := (&Extractor{llm: client, grounding: mustGroundingResolver(t, request.References)}).Extract(context.Background(), request); err == nil || !strings.Contains(err.Error(), "NPC registry") {
+		t.Fatalf("Extract() error = %v, want required grounding context", err)
+	}
+
+	provider := &fakeEnemyEventsLLMClient{err: errors.New("provider unavailable")}
+	if _, err := newEnemyExtractor(t, provider).Extract(context.Background(), enemyExtractionRequest(t)); err == nil || !strings.Contains(err.Error(), "complete structured output") || !strings.Contains(err.Error(), "provider unavailable") {
+		t.Fatalf("Extract() error = %v, want provider context", err)
+	}
+}
+
+func TestConstructorSpecOptionsAndSafeMetadata(t *testing.T) {
+	if _, err := New(nil, Options{}); err == nil || !strings.Contains(err.Error(), "LLM client") {
+		t.Fatalf("New(nil) error = %v", err)
+	}
+	if _, err := New(&fakeEnemyEventsLLMClient{}, Options{}, contracts.ReferenceSet{}, contracts.ReferenceSet{}); err == nil || !strings.Contains(err.Error(), "at most one") {
+		t.Fatalf("New() error = %v", err)
+	}
+	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil || !strings.Contains(err.Error(), "unknown option") {
+		t.Fatalf("DecodeOptions() error = %v", err)
+	}
+
+	first := ModuleSpec()
+	first.Requires[0] = "changed"
+	first.ReferenceSlots[0].AcceptedMediaTypes[0] = "changed"
+	second := ModuleSpec()
+	if second.Requires[0] != "chunks" || second.ArtifactKind != dnd.EnemyEventListKind || second.ExecutionClass != contracts.ExecutionClassLLMBacked || second.ReferenceSlots[0].AcceptedMediaTypes[0] == "changed" {
+		t.Fatalf("ModuleSpec() reused mutable state: %#v", second)
+	}
+	registry := pipeline.NewExtractorRegistry()
+	if err := Register(registry); err != nil {
+		t.Fatal(err)
+	}
+	if spec, ok := registry.Spec(Key); !ok || spec.Key != Key || spec.ArtifactKind != dnd.EnemyEventListKind {
+		t.Fatalf("registered spec = %#v, %t", spec, ok)
+	}
+
+	extractor := newEnemyExtractor(t, &fakeEnemyEventsLLMClient{}, groundingReferences(t, "Ashfang", dnd.SceneKindCombat))
+	metadata := extractor.ManifestMetadata()
+	encoded, err := json.Marshal(metadata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(encoded), "Ashfang") || metadata["mapping_policy"] != mappingPolicy || metadata["scene_gate_policy"] != sceneGatePolicy {
+		t.Fatalf("unsafe or incomplete metadata = %s", encoded)
+	}
+	fingerprints := extractor.CheckpointFingerprints()
+	if len(fingerprints) != 4 || fingerprints[0].Value != metadata["prompt_sha256"] || fingerprints[1].Value != metadata["response_schema_sha256"] || fingerprints[2].Value != mappingPolicy || fingerprints[3].Value != sceneGatePolicy {
+		t.Fatalf("fingerprints = %#v", fingerprints)
+	}
+}
+
+func newEnemyExtractor(t *testing.T, client contracts.StructuredLLMClient, references ...contracts.ReferenceSet) *Extractor {
+	t.Helper()
+	if len(references) == 0 {
+		references = []contracts.ReferenceSet{groundingReferences(t, "Ashfang", dnd.SceneKindCombat)}
+	}
+	extractor, err := New(client, Options{}, references...)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return extractor
+}
+
+func mustGroundingResolver(t *testing.T, references contracts.ReferenceSet) *groundingResolver {
+	t.Helper()
+	resolver, err := newGroundingResolver(references)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return resolver
+}
+
+func enemyExtractionRequest(t *testing.T) contracts.TypedExtractionRequest {
+	t.Helper()
+	chunk := combatChunk()
+	chunk.Units = []source.SourceUnit{{ID: 1}, {ID: 2}, {ID: 3}, {ID: 4}}
+	chunk.MediaType = "application/json"
+	chunk.Content = []byte(`{"id":"combat-scene","units":[1,2,3,4]}`)
+	return contracts.TypedExtractionRequest{
+		Source:      &source.SourceDocument{ID: "combat-session", Units: append([]source.SourceUnit(nil), chunk.Units...)},
+		Chunk:       chunk,
+		SourceInput: contracts.NewLLMInputMaterial("source", "application/json", chunk.Content, digest(chunk.Content), "file:///combat-session.json"),
+		References:  groundingReferences(t, "Ashfang", dnd.SceneKindCombat),
+		LLMProfile:  "enemy-profile",
+		SessionID:   "session-123",
+	}
+}
+
+type fakeEnemyEventsLLMClient struct {
+	response extractionResponse
+	err      error
+	requests []contracts.StructuredCompletionRequest
+}
+
+func (client *fakeEnemyEventsLLMClient) CompleteStructured(_ context.Context, request contracts.StructuredCompletionRequest, out any) (contracts.StructuredCompletionResponse, error) {
+	client.requests = append(client.requests, cloneEnemyRequest(request))
+	if client.err != nil {
+		return contracts.StructuredCompletionResponse{}, client.err
+	}
+	target, ok := out.(*extractionResponse)
+	if !ok {
+		return contracts.StructuredCompletionResponse{}, errors.New("unexpected output target")
+	}
+	*target = client.response
+	content, err := json.Marshal(client.response)
+	if err != nil {
+		return contracts.StructuredCompletionResponse{}, err
+	}
+	return contracts.StructuredCompletionResponse{Content: content}, nil
+}
+
+func cloneEnemyRequest(request contracts.StructuredCompletionRequest) contracts.StructuredCompletionRequest {
+	request.Inputs = request.Inputs.Clone()
+	return request
+}

internal/modules/dnd/extract/enemyevents/grounding.go

@@ -0,0 +1,293 @@
+// Package enemyevents prepares validated D&D combat grounding for enemy-event
+// extraction.
+package enemyevents
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"mime"
+	"sort"
+	"strings"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	combatturncodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/combatturns"
+	interactioncodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcinteractions"
+	npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcs"
+	scenecodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/scenedescriptions"
+	npcregistry "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/registry"
+	sceneregistry "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/scenedescriptions/registry"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
+)
+
+const (
+	NPCRegistryReferenceSlot      = npcregistry.ReferenceSlot
+	SceneDescriptionReferenceSlot = sceneregistry.ReferenceSlot
+	CombatTurnReferenceSlot       = "combat_turns"
+	NPCInteractionReferenceSlot   = "npc_interactions"
+	ReferenceMaxBytes             = 1048576
+	promptProjectionMediaType     = "application/json"
+)
+
+var referenceSlotDescriptions = shared.ReferenceSlotDescriptions{
+	Glossary: "Optional campaign glossary reference material used only for disambiguation.",
+	Party:    "Optional party roster reference material used only for disambiguation.",
+	Players:  "Optional player list reference material used only for disambiguation.",
+	Roster:   "Deprecated alias for party roster reference material used only for disambiguation.",
+}
+
+func referenceSlots() []contracts.ReferenceSlot {
+	slots := shared.ReferenceSlots(referenceSlotDescriptions)
+	slots = append(slots,
+		contracts.ReferenceSlot{
+			Name:                  NPCRegistryReferenceSlot,
+			Description:           "Required normalized NPC registry used only for enemy-subject grounding, never as event evidence.",
+			Required:              true,
+			AcceptedMediaTypes:    []string{npccodec.MediaType},
+			AcceptedArtifactKinds: []contracts.ArtifactKind{dnd.NPCListKind},
+			MaxBytes:              ReferenceMaxBytes,
+		},
+		contracts.ReferenceSlot{
+			Name:                  SceneDescriptionReferenceSlot,
+			Description:           "Required scene descriptions used only to determine exact combat eligibility, never as event evidence.",
+			Required:              true,
+			AcceptedMediaTypes:    []string{scenecodec.MediaType},
+			AcceptedArtifactKinds: []contracts.ArtifactKind{dnd.SceneDescriptionListKind},
+			MaxBytes:              ReferenceMaxBytes,
+		},
+		contracts.ReferenceSlot{
+			Name:                  CombatTurnReferenceSlot,
+			Description:           "Required combat-turn artifact used only as source-free enemy-event grounding.",
+			Required:              true,
+			AcceptedMediaTypes:    []string{combatturncodec.MediaType},
+			AcceptedArtifactKinds: []contracts.ArtifactKind{dnd.CombatTurnListKind},
+			MaxBytes:              ReferenceMaxBytes,
+		},
+		contracts.ReferenceSlot{
+			Name:                  NPCInteractionReferenceSlot,
+			Description:           "Required NPC-interaction artifact used only as source-free enemy-event grounding.",
+			Required:              true,
+			AcceptedMediaTypes:    []string{interactioncodec.MediaType},
+			AcceptedArtifactKinds: []contracts.ArtifactKind{dnd.NPCInteractionListKind},
+			MaxBytes:              ReferenceMaxBytes,
+		},
+	)
+	sort.Slice(slots, func(left, right int) bool { return slots[left].Name < slots[right].Name })
+	return contracts.CloneReferenceSlots(slots)
+}
+
+// groundingResolver retains only validated, compact construction-time views.
+// Per-operation generated references are decoded when supplied and never
+// become static metadata.
+type groundingResolver struct {
+	npcs   *npcregistry.Resolver
+	scenes *sceneregistry.Resolver
+
+	combatTurns     *contracts.LLMInputMaterial
+	npcInteractions *contracts.LLMInputMaterial
+}
+
+type grounding struct {
+	npcInput            contracts.LLMInputMaterial
+	combatTurnInput     contracts.LLMInputMaterial
+	npcInteractionInput contracts.LLMInputMaterial
+}
+
+func newGroundingResolver(references contracts.ReferenceSet) (*groundingResolver, error) {
+	npcs, err := npcregistry.NewResolver(references)
+	if err != nil {
+		return nil, fmt.Errorf("prepare NPC registry grounding: %w", err)
+	}
+	scenes, err := sceneregistry.NewResolver(references)
+	if err != nil {
+		return nil, fmt.Errorf("prepare scene eligibility: %w", err)
+	}
+	combatTurns, err := prepareCombatTurnInput(references)
+	if err != nil {
+		return nil, err
+	}
+	npcInteractions, err := prepareNPCInteractionInput(references)
+	if err != nil {
+		return nil, err
+	}
+	return &groundingResolver{
+		npcs:            npcs,
+		scenes:          scenes,
+		combatTurns:     combatTurns,
+		npcInteractions: npcInteractions,
+	}, nil
+}
+
+func (r *groundingResolver) Resolve(references contracts.ReferenceSet) (grounding, error) {
+	if r == nil {
+		return grounding{}, fmt.Errorf("grounding resolver must not be nil")
+	}
+	npcs, err := r.npcs.Resolve(references)
+	if err != nil {
+		return grounding{}, fmt.Errorf("resolve NPC registry grounding: %w", err)
+	}
+	if !npcs.Bound() {
+		return grounding{}, fmt.Errorf("NPC registry reference is required")
+	}
+	combatTurns, err := resolveInput(references, CombatTurnReferenceSlot, r.combatTurns, prepareCombatTurnInput)
+	if err != nil {
+		return grounding{}, err
+	}
+	npcInteractions, err := resolveInput(references, NPCInteractionReferenceSlot, r.npcInteractions, prepareNPCInteractionInput)
+	if err != nil {
+		return grounding{}, err
+	}
+	return grounding{
+		npcInput:            npcs.PromptInput(),
+		combatTurnInput:     combatTurns,
+		npcInteractionInput: npcInteractions,
+	}, nil
+}
+
+func (r *groundingResolver) SceneMatch(references contracts.ReferenceSet, chunk *source.Chunk) (sceneregistry.ChunkMatch, error) {
+	if r == nil {
+		return sceneregistry.ChunkMatch{}, fmt.Errorf("grounding resolver must not be nil")
+	}
+	scenes, err := r.resolveScenes(references)
+	if err != nil {
+		return sceneregistry.ChunkMatch{}, err
+	}
+	return scenes.Match(chunk), nil
+}
+
+func (r *groundingResolver) resolveScenes(references contracts.ReferenceSet) (*sceneregistry.Registry, error) {
+	scenes, err := r.scenes.Resolve(references)
+	if err != nil {
+		return nil, fmt.Errorf("resolve scene eligibility: %w", err)
+	}
+	if !scenes.Bound() {
+		return nil, fmt.Errorf("scene descriptions reference is required")
+	}
+	return scenes, nil
+}
+
+func resolveInput(references contracts.ReferenceSet, slot string, seeded *contracts.LLMInputMaterial, prepare func(contracts.ReferenceSet) (*contracts.LLMInputMaterial, error)) (contracts.LLMInputMaterial, error) {
+	if _, ok := references.Slots[slot]; ok {
+		value, err := prepare(references)
+		if err != nil {
+			return contracts.LLMInputMaterial{}, err
+		}
+		if value == nil {
+			return contracts.LLMInputMaterial{}, fmt.Errorf("%s reference is required", slot)
+		}
+		return value.Clone(), nil
+	}
+	if seeded == nil {
+		return contracts.LLMInputMaterial{}, fmt.Errorf("%s reference is required", slot)
+	}
+	return seeded.Clone(), nil
+}
+
+func (g grounding) PromptInputs() contracts.LLMInputSet {
+	return contracts.LLMInputSet{
+		NPCRegistryReferenceSlot:    g.npcInput.Clone(),
+		CombatTurnReferenceSlot:     g.combatTurnInput.Clone(),
+		NPCInteractionReferenceSlot: g.npcInteractionInput.Clone(),
+	}
+}
+
+func prepareCombatTurnInput(references contracts.ReferenceSet) (*contracts.LLMInputMaterial, error) {
+	item, ok, err := referenceItem(references, CombatTurnReferenceSlot, combatturncodec.MediaType)
+	if err != nil || !ok {
+		return nil, err
+	}
+	value, err := combatturncodec.New().Decode(item.Content)
+	if err != nil {
+		return nil, fmt.Errorf("decode combat-turn grounding: invalid approved combat-turn JSON")
+	}
+	content, err := json.Marshal(struct {
+		CombatTurns []combatTurnProjection `json:"combat_turns"`
+	}{CombatTurns: projectCombatTurns(value.CombatTurns)})
+	if err != nil {
+		return nil, fmt.Errorf("encode combat-turn grounding: %w", err)
+	}
+	return newPromptInput(CombatTurnReferenceSlot, content), nil
+}
+
+func prepareNPCInteractionInput(references contracts.ReferenceSet) (*contracts.LLMInputMaterial, error) {
+	item, ok, err := referenceItem(references, NPCInteractionReferenceSlot, interactioncodec.MediaType)
+	if err != nil || !ok {
+		return nil, err
+	}
+	value, err := interactioncodec.New().Decode(item.Content)
+	if err != nil {
+		return nil, fmt.Errorf("decode NPC-interaction grounding: invalid approved NPC-interaction JSON")
+	}
+	content, err := json.Marshal(struct {
+		Interactions []npcInteractionProjection `json:"npc_interactions"`
+	}{Interactions: projectNPCInteractions(value.Interactions)})
+	if err != nil {
+		return nil, fmt.Errorf("encode NPC-interaction grounding: %w", err)
+	}
+	return newPromptInput(NPCInteractionReferenceSlot, content), nil
+}
+
+func referenceItem(references contracts.ReferenceSet, slotName, expectedMediaType string) (contracts.ReferenceItem, bool, error) {
+	slot, ok := references.Slots[slotName]
+	if !ok {
+		return contracts.ReferenceItem{}, false, nil
+	}
+	if len(slot.Items) == 0 {
+		return contracts.ReferenceItem{}, false, nil
+	}
+	if len(slot.Items) != 1 {
+		return contracts.ReferenceItem{}, false, fmt.Errorf("reference slot %q must contain exactly one item", slotName)
+	}
+	item := slot.Items[0]
+	mediaType, _, err := mime.ParseMediaType(item.MediaType)
+	if err != nil {
+		return contracts.ReferenceItem{}, false, fmt.Errorf("reference slot %q item media type is invalid", slotName)
+	}
+	if !strings.EqualFold(mediaType, expectedMediaType) {
+		return contracts.ReferenceItem{}, false, fmt.Errorf("reference slot %q item media type must be %s", slotName, expectedMediaType)
+	}
+	if len(item.Content) > ReferenceMaxBytes {
+		return contracts.ReferenceItem{}, false, fmt.Errorf("reference slot %q item is %d bytes, limit %d", slotName, len(item.Content), ReferenceMaxBytes)
+	}
+	return item, true, nil
+}
+
+type combatTurnProjection struct {
+	Actor    string             `json:"actor"`
+	TurnKind dnd.CombatTurnKind `json:"turn_kind"`
+}
+
+func projectCombatTurns(turns []dnd.CombatTurn) []combatTurnProjection {
+	if turns == nil {
+		return nil
+	}
+	projection := make([]combatTurnProjection, len(turns))
+	for index, turn := range turns {
+		projection[index] = combatTurnProjection{Actor: turn.Actor, TurnKind: turn.TurnKind}
+	}
+	return projection
+}
+
+type npcInteractionProjection struct {
+	Name string                 `json:"name"`
+	Kind dnd.NPCInteractionKind `json:"kind"`
+}
+
+func projectNPCInteractions(interactions []dnd.NPCInteraction) []npcInteractionProjection {
+	projection := make([]npcInteractionProjection, 0, len(interactions))
+	for _, interaction := range interactions {
+		if interaction.Kind == dnd.NPCInteractionKindCombatOpponent {
+			projection = append(projection, npcInteractionProjection{Name: interaction.Name, Kind: interaction.Kind})
+		}
+	}
+	return projection
+}
+
+func newPromptInput(name string, content []byte) *contracts.LLMInputMaterial {
+	sum := sha256.Sum256(content)
+	material := contracts.NewLLMInputMaterial(name, promptProjectionMediaType, content, "sha256:"+hex.EncodeToString(sum[:]), "")
+	return &material
+}

internal/modules/dnd/extract/enemyevents/grounding_test.go

@@ -0,0 +1,279 @@
+package enemyevents
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	combatturncodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/combatturns"
+	interactioncodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcinteractions"
+	npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcs"
+	scenecodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/scenedescriptions"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
+	sceneregistry "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/scenedescriptions/registry"
+)
+
+func TestReferenceSlotsDescribeRequiredTypedArtifacts(t *testing.T) {
+	slots := referenceSlots()
+	if len(slots) != 8 {
+		t.Fatalf("ReferenceSlots() count = %d, want 8", len(slots))
+	}
+	byName := make(map[string]contracts.ReferenceSlot, len(slots))
+	for index, slot := range slots {
+		if index > 0 && slots[index-1].Name > slot.Name {
+			t.Fatalf("ReferenceSlots() is not sorted: %#v", slots)
+		}
+		byName[slot.Name] = slot
+	}
+	for _, want := range []struct {
+		name string
+		kind contracts.ArtifactKind
+	}{
+		{NPCRegistryReferenceSlot, dnd.NPCListKind},
+		{SceneDescriptionReferenceSlot, dnd.SceneDescriptionListKind},
+		{CombatTurnReferenceSlot, dnd.CombatTurnListKind},
+		{NPCInteractionReferenceSlot, dnd.NPCInteractionListKind},
+	} {
+		slot, ok := byName[want.name]
+		if !ok || !slot.Required || slot.MaxBytes != ReferenceMaxBytes || len(slot.AcceptedMediaTypes) != 1 || slot.AcceptedMediaTypes[0] != "application/json" || len(slot.AcceptedArtifactKinds) != 1 || slot.AcceptedArtifactKinds[0] != want.kind {
+			t.Fatalf("slot %q = %#v", want.name, slot)
+		}
+	}
+
+	slots[0].AcceptedMediaTypes[0] = "changed"
+	if referenceSlots()[0].AcceptedMediaTypes[0] == "changed" {
+		t.Fatal("ReferenceSlots() returned caller-owned storage")
+	}
+}
+
+func TestGroundingProducesExactSourceFreePromptInputs(t *testing.T) {
+	resolver, err := newGroundingResolver(groundingReferences(t, "Ashfang", dnd.SceneKindCombat))
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolved, err := resolver.Resolve(contracts.ReferenceSet{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	inputs := resolved.PromptInputs()
+	want := map[string]string{
+		NPCRegistryReferenceSlot:    `{"npcs":[{"name":"Ashfang"}]}`,
+		CombatTurnReferenceSlot:     `{"combat_turns":[{"actor":"Ashfang","turn_kind":"turn"},{"actor":"Aria","turn_kind":"reaction"}]}`,
+		NPCInteractionReferenceSlot: `{"npc_interactions":[{"name":"Ashfang","kind":"combat_opponent"}]}`,
+	}
+	if len(inputs) != len(want) {
+		t.Fatalf("PromptInputs() = %#v", inputs)
+	}
+	for name, content := range want {
+		input, ok := inputs[name]
+		if !ok || string(input.Content) != content || input.Digest != digest([]byte(content)) || input.OriginURI != "" || input.MediaType != "application/json" {
+			t.Fatalf("PromptInputs()[%q] = %#v, want %q", name, input, content)
+		}
+		for _, forbidden := range []string{"source_ref", "npc-ashfang", "origin", "summary", "combat-session"} {
+			if strings.Contains(string(input.Content), forbidden) {
+				t.Fatalf("PromptInputs()[%q] leaked %q: %s", name, forbidden, input.Content)
+			}
+		}
+	}
+	if _, ok := inputs[SceneDescriptionReferenceSlot]; ok {
+		t.Fatal("scene descriptions were rendered as prompt grounding")
+	}
+
+	inputs[CombatTurnReferenceSlot] = contracts.NewLLMInputMaterial("changed", "text/plain", []byte("changed"), "", "")
+	if next := resolved.PromptInputs()[CombatTurnReferenceSlot]; string(next.Content) != want[CombatTurnReferenceSlot] {
+		t.Fatal("PromptInputs() did not return a defensive copy")
+	}
+}
+
+func TestGroundingResolvesGeneratedReferencesAndSceneEligibility(t *testing.T) {
+	prepared := groundingReferences(t, "Ashfang", dnd.SceneKindCombat)
+	resolver, err := newGroundingResolver(prepared)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	generated := groundingReferences(t, "Grimjaw", dnd.SceneKindNarrative)
+	resolved, err := resolver.Resolve(generated)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := string(resolved.PromptInputs()[NPCRegistryReferenceSlot].Content); got != `{"npcs":[{"name":"Grimjaw"}]}` {
+		t.Fatalf("generated NPC projection = %s", got)
+	}
+	match, err := resolver.SceneMatch(generated, combatChunk())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if match != (sceneregistry.ChunkMatch{State: sceneregistry.MatchExact, Kind: dnd.SceneKindNarrative}) {
+		t.Fatalf("generated scene match = %#v", match)
+	}
+	match, err = resolver.SceneMatch(generated, &source.Chunk{ID: "other", Ref: combatChunk().Ref})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if match.State != sceneregistry.MatchMissing {
+		t.Fatal("missing scene was not reported")
+	}
+	mismatched := combatChunk()
+	mismatched.Ref.EndUnitID++
+	match, err = resolver.SceneMatch(generated, mismatched)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if match.State != sceneregistry.MatchMismatched {
+		t.Fatal("mismatched scene was not reported")
+	}
+
+	static, err := resolver.Resolve(contracts.ReferenceSet{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := string(static.PromptInputs()[NPCRegistryReferenceSlot].Content); got != `{"npcs":[{"name":"Ashfang"}]}` {
+		t.Fatalf("static NPC projection changed after generated resolution: %s", got)
+	}
+	match, err = resolver.SceneMatch(contracts.ReferenceSet{}, combatChunk())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if match != (sceneregistry.ChunkMatch{State: sceneregistry.MatchExact, Kind: dnd.SceneKindCombat}) {
+		t.Fatalf("static scene match = %#v", match)
+	}
+}
+
+func TestGroundingRejectsMissingAndInvalidReferences(t *testing.T) {
+	valid := groundingReferences(t, "Ashfang", dnd.SceneKindCombat)
+	for _, test := range []struct {
+		slot string
+		want string
+	}{
+		{NPCRegistryReferenceSlot, "NPC registry"},
+		{SceneDescriptionReferenceSlot, "scene descriptions"},
+		{CombatTurnReferenceSlot, CombatTurnReferenceSlot},
+		{NPCInteractionReferenceSlot, NPCInteractionReferenceSlot},
+	} {
+		t.Run("missing "+test.slot, func(t *testing.T) {
+			resolver, err := newGroundingResolver(withoutSlot(valid, test.slot))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if test.slot == SceneDescriptionReferenceSlot {
+				_, err = resolver.SceneMatch(contracts.ReferenceSet{}, combatChunk())
+			} else {
+				_, err = resolver.Resolve(contracts.ReferenceSet{})
+			}
+			if err == nil || !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("grounding error = %v, want missing %q reference", err, test.slot)
+			}
+		})
+	}
+
+	tests := []struct {
+		name string
+		set  contracts.ReferenceSet
+	}{
+		{"multiple items", replaceSlot(valid, CombatTurnReferenceSlot, contracts.ResolvedReferenceSlot{Items: []contracts.ReferenceItem{{MediaType: "application/json"}, {MediaType: "application/json"}}})},
+		{"malformed durable content", replaceItem(valid, NPCInteractionReferenceSlot, contracts.ReferenceItem{MediaType: "application/json", Content: []byte(`{}`)})},
+		{"wrong media type", replaceItem(valid, CombatTurnReferenceSlot, contracts.ReferenceItem{MediaType: "text/plain", Content: valid.Slots[CombatTurnReferenceSlot].Items[0].Content})},
+		{"oversize", replaceItem(valid, CombatTurnReferenceSlot, contracts.ReferenceItem{MediaType: "application/json", Content: make([]byte, ReferenceMaxBytes+1)})},
+	}
+	resolver, err := newGroundingResolver(valid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if _, err := resolver.Resolve(test.set); err == nil {
+				t.Fatal("Resolve() error = nil")
+			}
+		})
+	}
+}
+
+func groundingReferences(t *testing.T, enemy string, sceneKind dnd.SceneKind) contracts.ReferenceSet {
+	t.Helper()
+	npcContent, err := npccodec.New().Encode(dnd.NPCList{NPCs: []dnd.NPC{{
+		ID:         identity.DeriveID(enemy),
+		Name:       enemy,
+		SourceRefs: []source.SourceRef{{SourceID: "combat-session", StartUnitID: 1, EndUnitID: 1}},
+	}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	sceneContent, err := scenecodec.New().Encode(dnd.SceneDescriptionList{Scenes: []dnd.SceneDescription{{
+		ID:        "combat-scene",
+		SourceRef: source.SourceRef{SourceID: "combat-session", StartUnitID: 1, EndUnitID: 4},
+		Kind:      sceneKind,
+		Title:     "Combat session",
+		Summary:   "A detailed scene summary that must not reach the prompt.",
+	}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	turnContent, err := combatturncodec.New().Encode(dnd.CombatTurnList{CombatTurns: []dnd.CombatTurn{
+		{Actor: enemy, TurnKind: dnd.CombatTurnKindTurn, SourceRefs: []source.SourceRef{{SourceID: "combat-session", StartUnitID: 1, EndUnitID: 1}}},
+		{Actor: "Aria", TurnKind: dnd.CombatTurnKindReaction, SourceRefs: []source.SourceRef{{SourceID: "combat-session", StartUnitID: 2, EndUnitID: 2}}},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	interactionContent, err := interactioncodec.New().Encode(dnd.NPCInteractionList{Interactions: []dnd.NPCInteraction{
+		{Name: enemy, Kind: dnd.NPCInteractionKindCombatOpponent, SourceRefs: []source.SourceRef{{SourceID: "combat-session", StartUnitID: 1, EndUnitID: 1}}},
+		{Name: "Aria", Kind: dnd.NPCInteractionKindCombatAlly, SourceRefs: []source.SourceRef{{SourceID: "combat-session", StartUnitID: 2, EndUnitID: 2}}},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{
+		NPCRegistryReferenceSlot:      {Items: []contracts.ReferenceItem{newReferenceItem(NPCRegistryReferenceSlot, npcContent)}},
+		SceneDescriptionReferenceSlot: {Items: []contracts.ReferenceItem{newReferenceItem(SceneDescriptionReferenceSlot, sceneContent)}},
+		CombatTurnReferenceSlot:       {Items: []contracts.ReferenceItem{newReferenceItem(CombatTurnReferenceSlot, turnContent)}},
+		NPCInteractionReferenceSlot:   {Items: []contracts.ReferenceItem{newReferenceItem(NPCInteractionReferenceSlot, interactionContent)}},
+	}}
+}
+
+func newReferenceItem(slot string, content []byte) contracts.ReferenceItem {
+	return contracts.ReferenceItem{
+		SlotName:  slot,
+		MediaType: "application/json",
+		Content:   append([]byte(nil), content...),
+		Digest:    digest(content),
+		Origin:    contracts.ReferenceOrigin{Type: "file", URI: "file:///private/reference.json"},
+		Producer:  contracts.ReferenceProducer{PipelineID: "prior", StepID: "extract", LaneID: "lane", ModuleKey: "dnd/example"},
+	}
+}
+
+func withoutSlot(set contracts.ReferenceSet, name string) contracts.ReferenceSet {
+	cloned := contracts.ReferenceSet{Slots: make(map[string]contracts.ResolvedReferenceSlot, len(set.Slots)-1)}
+	for slotName, slot := range set.Slots {
+		if slotName != name {
+			cloned.Slots[slotName] = slot
+		}
+	}
+	return cloned
+}
+
+func replaceSlot(set contracts.ReferenceSet, name string, value contracts.ResolvedReferenceSlot) contracts.ReferenceSet {
+	cloned := contracts.ReferenceSet{Slots: make(map[string]contracts.ResolvedReferenceSlot, len(set.Slots))}
+	for slotName, slot := range set.Slots {
+		cloned.Slots[slotName] = slot
+	}
+	cloned.Slots[name] = value
+	return cloned
+}
+
+func replaceItem(set contracts.ReferenceSet, name string, item contracts.ReferenceItem) contracts.ReferenceSet {
+	return replaceSlot(set, name, contracts.ResolvedReferenceSlot{Items: []contracts.ReferenceItem{item}})
+}
+
+func combatChunk() *source.Chunk {
+	return &source.Chunk{ID: "combat-scene", Ref: source.SourceRef{SourceID: "combat-session", StartUnitID: 1, EndUnitID: 4}}
+}
+
+func digest(content []byte) string {
+	sum := sha256.Sum256(content)
+	return "sha256:" + hex.EncodeToString(sum[:])
+}

internal/modules/dnd/extract/enemyevents/mapping.go

@@ -0,0 +1,60 @@
+package enemyevents
+
+import (
+	"sort"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
+)
+
+type orderedEnemyEvent struct {
+	value       dnd.EnemyEvent
+	earliest    int
+	hasEvidence bool
+}
+
+func canonicalEnemyEventList(response extractionResponse, order shared.SourceRefOrder, sourceID string) dnd.EnemyEventList {
+	if response.Events == nil {
+		return dnd.EnemyEventList{}
+	}
+	ordered := make([]orderedEnemyEvent, len(response.Events))
+	for index, event := range response.Events {
+		refs := order.Canonicalize(sourceRefs(event.SourceRefs, sourceID))
+		earliest, hasEvidence := order.EarliestValid(refs)
+		ordered[index] = orderedEnemyEvent{
+			value: dnd.EnemyEvent{
+				Name:       event.Name,
+				Kind:       dnd.EnemyEventKind(event.Kind),
+				SourceRefs: refs,
+			},
+			earliest:    earliest,
+			hasEvidence: hasEvidence,
+		}
+	}
+	sort.SliceStable(ordered, func(left, right int) bool {
+		if ordered[left].hasEvidence != ordered[right].hasEvidence {
+			return ordered[left].hasEvidence
+		}
+		if !ordered[left].hasEvidence {
+			return false
+		}
+		return ordered[left].earliest < ordered[right].earliest
+	})
+	events := make([]dnd.EnemyEvent, len(ordered))
+	for index := range ordered {
+		events[index] = ordered[index].value
+	}
+	return dnd.EnemyEventList{Events: events}
+}
+
+func sourceRefs(refs []enemySourceRefResponse, sourceID string) []source.SourceRef {
+	if refs == nil {
+		return nil
+	}
+	values := make([]source.SourceRef, len(refs))
+	for index, ref := range refs {
+		values[index] = source.SourceRef{SourceID: sourceID, StartUnitID: ref.StartUnitID, EndUnitID: ref.EndUnitID}
+	}
+	return values
+}

internal/modules/dnd/extract/enemyevents/model.go

@@ -0,0 +1,16 @@
+package enemyevents
+
+type extractionResponse struct {
+	Events []enemyEventResponse `json:"events"`
+}
+
+type enemyEventResponse struct {
+	Name       string                   `json:"name"`
+	Kind       string                   `json:"kind"`
+	SourceRefs []enemySourceRefResponse `json:"source_refs"`
+}
+
+type enemySourceRefResponse struct {
+	StartUnitID int `json:"start_unit_id"`
+	EndUnitID   int `json:"end_unit_id"`
+}

internal/modules/dnd/extract/enemyevents/prompt_assets.go

@@ -0,0 +1,54 @@
+package enemyevents
+
+import (
+	"fmt"
+	"sync"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/promptfs"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
+)
+
+const promptAssetRoot = "assets/prompts"
+
+var promptAssetManifest = shared.PromptAssetManifest{
+	ModuleDir: "dnd.enemy_events",
+	ModuleFiles: []promptfs.ModulePromptFile{
+		{Name: "dnd.enemy_events.yaml", Path: "assets/prompts/dnd.enemy_events.yaml"},
+		{Name: "grounding.md", Path: "assets/prompts/grounding.md"},
+		{Name: "task.md", Path: "assets/prompts/task.md"},
+		{Name: "instructions.md", Path: "assets/prompts/instructions.md"},
+	},
+	SharedFiles: []string{
+		"common-dnd-system.md",
+		"common-dnd-extraction-evidence.md",
+		"common-dnd-identity.md",
+		"common-dnd-transcript.md",
+		"common-dnd-references.md",
+		"common-dnd-npcs.md",
+	},
+}
+
+func RegisterPromptAssets(registry *llm.AssetRegistry) error {
+	promptFS, err := promptAssetManifest.PromptFS(embeddedAssets)
+	if err != nil {
+		return fmt.Errorf("prepare enemy-event prompt assets: %w", err)
+	}
+	if err := registry.RegisterPromptFS(promptFS, promptAssetRoot); err != nil {
+		return err
+	}
+	return registry.RegisterSchemaFS(embeddedAssets, "assets/schemas")
+}
+
+func promptAssetMetadata() (string, error) {
+	promptAssetHashOnce.Do(func() {
+		promptAssetHash, promptAssetHashErr = promptAssetManifest.Hash(embeddedAssets)
+	})
+	return promptAssetHash, promptAssetHashErr
+}
+
+var (
+	promptAssetHashOnce sync.Once
+	promptAssetHash     string
+	promptAssetHashErr  error
+)

internal/modules/dnd/extract/enemyevents/prompt_assets_test.go

@@ -0,0 +1,123 @@
+package enemyevents
+
+import (
+	"context"
+	"io/fs"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
+	"gitea.maximumdirect.net/eric/promptkit"
+)
+
+func TestRegisterPromptAssetsAndPrepareEnemyEventPrompt(t *testing.T) {
+	registry := llm.NewAssetRegistry()
+	if err := RegisterPromptAssets(registry); err != nil {
+		t.Fatal(err)
+	}
+	schemaFS, err := registry.SchemaFS()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := fs.ReadFile(schemaFS, "dnd_enemy_events_llm.v1.json"); err != nil {
+		t.Fatalf("response schema asset: %v", err)
+	}
+
+	prepared := prepareEnemyEventPrompt(t)
+	if prepared.PromptID != PromptID || prepared.OutputContract.SchemaPath != "dnd_enemy_events_llm.v1.json" || prepared.SelectedProfileID != "dnd-extraction" {
+		t.Fatalf("prepared prompt = %#v", prepared)
+	}
+	transcriptIndex := renderedMessageIndex(t, prepared.Messages, "enemy-transcript")
+	for _, sentinel := range []string{"enemy-npc", "enemy-turn", "enemy-opponent", "Extract Dungeons & Dragons enemy events"} {
+		if index := renderedMessageIndex(t, prepared.Messages, sentinel); index <= transcriptIndex {
+			t.Fatalf("message containing %q has index %d, want after transcript index %d", sentinel, index, transcriptIndex)
+		}
+	}
+	instructionIndex := renderedMessageIndex(t, prepared.Messages, "Return the `events` array")
+	if instructionIndex <= transcriptIndex {
+		t.Fatalf("instruction index = %d, want after transcript index %d", instructionIndex, transcriptIndex)
+	}
+	if instructionIndex != len(prepared.Messages)-1 {
+		t.Fatalf("instruction message index = %d, want final message", instructionIndex)
+	}
+	if cache := prepared.Messages[instructionIndex].CacheControl; cache == nil || cache.Type != promptkit.CacheControlEphemeral {
+		t.Fatalf("final instruction cache control = %#v", cache)
+	}
+}
+
+func TestEnemyEventPromptRequiresGroundingInputs(t *testing.T) {
+	engine := newEnemyEventPromptEngine(t)
+	for _, inputName := range []string{"npcs", "combat_turns", "npc_interactions"} {
+		t.Run(inputName, func(t *testing.T) {
+			inputs := enemyEventPromptInputs()
+			delete(inputs, inputName)
+			_, err := engine.Prepare(context.Background(), promptkit.RunRequest{
+				PromptID: PromptID, PromptVersion: SchemaVersion, Inputs: inputs,
+			})
+			if err == nil || !strings.Contains(err.Error(), inputName) {
+				t.Fatalf("Prepare() error = %v, want required %q input", err, inputName)
+			}
+		})
+	}
+}
+
+func prepareEnemyEventPrompt(t *testing.T) *promptkit.PreparedRun {
+	t.Helper()
+	prepared, err := newEnemyEventPromptEngine(t).Prepare(context.Background(), promptkit.RunRequest{
+		PromptID: PromptID, PromptVersion: SchemaVersion, Inputs: enemyEventPromptInputs(),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return prepared
+}
+
+func newEnemyEventPromptEngine(t *testing.T) *promptkit.Engine {
+	t.Helper()
+	registry := llm.NewAssetRegistry()
+	if err := RegisterPromptAssets(registry); err != nil {
+		t.Fatal(err)
+	}
+	options, err := registry.PromptKitOptions()
+	if err != nil {
+		t.Fatal(err)
+	}
+	options = append(options, promptkit.WithProfiles(promptkit.OpenAICompatibleProfile(promptkit.OpenAICompatibleProfileConfig{
+		ID: "dnd-extraction", Endpoint: "http://127.0.0.1:1/v1", Model: "enemy-test-model",
+	})))
+	engine, err := promptkit.NewEngine(promptkit.Config{Timeout: time.Second}, options...)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return engine
+}
+
+func enemyEventPromptInputs() map[string]promptkit.ArtifactRef {
+	return map[string]promptkit.ArtifactRef{
+		"transcript":       promptkit.Inline(`{"value":"enemy-transcript"}`),
+		"players":          promptkit.Inline("enemy-player"),
+		"party":            promptkit.Inline("enemy-party"),
+		"glossary":         promptkit.Inline("enemy-glossary"),
+		"npcs":             promptkit.Inline(`{"npcs":[{"name":"enemy-npc"}]}`),
+		"combat_turns":     promptkit.Inline(`{"combat_turns":[{"actor":"enemy-turn","turn_kind":"turn"}]}`),
+		"npc_interactions": promptkit.Inline(`{"npc_interactions":[{"name":"enemy-opponent","kind":"combat_opponent"}]}`),
+	}
+}
+
+func renderedMessageIndex(t *testing.T, messages []promptkit.RenderedMessage, sentinel string) int {
+	t.Helper()
+	index := -1
+	occurrences := 0
+	for messageIndex, message := range messages {
+		count := strings.Count(message.Content, sentinel)
+		if count > 0 {
+			index = messageIndex
+			occurrences += count
+		}
+	}
+	if occurrences != 1 {
+		t.Fatalf("message sentinel %q rendered %d times, want exactly once", sentinel, occurrences)
+	}
+	return index
+}

internal/modules/dnd/extract/enemyevents/schema.go

@@ -0,0 +1,21 @@
+package enemyevents
+
+import "gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
+
+const (
+	PromptID           = "dnd.enemy_events"
+	ResponseSchemaKey  = llm.ResponseSchemaKey("dnd_enemy_events_llm")
+	ResponseSchemaID   = "notarius.dnd.enemy_events.llm"
+	ResponseSchemaName = "notarius_dnd_enemy_events_llm_v1"
+	SchemaVersion      = "v1"
+)
+
+func loadResponseSchema() (llm.ResponseSchema, error) {
+	return llm.LoadResponseSchema(embeddedAssets, llm.ResponseSchemaDefinition{
+		Key:       ResponseSchemaKey,
+		ID:        ResponseSchemaID,
+		Version:   SchemaVersion,
+		Name:      ResponseSchemaName,
+		AssetPath: "assets/schemas/dnd_enemy_events_llm.v1.json",
+	})
+}

internal/modules/dnd/extract/enemyevents/schema_test.go

@@ -0,0 +1,97 @@
+package enemyevents
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/santhosh-tekuri/jsonschema/v6"
+)
+
+func TestResponseSchemaDefinesPrivateStructuralBoundary(t *testing.T) {
+	schema, err := loadResponseSchema()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if schema.Key != ResponseSchemaKey || schema.ID != ResponseSchemaID || schema.Name != ResponseSchemaName || schema.Version != SchemaVersion || !strings.HasPrefix(schema.SHA256, "sha256:") || !json.Valid(schema.JSONSchema) {
+		t.Fatalf("schema = %#v", schema)
+	}
+	valid := validEnemyResponse()
+	content, err := json.Marshal(valid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := validateEnemySchema(content, schema.JSONSchema); err != nil {
+		t.Fatalf("valid response rejected: %v", err)
+	}
+	semantic := validEnemyResponse()
+	event := semantic["events"].([]any)[0].(map[string]any)
+	event["name"] = ""
+	event["kind"] = "unsupported"
+	ref := event["source_refs"].([]any)[0].(map[string]any)
+	ref["start_unit_id"] = 0
+	ref["end_unit_id"] = -1
+	content, err = json.Marshal(semantic)
+	if err != nil || validateEnemySchema(content, schema.JSONSchema) != nil {
+		t.Fatalf("validator-owned semantics were rejected: %v", err)
+	}
+}
+
+func TestResponseSchemaRejectsInvalidStructure(t *testing.T) {
+	schema, err := loadResponseSchema()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutate := range []func(map[string]any){
+		func(event map[string]any) { delete(event, "name") },
+		func(event map[string]any) { event["kind"] = 1 },
+		func(event map[string]any) { event["unexpected"] = true },
+		func(event map[string]any) { event["source_refs"].([]any)[0].(map[string]any)["source_id"] = "session" },
+	} {
+		candidate := validEnemyResponse()
+		mutate(candidate["events"].([]any)[0].(map[string]any))
+		content, err := json.Marshal(candidate)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := validateEnemySchema(content, schema.JSONSchema); err == nil {
+			t.Fatal("private schema accepted structurally invalid response")
+		}
+	}
+	first, err := loadResponseSchema()
+	if err != nil {
+		t.Fatal(err)
+	}
+	first.JSONSchema[0] = '['
+	second, err := loadResponseSchema()
+	if err != nil || !json.Valid(second.JSONSchema) || bytes.Equal(first.JSONSchema, second.JSONSchema) {
+		t.Fatalf("schema defensive copy = %s, %v", second.JSONSchema, err)
+	}
+}
+
+func validEnemyResponse() map[string]any {
+	return map[string]any{"events": []any{map[string]any{
+		"name": "Ashfang", "kind": "engaged", "source_refs": []any{map[string]any{"start_unit_id": 1, "end_unit_id": 1}},
+	}}}
+}
+
+func validateEnemySchema(instanceContent, schemaContent []byte) error {
+	instance, err := jsonschema.UnmarshalJSON(bytes.NewReader(instanceContent))
+	if err != nil {
+		return err
+	}
+	document, err := jsonschema.UnmarshalJSON(bytes.NewReader(schemaContent))
+	if err != nil {
+		return err
+	}
+	compiler := jsonschema.NewCompiler()
+	if err := compiler.AddResource("schema.json", document); err != nil {
+		return err
+	}
+	schema, err := compiler.Compile("schema.json")
+	if err != nil {
+		return err
+	}
+	return schema.Validate(instance)
+}

internal/modules/dnd/normalize/enemyevents/normalizer.go

@@ -0,0 +1,297 @@
+// Package enemyevents normalizes merged D&D enemy-event candidates.
+package enemyevents
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	enemyeventmodel "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/enemyevents"
+	npcregistry "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/registry"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
+)
+
+const (
+	Key                 = "dnd/enemy-events"
+	normalizationPolicy = "dnd.enemy_events.normalize.v1"
+	NormalizationPolicy = normalizationPolicy
+
+	ReasonCodeNameCanonicalized    = "enemy_event_name_canonicalized"
+	ReasonCodeSourceRefsNormalized = "source_references_normalized"
+	ReasonCodeEventsReordered      = "enemy_events_reordered"
+	ReasonCodeDuplicateCollapsed   = "duplicate_enemy_event_collapsed"
+	ReasonCodeWarningsOmitted      = "enemy_event_normalization_warnings_omitted"
+)
+
+const (
+	NPCRegistryReferenceSlot = npcregistry.ReferenceSlot
+	NPCRegistryMaxBytes      = npcregistry.MaxBytes
+)
+
+var requiredCapabilities = []string{"merged"}
+var providedCapabilities = []string{"normalized"}
+
+var _ contracts.Normalizer[dnd.EnemyEventList] = (*Normalizer)(nil)
+var _ contracts.ManifestMetadataProvider = (*Normalizer)(nil)
+var _ pipeline.CheckpointFingerprintProvider = (*Normalizer)(nil)
+
+type Options struct{}
+
+type Normalizer struct {
+	npcResolver *npcregistry.Resolver
+}
+
+func New(_ Options, references ...contracts.ReferenceSet) (*Normalizer, error) {
+	if len(references) > 1 {
+		return nil, normalizerErrorf("at most one reference set may be supplied")
+	}
+	var referenceSet contracts.ReferenceSet
+	if len(references) == 1 {
+		referenceSet = references[0]
+	}
+	resolver, err := npcregistry.NewResolver(referenceSet)
+	if err != nil {
+		return nil, normalizerErrorf("prepare NPC registry: %w", err)
+	}
+	return &Normalizer{npcResolver: resolver}, nil
+}
+
+func (n *Normalizer) Key() string { return Key }
+
+func (n *Normalizer) ReferenceSlots() []contracts.ReferenceSlot { return referenceSlots() }
+
+func (n *Normalizer) ManifestMetadata() map[string]any {
+	if n == nil || n.npcResolver == nil {
+		return nil
+	}
+	metadata := map[string]any{"normalization_policy": normalizationPolicy}
+	if seeded := n.npcResolver.Seeded(); seeded.Bound() {
+		metadata["npc_registry_digest"] = seeded.Digest()
+	}
+	return metadata
+}
+
+func (n *Normalizer) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
+	if n == nil || n.npcResolver == nil {
+		return nil
+	}
+	return []pipeline.CheckpointFingerprint{
+		{Name: "normalization_policy", Value: normalizationPolicy},
+		{Name: "npc_registry", Value: n.npcResolver.Seeded().ProjectionDigest()},
+	}
+}
+
+func (n *Normalizer) Normalize(ctx context.Context, req contracts.TypedNormalizeRequest[dnd.EnemyEventList]) (contracts.TypedNormalizeResult[dnd.EnemyEventList], error) {
+	if n == nil || n.npcResolver == nil {
+		return contracts.TypedNormalizeResult[dnd.EnemyEventList]{}, normalizerErrorf("normalizer must not be nil")
+	}
+	if ctx == nil {
+		return contracts.TypedNormalizeResult[dnd.EnemyEventList]{}, normalizerErrorf("context must not be nil")
+	}
+	if err := ctx.Err(); err != nil {
+		return contracts.TypedNormalizeResult[dnd.EnemyEventList]{}, normalizerErrorf("context error before normalize: %w", err)
+	}
+	registry, err := n.npcResolver.Resolve(req.References)
+	if err != nil {
+		return contracts.TypedNormalizeResult[dnd.EnemyEventList]{}, normalizerErrorf("resolve NPC registry: %w", err)
+	}
+	if !registry.Bound() {
+		return contracts.TypedNormalizeResult[dnd.EnemyEventList]{}, normalizerErrorf("NPC registry reference is required")
+	}
+	index := source.NewDocumentIndex(req.Source)
+	order := shared.NewSourceRefOrderFromIndex(index)
+	value, warnings := normalizeList(req.MergeOutput.Value, order, registry)
+	return contracts.TypedNormalizeResult[dnd.EnemyEventList]{Value: value, Warnings: warnings}, nil
+}
+
+type normalizedRecord struct {
+	event      dnd.EnemyEvent
+	inputIndex int
+}
+
+type nameCanonicalization struct {
+	from string
+	to   string
+}
+
+func normalizeList(input dnd.EnemyEventList, order shared.SourceRefOrder, registry *npcregistry.Registry) (dnd.EnemyEventList, []contracts.Warning) {
+	if input.Events == nil {
+		return dnd.EnemyEventList{}, nil
+	}
+	records := make([]normalizedRecord, len(input.Events))
+	warnings := make([]contracts.Warning, 0)
+	for index, inputEvent := range input.Events {
+		event, nameChange, refsChanged := normalizeEvent(inputEvent, order, registry)
+		records[index] = normalizedRecord{event: event, inputIndex: index}
+		if nameChange != nil {
+			warnings = append(warnings, contracts.Warning{
+				Scope:      eventScope(index),
+				ReasonCode: ReasonCodeNameCanonicalized,
+				Message: fmt.Sprintf("input index %d: subject canonicalized from %s to %s",
+					index, diagnostics.Quote(nameChange.from), diagnostics.Quote(nameChange.to)),
+			})
+		}
+		if refsChanged {
+			warnings = append(warnings, contracts.Warning{
+				Scope:      eventScope(index),
+				ReasonCode: ReasonCodeSourceRefsNormalized,
+				Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)",
+					index, len(inputEvent.SourceRefs), len(event.SourceRefs)),
+			})
+		}
+	}
+
+	sort.SliceStable(records, func(left, right int) bool {
+		return enemyeventmodel.Less(order, records[left].event, records[right].event)
+	})
+	for position, record := range records {
+		if position == record.inputIndex {
+			continue
+		}
+		warnings = append(warnings, contracts.Warning{
+			Scope:      eventScope(record.inputIndex),
+			ReasonCode: ReasonCodeEventsReordered,
+			Message:    fmt.Sprintf("input index %d moved to normalized position %d", record.inputIndex, position),
+		})
+	}
+
+	output, duplicateWarnings := collapseDuplicates(records, order)
+	warnings = append(warnings, duplicateWarnings...)
+	return dnd.EnemyEventList{Events: output}, diagnostics.LimitWarnings(warnings, "enemy_events", ReasonCodeWarningsOmitted)
+}
+
+func normalizeEvent(input dnd.EnemyEvent, order shared.SourceRefOrder, registry *npcregistry.Registry) (dnd.EnemyEvent, *nameCanonicalization, bool) {
+	output := cloneEvent(input)
+	output.Name = enemyeventmodel.NormalizeDisplay(input.Name)
+	if canonical, ok := registry.Lookup(output.Name); ok {
+		output.Name = enemyeventmodel.NormalizeDisplay(canonical.Name)
+	}
+	var nameChange *nameCanonicalization
+	if input.Name != output.Name {
+		nameChange = &nameCanonicalization{from: input.Name, to: output.Name}
+	}
+	output.SourceRefs = order.Canonicalize(input.SourceRefs)
+	return output, nameChange, !rawSourceRefsEqual(input.SourceRefs, output.SourceRefs)
+}
+
+func cloneEvent(input dnd.EnemyEvent) dnd.EnemyEvent {
+	output := input
+	if input.SourceRefs != nil {
+		output.SourceRefs = append([]source.SourceRef(nil), input.SourceRefs...)
+	}
+	return output
+}
+
+func rawSourceRefsEqual(left, right []source.SourceRef) bool {
+	if (left == nil) != (right == nil) || len(left) != len(right) {
+		return false
+	}
+	for index := range left {
+		if left[index] != right[index] {
+			return false
+		}
+	}
+	return true
+}
+
+type duplicateGroup struct {
+	retainedIndex int
+	removed       []int
+}
+
+func collapseDuplicates(records []normalizedRecord, order shared.SourceRefOrder) ([]dnd.EnemyEvent, []contracts.Warning) {
+	if len(records) == 0 {
+		return make([]dnd.EnemyEvent, 0), nil
+	}
+	kept := make([]normalizedRecord, 0, len(records))
+	groups := make([]duplicateGroup, 0)
+	for _, record := range records {
+		match := -1
+		for index := range kept {
+			if enemyeventmodel.ExactEqual(order, kept[index].event, record.event) {
+				match = index
+				break
+			}
+		}
+		if match < 0 {
+			kept = append(kept, record)
+			groups = append(groups, duplicateGroup{retainedIndex: record.inputIndex})
+			continue
+		}
+		groups[match].removed = append(groups[match].removed, record.inputIndex)
+	}
+	output := make([]dnd.EnemyEvent, len(kept))
+	for index, record := range kept {
+		output[index] = cloneEvent(record.event)
+	}
+	warnings := make([]contracts.Warning, 0)
+	for _, group := range groups {
+		if len(group.removed) == 0 {
+			continue
+		}
+		issues := make([]string, len(group.removed))
+		for index, removed := range group.removed {
+			issues[index] = fmt.Sprintf("removed input index %d", removed)
+		}
+		warnings = append(warnings, contracts.Warning{
+			Scope:      eventScope(group.retainedIndex),
+			ReasonCode: ReasonCodeDuplicateCollapsed,
+			Message: diagnostics.Aggregate(
+				fmt.Sprintf("duplicate enemy event collapsed; retained input index %d", group.retainedIndex), issues),
+		})
+	}
+	return output, warnings
+}
+
+func eventScope(index int) string { return fmt.Sprintf("events[%d]", index) }
+
+func referenceSlots() []contracts.ReferenceSlot {
+	return contracts.CloneReferenceSlots([]contracts.ReferenceSlot{{
+		Name:                  NPCRegistryReferenceSlot,
+		Description:           "Required normalized NPC registry used only to canonicalize enemy-subject names, never as event evidence.",
+		Required:              true,
+		AcceptedMediaTypes:    []string{"application/json"},
+		AcceptedArtifactKinds: []contracts.ArtifactKind{dnd.NPCListKind},
+		MaxBytes:              NPCRegistryMaxBytes,
+	}})
+}
+
+func ModuleSpec() pipeline.ModuleSpec {
+	return pipeline.ModuleSpec{
+		Key:            Key,
+		Stage:          pipeline.StageNormalize,
+		ExecutionClass: contracts.ExecutionClassDeterministic,
+		Requires:       append([]string(nil), requiredCapabilities...),
+		Provides:       append([]string(nil), providedCapabilities...),
+		ArtifactKind:   dnd.EnemyEventListKind,
+		ReferenceSlots: referenceSlots(),
+	}
+}
+
+func Register(registry *pipeline.NormalizerRegistry) error {
+	return pipeline.RegisterNormalizerBuilder(registry, ModuleSpec(), validateOptions, func(request pipeline.BuildRequest) (contracts.Normalizer[dnd.EnemyEventList], error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return New(options, request.References)
+	})
+}
+
+func DecodeOptions(options map[string]any) (Options, error) {
+	if err := pipeline.RejectUnknownOptions(options); err != nil {
+		return Options{}, normalizerErrorf("%w", err)
+	}
+	return Options{}, nil
+}
+
+func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }
+
+func normalizerErrorf(format string, args ...any) error {
+	return fmt.Errorf("dnd enemy events normalizer: "+format, args...)
+}

internal/modules/dnd/normalize/enemyevents/normalizer_test.go

@@ -0,0 +1,207 @@
+package enemyevents
+
+import (
+	"context"
+	"encoding/json"
+	"reflect"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"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 TestNormalizeCanonicalizesSubjectsEvidenceOrderAndDuplicates(t *testing.T) {
+	document := &source.SourceDocument{ID: "session", Units: []source.SourceUnit{{ID: 30}, {ID: 10}, {ID: 20}, {ID: 40}}}
+	ref := func(unitID int) []source.SourceRef {
+		return []source.SourceRef{{SourceID: document.ID, StartUnitID: unitID, EndUnitID: unitID}}
+	}
+	input := dnd.EnemyEventList{Events: []dnd.EnemyEvent{
+		{Name: "  áRIA  ", Kind: dnd.EnemyEventKindKilled, SourceRefs: append(ref(30), ref(10)...)},
+		{Name: "  Remaining   Orcs ", Kind: dnd.EnemyEventKindEngaged, SourceRefs: ref(20)},
+		{Name: "Ária", Kind: dnd.EnemyEventKindKilled, SourceRefs: []source.SourceRef{{SourceID: document.ID, StartUnitID: 10, EndUnitID: 10}, {SourceID: document.ID, StartUnitID: 30, EndUnitID: 30}}},
+		{Name: "Ária", Kind: dnd.EnemyEventKindFled, SourceRefs: ref(40)},
+	}}
+	originalRefs := append([]source.SourceRef(nil), input.Events[0].SourceRefs...)
+	normalizer := newNormalizer(t, npcReferences(t))
+	result, err := normalizer.Normalize(context.Background(), normalizeRequest(document, input, contracts.ReferenceSet{}))
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := result.Value.Events
+	if len(got) != 3 || got[0].Name != "Ária" || got[0].Kind != dnd.EnemyEventKindKilled || !reflect.DeepEqual(got[0].SourceRefs, []source.SourceRef{{SourceID: document.ID, StartUnitID: 30, EndUnitID: 30}, {SourceID: document.ID, StartUnitID: 10, EndUnitID: 10}}) || got[1].Name != "Remaining Orcs" || got[2].Kind != dnd.EnemyEventKindFled {
+		t.Fatalf("normalized events = %#v", got)
+	}
+	for _, reason := range []string{ReasonCodeNameCanonicalized, ReasonCodeSourceRefsNormalized, ReasonCodeEventsReordered, ReasonCodeDuplicateCollapsed} {
+		if !hasWarning(result.Warnings, reason) {
+			t.Fatalf("warnings = %#v, missing %q", result.Warnings, reason)
+		}
+	}
+	if !reflect.DeepEqual(input.Events[0].SourceRefs, originalRefs) {
+		t.Fatalf("Normalize() mutated input: %#v", input)
+	}
+	got[0].SourceRefs[0].StartUnitID = 999
+	if input.Events[0].SourceRefs[0].StartUnitID == 999 {
+		t.Fatal("normalized source references alias input")
+	}
+}
+
+func TestNormalizeUsesExplicitKindOrderAndPreservesDistinctObservations(t *testing.T) {
+	document := &source.SourceDocument{ID: "session", Units: []source.SourceUnit{{ID: 1}, {ID: 2}, {ID: 3}}}
+	ref := func(unitID int) []source.SourceRef {
+		return []source.SourceRef{{SourceID: document.ID, StartUnitID: unitID, EndUnitID: unitID}}
+	}
+	input := dnd.EnemyEventList{Events: []dnd.EnemyEvent{
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindKilled, SourceRefs: ref(1)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindFled, SourceRefs: ref(1)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindCaptured, SourceRefs: ref(1)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindIncapacitated, SourceRefs: ref(1)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindEngaged, SourceRefs: ref(1)},
+		{Name: "Ashfang", Kind: dnd.EnemyEventKindEngaged, SourceRefs: ref(3)},
+	}}
+	result, err := newNormalizer(t, npcReferences(t)).Normalize(context.Background(), normalizeRequest(document, input, contracts.ReferenceSet{}))
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []dnd.EnemyEventKind{
+		dnd.EnemyEventKindEngaged,
+		dnd.EnemyEventKindIncapacitated,
+		dnd.EnemyEventKindCaptured,
+		dnd.EnemyEventKindFled,
+		dnd.EnemyEventKindKilled,
+		dnd.EnemyEventKindEngaged,
+	}
+	for index, kind := range want {
+		if result.Value.Events[index].Kind != kind {
+			t.Fatalf("event %d kind = %q, want %q", index, result.Value.Events[index].Kind, kind)
+		}
+	}
+}
+
+func TestNormalizeIsIdempotentAndPreservesEmptyRepresentation(t *testing.T) {
+	normalizer := newNormalizer(t, npcReferences(t))
+	for _, input := range []dnd.EnemyEventList{{}, {Events: []dnd.EnemyEvent{}}} {
+		result, err := normalizer.Normalize(context.Background(), normalizeRequest(testDocument(), input, contracts.ReferenceSet{}))
+		if err != nil || (result.Value.Events == nil) != (input.Events == nil) {
+			t.Fatalf("Normalize() = %#v, %v for %#v", result, err, input)
+		}
+	}
+	input := dnd.EnemyEventList{Events: []dnd.EnemyEvent{{Name: "  Remaining orcs ", Kind: dnd.EnemyEventKindEngaged, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 20, EndUnitID: 20}}}}}
+	first, err := normalizer.Normalize(context.Background(), normalizeRequest(testDocument(), input, contracts.ReferenceSet{}))
+	if err != nil {
+		t.Fatal(err)
+	}
+	second, err := normalizer.Normalize(context.Background(), normalizeRequest(testDocument(), first.Value, contracts.ReferenceSet{}))
+	if err != nil || !reflect.DeepEqual(second.Value, first.Value) || len(second.Warnings) != 0 {
+		t.Fatalf("second normalization = %#v, %v", second, err)
+	}
+}
+
+func TestNormalizeRequiresRegistryAndKeepsOperationContentOutOfMetadata(t *testing.T) {
+	normalizer, err := New(Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := normalizer.Normalize(context.Background(), normalizeRequest(testDocument(), dnd.EnemyEventList{}, contracts.ReferenceSet{})); err == nil || !strings.Contains(err.Error(), "NPC registry") {
+		t.Fatalf("Normalize() error = %v", err)
+	}
+	operationReferences := npcReferences(t)
+	result, err := normalizer.Normalize(context.Background(), normalizeRequest(testDocument(), dnd.EnemyEventList{Events: []dnd.EnemyEvent{}}, operationReferences))
+	if err != nil || result.Value.Events == nil {
+		t.Fatalf("Normalize() = %#v, %v", result, err)
+	}
+	if metadata := normalizer.ManifestMetadata(); metadata["npc_registry_digest"] != nil {
+		t.Fatalf("operation registry leaked into metadata: %#v", metadata)
+	}
+}
+
+func TestNormalizerContractAndWarningBound(t *testing.T) {
+	normalizer := newNormalizer(t, npcReferences(t))
+	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil {
+		t.Fatal("DecodeOptions() accepted an unknown option")
+	}
+	first := ModuleSpec()
+	first.ReferenceSlots[0].AcceptedMediaTypes[0] = "changed"
+	second := ModuleSpec()
+	if second.Key != Key || second.Stage != pipeline.StageNormalize || second.ExecutionClass != contracts.ExecutionClassDeterministic || second.ArtifactKind != dnd.EnemyEventListKind || second.ReferenceSlots[0].AcceptedMediaTypes[0] != "application/json" {
+		t.Fatalf("ModuleSpec() = %#v", second)
+	}
+	registry := pipeline.NewNormalizerRegistry()
+	if err := Register(registry); err != nil {
+		t.Fatal(err)
+	}
+	if spec, ok := registry.Spec(Key); !ok || spec.ArtifactKind != dnd.EnemyEventListKind {
+		t.Fatalf("registered spec = %#v, %t", spec, ok)
+	}
+	metadata := normalizer.ManifestMetadata()
+	if metadata["normalization_policy"] != normalizationPolicy || !strings.HasPrefix(metadata["npc_registry_digest"].(string), "sha256:") {
+		t.Fatalf("metadata = %#v", metadata)
+	}
+	encoded, err := json.Marshal(metadata)
+	if err != nil || strings.Contains(string(encoded), "Ária") {
+		t.Fatalf("unsafe metadata = %s, %v", encoded, err)
+	}
+
+	count := diagnostics.MaxWarnings + 5
+	document := &source.SourceDocument{ID: "session", Units: make([]source.SourceUnit, count)}
+	input := dnd.EnemyEventList{Events: make([]dnd.EnemyEvent, count)}
+	for index := range document.Units {
+		document.Units[index].ID = index + 1
+		input.Events[index] = dnd.EnemyEvent{Name: "  ÁRIA ", Kind: dnd.EnemyEventKindEngaged, SourceRefs: []source.SourceRef{{SourceID: document.ID, StartUnitID: count - index, EndUnitID: count - index}}}
+	}
+	result, err := normalizer.Normalize(context.Background(), normalizeRequest(document, input, contracts.ReferenceSet{}))
+	if err != nil || len(result.Warnings) != diagnostics.MaxWarnings || result.Warnings[len(result.Warnings)-1].ReasonCode != ReasonCodeWarningsOmitted {
+		t.Fatalf("warnings = %#v, %v", result.Warnings, err)
+	}
+}
+
+func newNormalizer(t *testing.T, references contracts.ReferenceSet) *Normalizer {
+	t.Helper()
+	normalizer, err := New(Options{}, references)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return normalizer
+}
+
+func normalizeRequest(document *source.SourceDocument, value dnd.EnemyEventList, references contracts.ReferenceSet) contracts.TypedNormalizeRequest[dnd.EnemyEventList] {
+	return contracts.TypedNormalizeRequest[dnd.EnemyEventList]{
+		Source:      document,
+		MergeOutput: contracts.MergeArtifact[dnd.EnemyEventList]{Value: value},
+		References:  references,
+	}
+}
+
+func testDocument() *source.SourceDocument {
+	return &source.SourceDocument{ID: "session", Units: []source.SourceUnit{{ID: 10}, {ID: 20}, {ID: 30}}}
+}
+
+func npcReferences(t *testing.T) contracts.ReferenceSet {
+	t.Helper()
+	value := dnd.NPCList{NPCs: []dnd.NPC{{
+		ID: identity.DeriveID("Ária"), Name: "Ária",
+		SourceRefs: []source.SourceRef{{SourceID: "registry", StartUnitID: 1, EndUnitID: 1}},
+	}}}
+	content, err := npccodec.New().Encode(value)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{NPCRegistryReferenceSlot: {
+		Slot:  contracts.ReferenceSlot{Name: NPCRegistryReferenceSlot},
+		Items: []contracts.ReferenceItem{{SlotName: NPCRegistryReferenceSlot, MediaType: npccodec.MediaType, Content: content}},
+	}}}
+}
+
+func hasWarning(warnings []contracts.Warning, reason string) bool {
+	for _, warning := range warnings {
+		if warning.ReasonCode == reason {
+			return true
+		}
+	}
+	return false
+}

internal/modules/dnd/register/chains.go

@@ -3,12 +3,14 @@ package register
 import (
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
 	combatextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/combatturns"
+	enemyeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/enemyevents"
 	itemeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/itemevents"
 	interactionextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcinteractions"
 	npcextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcs"
 	scenedescriptionextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/scenedescriptions"
 	spellextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/spells"
 	combatnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/combatturns"
+	enemyeventnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/enemyevents"
 	itemeventnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/itemevents"
 	interactionnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/npcinteractions"
 	npcnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/npcs"
@@ -18,6 +20,11 @@ import (
 	combatshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/combatturns/shape"
 	combatsourcerefs "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/combatturns/source_refs"
 	combatrelatedness "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/combatturns/source_relatedness"
+	enemyeventengagements "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/engagements"
+	enemyeventinvariants "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/invariants"
+	enemyeventshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/shape"
+	enemyeventrefs "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/source_refs"
+	enemyeventrelatedness "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/source_relatedness"
 	itemeventinvariants "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/itemevents/invariants"
 	itemeventshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/itemevents/shape"
 	itemeventrefs "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/itemevents/source_refs"
@@ -127,6 +134,34 @@ func registerDefaultChains(registry *pipeline.ValidatorChainRegistry) error {
 				},
 			})
 		}},
+		{name: "enemy events validator chain", register: func() error {
+			return registry.Register(pipeline.ValidatorChainMapping{
+				Stage:  pipeline.StageExtract,
+				Module: enemyeventextract.Key,
+				Validators: []pipeline.ModuleBinding{
+					pipeline.Binding(validjson.Key),
+					pipeline.Binding(enemyeventshape.Key),
+					pipeline.Binding(enemyeventengagements.Key),
+					pipeline.Binding(enemyeventrefs.Key),
+					pipeline.Binding(validjsonschema.Key),
+					pipeline.Binding(enemyeventrelatedness.Key),
+				},
+			})
+		}},
+		{name: "enemy events normalize validator chain", register: func() error {
+			return registry.Register(pipeline.ValidatorChainMapping{
+				Stage:  pipeline.StageNormalize,
+				Module: enemyeventnormalize.Key,
+				Validators: []pipeline.ModuleBinding{
+					pipeline.Binding(validjson.Key),
+					pipeline.Binding(enemyeventshape.Key),
+					pipeline.Binding(enemyeventinvariants.Key),
+					pipeline.Binding(enemyeventrefs.Key),
+					pipeline.Binding(validjsonschema.Key),
+					pipeline.Binding(enemyeventrelatedness.Key),
+				},
+			})
+		}},
 		{name: "item events validator chain", register: func() error {
 			return registry.Register(pipeline.ValidatorChainMapping{
 				Stage:  pipeline.StageExtract,

internal/modules/dnd/register/evidence.go

@@ -13,6 +13,9 @@ func registerEvidence(registry *pipeline.ArtifactEvidenceRegistry) error {
 		{name: "combat turns evidence", register: func() error {
 			return pipeline.RegisterArtifactEvidence(registry, dnd.CombatTurnListKind, combatTurnEvidence)
 		}},
+		{name: "enemy events evidence", register: func() error {
+			return pipeline.RegisterArtifactEvidence(registry, dnd.EnemyEventListKind, enemyEventEvidence)
+		}},
 		{name: "item events evidence", register: func() error {
 			return pipeline.RegisterArtifactEvidence(registry, dnd.ItemEventListKind, itemEventEvidence)
 		}},
@@ -49,6 +52,14 @@ func combatTurnEvidence(value dnd.CombatTurnList) []source.SourceRef {
 	return append([]source.SourceRef(nil), refs...)
 }
 
+func enemyEventEvidence(value dnd.EnemyEventList) []source.SourceRef {
+	var refs []source.SourceRef
+	for _, record := range value.Events {
+		refs = append(refs, record.SourceRefs...)
+	}
+	return append([]source.SourceRef(nil), refs...)
+}
+
 func itemEventEvidence(value dnd.ItemEventList) []source.SourceRef {
 	var refs []source.SourceRef
 	for _, record := range value.Events {

internal/modules/dnd/register/merge.go

@@ -70,6 +70,27 @@ func appendCombatTurnLists(values []dnd.CombatTurnList) (dnd.CombatTurnList, err
 	return combined, nil
 }
 
+func appendEnemyEventLists(values []dnd.EnemyEventList) (dnd.EnemyEventList, error) {
+	count := 0
+	present := false
+	for _, value := range values {
+		if value.Events != nil {
+			present = true
+		}
+		count += len(value.Events)
+	}
+	if !present {
+		return dnd.EnemyEventList{}, nil
+	}
+	combined := dnd.EnemyEventList{Events: make([]dnd.EnemyEvent, 0, count)}
+	for _, value := range values {
+		for _, event := range value.Events {
+			combined.Events = append(combined.Events, cloneEnemyEvent(event))
+		}
+	}
+	return combined, nil
+}
+
 func appendItemEventLists(values []dnd.ItemEventList) (dnd.ItemEventList, error) {
 	count := 0
 	present := false
@@ -137,6 +158,12 @@ func cloneCombatTurn(value dnd.CombatTurn) dnd.CombatTurn {
 	return clone
 }
 
+func cloneEnemyEvent(value dnd.EnemyEvent) dnd.EnemyEvent {
+	clone := value
+	clone.SourceRefs = cloneSourceRefs(value.SourceRefs)
+	return clone
+}
+
 func cloneItemEvent(value dnd.ItemEvent) dnd.ItemEvent {
 	clone := value
 	if value.Quantity != nil {

internal/modules/dnd/register/modules.go

@@ -6,18 +6,21 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/chunk/scenes"
 	combatcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/combatturns"
+	enemyeventcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/enemyevents"
 	itemeventcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/itemevents"
 	interactioncodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcinteractions"
 	npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcs"
 	scenedescriptioncodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/scenedescriptions"
 	spellcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/spells"
 	combatextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/combatturns"
+	enemyeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/enemyevents"
 	itemeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/itemevents"
 	interactionextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcinteractions"
 	npcextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcs"
 	scenedescriptionextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/scenedescriptions"
 	spellextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/spells"
 	combatnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/combatturns"
+	enemyeventnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/enemyevents"
 	itemeventnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/itemevents"
 	interactionnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/npcinteractions"
 	npcnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/npcs"
@@ -33,6 +36,7 @@ func registerModules(registries pipeline.Registries) error {
 		{name: "spells codec", register: func() error { return pipeline.RegisterArtifactCodec(registries.ArtifactCodecs, codec) }},
 		{name: "npcs codec", register: func() error { return pipeline.RegisterArtifactCodec(registries.ArtifactCodecs, npccodec.New()) }},
 		{name: "combat turns codec", register: func() error { return pipeline.RegisterArtifactCodec(registries.ArtifactCodecs, combatcodec.New()) }},
+		{name: "enemy events codec", register: func() error { return pipeline.RegisterArtifactCodec(registries.ArtifactCodecs, enemyeventcodec.New()) }},
 		{name: "item events codec", register: func() error { return pipeline.RegisterArtifactCodec(registries.ArtifactCodecs, itemeventcodec.New()) }},
 		{name: "npc interactions codec", register: func() error { return pipeline.RegisterArtifactCodec(registries.ArtifactCodecs, interactioncodec.New()) }},
 		{name: "scene descriptions codec", register: func() error {
@@ -42,6 +46,7 @@ func registerModules(registries pipeline.Registries) error {
 		{name: "spells extractor", register: func() error { return spellextract.Register(registries.Extractors) }},
 		{name: "npcs extractor", register: func() error { return npcextract.Register(registries.Extractors) }},
 		{name: "combat turns extractor", register: func() error { return combatextract.Register(registries.Extractors) }},
+		{name: "enemy events extractor", register: func() error { return enemyeventextract.Register(registries.Extractors) }},
 		{name: "item events extractor", register: func() error { return itemeventextract.Register(registries.Extractors) }},
 		{name: "npc interactions extractor", register: func() error { return interactionextract.Register(registries.Extractors) }},
 		{name: "scene descriptions extractor", register: func() error { return scenedescriptionextract.Register(registries.Extractors) }},
@@ -54,6 +59,9 @@ func registerModules(registries pipeline.Registries) error {
 		{name: "combat-turn-list appendorder merger", register: func() error {
 			return appendorder.RegisterTyped(registries.Mergers, dnd.CombatTurnListKind, appendCombatTurnLists)
 		}},
+		{name: "enemy-event-list appendorder merger", register: func() error {
+			return appendorder.RegisterTyped(registries.Mergers, dnd.EnemyEventListKind, appendEnemyEventLists)
+		}},
 		{name: "item-event-list appendorder merger", register: func() error {
 			return appendorder.RegisterTyped(registries.Mergers, dnd.ItemEventListKind, appendItemEventLists)
 		}},
@@ -66,6 +74,7 @@ func registerModules(registries pipeline.Registries) error {
 		{name: "spells normalizer", register: func() error { return spellnormalize.Register(registries.Normalizers) }},
 		{name: "npcs normalizer", register: func() error { return npcnormalize.Register(registries.Normalizers) }},
 		{name: "combat turns normalizer", register: func() error { return combatnormalize.Register(registries.Normalizers) }},
+		{name: "enemy events normalizer", register: func() error { return enemyeventnormalize.Register(registries.Normalizers) }},
 		{name: "item events normalizer", register: func() error { return itemeventnormalize.Register(registries.Normalizers) }},
 		{name: "npc interactions normalizer", register: func() error { return interactionnormalize.Register(registries.Normalizers) }},
 		{name: "scene descriptions normalizer", register: func() error { return scenedescriptionnormalize.Register(registries.Normalizers) }},
@@ -78,6 +87,9 @@ func registerModules(registries pipeline.Registries) error {
 		{name: "combat-turn-list noop normalizer", register: func() error {
 			return noop.RegisterTyped[dnd.CombatTurnList](registries.Normalizers, dnd.CombatTurnListKind)
 		}},
+		{name: "enemy-event-list noop normalizer", register: func() error {
+			return noop.RegisterTyped[dnd.EnemyEventList](registries.Normalizers, dnd.EnemyEventListKind)
+		}},
 		{name: "item-event-list noop normalizer", register: func() error {
 			return noop.RegisterTyped[dnd.ItemEventList](registries.Normalizers, dnd.ItemEventListKind)
 		}},
@@ -97,6 +109,7 @@ func registerPromptAssets(assets *llm.AssetRegistry) error {
 		{name: "npcs prompt assets", register: func() error { return npcextract.RegisterPromptAssets(assets) }},
 		{name: "npc normalization prompt assets", register: func() error { return npcnormalize.RegisterPromptAssets(assets) }},
 		{name: "combat turns prompt assets", register: func() error { return combatextract.RegisterPromptAssets(assets) }},
+		{name: "enemy events prompt assets", register: func() error { return enemyeventextract.RegisterPromptAssets(assets) }},
 		{name: "item events prompt assets", register: func() error { return itemeventextract.RegisterPromptAssets(assets) }},
 		{name: "npc interactions prompt assets", register: func() error { return interactionextract.RegisterPromptAssets(assets) }},
 		{name: "scene descriptions prompt assets", register: func() error { return scenedescriptionextract.RegisterPromptAssets(assets) }},

internal/modules/dnd/register/prompt_cache_test.go

@@ -9,6 +9,7 @@ import (
 
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
 	combatextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/combatturns"
+	enemyeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/enemyevents"
 	itemeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/itemevents"
 	interactionextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcinteractions"
 	npcextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcs"
@@ -38,12 +39,11 @@ func TestExtractionPromptsShareRenderedPrefix(t *testing.T) {
 		"glossary":   promptkit.Inline(glossarySentinel),
 	}
 	cases := []struct {
-		name              string
-		promptID          string
-		promptVersion     string
-		inputs            map[string]promptkit.ArtifactRef
-		npcInput          bool
-		spellCatalogInput bool
+		name           string
+		promptID       string
+		promptVersion  string
+		inputs         map[string]promptkit.ArtifactRef
+		inputSentinels []string
 	}{
 		{name: "npcs", promptID: npcextract.PromptID, promptVersion: npcextract.SchemaVersion, inputs: commonInputs},
 		{name: "item events", promptID: itemeventextract.PromptID, promptVersion: itemeventextract.SchemaVersion, inputs: commonInputs},
@@ -55,7 +55,18 @@ func TestExtractionPromptsShareRenderedPrefix(t *testing.T) {
 			inputs: withPromptInputs(commonInputs, map[string]promptkit.ArtifactRef{
 				"npcs": promptkit.Inline(`{"sentinel":"` + npcSentinel + `"}`),
 			}),
-			npcInput: true,
+			inputSentinels: []string{npcSentinel},
+		},
+		{
+			name:          "enemy events",
+			promptID:      enemyeventextract.PromptID,
+			promptVersion: enemyeventextract.SchemaVersion,
+			inputs: withPromptInputs(commonInputs, map[string]promptkit.ArtifactRef{
+				"npcs":             promptkit.Inline(`{"sentinel":"` + npcSentinel + `"}`),
+				"combat_turns":     promptkit.Inline(`{"sentinel":"combat-turns-sentinel"}`),
+				"npc_interactions": promptkit.Inline(`{"sentinel":"npc-interactions-sentinel"}`),
+			}),
+			inputSentinels: []string{npcSentinel, "combat-turns-sentinel", "npc-interactions-sentinel"},
 		},
 		{
 			name:          "npc interactions",
@@ -64,7 +75,7 @@ func TestExtractionPromptsShareRenderedPrefix(t *testing.T) {
 			inputs: withPromptInputs(commonInputs, map[string]promptkit.ArtifactRef{
 				"npcs": promptkit.Inline(`{"sentinel":"` + npcSentinel + `"}`),
 			}),
-			npcInput: true,
+			inputSentinels: []string{npcSentinel},
 		},
 		{
 			name:          "spells",
@@ -74,8 +85,7 @@ func TestExtractionPromptsShareRenderedPrefix(t *testing.T) {
 				"npcs":          promptkit.Inline(`{"sentinel":"` + npcSentinel + `"}`),
 				"spell_catalog": promptkit.Inline(`{"sentinel":"` + catalogSentinel + `"}`),
 			}),
-			npcInput:          true,
-			spellCatalogInput: true,
+			inputSentinels: []string{npcSentinel, catalogSentinel},
 		},
 	}
 
@@ -93,9 +103,6 @@ func TestExtractionPromptsShareRenderedPrefix(t *testing.T) {
 			}
 			transcriptIndex := renderedInputMessageIndex(t, prepared.Messages, transcriptSentinel)
 			prefix := prepared.Messages[:transcriptIndex+1]
-			if len(prefix) != 4 {
-				t.Fatalf("messages through transcript = %d, want 4", len(prefix))
-			}
 			if len(prepared.Messages) <= len(prefix) {
 				t.Fatalf("prepared prompt has %d messages, want lane-specific suffix after transcript", len(prepared.Messages))
 			}
@@ -104,11 +111,8 @@ func TestExtractionPromptsShareRenderedPrefix(t *testing.T) {
 			} else if !reflect.DeepEqual(prefix, sharedPrefix) {
 				t.Fatalf("rendered prefix = %#v, want %#v", prefix, sharedPrefix)
 			}
-			if testCase.npcInput {
-				assertRenderedInputAfter(t, prepared.Messages, npcSentinel, transcriptIndex)
-			}
-			if testCase.spellCatalogInput {
-				assertRenderedInputAfter(t, prepared.Messages, catalogSentinel, transcriptIndex)
+			for _, sentinel := range testCase.inputSentinels {
+				assertRenderedInputAfter(t, prepared.Messages, sentinel, transcriptIndex)
 			}
 		})
 	}

internal/modules/dnd/register/register_test.go

@@ -13,12 +13,14 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	combatextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/combatturns"
+	enemyeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/enemyevents"
 	itemeventextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/itemevents"
 	interactionextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcinteractions"
 	npcextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/npcs"
 	scenedescriptionextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/scenedescriptions"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/spells"
 	combatnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/combatturns"
+	enemyeventnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/enemyevents"
 	itemeventnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/itemevents"
 	interactionnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/npcinteractions"
 	npcnormalize "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/normalize/npcs"
@@ -44,6 +46,7 @@ func TestRegisterAddsDNDFamily(t *testing.T) {
 		"dnd.spells/dnd.spells.yaml",
 		"dnd.npcs/dnd.npcs.yaml",
 		"dnd.combat_turns/dnd.combat_turns.yaml",
+		"dnd.enemy_events/dnd.enemy_events.yaml",
 		"dnd.item_events/dnd.item_events.yaml",
 		"dnd.npc_interactions/dnd.npc_interactions.yaml",
 		"dnd.scene_descriptions/dnd.scene_descriptions.yaml",
@@ -72,14 +75,15 @@ func TestRegisterAddsDNDFamily(t *testing.T) {
 		t.Fatalf("normalization schema asset = %v, want registered private schema", err)
 	}
 	assertContainsKeys(t, "chunkers", registries.Chunkers.RegisteredKeys(), []string{"dnd/scenes"})
-	assertContainsKeys(t, "extractors", registries.Extractors.RegisteredKeys(), []string{"dnd/spells", npcextract.Key, combatextract.Key, itemeventextract.Key, interactionextract.Key, scenedescriptionextract.Key})
-	assertContainsKeys(t, "normalizers", registries.Normalizers.RegisteredKeys(), []string{spellnormalize.Key, npcnormalize.Key, combatnormalize.Key, itemeventnormalize.Key, interactionnormalize.Key, scenedescriptionnormalize.Key, pipeline.DefaultNormalizeModule})
-	assertContainsArtifactKinds(t, registries.ArtifactCodecs.RegisteredKinds(), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind, dnd.NPCInteractionListKind, dnd.SceneDescriptionListKind})
-	assertContainsArtifactKinds(t, registries.ArtifactEvidence.RegisteredKinds(), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind, dnd.NPCInteractionListKind, dnd.SceneDescriptionListKind})
-	assertContainsArtifactKinds(t, registries.Mergers.RegisteredArtifactKinds(pipeline.DefaultMergeModule), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind, dnd.NPCInteractionListKind, dnd.SceneDescriptionListKind})
-	assertContainsArtifactKinds(t, registries.Normalizers.RegisteredArtifactKinds(pipeline.DefaultNormalizeModule), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.ItemEventListKind, dnd.NPCInteractionListKind, dnd.SceneDescriptionListKind})
+	assertContainsKeys(t, "extractors", registries.Extractors.RegisteredKeys(), []string{"dnd/spells", npcextract.Key, combatextract.Key, enemyeventextract.Key, itemeventextract.Key, interactionextract.Key, scenedescriptionextract.Key})
+	assertContainsKeys(t, "normalizers", registries.Normalizers.RegisteredKeys(), []string{spellnormalize.Key, npcnormalize.Key, combatnormalize.Key, enemyeventnormalize.Key, itemeventnormalize.Key, interactionnormalize.Key, scenedescriptionnormalize.Key, pipeline.DefaultNormalizeModule})
+	assertContainsArtifactKinds(t, registries.ArtifactCodecs.RegisteredKinds(), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.EnemyEventListKind, dnd.ItemEventListKind, dnd.NPCInteractionListKind, dnd.SceneDescriptionListKind})
+	assertContainsArtifactKinds(t, registries.ArtifactEvidence.RegisteredKinds(), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.EnemyEventListKind, dnd.ItemEventListKind, dnd.NPCInteractionListKind, dnd.SceneDescriptionListKind})
+	assertContainsArtifactKinds(t, registries.Mergers.RegisteredArtifactKinds(pipeline.DefaultMergeModule), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.EnemyEventListKind, dnd.ItemEventListKind, dnd.NPCInteractionListKind, dnd.SceneDescriptionListKind})
+	assertContainsArtifactKinds(t, registries.Normalizers.RegisteredArtifactKinds(pipeline.DefaultNormalizeModule), []contracts.ArtifactKind{dnd.SpellListKind, dnd.NPCListKind, dnd.CombatTurnListKind, dnd.EnemyEventListKind, dnd.ItemEventListKind, dnd.NPCInteractionListKind, dnd.SceneDescriptionListKind})
 	assertContainsArtifactKinds(t, registries.Normalizers.RegisteredArtifactKinds(npcnormalize.Key), []contracts.ArtifactKind{dnd.NPCListKind})
 	assertContainsArtifactKinds(t, registries.Normalizers.RegisteredArtifactKinds(combatnormalize.Key), []contracts.ArtifactKind{dnd.CombatTurnListKind})
+	assertContainsArtifactKinds(t, registries.Normalizers.RegisteredArtifactKinds(enemyeventnormalize.Key), []contracts.ArtifactKind{dnd.EnemyEventListKind})
 	assertContainsArtifactKinds(t, registries.Normalizers.RegisteredArtifactKinds(itemeventnormalize.Key), []contracts.ArtifactKind{dnd.ItemEventListKind})
 	assertContainsArtifactKinds(t, registries.Normalizers.RegisteredArtifactKinds(interactionnormalize.Key), []contracts.ArtifactKind{dnd.NPCInteractionListKind})
 	assertContainsArtifactKinds(t, registries.Normalizers.RegisteredArtifactKinds(scenedescriptionnormalize.Key), []contracts.ArtifactKind{dnd.SceneDescriptionListKind})
@@ -96,6 +100,11 @@ func TestRegisterAddsDNDFamily(t *testing.T) {
 		"extract/dnd/combat-turns/source_refs",
 		"extract/dnd/combat-turns/source_relatedness",
 		"normalize/dnd/combat-turns/invariants",
+		"extract/dnd/enemy-events/shape",
+		"extract/dnd/enemy-events/engagements",
+		"extract/dnd/enemy-events/source_refs",
+		"extract/dnd/enemy-events/source_relatedness",
+		"normalize/dnd/enemy-events/invariants",
 		"extract/dnd/item-events/shape",
 		"extract/dnd/item-events/source_refs",
 		"extract/dnd/item-events/source_relatedness",
@@ -168,6 +177,28 @@ func TestRegisterAddsDNDFamily(t *testing.T) {
 	if got := registries.ValidatorChains.Validators(pipeline.StageNormalize, combatnormalize.Key); !reflect.DeepEqual(got, combatNormalizeChain) {
 		t.Fatalf("combat normalize validator chain = %#v, want %#v", got, combatNormalizeChain)
 	}
+	enemyEventExtractChain := []pipeline.ModuleBinding{
+		pipeline.Binding("generic/valid_json"),
+		pipeline.Binding("extract/dnd/enemy-events/shape"),
+		pipeline.Binding("extract/dnd/enemy-events/engagements"),
+		pipeline.Binding("extract/dnd/enemy-events/source_refs"),
+		pipeline.Binding("generic/valid_json_schema"),
+		pipeline.Binding("extract/dnd/enemy-events/source_relatedness"),
+	}
+	enemyEventNormalizeChain := []pipeline.ModuleBinding{
+		pipeline.Binding("generic/valid_json"),
+		pipeline.Binding("extract/dnd/enemy-events/shape"),
+		pipeline.Binding("normalize/dnd/enemy-events/invariants"),
+		pipeline.Binding("extract/dnd/enemy-events/source_refs"),
+		pipeline.Binding("generic/valid_json_schema"),
+		pipeline.Binding("extract/dnd/enemy-events/source_relatedness"),
+	}
+	if got := registries.ValidatorChains.Validators(pipeline.StageExtract, enemyeventextract.Key); !reflect.DeepEqual(got, enemyEventExtractChain) {
+		t.Fatalf("enemy event extract validator chain = %#v, want %#v", got, enemyEventExtractChain)
+	}
+	if got := registries.ValidatorChains.Validators(pipeline.StageNormalize, enemyeventnormalize.Key); !reflect.DeepEqual(got, enemyEventNormalizeChain) {
+		t.Fatalf("enemy event normalize validator chain = %#v, want %#v", got, enemyEventNormalizeChain)
+	}
 	itemEventExtractChain := []pipeline.ModuleBinding{
 		pipeline.Binding("generic/valid_json"),
 		pipeline.Binding("extract/dnd/item-events/shape"),
@@ -264,6 +295,10 @@ func TestRegisterAddsDNDFamily(t *testing.T) {
 		"dnd.combat_turns/sharedassets/common-dnd-system.md",
 		"dnd.combat_turns/sharedassets/common-dnd-transcript.md",
 		"dnd.combat_turns/task.md",
+		"dnd.enemy_events/dnd.enemy_events.yaml",
+		"dnd.enemy_events/grounding.md",
+		"dnd.enemy_events/instructions.md",
+		"dnd.enemy_events/task.md",
 		"dnd.item_events/dnd.item_events.yaml",
 		"dnd.item_events/instructions.md",
 		"dnd.item_events/sharedassets/common-dnd-extraction-evidence.md",
@@ -289,6 +324,7 @@ func TestRegisterAddsDNDFamily(t *testing.T) {
 		"dnd_spells_llm.v1.json",
 		"dnd_npcs_llm.v1.json",
 		"dnd_combat_turns_llm.v1.json",
+		"dnd_enemy_events_llm.v1.json",
 		"dnd_item_events_llm.v1.json",
 		"dnd_npc_interactions_llm.v1.json",
 		"dnd_scene_descriptions_llm.v1.json",
@@ -314,6 +350,19 @@ func TestRegisterAddsDNDFamily(t *testing.T) {
 	if spec, ok := registries.Normalizers.Spec(combatnormalize.Key); !ok || spec.ArtifactKind != dnd.CombatTurnListKind || spec.Stage != pipeline.StageNormalize {
 		t.Fatalf("combat normalizer spec = %#v, present = %t; want dnd combat-turn-list artifact", spec, ok)
 	}
+	enemyEventExtractSpec, enemyEventExtractOK := registries.Extractors.Spec(enemyeventextract.Key)
+	enemyEventNormalizeSpec, enemyEventNormalizeOK := registries.Normalizers.Spec(enemyeventnormalize.Key)
+	if !enemyEventExtractOK || enemyEventExtractSpec.ArtifactKind != dnd.EnemyEventListKind || !enemyEventNormalizeOK || enemyEventNormalizeSpec.ArtifactKind != dnd.EnemyEventListKind || enemyEventNormalizeSpec.Stage != pipeline.StageNormalize {
+		t.Fatalf("enemy event specs = %#v / %#v, present = %t / %t", enemyEventExtractSpec, enemyEventNormalizeSpec, enemyEventExtractOK, enemyEventNormalizeOK)
+	}
+	if len(enemyEventExtractSpec.ReferenceSlots) != 8 || len(enemyEventNormalizeSpec.ReferenceSlots) != 1 {
+		t.Fatalf("enemy event reference slots = %#v / %#v", enemyEventExtractSpec.ReferenceSlots, enemyEventNormalizeSpec.ReferenceSlots)
+	}
+	npcRegistrySlot := referenceSlot(enemyEventExtractSpec.ReferenceSlots, "npcs")
+	enemyNormalizeRegistrySlot := referenceSlot(enemyEventNormalizeSpec.ReferenceSlots, "npcs")
+	if !npcRegistrySlot.Required || !enemyNormalizeRegistrySlot.Required || npcRegistrySlot.MaxBytes != enemyNormalizeRegistrySlot.MaxBytes || !reflect.DeepEqual(npcRegistrySlot.AcceptedMediaTypes, enemyNormalizeRegistrySlot.AcceptedMediaTypes) || !reflect.DeepEqual(npcRegistrySlot.AcceptedArtifactKinds, enemyNormalizeRegistrySlot.AcceptedArtifactKinds) {
+		t.Fatalf("enemy-event NPC registry slots disagree: %#v / %#v", enemyEventExtractSpec.ReferenceSlots, enemyEventNormalizeSpec.ReferenceSlots)
+	}
 	itemEventExtractSpec, itemEventExtractOK := registries.Extractors.Spec(itemeventextract.Key)
 	itemEventNormalizeSpec, itemEventNormalizeOK := registries.Normalizers.Spec(itemeventnormalize.Key)
 	if !itemEventExtractOK || itemEventExtractSpec.ArtifactKind != dnd.ItemEventListKind || !itemEventNormalizeOK || itemEventNormalizeSpec.ArtifactKind != dnd.ItemEventListKind || itemEventNormalizeSpec.Stage != pipeline.StageNormalize || len(itemEventNormalizeSpec.ReferenceSlots) != 0 {
@@ -361,6 +410,9 @@ func TestEvidenceProjectorsPreserveDirectReferencesWithIndependentStorage(t *tes
 		{name: "combat turns", project: func() []source.SourceRef {
 			return combatTurnEvidence(dnd.CombatTurnList{CombatTurns: []dnd.CombatTurn{{SourceRefs: []source.SourceRef{first, second}}}})
 		}, want: []source.SourceRef{first, second}},
+		{name: "enemy events", project: func() []source.SourceRef {
+			return enemyEventEvidence(dnd.EnemyEventList{Events: []dnd.EnemyEvent{{SourceRefs: []source.SourceRef{first, second}}}})
+		}, want: []source.SourceRef{first, second}},
 		{name: "item events", project: func() []source.SourceRef {
 			return itemEventEvidence(dnd.ItemEventList{Events: []dnd.ItemEvent{{SourceRefs: []source.SourceRef{first, second}}}})
 		}, want: []source.SourceRef{first, second}},
@@ -536,6 +588,30 @@ func TestAppendCombatTurnListsPreservesOrderPresenceAndOwnership(t *testing.T) {
 	}
 }
 
+func TestAppendEnemyEventListsPreservesOrderPresenceAndOwnership(t *testing.T) {
+	refs := []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}}
+	input := []dnd.EnemyEventList{
+		{},
+		{Events: []dnd.EnemyEvent{}},
+		{Events: []dnd.EnemyEvent{{Name: "first", Kind: dnd.EnemyEventKindEngaged, SourceRefs: refs}}},
+		{Events: []dnd.EnemyEvent{{Name: "second", Kind: dnd.EnemyEventKindFled, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 2, EndUnitID: 2}}}}},
+	}
+	got, err := appendEnemyEventLists(input)
+	if err != nil || got.Events == nil || !reflect.DeepEqual([]string{got.Events[0].Name, got.Events[1].Name}, []string{"first", "second"}) {
+		t.Fatalf("appendEnemyEventLists() = %#v, error = %v", got, err)
+	}
+	got.Events[0].SourceRefs[0].StartUnitID = 999
+	if input[2].Events[0].SourceRefs[0].StartUnitID != 1 {
+		t.Fatal("merged enemy events share source-reference storage")
+	}
+	for _, values := range [][]dnd.EnemyEventList{nil, []dnd.EnemyEventList{{}, {}}} {
+		result, err := appendEnemyEventLists(values)
+		if err != nil || result.Events != nil {
+			t.Fatalf("nil-only merge = %#v, %v; want nil events", result, err)
+		}
+	}
+}
+
 func TestAppendItemEventListsPreservesOrderPresenceAndOwnership(t *testing.T) {
 	quantity := 3
 	refs := []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}}
@@ -578,6 +654,11 @@ func TestAppendListsPreserveNestedSourceReferencePresence(t *testing.T) {
 		t.Fatalf("appendCombatTurnLists() = %#v, %v; want present-empty source refs", turns, err)
 	}
 
+	enemyEvents, err := appendEnemyEventLists([]dnd.EnemyEventList{{Events: []dnd.EnemyEvent{{SourceRefs: []source.SourceRef{}}}}})
+	if err != nil || enemyEvents.Events[0].SourceRefs == nil {
+		t.Fatalf("appendEnemyEventLists() = %#v, %v; want present-empty source refs", enemyEvents, err)
+	}
+
 	interactions, err := appendNPCInteractionLists([]dnd.NPCInteractionList{{Interactions: []dnd.NPCInteraction{{SourceRefs: []source.SourceRef{}}}}})
 	if err != nil || interactions.Interactions[0].SourceRefs == nil {
 		t.Fatalf("appendNPCInteractionLists() = %#v, %v; want present-empty source refs", interactions, err)

internal/modules/dnd/register/validators.go

@@ -7,6 +7,11 @@ import (
 	combatshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/combatturns/shape"
 	combatsourcerefs "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/combatturns/source_refs"
 	combatrelatedness "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/combatturns/source_relatedness"
+	enemyeventengagements "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/engagements"
+	enemyeventinvariants "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/invariants"
+	enemyeventshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/shape"
+	enemyeventrefs "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/source_refs"
+	enemyeventrelatedness "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/source_relatedness"
 	itemeventinvariants "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/itemevents/invariants"
 	itemeventshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/itemevents/shape"
 	itemeventrefs "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/itemevents/source_refs"
@@ -46,6 +51,11 @@ func registerValidators(registries pipeline.Registries) error {
 		{name: "combat source references validator", register: func() error { return combatsourcerefs.Register(registries.Validators) }},
 		{name: "combat source relatedness validator", register: func() error { return combatrelatedness.Register(registries.Validators) }},
 		{name: "combat normalized invariants validator", register: func() error { return combatinvariants.Register(registries.Validators) }},
+		{name: "enemy event shape validator", register: func() error { return enemyeventshape.Register(registries.Validators) }},
+		{name: "enemy event engagement validator", register: func() error { return enemyeventengagements.Register(registries.Validators) }},
+		{name: "enemy event source references validator", register: func() error { return enemyeventrefs.Register(registries.Validators) }},
+		{name: "enemy event source relatedness validator", register: func() error { return enemyeventrelatedness.Register(registries.Validators) }},
+		{name: "enemy event normalized invariants validator", register: func() error { return enemyeventinvariants.Register(registries.Validators) }},
 		{name: "item event shape validator", register: func() error { return itemeventshape.Register(registries.Validators) }},
 		{name: "item event source references validator", register: func() error { return itemeventrefs.Register(registries.Validators) }},
 		{name: "item event source relatedness validator", register: func() error { return itemeventrelatedness.Register(registries.Validators) }},
@@ -77,6 +87,12 @@ func registerValidators(registries pipeline.Registries) error {
 		{name: "combat-turn-list always reject validator", register: func() error {
 			return alwaysreject.RegisterTyped[dnd.CombatTurnList](registries.Validators, dnd.CombatTurnListKind)
 		}},
+		{name: "enemy-event-list always accept validator", register: func() error {
+			return alwaysaccept.RegisterTyped[dnd.EnemyEventList](registries.Validators, dnd.EnemyEventListKind)
+		}},
+		{name: "enemy-event-list always reject validator", register: func() error {
+			return alwaysreject.RegisterTyped[dnd.EnemyEventList](registries.Validators, dnd.EnemyEventListKind)
+		}},
 		{name: "item-event-list always accept validator", register: func() error {
 			return alwaysaccept.RegisterTyped[dnd.ItemEventList](registries.Validators, dnd.ItemEventListKind)
 		}},

internal/modules/dnd/types.go

@@ -18,6 +18,8 @@ const SceneDescriptionListKind contracts.ArtifactKind = "dnd/scene-description-l
 
 const ItemEventListKind contracts.ArtifactKind = "dnd/item-event-list"
 
+const EnemyEventListKind contracts.ArtifactKind = "dnd/enemy-event-list"
+
 type SpellList struct {
 	SpellCasts []SpellCast `json:"spell_casts"`
 }
@@ -122,3 +124,23 @@ type ItemEvent struct {
 	To         string             `json:"to,omitempty"`
 	SourceRefs []source.SourceRef `json:"source_refs"`
 }
+
+type EnemyEventKind string
+
+const (
+	EnemyEventKindEngaged       EnemyEventKind = "engaged"
+	EnemyEventKindKilled        EnemyEventKind = "killed"
+	EnemyEventKindFled          EnemyEventKind = "fled"
+	EnemyEventKindCaptured      EnemyEventKind = "captured"
+	EnemyEventKindIncapacitated EnemyEventKind = "incapacitated"
+)
+
+type EnemyEventList struct {
+	Events []EnemyEvent `json:"events"`
+}
+
+type EnemyEvent struct {
+	Name       string             `json:"name"`
+	Kind       EnemyEventKind     `json:"kind"`
+	SourceRefs []source.SourceRef `json:"source_refs"`
+}

internal/modules/dnd/validate/enemyevents/engagements/validator.go

@@ -0,0 +1,85 @@
+// Package engagements prevents duplicate enemy engagements within one scene.
+package engagements
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	enemyeventmodel "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/enemyevents"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
+	enemyeventshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/shape"
+)
+
+const (
+	Key        = "extract/dnd/enemy-events/engagements"
+	ReasonCode = "duplicate_enemy_engagement"
+	policy     = "dnd.enemy_events.validator.engagements.v1"
+)
+
+type Options struct{}
+type Validator struct{}
+
+var _ contracts.TypedValidator[dnd.EnemyEventList] = (*Validator)(nil)
+var _ pipeline.CheckpointFingerprintProvider = (*Validator)(nil)
+
+func New(Options) *Validator      { return &Validator{} }
+func (v *Validator) Name() string { return Key }
+func (v *Validator) ExecutionClass() contracts.ExecutionClass {
+	return contracts.ExecutionClassDeterministic
+}
+func (v *Validator) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
+	return []pipeline.CheckpointFingerprint{{Name: "policy", Value: policy}}
+}
+
+func (v *Validator) Validate(_ context.Context, req contracts.TypedValidationRequest[dnd.EnemyEventList]) (contracts.ValidationResult, error) {
+	if enemyeventshape.Validate(req.Value) != nil {
+		return contracts.ValidationResult{Approved: true}, nil
+	}
+	seen := make(map[string]struct{})
+	for _, event := range req.Value.Events {
+		if event.Kind != dnd.EnemyEventKindEngaged {
+			continue
+		}
+		identity := enemyeventmodel.ComparisonKey(event.Name)
+		if identity == "" {
+			continue
+		}
+		if _, found := seen[identity]; found {
+			return contracts.ValidationResult{
+				Approved:   false,
+				ReasonCode: ReasonCode,
+				Message: diagnostics.Aggregate("duplicate enemy engagement", []string{
+					fmt.Sprintf("subject %s has more than one engagement in one combat scene", diagnostics.Quote(event.Name)),
+				}),
+			}, nil
+		}
+		seen[identity] = struct{}{}
+	}
+	return contracts.ValidationResult{Approved: true}, nil
+}
+
+func Spec() pipeline.ValidatorSpec {
+	return pipeline.ValidatorSpec{Key: Key, ExecutionClass: contracts.ExecutionClassDeterministic}
+}
+
+func Register(registry *pipeline.ValidatorRegistry) error {
+	return pipeline.RegisterTypedValidatorBuilder(registry, dnd.EnemyEventListKind, Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.TypedValidator[dnd.EnemyEventList], error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return New(options), nil
+	})
+}
+
+func DecodeOptions(options map[string]any) (Options, error) {
+	if err := pipeline.RejectUnknownOptions(options); err != nil {
+		return Options{}, err
+	}
+	return Options{}, nil
+}
+
+func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }

internal/modules/dnd/validate/enemyevents/engagements/validator_test.go

@@ -0,0 +1,77 @@
+package engagements
+
+import (
+	"context"
+	"reflect"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+)
+
+func TestValidatorEnforcesOneEngagementPerSubject(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		value    dnd.EnemyEventList
+		approved bool
+	}{
+		{name: "empty", value: dnd.EnemyEventList{Events: []dnd.EnemyEvent{}}, approved: true},
+		{name: "one engagement", value: events(event("Ashfang", dnd.EnemyEventKindEngaged, 1)), approved: true},
+		{name: "same subject different evidence", value: events(event("Ashfang", dnd.EnemyEventKindEngaged, 1), event("Ashfang", dnd.EnemyEventKindEngaged, 2))},
+		{name: "whitespace and case variant", value: events(event("Ashfang", dnd.EnemyEventKindEngaged, 1), event("  ASHFANG  ", dnd.EnemyEventKindEngaged, 2))},
+		{name: "different subjects", value: events(event("Ashfang", dnd.EnemyEventKindEngaged, 1), event("Briar", dnd.EnemyEventKindEngaged, 2)), approved: true},
+		{name: "different kinds", value: events(event("Ashfang", dnd.EnemyEventKindEngaged, 1), event("Ashfang", dnd.EnemyEventKindFled, 2)), approved: true},
+		{name: "malformed shape", value: dnd.EnemyEventList{Events: []dnd.EnemyEvent{{Name: "Ashfang"}, {Name: "Ashfang", Kind: dnd.EnemyEventKindEngaged, SourceRefs: refs(2)}}}, approved: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Value: test.value})
+			if err != nil || result.Approved != test.approved {
+				t.Fatalf("Validate() = %#v, %v; want approved=%t", result, err, test.approved)
+			}
+			if !test.approved && result.ReasonCode != ReasonCode {
+				t.Fatalf("reason code = %q, want %q", result.ReasonCode, ReasonCode)
+			}
+		})
+	}
+	validator := New(Options{})
+	for _, unitID := range []int{1, 2} {
+		value := events(event("Ashfang", dnd.EnemyEventKindEngaged, unitID))
+		before := events(event("Ashfang", dnd.EnemyEventKindEngaged, unitID))
+		result, err := validator.Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Value: value})
+		if err != nil || !result.Approved {
+			t.Fatalf("separate scene validation = %#v, %v; want approved", result, err)
+		}
+		if !reflect.DeepEqual(value, before) {
+			t.Fatalf("Validate() mutated separate scene value: got %#v, want %#v", value, before)
+		}
+	}
+}
+
+func TestValidatorRegistersStrictOptionsAndPolicy(t *testing.T) {
+	registry := pipeline.NewValidatorRegistry()
+	if err := Register(registry); err != nil {
+		t.Fatal(err)
+	}
+	if Spec().Key != Key || Spec().ExecutionClass != contracts.ExecutionClassDeterministic {
+		t.Fatalf("Spec() = %#v", Spec())
+	}
+	if got := New(Options{}).CheckpointFingerprints(); len(got) != 1 || got[0].Name != "policy" || got[0].Value != policy {
+		t.Fatalf("CheckpointFingerprints() = %#v", got)
+	}
+	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil || !strings.Contains(err.Error(), "unknown option") {
+		t.Fatalf("DecodeOptions() error = %v, want strict option rejection", err)
+	}
+}
+
+func events(values ...dnd.EnemyEvent) dnd.EnemyEventList { return dnd.EnemyEventList{Events: values} }
+
+func event(name string, kind dnd.EnemyEventKind, unitID int) dnd.EnemyEvent {
+	return dnd.EnemyEvent{Name: name, Kind: kind, SourceRefs: refs(unitID)}
+}
+
+func refs(unitID int) []source.SourceRef {
+	return []source.SourceRef{{SourceID: "session", StartUnitID: unitID, EndUnitID: unitID}}
+}

internal/modules/dnd/validate/enemyevents/invariants/validator.go

@@ -0,0 +1,170 @@
+// Package invariants validates normalized D&D enemy-event artifacts.
+package invariants
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	enemyeventmodel "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/enemyevents"
+	npcregistry "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/registry"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
+	enemyeventshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/shape"
+)
+
+const (
+	Key        = "normalize/dnd/enemy-events/invariants"
+	ReasonCode = "invalid_enemy_event_normalization"
+	policy     = "dnd.enemy_events.validator.normalized.v1"
+)
+
+type Options struct{}
+
+type Validator struct {
+	npcResolver *npcregistry.Resolver
+}
+
+var _ contracts.TypedValidator[dnd.EnemyEventList] = (*Validator)(nil)
+var _ contracts.ManifestMetadataProvider = (*Validator)(nil)
+var _ pipeline.CheckpointFingerprintProvider = (*Validator)(nil)
+
+func New(_ Options, references ...contracts.ReferenceSet) (*Validator, error) {
+	if len(references) > 1 {
+		return nil, fmt.Errorf("enemy event invariants validator accepts at most one reference set")
+	}
+	var referenceSet contracts.ReferenceSet
+	if len(references) == 1 {
+		referenceSet = references[0]
+	}
+	resolver, err := npcregistry.NewResolver(referenceSet)
+	if err != nil {
+		return nil, fmt.Errorf("prepare NPC registry: %w", err)
+	}
+	return &Validator{npcResolver: resolver}, nil
+}
+
+func (v *Validator) Name() string { return Key }
+func (v *Validator) ExecutionClass() contracts.ExecutionClass {
+	return contracts.ExecutionClassDeterministic
+}
+
+func (v *Validator) ManifestMetadata() map[string]any {
+	if v == nil || v.npcResolver == nil {
+		return nil
+	}
+	metadata := map[string]any{"policy": policy}
+	if seeded := v.npcResolver.Seeded(); seeded.Bound() {
+		metadata["npc_registry_digest"] = seeded.Digest()
+	}
+	return metadata
+}
+
+func (v *Validator) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
+	if v == nil || v.npcResolver == nil {
+		return nil
+	}
+	return []pipeline.CheckpointFingerprint{
+		{Name: "policy", Value: policy},
+		{Name: "npc_registry", Value: v.npcResolver.Seeded().ProjectionDigest()},
+	}
+}
+
+func (v *Validator) Validate(_ context.Context, req contracts.TypedValidationRequest[dnd.EnemyEventList]) (contracts.ValidationResult, error) {
+	if enemyeventshape.Validate(req.Value) != nil {
+		return contracts.ValidationResult{Approved: true}, nil
+	}
+	index := source.NewDocumentIndex(req.Source)
+	if !allSourceRefsValid(index, req.Value) {
+		return contracts.ValidationResult{Approved: true}, nil
+	}
+	if v == nil || v.npcResolver == nil {
+		return contracts.ValidationResult{}, fmt.Errorf("enemy event invariants validator must not be nil")
+	}
+	registry, err := v.npcResolver.Resolve(req.References)
+	if err != nil {
+		return contracts.ValidationResult{}, fmt.Errorf("resolve NPC registry: %w", err)
+	}
+	if !registry.Bound() {
+		return contracts.ValidationResult{Approved: false, ReasonCode: ReasonCode, Message: "invalid enemy event normalization: NPC registry reference is required"}, nil
+	}
+	issues := issuesFor(shared.NewSourceRefOrderFromIndex(index), req.Value, registry)
+	if len(issues) == 0 {
+		return contracts.ValidationResult{Approved: true}, nil
+	}
+	return contracts.ValidationResult{Approved: false, ReasonCode: ReasonCode, Message: diagnostics.Aggregate("invalid enemy event normalization", issues)}, nil
+}
+
+func allSourceRefsValid(index source.DocumentIndex, value dnd.EnemyEventList) bool {
+	for _, event := range value.Events {
+		for _, ref := range event.SourceRefs {
+			if index.ValidateRef(ref) != nil {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func issuesFor(order shared.SourceRefOrder, value dnd.EnemyEventList, registry *npcregistry.Registry) []string {
+	issues := make([]string, 0)
+	for eventIndex, event := range value.Events {
+		prefix := fmt.Sprintf("events[%d]", eventIndex)
+		if normalized := enemyeventmodel.NormalizeDisplay(event.Name); event.Name != normalized {
+			issues = append(issues, prefix+".name is not whitespace-normalized: "+diagnostics.Quote(event.Name))
+		}
+		if canonical, ok := registry.Lookup(event.Name); ok && event.Name != canonical.Name {
+			issues = append(issues, prefix+".name is not the canonical NPC display name: "+diagnostics.Quote(event.Name))
+		}
+		for refIndex := 1; refIndex < len(event.SourceRefs); refIndex++ {
+			previous := event.SourceRefs[refIndex-1]
+			current := event.SourceRefs[refIndex]
+			if order.Less(current, previous) {
+				issues = append(issues, fmt.Sprintf("%s.source_refs are not in canonical order at index %d", prefix, refIndex))
+			} else if current == previous {
+				issues = append(issues, fmt.Sprintf("%s.source_refs[%d] duplicates the previous reference", prefix, refIndex))
+			}
+		}
+	}
+	if !sort.SliceIsSorted(value.Events, func(left, right int) bool {
+		return enemyeventmodel.Less(order, value.Events[left], value.Events[right])
+	}) {
+		issues = append(issues, "events are not in canonical order")
+	}
+	for eventIndex, event := range value.Events {
+		for previousIndex := 0; previousIndex < eventIndex; previousIndex++ {
+			if enemyeventmodel.ExactEqual(order, value.Events[previousIndex], event) {
+				issues = append(issues, fmt.Sprintf("events[%d] duplicates event %d", eventIndex, previousIndex))
+				break
+			}
+		}
+	}
+	return issues
+}
+
+func Spec() pipeline.ValidatorSpec {
+	return pipeline.ValidatorSpec{Key: Key, ExecutionClass: contracts.ExecutionClassDeterministic}
+}
+
+func Register(registry *pipeline.ValidatorRegistry) error {
+	return pipeline.RegisterTypedValidatorBuilder(registry, dnd.EnemyEventListKind, Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.TypedValidator[dnd.EnemyEventList], error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return New(options, request.References)
+	})
+}
+
+func DecodeOptions(options map[string]any) (Options, error) {
+	if err := pipeline.RejectUnknownOptions(options); err != nil {
+		return Options{}, err
+	}
+	return Options{}, nil
+}
+
+func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }

internal/modules/dnd/validate/enemyevents/invariants/validator_test.go

@@ -0,0 +1,145 @@
+package invariants
+
+import (
+	"context"
+	"encoding/json"
+	"reflect"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"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"
+	npcregistry "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/registry"
+)
+
+func TestValidatorApprovesNormalizedEventsAndGenericGroups(t *testing.T) {
+	references := registryReferences(t, "Ária")
+	value := normalizedList()
+	result, err := newValidator(t, references).Validate(context.Background(), request(references, value))
+	if err != nil || !result.Approved {
+		t.Fatalf("Validate() = %#v, %v", result, err)
+	}
+}
+
+func TestValidatorRejectsNormalizationDrift(t *testing.T) {
+	references := registryReferences(t, "Ária")
+	for _, test := range []struct {
+		name   string
+		mutate func(*dnd.EnemyEventList)
+		want   string
+	}{
+		{"registry display", func(value *dnd.EnemyEventList) { value.Events[0].Name = " ária " }, "canonical NPC display name"},
+		{"generic whitespace", func(value *dnd.EnemyEventList) { value.Events[1].Name = " Remaining\tOrcs " }, "whitespace-normalized"},
+		{"evidence order", func(value *dnd.EnemyEventList) {
+			value.Events[0].SourceRefs = []source.SourceRef{{SourceID: "session", StartUnitID: 20, EndUnitID: 20}, {SourceID: "session", StartUnitID: 10, EndUnitID: 10}}
+		}, "not in canonical order"},
+		{"duplicate evidence", func(value *dnd.EnemyEventList) {
+			value.Events[0].SourceRefs = append(value.Events[0].SourceRefs, value.Events[0].SourceRefs[0])
+		}, "duplicates the previous reference"},
+		{"event order", func(value *dnd.EnemyEventList) { value.Events[0], value.Events[1] = value.Events[1], value.Events[0] }, "events are not in canonical order"},
+		{"exact duplicate", func(value *dnd.EnemyEventList) { value.Events = append(value.Events, value.Events[0]) }, "duplicates event"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			value := normalizedList()
+			test.mutate(&value)
+			result, err := newValidator(t, references).Validate(context.Background(), request(references, value))
+			if err != nil || result.Approved || result.ReasonCode != ReasonCode || !strings.Contains(result.Message, test.want) {
+				t.Fatalf("Validate() = %#v, %v; want %q", result, err, test.want)
+			}
+		})
+	}
+}
+
+func TestValidatorDefersEarlierFailuresAndResolvesOperationRegistryWithoutMutation(t *testing.T) {
+	references := registryReferences(t, "Ária")
+	for _, value := range []dnd.EnemyEventList{
+		{Events: []dnd.EnemyEvent{{Name: "Ária"}}},
+		{Events: []dnd.EnemyEvent{{Name: "Ária", Kind: dnd.EnemyEventKindEngaged, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 99, EndUnitID: 99}}}}},
+	} {
+		result, err := newValidator(t, references).Validate(context.Background(), request(references, value))
+		if err != nil || !result.Approved {
+			t.Fatalf("deferral = %#v, %v", result, err)
+		}
+	}
+	value := normalizedList()
+	before := cloneList(value)
+	result, err := newValidator(t).Validate(context.Background(), request(references, value))
+	if err != nil || !result.Approved || !reflect.DeepEqual(value, before) {
+		t.Fatalf("operation registry = %#v, %v; value=%#v", result, err, value)
+	}
+	result, err = newValidator(t).Validate(context.Background(), request(contracts.ReferenceSet{}, normalizedList()))
+	if err != nil || result.Approved || result.ReasonCode != ReasonCode || !strings.Contains(result.Message, "required") {
+		t.Fatalf("unbound registry = %#v, %v", result, err)
+	}
+}
+
+func TestValidatorMetadataFingerprintsAndRegistrationAreSafe(t *testing.T) {
+	references := registryReferences(t, "Ária")
+	metadata, err := json.Marshal(newValidator(t, references).ManifestMetadata())
+	if err != nil || strings.Contains(string(metadata), "Ária") {
+		t.Fatalf("ManifestMetadata() = %s, %v", metadata, err)
+	}
+	if got := newValidator(t, references).CheckpointFingerprints(); len(got) != 2 || got[0].Value != policy || !strings.HasPrefix(got[1].Value, "sha256:") {
+		t.Fatalf("CheckpointFingerprints() = %#v", got)
+	}
+	registry := pipeline.NewValidatorRegistry()
+	if err := Register(registry); err != nil {
+		t.Fatal(err)
+	}
+	if Spec().Key != Key || Spec().ExecutionClass != contracts.ExecutionClassDeterministic {
+		t.Fatalf("Spec() = %#v", Spec())
+	}
+	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil {
+		t.Fatal("DecodeOptions() accepted unknown option")
+	}
+}
+
+func newValidator(t *testing.T, references ...contracts.ReferenceSet) *Validator {
+	t.Helper()
+	validator, err := New(Options{}, references...)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return validator
+}
+
+func request(references contracts.ReferenceSet, value dnd.EnemyEventList) contracts.TypedValidationRequest[dnd.EnemyEventList] {
+	return contracts.TypedValidationRequest[dnd.EnemyEventList]{Source: document(), References: references, Value: value}
+}
+
+func document() *source.SourceDocument {
+	return &source.SourceDocument{ID: "session", Units: []source.SourceUnit{{ID: 10}, {ID: 20}}}
+}
+
+func normalizedList() dnd.EnemyEventList {
+	return dnd.EnemyEventList{Events: []dnd.EnemyEvent{
+		{Name: "Ária", Kind: dnd.EnemyEventKindEngaged, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 10, EndUnitID: 10}}},
+		{Name: "Remaining Orcs", Kind: dnd.EnemyEventKindFled, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 20, EndUnitID: 20}}},
+	}}
+}
+
+func cloneList(value dnd.EnemyEventList) dnd.EnemyEventList {
+	clone := dnd.EnemyEventList{Events: make([]dnd.EnemyEvent, len(value.Events))}
+	for index, event := range value.Events {
+		clone.Events[index] = event
+		clone.Events[index].SourceRefs = append([]source.SourceRef(nil), event.SourceRefs...)
+	}
+	return clone
+}
+
+func registryReferences(t *testing.T, names ...string) contracts.ReferenceSet {
+	t.Helper()
+	npcs := make([]dnd.NPC, len(names))
+	for index, name := range names {
+		npcs[index] = dnd.NPC{ID: identity.DeriveID(name), Name: name, SourceRefs: []source.SourceRef{{SourceID: "other", StartUnitID: index + 1, EndUnitID: index + 1}}}
+	}
+	content, err := npccodec.New().Encode(dnd.NPCList{NPCs: npcs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{npcregistry.ReferenceSlot: {Slot: contracts.ReferenceSlot{Name: npcregistry.ReferenceSlot}, Items: []contracts.ReferenceItem{{SlotName: npcregistry.ReferenceSlot, MediaType: npccodec.MediaType, Content: content, Origin: contracts.ReferenceOrigin{Type: "generated"}}}}}}
+}

internal/modules/dnd/validate/enemyevents/shape/validator.go

@@ -0,0 +1,93 @@
+// Package shape validates the candidate shape of D&D enemy-event artifacts.
+package shape
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	enemyeventmodel "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/enemyevents"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
+)
+
+const (
+	Key        = "extract/dnd/enemy-events/shape"
+	ReasonCode = "invalid_enemy_event_shape"
+	policy     = "dnd.enemy_events.validator.shape.v1"
+)
+
+type Options struct{}
+type Validator struct{}
+
+var _ contracts.TypedValidator[dnd.EnemyEventList] = (*Validator)(nil)
+var _ pipeline.CheckpointFingerprintProvider = (*Validator)(nil)
+
+func New(Options) *Validator      { return &Validator{} }
+func (v *Validator) Name() string { return Key }
+func (v *Validator) ExecutionClass() contracts.ExecutionClass {
+	return contracts.ExecutionClassDeterministic
+}
+func (v *Validator) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
+	return []pipeline.CheckpointFingerprint{{Name: "policy", Value: policy}}
+}
+
+func (v *Validator) Validate(_ context.Context, req contracts.TypedValidationRequest[dnd.EnemyEventList]) (contracts.ValidationResult, error) {
+	if err := Validate(req.Value); err != nil {
+		return contracts.ValidationResult{Approved: false, ReasonCode: ReasonCode, Message: err.Error()}, nil
+	}
+	return contracts.ValidationResult{Approved: true}, nil
+}
+
+func Validate(value dnd.EnemyEventList) error {
+	issues := issuesFor(value)
+	if len(issues) == 0 {
+		return nil
+	}
+	return fmt.Errorf("%s", diagnostics.Aggregate("invalid enemy event shape", issues))
+}
+
+func issuesFor(value dnd.EnemyEventList) []string {
+	if value.Events == nil {
+		return []string{"events must be present"}
+	}
+	issues := make([]string, 0)
+	for eventIndex, event := range value.Events {
+		prefix := fmt.Sprintf("events[%d]", eventIndex)
+		if strings.TrimSpace(event.Name) == "" {
+			issues = append(issues, prefix+".name must not be empty: "+diagnostics.Quote(event.Name))
+		}
+		if !enemyeventmodel.SupportedKind(event.Kind) {
+			issues = append(issues, prefix+".kind is unsupported: "+diagnostics.Quote(string(event.Kind)))
+		}
+		if len(event.SourceRefs) == 0 {
+			issues = append(issues, prefix+".source_refs must contain at least one reference")
+		}
+	}
+	return issues
+}
+
+func Spec() pipeline.ValidatorSpec {
+	return pipeline.ValidatorSpec{Key: Key, ExecutionClass: contracts.ExecutionClassDeterministic}
+}
+
+func Register(registry *pipeline.ValidatorRegistry) error {
+	return pipeline.RegisterTypedValidatorBuilder(registry, dnd.EnemyEventListKind, Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.TypedValidator[dnd.EnemyEventList], error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return New(options), nil
+	})
+}
+
+func DecodeOptions(options map[string]any) (Options, error) {
+	if err := pipeline.RejectUnknownOptions(options); err != nil {
+		return Options{}, err
+	}
+	return Options{}, nil
+}
+
+func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }

internal/modules/dnd/validate/enemyevents/shape/validator_test.go

@@ -0,0 +1,76 @@
+package shape
+
+import (
+	"context"
+	"strings"
+	"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/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+)
+
+func TestValidatorAcceptsEmptyAndWellFormedEventLists(t *testing.T) {
+	for _, value := range []dnd.EnemyEventList{{Events: []dnd.EnemyEvent{}}, validEventList()} {
+		result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Value: value})
+		if err != nil || !result.Approved || len(result.Warnings) != 0 {
+			t.Fatalf("Validate() = %#v, %v", result, err)
+		}
+	}
+}
+
+func TestValidatorRejectsOwnedShapeBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		mutate func(*dnd.EnemyEventList)
+		want   string
+	}{
+		{"missing events", func(value *dnd.EnemyEventList) { value.Events = nil }, "events must be present"},
+		{"blank name", func(value *dnd.EnemyEventList) { value.Events[0].Name = " \t" }, "name must not be empty"},
+		{"unsupported kind", func(value *dnd.EnemyEventList) { value.Events[0].Kind = "unknown" }, "kind is unsupported"},
+		{"missing evidence", func(value *dnd.EnemyEventList) { value.Events[0].SourceRefs = nil }, "source_refs must contain"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			value := validEventList()
+			test.mutate(&value)
+			result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Value: value})
+			if err != nil || result.Approved || result.ReasonCode != ReasonCode || !strings.Contains(result.Message, test.want) {
+				t.Fatalf("Validate() = %#v, %v; want %q", result, err, test.want)
+			}
+		})
+	}
+}
+
+func TestValidatorBoundsDiagnosticsAndRegistersStrictly(t *testing.T) {
+	value := dnd.EnemyEventList{Events: make([]dnd.EnemyEvent, 30)}
+	for index := range value.Events {
+		value.Events[index].Name = strings.Repeat("火", 300)
+		value.Events[index].Kind = "invalid"
+	}
+	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Value: value})
+	if err != nil || result.Approved || !utf8.ValidString(result.Message) || len([]byte(result.Message)) > 4096 || !strings.Contains(result.Message, "additional issue(s) omitted") {
+		t.Fatalf("Validate() = %#v, %v", result, err)
+	}
+	if got := New(Options{}).CheckpointFingerprints(); len(got) != 1 || got[0].Name != "policy" || got[0].Value != policy {
+		t.Fatalf("CheckpointFingerprints() = %#v", got)
+	}
+	registry := pipeline.NewValidatorRegistry()
+	if err := Register(registry); err != nil {
+		t.Fatal(err)
+	}
+	if Spec().Key != Key || Spec().ExecutionClass != contracts.ExecutionClassDeterministic {
+		t.Fatalf("Spec() = %#v", Spec())
+	}
+	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil {
+		t.Fatal("DecodeOptions() accepted unknown option")
+	}
+}
+
+func validEventList() dnd.EnemyEventList {
+	return dnd.EnemyEventList{Events: []dnd.EnemyEvent{{
+		Name: "Ashfang", Kind: dnd.EnemyEventKindEngaged,
+		SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}},
+	}}}
+}

internal/modules/dnd/validate/enemyevents/source_refs/validator.go

@@ -0,0 +1,123 @@
+// Package sourcerefs validates enemy-event evidence against the current source document.
+package sourcerefs
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
+	enemyeventshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/shape"
+)
+
+const (
+	Key        = "extract/dnd/enemy-events/source_refs"
+	ReasonCode = "invalid_enemy_event_source_refs"
+	policy     = "dnd.enemy_events.validator.source_refs.v1"
+)
+
+type Options struct{}
+type Validator struct{}
+
+var _ contracts.TypedValidator[dnd.EnemyEventList] = (*Validator)(nil)
+var _ pipeline.CheckpointFingerprintProvider = (*Validator)(nil)
+
+func New(Options) *Validator      { return &Validator{} }
+func (v *Validator) Name() string { return Key }
+func (v *Validator) ExecutionClass() contracts.ExecutionClass {
+	return contracts.ExecutionClassDeterministic
+}
+func (v *Validator) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
+	return []pipeline.CheckpointFingerprint{{Name: "policy", Value: policy}}
+}
+
+func (v *Validator) Validate(_ context.Context, req contracts.TypedValidationRequest[dnd.EnemyEventList]) (contracts.ValidationResult, error) {
+	if req.Stage == string(pipeline.StageExtract) && req.Chunk == nil {
+		return contracts.ValidationResult{}, fmt.Errorf("enemy event source-reference validator requires the current extraction chunk")
+	}
+	if err := enemyeventshape.Validate(req.Value); err != nil {
+		return contracts.ValidationResult{Approved: true}, nil
+	}
+	index := source.NewDocumentIndex(req.Source)
+	var coverage *chunkCoverage
+	if req.Stage == string(pipeline.StageExtract) {
+		coverage = newChunkCoverage(req.Chunk)
+	}
+	issues := sourceRefIssues(index, req.Source, coverage, req.Value)
+	if len(issues) == 0 {
+		return contracts.ValidationResult{Approved: true}, nil
+	}
+	return contracts.ValidationResult{Approved: false, ReasonCode: ReasonCode, Message: diagnostics.Aggregate("invalid enemy event source references", issues)}, nil
+}
+
+func sourceRefIssues(index source.DocumentIndex, doc *source.SourceDocument, coverage *chunkCoverage, value dnd.EnemyEventList) []string {
+	issues := make([]string, 0)
+	for eventIndex, event := range value.Events {
+		for refIndex, ref := range event.SourceRefs {
+			if err := index.ValidateRef(ref); err != nil {
+				issues = append(issues, fmt.Sprintf("events[%d].source_refs[%d]: %s", eventIndex, refIndex, diagnostics.Truncate(err.Error())))
+				continue
+			}
+			if coverage != nil && !coverage.contains(doc, ref) {
+				issues = append(issues, fmt.Sprintf("events[%d].source_refs[%d]: source reference is outside the current extraction chunk", eventIndex, refIndex))
+			}
+		}
+	}
+	return issues
+}
+
+type chunkCoverage struct {
+	sourceID string
+	unitIDs  map[int]struct{}
+}
+
+func newChunkCoverage(chunk *source.Chunk) *chunkCoverage {
+	coverage := &chunkCoverage{sourceID: chunk.SourceID, unitIDs: make(map[int]struct{}, len(chunk.Units))}
+	for _, unit := range chunk.Units {
+		coverage.unitIDs[unit.ID] = struct{}{}
+	}
+	return coverage
+}
+
+func (coverage *chunkCoverage) contains(doc *source.SourceDocument, ref source.SourceRef) bool {
+	if coverage == nil || doc == nil || ref.SourceID != coverage.sourceID {
+		return false
+	}
+	start, startOK := source.UnitIndex(doc, ref.StartUnitID)
+	end, endOK := source.UnitIndex(doc, ref.EndUnitID)
+	if !startOK || !endOK || start > end {
+		return false
+	}
+	for position := start; position <= end; position++ {
+		if _, found := coverage.unitIDs[doc.Units[position].ID]; !found {
+			return false
+		}
+	}
+	return true
+}
+
+func Spec() pipeline.ValidatorSpec {
+	return pipeline.ValidatorSpec{Key: Key, ExecutionClass: contracts.ExecutionClassDeterministic}
+}
+
+func Register(registry *pipeline.ValidatorRegistry) error {
+	return pipeline.RegisterTypedValidatorBuilder(registry, dnd.EnemyEventListKind, Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.TypedValidator[dnd.EnemyEventList], error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return New(options), nil
+	})
+}
+
+func DecodeOptions(options map[string]any) (Options, error) {
+	if err := pipeline.RejectUnknownOptions(options); err != nil {
+		return Options{}, err
+	}
+	return Options{}, nil
+}
+
+func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }

internal/modules/dnd/validate/enemyevents/source_refs/validator_test.go

@@ -0,0 +1,86 @@
+package sourcerefs
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+)
+
+func TestValidatorAcceptsCurrentDocumentAndChunkEvidence(t *testing.T) {
+	value := validEventList()
+	chunk := &source.Chunk{SourceID: "session", Units: []source.SourceUnit{{ID: 1}, {ID: 2}}}
+	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Stage: string(pipeline.StageExtract), Source: document(), Chunk: chunk, Value: value})
+	if err != nil || !result.Approved {
+		t.Fatalf("Validate() = %#v, %v", result, err)
+	}
+}
+
+func TestValidatorRejectsInvalidOrOutOfChunkEvidence(t *testing.T) {
+	for _, test := range []struct {
+		name    string
+		ref     source.SourceRef
+		chunk   *source.Chunk
+		want    string
+		missing bool
+	}{
+		{"wrong source", source.SourceRef{SourceID: "other", StartUnitID: 1, EndUnitID: 1}, nil, "does not match document", false},
+		{"unknown unit", source.SourceRef{SourceID: "session", StartUnitID: 99, EndUnitID: 99}, nil, "was not found", false},
+		{"backward range", source.SourceRef{SourceID: "session", StartUnitID: 3, EndUnitID: 1}, nil, "appears after", false},
+		{"outside chunk", source.SourceRef{SourceID: "session", StartUnitID: 2, EndUnitID: 3}, &source.Chunk{SourceID: "session", Units: []source.SourceUnit{{ID: 1}, {ID: 2}}}, "outside the current extraction chunk", false},
+		{"missing chunk", source.SourceRef{SourceID: "session", StartUnitID: 1, EndUnitID: 1}, nil, "current extraction chunk", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			value := validEventList()
+			value.Events[0].SourceRefs[0] = test.ref
+			request := contracts.TypedValidationRequest[dnd.EnemyEventList]{Source: document(), Value: value}
+			if test.chunk != nil || test.missing {
+				request.Stage = string(pipeline.StageExtract)
+				request.Chunk = test.chunk
+			}
+			result, err := New(Options{}).Validate(context.Background(), request)
+			if test.missing {
+				if err == nil || !strings.Contains(err.Error(), test.want) {
+					t.Fatalf("Validate() error = %v; want %q", err, test.want)
+				}
+				return
+			}
+			if err != nil || result.Approved || result.ReasonCode != ReasonCode || !strings.Contains(result.Message, test.want) {
+				t.Fatalf("Validate() = %#v, %v; want %q", result, err, test.want)
+			}
+		})
+	}
+}
+
+func TestValidatorDefersShapeFailureAndRegistersStrictly(t *testing.T) {
+	malformed := dnd.EnemyEventList{Events: []dnd.EnemyEvent{{Name: "Ashfang"}}}
+	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Source: document(), Value: malformed})
+	if err != nil || !result.Approved {
+		t.Fatalf("shape deferral = %#v, %v", result, err)
+	}
+	registry := pipeline.NewValidatorRegistry()
+	if err := Register(registry); err != nil {
+		t.Fatal(err)
+	}
+	if Spec().Key != Key || Spec().ExecutionClass != contracts.ExecutionClassDeterministic {
+		t.Fatalf("Spec() = %#v", Spec())
+	}
+	if got := New(Options{}).CheckpointFingerprints(); len(got) != 1 || got[0].Value != policy {
+		t.Fatalf("CheckpointFingerprints() = %#v", got)
+	}
+	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil {
+		t.Fatal("DecodeOptions() accepted unknown option")
+	}
+}
+
+func validEventList() dnd.EnemyEventList {
+	return dnd.EnemyEventList{Events: []dnd.EnemyEvent{{Name: "Ashfang", Kind: dnd.EnemyEventKindEngaged, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 2}}}}}
+}
+
+func document() *source.SourceDocument {
+	return &source.SourceDocument{ID: "session", Units: []source.SourceUnit{{ID: 1, Text: "Ashfang attacks."}, {ID: 2, Text: "Ashfang retreats."}, {ID: 3, Text: "Later."}}}
+}

internal/modules/dnd/validate/enemyevents/source_relatedness/validator.go

@@ -0,0 +1,84 @@
+// Package sourcerelatedness reports advisory enemy-subject evidence concerns.
+package sourcerelatedness
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
+	enemyeventshape "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/enemyevents/shape"
+)
+
+const (
+	Key               = "extract/dnd/enemy-events/source_relatedness"
+	WarningReasonCode = "enemy_event_not_near_source"
+	OmittedReasonCode = "enemy_event_relatedness_warnings_omitted"
+	policy            = "dnd.enemy_events.validator.source_relatedness.v1"
+)
+
+type Options struct{}
+type Validator struct{}
+
+var _ contracts.TypedValidator[dnd.EnemyEventList] = (*Validator)(nil)
+var _ pipeline.CheckpointFingerprintProvider = (*Validator)(nil)
+
+func New(Options) *Validator      { return &Validator{} }
+func (v *Validator) Name() string { return Key }
+func (v *Validator) ExecutionClass() contracts.ExecutionClass {
+	return contracts.ExecutionClassDeterministic
+}
+func (v *Validator) CheckpointFingerprints() []pipeline.CheckpointFingerprint {
+	return []pipeline.CheckpointFingerprint{{Name: "policy", Value: policy}}
+}
+
+func (v *Validator) Validate(_ context.Context, req contracts.TypedValidationRequest[dnd.EnemyEventList]) (contracts.ValidationResult, error) {
+	if enemyeventshape.Validate(req.Value) != nil {
+		return contracts.ValidationResult{Approved: true}, nil
+	}
+	resolver, err := shared.NewCitationResolver(req.Source)
+	if err != nil {
+		return contracts.ValidationResult{Approved: true}, nil
+	}
+	warnings := make([]contracts.Warning, 0)
+	for eventIndex, event := range req.Value.Events {
+		citedText, err := resolver.CitedText(event.SourceRefs)
+		if err != nil || shared.ContainsTokenSequence(citedText, event.Name) {
+			continue
+		}
+		warnings = append(warnings, contracts.Warning{
+			Scope:      fmt.Sprintf("events[%d]", eventIndex),
+			ReasonCode: WarningReasonCode,
+			Message: diagnostics.Aggregate("enemy event subject not near source", []string{
+				fmt.Sprintf("subject %s was not found in cited source text", diagnostics.Quote(event.Name)),
+			}),
+		})
+	}
+	return contracts.ValidationResult{Approved: true, Warnings: diagnostics.LimitWarnings(warnings, "enemy_events", OmittedReasonCode)}, nil
+}
+
+func Spec() pipeline.ValidatorSpec {
+	return pipeline.ValidatorSpec{Key: Key, ExecutionClass: contracts.ExecutionClassDeterministic}
+}
+
+func Register(registry *pipeline.ValidatorRegistry) error {
+	return pipeline.RegisterTypedValidatorBuilder(registry, dnd.EnemyEventListKind, Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.TypedValidator[dnd.EnemyEventList], error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return New(options), nil
+	})
+}
+
+func DecodeOptions(options map[string]any) (Options, error) {
+	if err := pipeline.RejectUnknownOptions(options); err != nil {
+		return Options{}, err
+	}
+	return Options{}, nil
+}
+
+func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }

internal/modules/dnd/validate/enemyevents/source_relatedness/validator_test.go

@@ -0,0 +1,66 @@
+package sourcerelatedness
+
+import (
+	"context"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+)
+
+func TestValidatorUsesOnlyCitedTranscriptEvidence(t *testing.T) {
+	value := validEventList()
+	references := contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{"npcs": {Items: []contracts.ReferenceItem{{Content: []byte("Ashfang")}}}}}
+	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Source: document("The party waits."), References: references, Value: value})
+	if err != nil || !result.Approved || len(result.Warnings) != 1 || result.Warnings[0].ReasonCode != WarningReasonCode {
+		t.Fatalf("Validate() = %#v, %v", result, err)
+	}
+}
+
+func TestValidatorAcceptsUnicodeSubjectInCitedEvidence(t *testing.T) {
+	value := validEventList()
+	value.Events[0].Name = "O'Rin Thorn"
+	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Source: document("o’rin\u2003thorn flees."), Value: value})
+	if err != nil || !result.Approved || len(result.Warnings) != 0 {
+		t.Fatalf("Validate() = %#v, %v", result, err)
+	}
+}
+
+func TestValidatorDefersMalformedValuesAndBoundsWarnings(t *testing.T) {
+	malformed := dnd.EnemyEventList{Events: []dnd.EnemyEvent{{Name: "Ashfang"}}}
+	result, err := New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Source: document("none"), Value: malformed})
+	if err != nil || !result.Approved || len(result.Warnings) != 0 {
+		t.Fatalf("shape deferral = %#v, %v", result, err)
+	}
+	value := dnd.EnemyEventList{Events: make([]dnd.EnemyEvent, 30)}
+	for index := range value.Events {
+		value.Events[index] = dnd.EnemyEvent{Name: "Missing", Kind: dnd.EnemyEventKindEngaged, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}}}
+	}
+	result, err = New(Options{}).Validate(context.Background(), contracts.TypedValidationRequest[dnd.EnemyEventList]{Source: document("none"), Value: value})
+	if err != nil || !result.Approved || len(result.Warnings) == 0 || result.Warnings[len(result.Warnings)-1].ReasonCode != OmittedReasonCode {
+		t.Fatalf("bounded warnings = %#v, %v", result, err)
+	}
+	registry := pipeline.NewValidatorRegistry()
+	if err := Register(registry); err != nil {
+		t.Fatal(err)
+	}
+	if Spec().Key != Key || Spec().ExecutionClass != contracts.ExecutionClassDeterministic {
+		t.Fatalf("Spec() = %#v", Spec())
+	}
+	if got := New(Options{}).CheckpointFingerprints(); len(got) != 1 || got[0].Value != policy {
+		t.Fatalf("CheckpointFingerprints() = %#v", got)
+	}
+	if _, err := DecodeOptions(map[string]any{"unexpected": true}); err == nil {
+		t.Fatal("DecodeOptions() accepted unknown option")
+	}
+}
+
+func validEventList() dnd.EnemyEventList {
+	return dnd.EnemyEventList{Events: []dnd.EnemyEvent{{Name: "Ashfang", Kind: dnd.EnemyEventKindFled, SourceRefs: []source.SourceRef{{SourceID: "session", StartUnitID: 1, EndUnitID: 1}}}}}
+}
+
+func document(text string) *source.SourceDocument {
+	return &source.SourceDocument{ID: "session", Units: []source.SourceUnit{{ID: 1, Text: text}}}
+}