## Phase 75: Themis Universal Originality Shield — Cross-Media IP Protection for All Generated Content

**Purpose:** Extend the Themis Music Shield (Phase 74) to cover EVERY form of
media generated across the entire Oshun ecosystem — visual art, video, text, 3D
models, characters, narrative, animation, fashion, game environments, and more.
Build unified cross-media compound detection, universal reference databases,
universal provenance/review/remediation/analytics, watermarking and content
authentication, and cross-media model governance. This is the complete IP
protection layer that gates all 31 content-generating domains.

**Scope:** ~60 new libraries under `libs/themis/` (TypeScript + Rust WASM + ONNX
Runtime for ML inference). Integrates with Phase 74 Music Shield and all
generating domains: Calliope, Euterpe, Isis, Hathor, Veritas, Maya, Yemaya, Aja,
Galatea, Aglaea, Psyche, Iris, Nous, Metis, Nisaba, Aphrodite, Bellona, Hestia.
Reference proposal:
`docs/domains/themis-universal-originality-shield-proposal.md`.

**Key Design Principles:**

- **Media-specific engines, shared infrastructure** — Each media type has
  detection engines tuned to its characteristics; risk scoring, provenance,
  review, and analytics are shared across all.
- **Cross-media compound detection** — A music video is music + visual + text;
  compound matches across media types targeting the same source escalate
  non-linearly.
- **Legally calibrated thresholds** — Every threshold grounded in case law and
  per-media-type protectability analysis.
- **Progressive scanning** — Fast pre-filters first, expensive deep scans only
  on content that survives pre-filters.

---

### 75.1 Visual Originality Shield — Core & Composition (`@themis/visual-shield`)

Protects all AI-generated images, artwork, illustrations, design assets, and
visual branding across Isis, Calliope, Yemaya, Aglaea, Galatea, Metis.

#### 75.1.1 Project Scaffolding & Core Types

- [x] **75.1.1.1** Create `libs/themis/visual-shield/` project scaffolding
      (project.json with Nx targets for build/test/lint; package.json as
      `@themis/visual-shield`; tsconfig.json extending base; vitest.config.ts;
      src/index.ts barrel export)
- [x] **75.1.1.2** Define visual shield core types (VisualScanRequest with image
      as Uint8Array | URL string, width/height, format 'png'|'jpg'|
      'webp'|'svg', generationPrompt optional string, modelId, metadata;
      VisualScanResult with overallRisk RiskLevel, compositionScore,
      embeddingScore, characterScore, faceScore, trademarkScore,
      memorizationScore, matches array of VisualMatch, scanDurationMs;
      VisualMatch with referenceId, referenceTitle, matchType 'composition'|
      'embedding'|'character'|'face'|'trademark'|'memorization'|'watermark',
      similarity 0-1, boundingBox optional, matchedRegion description)
- [x] **75.1.1.3** Define VisualScanEngine interface (name string, scan method
      accepting image + config returning element score, supported match types
      array, estimateLatency method)
- [x] **75.1.1.4** Implement VisualShieldPipeline orchestrator (coordinates all
      visual scan engines in parallel; pre-processes image — decode, normalize
      to RGB, resize to standard analysis resolution max 1024px; dispatches to
      enabled engines concurrently; aggregates results; fast-path mode with
      perceptual hash + CLIP only for < 2s latency; full scan runs all engines
      target < 5s)

#### 75.1.2 Image Composition Analysis

- [x] **75.1.2.1** Implement GIST descriptor extraction (extract holistic scene
      descriptor — 512D vector capturing spatial envelope via oriented Gabor
      filters at multiple scales and orientations; captures overall layout:
      subject placement, horizon line, perspective, spatial frequency
      distribution; compare via cosine similarity against reference database;
      threshold > 0.80 = compositionally similar)
- [x] **75.1.2.2** Implement spatial pyramid matching (divide image into 1×1,
      2×2, 4×4 grids hierarchically; extract feature histogram per cell using
      visual bag-of-words or CNN features; concatenate weighted histograms into
      single vector; compare pyramid vectors via histogram intersection kernel;
      captures both global and local spatial arrangement)
- [x] **75.1.2.3** Implement layout analysis (use object detection model to
      identify foreground subject, secondary elements, background; extract
      relative positions — subject centroid as fraction of image width/height,
      subject area as fraction of total, negative space distribution; compare
      layout descriptors between generated and reference images; two images with
      identical subject placement/framing flagged even with different content)
- [x] **75.1.2.4** Implement color histogram comparison (extract 3D color
      histogram in HSV space — 16 hue × 4 saturation × 4 value = 256 bins;
      normalize to probability distribution; compare using chi-squared distance
      or Earth Mover's Distance; color alone is not protectable but combined
      with composition strengthens compound score)
- [x] **75.1.2.5** Write composition analysis tests (test GIST on rotated/
      flipped images — should detect similarity; test spatial pyramid on images
      with same layout different content; test layout — same subject position
      scores high; test color histogram — same palette scores high, inverted
      scores low; minimum 30 tests)

#### 75.1.3 Neural Image Embedding Comparison

- [x] **75.1.3.1** Implement CLIP embedding extraction and comparison (load CLIP
      ViT-L/14 model via ONNX Runtime; extract 768D embedding per image; L2
      normalize; compare via cosine similarity; CLIP captures semantic visual
      similarity — 'the same thing' in different styles scores high;
      thresholds: > 0.85 cosine = FLAG, > 0.92 = REJECT; batch inference support
      for throughput; cache embeddings by image content hash)
- [x] **75.1.3.2** Implement DINOv2 embedding extraction and comparison (load
      DINOv2 ViT-B/14 or ViT-L/14 via ONNX Runtime; extract self-supervised
      visual embeddings 768D or 1024D; captures structural visual similarity
      without text-image alignment bias; better at detecting visual copies with
      different color grading or artistic filters than CLIP; compare via cosine
      similarity; threshold > 0.82 = FLAG)
- [x] **75.1.3.3** Implement SSCD copy detection (load Meta's Self-Supervised
      Copy Detection model via ONNX; purpose-built for detecting copies,
      near-duplicates, and manipulated versions of images; more robust than
      generic embeddings for exact copy detection; output 512D descriptor;
      compare via cosine similarity; threshold > 0.75 = likely copy; invariant
      to crops, color shifts, overlays, compressions)
- [x] **75.1.3.4** Implement perceptual hashing (implement pHash — DCT-based
      perceptual hash 64-bit; dHash — difference hash 64-bit; aHash — average
      hash 64-bit; compute all three for each image; compare via Hamming
      distance; pHash Hamming < 10 = near-duplicate; fast pre-filter — O(1)
      lookup against hash database in Redis; millions of images searchable in <
      1ms)
- [x] **75.1.3.5** Implement visual embedding database (store CLIP, DINOv2, SSCD
      embeddings in Qdrant vector database; support approximate nearest neighbor
      search with configurable top-K; index by reference work ID with metadata —
      title, artist, copyright holder, source; batch indexing for database
      population; incremental updates for new reference works)
- [x] **75.1.3.6** Write neural embedding tests (test CLIP — semantically
      similar images score > 0.80, unrelated < 0.30; test DINOv2 — same image
      with color filter still matches; test SSCD — cropped/overlaid copy still
      detected; test perceptual hash — same image through JPEG compression has
      Hamming < 5; test database — indexed image retrieved as top-1 match;
      minimum 35 tests)

#### 75.1.4 Character Recognition

- [x] **75.1.4.1** Implement fictional character detection classifier (fine-
      tune image classification model on dataset of copyrighted characters;
      character classes: Disney 50+ characters, Marvel 100+ characters, DC 50+
      characters, Nintendo 50+ characters, anime 200+ characters, other major
      franchises; multi-label classification — image may contain multiple
      characters; output per-character probability; threshold > 0.70 = character
      detected; handle stylistic variations — realistic renders, chibi, sketch,
      photographic)
- [x] **75.1.4.2** Implement character feature matching (extract character-
      defining visual features: dominant color palette via k-means on character
      region, silhouette shape via contour extraction, distinctive accessories
      via object detection, body proportions via pose estimation; encode as
      feature vector; compare against character database feature vectors via
      weighted Euclidean distance; catches characters that evade classifier —
      e.g., 'yellow humanoid with spiky hair' matching multiple characters)
- [x] **75.1.4.3** Implement character name-in-prompt detector (NER on
      generation prompts to detect copyrighted character names; maintain
      database of 10,000+ protected character names with aliases and common
      misspellings; phonetic matching for creative spellings — 'Pikachoo',
      'Micky Mouse'; flag BEFORE generation begins; block or inject negative
      constraints)
- [x] **75.1.4.4** Implement character silhouette comparison (extract foreground
      silhouette using segmentation model; compare silhouette shape against
      database of iconic character silhouettes using Hu moments and Fourier
      descriptors; many characters identifiable by silhouette alone — Batman,
      Mickey Mouse, Darth Vader, Pikachu; rotation and scale invariant
      comparison)
- [x] **75.1.4.5** Write character recognition tests (test classifier on known
      character images — correct identification; test stylistic variation —
      realistic Pikachu still detected; test feature matching — character with
      right colors/proportions/accessories matched; test prompt detection —
      'mickey mouse' flagged, 'a mouse cartoon' not flagged; test silhouette —
      Batman outline matched; minimum 35 tests)

#### 75.1.5 Face & Person Recognition

- [x] **75.1.5.1** Implement face detection pipeline (load RetinaFace or MTCNN
      model via ONNX; detect all faces in generated image with bounding boxes
      and landmarks; filter by face size — minimum 48×48 pixels for reliable
      recognition; output face crops, landmarks, and detection confidence per
      face)
- [x] **75.1.5.2** Implement face embedding extraction (load ArcFace or AdaFace
      model via ONNX; align face crops using landmarks; extract 512D face
      embedding per detected face; L2 normalize; these embeddings are biometric
      data — handle per GDPR requirements in EU jurisdictions)
- [x] **75.1.5.3** Implement protected person database (PostgreSQL with pgvector
      for face embedding storage; store: person name, known images count,
      embedding centroid from multiple reference images, consent status
      'consented'|'not_consented'|'unknown', jurisdiction notes; initial
      population: 100,000+ public figures/celebrities from open face datasets;
      support opt-in/opt-out management; GDPR-compliant data handling — purpose
      limitation, storage limitation, right to erasure)
- [x] **75.1.5.4** Implement face similarity comparison (compare detected face
      embeddings against protected person database using pgvector ANN search;
      cosine similarity thresholds: > 0.70 = FLAG, > 0.85 = REJECT unless
      consent verified; return top-5 matches with similarity scores; handle
      multiple faces per image — each face checked independently; consent
      verification — if matched person has consented, bypass flag)
- [x] **75.1.5.5** Implement deepfake indicator detection (analyze generated
      faces for synthetic media artifacts: inconsistent lighting/shadows, skin
      texture anomalies, eye reflection inconsistencies, hair boundary
      artifacts, temporal inconsistencies in video; output deepfake probability
      score; all AI-generated faces must be labeled per EU AI Act regardless of
      whether they match a real person)
- [x] **75.1.5.6** Write face recognition tests (test detection — face found in
      generated image; test embedding — same person different images cosine >
      0.85; different people cosine < 0.40; test database lookup — known
      celebrity matched; test consent bypass — consented person not flagged;
      test deepfake detection — synthetic face classified correctly; test GDPR —
      embeddings deletable on request; minimum 35 tests)

#### 75.1.6 Trademark & Logo Detection

- [x] **75.1.6.1** Implement logo detection model (fine-tune object detection
      model — YOLOv8 or RT-DETR — on trademark logo dataset; 1,000+ brand logo
      classes covering major global brands; output bounding boxes with brand
      classification and confidence; handle partial occlusion, rotation, and
      scale variation; detect both clean logos and logos embedded in generated
      scenes)
- [x] **75.1.6.2** Implement OCR text detection in images (use PaddleOCR or
      EasyOCR via ONNX to detect and extract text from generated images; compare
      extracted text against trademark database — brand names, product names,
      copyrighted phrases; flag images containing identifiable brand text;
      handle AI-generated garbled text that resembles brand names)
- [x] **75.1.6.3** Implement product identification (detect recognizable
      commercial products in generated images — specific car models, phones,
      sneakers, luxury goods, electronics; use object detection + brand
      classification; flag when generated images contain clearly identifiable
      trademarked products that could constitute trademark use in commerce)
- [x] **75.1.6.4** Write trademark detection tests (test logo detection — Nike
      swoosh detected in generated scene; test OCR — brand name text extracted;
      test product identification — specific car model recognized; test partial
      occlusion — partially visible logo still detected; minimum 25 tests)

#### 75.1.7 Training Data Memorization Detection

- [x] **75.1.7.1** Implement training data memorization detector (maintain SSCD
      embedding database of representative samples from known AI training
      datasets — LAION-5B subset, CC12M, OpenImages; compare generated images
      against database; SSCD cosine > 0.85 = potential memorization; also check
      perceptual hash — pHash Hamming < 8 against training data = near-verbatim
      reproduction)
- [x] **75.1.7.2** Implement watermark reproduction detector (train classifier
      to detect stock photo watermarks — Getty, Shutterstock, Alamy, iStock,
      Adobe Stock watermark patterns; scan generated images for watermark
      artifacts; any detected watermark is strong evidence of training data
      memorization and immediate REJECT)
- [x] **75.1.7.3** Implement style attribution advisory (use neural style
      analysis to quantify how much a generated image's style resembles specific
      known artists; output as advisory only — style is not copyrightable; but
      when style similarity is extreme AND combined with compositional
      similarity, elevate to FLAG; compare against database of 1,000+
      distinctive artist styles)
- [x] **75.1.7.4** Write memorization detection tests (test near-duplicate of
      training image detected; test watermark detection — synthetic Getty
      watermark flagged; test style attribution — generated image in distinctive
      artist style flagged as advisory; minimum 20 tests)

#### 75.1.8 Visual Shield Integration

- [x] **75.1.8.1** Implement composite visual similarity scorer (combine
      composition score × 0.10, neural embedding score × 0.30, character score ×
      0.25, face score × 0.20, trademark score × 0.10, memorization score ×
      0.05; if any single engine returns REJECT-level score, overall result is
      REJECT; output VisualScanResult with per-engine breakdown)
- [x] **75.1.8.2** Implement Isis integration adapter (hook into Isis text-to-
      image pipeline; scan every generated image before delivery to client;
      block delivery until scan completes; return scan result with image;
      support batch mode for factory generation runs)
- [x] **75.1.8.3** Implement Calliope integration adapter (hook into AI artist
      visual identity creation — album art, promotional images, social media
      visuals; per-artist configuration based on visual style; scan all visual
      assets before publication)
- [x] **75.1.8.4** Write visual shield end-to-end integration tests (test full
      pipeline — submit image → all engines run → composite score → decision;
      test known copyrighted character in generated image → REJECT; test
      celebrity face → FLAG; test brand logo → FLAG; test completely original
      image → PASS; test near-duplicate of training data → REJECT; minimum 30
      integration tests)

---

### 75.2 Text Originality Shield (`@themis/text-shield`)

Protects all AI-generated text — articles, dialogue, narratives, lyrics,
educational content, marketing copy, social posts across Veritas, Hathor, Iris,
Nisaba, Metis, Calliope.

#### 75.2.1 Project Scaffolding & Core Types

- [x] **75.2.1.1** Create `libs/themis/text-shield/` project scaffolding
      (project.json, package.json as `@themis/text-shield`, tsconfig.json,
      vitest.config.ts, src/index.ts)
- [x] **75.2.1.2** Define text shield core types (TextScanRequest with text
      string, contentType 'article'|'dialogue'|'narrative'|'educational'|
      'marketing'|'social'|'lyrics'|'script'|'general', language string,
      generationPrompt optional, modelId, metadata; TextScanResult with
      overallRisk RiskLevel, verbatimScore, semanticScore, narrativeScore,
      characterScore, brandScore, citationScore, matches array of TextMatch,
      scanDurationMs; TextMatch with referenceId, referenceTitle, matchType,
      similarity 0-1, queryExcerpt, referenceExcerpt, positions)

#### 75.2.2 Exact & Near-Exact Match Detection

- [x] **75.2.2.1** Implement verbatim text matching engine (tokenize text into
      words — lowercase, strip punctuation, normalize whitespace; extract
      character-level n-grams for n = 20, 50, 100 characters and word-level
      n-grams for n = 5, 8, 12 words; hash each n-gram using xxHash for speed;
      compare against reference corpus hash index via O(1) lookup; for each
      match, record matched text, position in query, reference work ID; score:
      weighted sum of matched n-grams / total, longer matches weighted
      exponentially — 50-word match scores 10× more than 5-word match)
- [x] **75.2.2.2** Implement near-duplicate detection via MinHash/SimHash
      (compute MinHash signature — 128 hash functions on 3-gram shingle set;
      estimate Jaccard similarity from MinHash signature overlap; threshold >
      0.60 Jaccard = FLAG as near-duplicate; also implement SimHash — 128-bit
      hash using random hyperplane projections; Hamming distance < 20 =
      structurally similar document; both methods support O(1) lookup via LSH
      banding for million-document scale)
- [x] **75.2.2.3** Implement cross-language text matching (load multilingual
      sentence transformer — mUSE or LaBSE via ONNX; encode text passages in
      source language; compare against reference passages in all indexed
      languages; detect when generated English text closely translates a
      copyrighted French/Spanish/German/Japanese/Chinese text; threshold > 0.85
      cross-lingual cosine = FLAG)
- [x] **75.2.2.4** Write exact matching tests (test verbatim — 50-word passage
      from known book detected; test near-duplicate — paraphrased passage
      detected via MinHash; test cross-language — English translation of French
      poem detected; test false positive — common phrases not flagged; minimum
      30 tests)

#### 75.2.3 Semantic Similarity Analysis

- [x] **75.2.3.1** Implement passage-level embedding comparison (load
      sentence-transformers model — all-MiniLM-L6-v2 or BGE-small via ONNX;
      encode each paragraph as 384D or 768D dense vector; compare against
      reference database via Qdrant ANN search; two passages conveying the same
      specific idea in completely different words score > 0.85 cosine; return
      top-K matches per paragraph with similarity scores and reference excerpts)
- [x] **75.2.3.2** Implement document-level embedding comparison (aggregate
      paragraph embeddings into document-level representation — weighted average
      by paragraph importance, or max-pooling; compare document vectors; catches
      cases where overall structure and argument flow are copied even though
      individual sentences differ; threshold > 0.80 = structurally similar
      documents)
- [x] **75.2.3.3** Implement contextual sequence matching (compare not just
      individual passages but their sequential ordering; two texts presenting
      the same sequence of specific arguments in the same order is stronger
      evidence than scattered similar passages; encode paragraph sequences as
      ordered lists of embeddings; compare sequence similarity using edit
      distance on embedding sequences with soft matching)
- [x] **75.2.3.4** Write semantic similarity tests (test paraphrase detection —
      same idea different words scores > 0.85; test unrelated passages score <
      0.30; test document-level — copied structure detected; test sequential —
      same argument order flagged; minimum 25 tests)

#### 75.2.4 Narrative & Plot Structure Analysis

- [x] **75.2.4.1** Implement plot event extraction (use LLM-based analysis to
      decompose narrative text into structured plot events: inciting incident,
      rising action events, climax, falling action, resolution; output as
      ordered list of PlotEvent objects with description, event type, characters
      involved, location, causal links to other events; support both short
      narratives and novel-length works)
- [x] **75.2.4.2** Implement plot structure comparison (compare extracted plot
      event sequences between generated and reference narratives; use sequence
      alignment — edit distance on event types with soft semantic matching on
      event descriptions; filter common structures — hero's journey, three-act
      structure, rags-to-riches are not protectable; flag when specific event
      sequences with specific causal relationships match at the expression
      level, not just at the structural/idea level)
- [x] **75.2.4.3** Implement character relationship graph extraction (extract
      character names via NER; identify relationships between characters from
      text — ally, enemy, romantic, familial, mentor/student, rival; construct
      character relationship graph; compare graphs between generated and
      reference works using graph isomorphism with soft matching on relationship
      types; isomorphic graphs with same relationship types suggest plot
      copying)
- [x] **75.2.4.4** Implement world-building element extraction (extract named
      fictional locations, rules/laws of the fictional world — magic systems,
      physics rules, political structures; extract historical events within the
      fiction, faction/organization names, unique terminology; compare against
      structured database of known fictional universes; detect when generated
      content is set in an existing copyrighted fictional universe —
      Middle-earth, Westeros, Hogwarts, etc.)
- [x] **75.2.4.5** Implement quest/mission structure comparison (for game
      narrative: extract quest objectives, branching decision points, reward
      structures, NPC interactions, prerequisite chains; compare against
      database of known game quests from major titles; flag when quest structure
      reproduces a specific known quest beyond generic patterns)
- [x] **75.2.4.6** Write narrative analysis tests (test plot extraction on known
      story — correct events identified; test plot comparison — two versions of
      the same story matched; test character graph — isomorphic relationships
      detected; test world-building — Hogwarts-like magic school detected; test
      quest structure — specific quest pattern matched; minimum 35 tests)

#### 75.2.5 Source Attribution & Brand Detection

- [x] **75.2.5.1** Implement factual claim detection (use NER + dependency
      parsing to identify factual claims — statistics, quotes, research
      findings, historical assertions; for each claim, check if attribution is
      present; flag unattributed claims that appear to originate from specific
      sources; for educational content, verify cited studies actually exist and
      citations are accurate)
- [x] **75.2.5.2** Implement brand/trademark detection in text (NER for brand
      names, product names, trademarked terms; maintain database of 100,000+
      trademarked phrases, slogans, and distinctive brand expressions — 'Just Do
      It', 'I'm Lovin' It', 'May the Force be with you', 'Winter is Coming';
      flag when generated text uses distinctive trademarked phrases;
      differentiate nominative fair use from trademark infringement)
- [x] **75.2.5.3** Implement common phrase filter (database of 50,000+ common
      text phrases, idioms, proverbs, genre clichés that are too common to be
      protectable; filter these from match results to reduce false positives;
      auto-expand: any phrase appearing in 200+ indexed works auto-classified as
      common)
- [x] **75.2.5.4** Write attribution and brand tests (test claim detection —
      unattributed statistic flagged; test brand detection — 'Just Do It'
      detected as Nike trademark; test common phrase filter — 'once upon a time'
      not flagged; minimum 20 tests)

#### 75.2.6 Text Shield Integration

- [x] **75.2.6.1** Implement composite text similarity scorer (combine verbatim
      score × 0.30, semantic score × 0.25, narrative/plot score × 0.20,
      character/world score × 0.10, brand score × 0.10, citation score × 0.05;
      content-type-aware weighting — journalism elevates verbatim weight,
      narrative elevates plot weight, educational elevates citation weight)
- [x] **75.2.6.2** Implement text reference database (passages from published
      works indexed by: verbatim n-gram hashes in Redis for O(1) lookup, passage
      embeddings in Qdrant for semantic search, full text in PostgreSQL for
      display; sources: Project Gutenberg public domain corpus, licensed excerpt
      databases, news article rolling 90-day index, academic paper abstracts,
      fictional universe structured databases with character
      names/locations/lore/magic systems)
- [x] **75.2.6.3** Implement domain integration adapters (Veritas — scan all
      generated articles/newsletters/social posts; Hathor — scan all generated
      dialogue/narrative/quest text; Iris — scan generated conversational
      responses for verbatim reproduction; Metis — scan educational content with
      citation verification; Nisaba — scan scholarly analysis; Calliope — scan
      artist bios and social content)
- [x] **75.2.6.4** Write text shield end-to-end integration tests (test verbatim
      article passage → FLAG; test paraphrased passage → FLAG via semantic; test
      novel set in Westeros → FLAG via world-building; test character graph
      matching Lord of the Rings → FLAG; test completely original text → PASS;
      test branded slogan → FLAG; test common phrase → PASS; minimum 30
      integration tests)

---

### 75.3 Video Originality Shield (`@themis/video-shield`)

Protects all AI-generated video across Isis, Calliope, Veritas, Yemaya, Uzume.

#### 75.3.1 Project Scaffolding & Types

- [x] **75.3.1.1** Create `libs/themis/video-shield/` project scaffolding
      (project.json, package.json as `@themis/video-shield`, tsconfig.json,
      vitest.config.ts, src/index.ts)
- [x] **75.3.1.2** Define video shield types (VideoScanRequest with video as
      Uint8Array | URL, durationMs, fps, resolution, hasAudio boolean;
      VideoScanResult with overallRisk, frameAnalysisResults array, sceneResults
      array, dialogueResults, audioResults from Music Shield, deepfakeScore,
      matches array, scanDurationMs; FrameResult with frameIndex, timestampMs,
      visualScanResult — delegated to Visual Shield; SceneResult with startMs,
      endMs, sceneType, matchedScenes array)

#### 75.3.2 Frame-Level Analysis

- [x] **75.3.2.1** Implement frame extraction and sampling (decode video to
      frames using FFmpeg via child process; configurable sample rate — default
      1fps for full scan, 0.2fps for quick scan; scene change detection using
      frame-to-frame histogram difference — when change exceeds threshold,
      extract additional keyframes around the change; output sampled frames as
      image buffers for Visual Shield analysis)
- [x] **75.3.2.2** Implement per-frame visual analysis (run each sampled frame
      through Visual Shield pipeline — neural embeddings, character recognition,
      face detection, trademark detection; parallelize across frames with
      configurable concurrency; aggregate frame-level results — character
      present in 10+ consecutive frames = strong flag; single frame = weak flag;
      track per-entity temporal presence)
- [x] **75.3.2.3** Implement temporal aggregation (aggregate per-frame
      detections over time; for each detected entity — character, face,
      trademark — compute total screen time in seconds, peak confidence, and
      temporal distribution; longer screen time = stronger evidence; output
      temporal summary per entity)

#### 75.3.3 Scene-Level Analysis

- [x] **75.3.3.1** Implement scene boundary detection (detect shot/scene changes
      using: color histogram difference, edge change ratio, and learned scene
      boundary detection; output scene segments with start/end timestamps and
      scene type classification — dialogue, action, montage, establishing,
      transition)
- [x] **75.3.3.2** Implement scene-level embedding comparison (extract
      scene-level representation — average CLIP embeddings across keyframes
      within a scene; compare against database of copyrighted scenes from
      films/TV; detect when a generated scene visually reproduces a copyrighted
      scene in composition, lighting, and content; threshold > 0.88 cosine =
      FLAG)
- [x] **75.3.3.3** Implement shot sequence matching (extract ordered sequence of
      shot types — wide, medium, close-up, POV, tracking, etc. using shot type
      classifier; compare shot type sequences between generated and reference
      video using sequence alignment; specific shot sequences reproduced in the
      same order may indicate scene copying)
- [x] **75.3.3.4** Implement montage pattern analysis (detect montage sequences
      — rapid editing with rhythmic cuts; extract edit rhythm — cut durations as
      time series; compare montage rhythms against reference database;
      distinctive montage patterns with specific timing may be protectable
      creative expression)

#### 75.3.4 Dialogue & Audio Analysis

- [x] **75.3.4.1** Implement speech extraction and transcription (extract audio
      track from video; run voice activity detection to isolate speech segments;
      transcribe using Whisper or equivalent ASR via ONNX; output timestamped
      text with speaker diarization; support multiple languages)
- [x] **75.3.4.2** Implement dialogue comparison (run transcribed dialogue
      through Text Shield pipeline — verbatim matching, semantic similarity;
      detect reproduction of copyrighted screenplay dialogue; weight matches by
      dialogue significance — memorable/quotable lines carry higher weight than
      generic exposition)
- [x] **75.3.4.3** Implement audio track delegation to Music Shield (extract
      audio track; if audio contains music — detected via music/speech
      classifier — route to Music Shield for full scan; aggregate Music Shield
      results into Video Shield result; handle background music, sound effects,
      and incidental audio separately)

#### 75.3.5 Deepfake & Synthetic Media Detection

- [x] **75.3.5.1** Implement synthetic video detection (load deepfake detection
      model via ONNX — e.g., EfficientNet-based detector; classify each video as
      synthetic/authentic; per-frame analysis with temporal consistency
      checking; detect GAN/diffusion artifacts, face manipulation, body
      manipulation; output deepfake probability score per video and per-face;
      ALL AI-generated video must be labeled regardless of content)
- [x] **75.3.5.2** Implement C2PA content provenance labeling (embed Coalition
      for Content Provenance and Authenticity metadata into all generated video;
      record: generation source 'oshun', model ID, timestamp, generation
      parameters; C2PA manifest signed with Oshun platform key; metadata
      survives reasonable transformations — transcoding, resizing; required by
      EU AI Act Article 50)
- [x] **75.3.5.3** Write video shield end-to-end tests (test copyrighted
      character in video → FLAG with temporal presence; test celebrity face in
      video → FLAG; test scene reproduction → FLAG; test dialogue reproduction →
      FLAG; test original video → PASS; test C2PA metadata embedded correctly;
      test audio delegation to Music Shield; minimum 30 tests)

#### 75.3.6 Video Shield Integration

- [x] **75.3.6.1** Implement composite video scorer (combine frame analysis ×
      0.30, scene analysis × 0.25, dialogue analysis × 0.20, audio analysis ×
      0.15, deepfake × 0.10; if character/face detection triggers REJECT in any
      frame, overall video is REJECT)
- [x] **75.3.6.2** Implement domain integration adapters (Isis — scan all
      text-to-video output; Calliope — scan all music videos; Veritas — scan
      generated news video; Yemaya — scan film/game cinematics)

---

### 75.4 3D Asset Originality Shield (`@themis/3d-shield`)

Protects AI-generated 3D models, environments, and assets across Isis, Maya,
Bellona.

#### 75.4.1 Project Setup & Shape Comparison

- [x] **75.4.1.1** Create `libs/themis/3d-shield/` project scaffolding
      (project.json, package.json as `@themis/3d-shield`, tsconfig.json,
      vitest.config.ts, src/index.ts)
- [x] **75.4.1.2** Define 3D shield types (Model3DScanRequest with mesh data as
      vertices Float32Array + indices Uint32Array, or glTF/glb/obj URL,
      textureUrls optional, metadata; Model3DScanResult with overallRisk,
      shapeScore, textureScore, characterScore, productScore, architectureScore,
      matches array, scanDurationMs)
- [x] **75.4.1.3** Implement point cloud comparison (convert input mesh to point
      cloud — sample 10K-100K surface points uniformly; normalize to unit
      bounding box centered at origin; PCA alignment for rotation invariance;
      compare using Chamfer distance and Earth Mover's Distance; threshold:
      Chamfer < 0.05 = similar shape; also implement Hausdorff distance for
      maximum deviation metric)
- [x] **75.4.1.4** Implement voxel occupancy comparison (voxelize 3D model at
      multiple resolutions — 32³, 64³, 128³; compare occupancy grids using
      Intersection over Union; IoU > 0.70 at 64³ = similar shape; fast
      pre-filter — voxelization is O(n) and comparison is O(v³);
      rotation-invariant via principal axis alignment)
- [x] **75.4.1.5** Implement neural 3D embeddings (load pre-trained 3D shape
      encoder — PointNet++ or Point-MAE via ONNX; extract fixed- length 256D or
      512D embedding from point cloud; compare via cosine similarity in Qdrant;
      captures semantic shape similarity — two different sword models score
      high; threshold > 0.80 = FLAG)
- [x] **75.4.1.6** Implement multi-view rendering comparison (render 3D model
      from 8 canonical viewpoints — front, back, left, right, top, 45° angles;
      run each rendered view through Visual Shield neural embedding comparison;
      aggregate view-level scores — if any view matches a reference above
      threshold, flag; catches visual similarity that may not be apparent from
      shape alone)

#### 75.4.2 Texture, Character & Product Detection

- [x] **75.4.2.1** Implement UV texture analysis (extract UV-mapped texture
      atlas from 3D model; run texture through Visual Shield pipeline for
      copyright analysis — perceptual hashing, SSCD, character detection,
      trademark detection; flag copyrighted patterns, logos, or images applied
      as textures to 3D models)
- [x] **75.4.2.2** Implement 3D character recognition (multi-view character
      detection — render from 8 views, run character classifier on each view;
      aggregate per-view character detections; also compare shape embeddings
      against database of known copyrighted 3D character models; flag when
      generated 3D model closely resembles copyrighted character)
- [x] **75.4.2.3** Implement product/brand detection in 3D (detect when
      generated 3D model represents a trademarked product — specific car models,
      consumer electronics, luxury goods, branded items; multi-view rendering +
      product classifier; compare silhouettes against design patent database for
      ornamental design similarity)
- [x] **75.4.2.4** Implement architectural work detection (for generated 3D
      buildings/structures: extract architectural features — facade pattern,
      roof form, window arrangement, decorative elements; compare against
      database of copyrighted architectural works — post-1990 commercial
      buildings protected under Architectural Works Copyright Protection Act;
      also detect reproduction of famous fictional architecture — Hogwarts,
      Rivendell, Jedi Temple)
- [x] **75.4.2.5** Implement asset library deduplication (maintain 3D embedding
      database of commercial asset library content — Sketchfab, TurboSquid,
      Unity Asset Store, Unreal Marketplace; detect when AI- generated 3D models
      reproduce exact meshes from commercial packs memorized during training;
      flag matches with asset library attribution requirements)
- [x] **75.4.2.6** Write 3D shield tests (test point cloud comparison — same
      model rescaled matches; test voxel IoU — similar shapes detected; test
      neural embeddings — semantically similar models match; test multi-view —
      copyrighted character in 3D flagged; test texture — logo on texture
      flagged; test architecture — famous building reproduced flagged; minimum
      35 tests)

---

### 75.5 Character Originality Shield (`@themis/character-shield`)

Cross-media character protection — unifies visual, text, voice, and animation
character matching across Calliope, Hathor, Psyche, Aphrodite.

#### 75.5.1 Project Setup & Implementation

- [x] **75.5.1.1** Create `libs/themis/character-shield/` project scaffolding
      (project.json, package.json as `@themis/character-shield`, tsconfig.json,
      vitest.config.ts, src/index.ts)
- [x] **75.5.1.2** Define character shield types (CharacterProfile with name,
      aliases array, visualDescriptors — colorPalette/silhouetteFeatures/
      distinctiveAccessories/bodyProportions, personalityTraits Big Five scores,
      backstoryElements — originEvent/motivation/keyRelationships/ abilities,
      voicePrintId optional, catchphrases array; CharacterMatch with
      referenceCharacterId, referenceName, matchType 'visual'|'name'|
      'profile'|'compound', similarity 0-1, matchedDimensions array)
- [x] **75.5.1.3** Implement character profile matching (accept generated
      CharacterProfile; compare against database of 50,000+ copyrighted
      characters: name collision detection — exact match, Levenshtein distance ≤
      2, phonetic match via Soundex/Metaphone; personality comparison — cosine
      similarity on Big Five trait vectors; backstory comparison — semantic
      similarity on backstory element descriptions; ability comparison —
      semantic similarity on ability descriptions; compound scoring — individual
      dimension matches escalate when multiple dimensions match the same
      reference character)
- [x] **75.5.1.4** Implement visual character matching (accept character image
      or 3D model; run through Visual Shield character recognition; additionally
      extract character-defining features — dominant colors via k-means,
      silhouette via segmentation, accessories via object detection, proportions
      via pose estimation; compare feature vector against character database;
      combine classifier output and feature matching for robust detection)
- [x] **75.5.1.5** Implement cross-media character compound detection (when a
      character has both visual and text profile, compound match across
      modalities: visual match to Character X AND name similar to Character X
      AND abilities similar to Character X = very strong compound; escalation: 2
      dimensions × 1.5, 3 dimensions × 2.5, 4+ dimensions × 4.0; a
      'golden-armored warrior named Mister Stank who builds powered suits' is
      clearly Tony Stark even without exact match on any single dimension)
- [x] **75.5.1.6** Implement archetype vs. specific character differentiation
      (maintain database of common character archetypes — the mentor, the chosen
      one, the trickster, the dark lord, the femme fatale; when a generated
      character matches an archetype but not a specific copyrighted character,
      classify as archetype match and do NOT flag; only flag when specificity
      exceeds archetype level — specific name + specific backstory + specific
      abilities = beyond archetype)
- [x] **75.5.1.7** Implement character database (PostgreSQL with: character
      profiles as structured JSONB, visual embeddings in pgvector, text
      embeddings for backstory/abilities in pgvector, name index for fast
      collision detection; populate with major franchises — Disney 500+, Marvel
      200+, DC 200+, Nintendo 100+, anime 2000+, literary 500+, game characters
      1000+, film/TV 1000+; support incremental updates as new copyrighted
      characters emerge)
- [x] **75.5.1.8** Write character shield tests (test name collision — 'Pikachu'
      flagged, 'Pikachew' flagged via phonetic; test visual matching — character
      with Batman's silhouette+colors flagged; test profile matching — Tony
      Stark personality+backstory+abilities combo flagged; test archetype —
      generic 'wise old mentor' NOT flagged; test cross-media compound —
      visual + name + abilities escalates; minimum 35 tests)

---

### 75.6 Motion & Animation Shield (`@themis/motion-shield`)

Protects against choreography infringement and unauthorized performer
replication across Aja, Calliope, Maya, Psyche.

#### 75.6.1 Project Setup & Implementation

- [x] **75.6.1.1** Create `libs/themis/motion-shield/` project scaffolding
      (project.json, package.json as `@themis/motion-shield`, tsconfig.json,
      vitest.config.ts, src/index.ts)
- [x] **75.6.1.2** Define motion shield types (MotionSequence with
      jointTrajectories as 2D array joints×frames of 3D positions, frameRate,
      jointNames array, durationMs; DanceMove with moveType string from
      vocabulary, startFrame, endFrame, confidence; ChoreographySequence as
      ordered array of DanceMove; MotionMatch with referenceId, matchType
      'sequence'|'choreography'|'style', similarity 0-1, matchedFrameRange)
- [x] **75.6.1.3** Implement joint trajectory comparison (accept two
      MotionSequence inputs; normalize for body proportions — scale to unit
      skeleton; align using Procrustes analysis; compare joint angle
      trajectories using Dynamic Time Warping — DTW on per-joint angle time
      series; aggregate across joints with anatomically-informed weighting —
      fingers low weight, torso/limbs high weight; output trajectory similarity
      0-1)
- [x] **75.6.1.4** Implement pose sequence matching (extract key poses every N
      frames using pose embedding — MotionBERT or PoseFormer via ONNX; encode
      pose sequences as embedding sequences; compare using sequence alignment
      with soft matching — cosine similarity on pose embeddings as match score;
      detect similar pose sequences even with different timing)
- [x] **75.6.1.5** Implement dance move vocabulary classification (classify
      individual motion segments into dance move vocabulary — 200+ move types
      across styles: ballet, hip-hop, contemporary, breakdancing, ballroom,
      folk, etc.; extract ordered sequence of move labels; individual common
      moves are NOT protectable; compare move sequences — 8+ specific moves in
      same order with similar timing = FLAG as potential choreography match)
- [x] **75.6.1.6** Implement choreography database (index registered
      choreographic works from US Copyright Office records; index well-known
      dance sequences from commercial performances, music videos, viral dances;
      store as MotionSequence + ChoreographySequence representations; support
      approximate matching for different performers/proportions)
- [x] **75.6.1.7** Implement performer style analysis (extract motion style
      features — average velocity, jerk profile, spatial range, rhythmic
      adherence, characteristic poses; compare against database of known
      performer motion profiles; flag when generated motion replicates a
      specific performer's distinctive movement style beyond generic technique;
      relevant for right of publicity claims)
- [x] **75.6.1.8** Implement performer consent verification (when motion is
      derived from mocap, verify the source performer has consented to the
      generated use; integrate with consent database; flag if mocap source
      performer is identifiable and consent not verified)
- [x] **75.6.1.9** Write motion shield tests (test trajectory comparison — same
      dance different performers matches; test pose sequence — similar sequence
      detected; test choreography — Fortnite dance sequence detected in
      generated animation; test performer style — distinctive style matched;
      test consent — unconsented mocap flagged; test common moves — single move
      NOT flagged; minimum 30 tests)

---

### 75.7 Fashion & Design Shield (`@themis/fashion-shield`)

Protects against design patent infringement, trade dress violation, and
pattern/print copyright across Galatea, Aglaea, Calliope.

#### 75.7.1 Project Setup & Implementation

- [x] **75.7.1.1** Create `libs/themis/fashion-shield/` project scaffolding
      (project.json, package.json as `@themis/fashion-shield`, tsconfig.json,
      vitest.config.ts, src/index.ts)
- [x] **75.7.1.2** Define fashion shield types (FashionDesignScan with
      designImage Uint8Array, designType 'garment'|'accessory'|'jewelry'|
      'footwear'|'print_pattern'|'textile', metadata; FashionScanResult with
      overallRisk, patternScore, tradeDressScore, designPatentScore, brandScore,
      matches array; FashionMatch with referenceId, matchType
      'pattern'|'trade_dress'|'design_patent'|'brand_element', similarity)
- [x] **75.7.1.3** Implement textile pattern comparison (extract pattern repeat
      unit from generated design using autocorrelation on image; compare repeat
      unit against database of copyrighted textile designs using SSCD +
      perceptual hash; handle rotations, color variations, and scale changes;
      threshold: SSCD > 0.80 = FLAG)
- [x] **75.7.1.4** Implement trade dress matching (maintain database of
      protected trade dress elements — Birkin bag shape, red soles from
      Louboutin, Burberry check pattern, Louis Vuitton monogram, Chanel quilted
      diamond pattern; extract design features via Visual Shield; compare
      against trade dress database; flag when generated design is 'confusingly
      similar' to established brand identity)
- [x] **75.7.1.5** Implement design patent comparison (compare generated design
      silhouettes and ornamental features against registered design patents —
      USPTO, EUIPO databases; use multi-view rendering comparison for 3D
      designs; use contour/shape matching for 2D patterns; flag designs within
      the 'scope of equivalents' of a registered patent)
- [x] **75.7.1.6** Implement brand element detection (detect fashion brand
      identifiers in generated designs — logos, monograms, distinctive hardware,
      signature stitching patterns; use Visual Shield trademark detector
      specialized for fashion context; flag unauthorized use of brand elements)
- [x] **75.7.1.7** Write fashion shield tests (test pattern comparison —
      copyrighted print detected; test trade dress — Birkin-shaped bag flagged;
      test brand elements — LV monogram on generated bag flagged; test original
      design → PASS; minimum 25 tests)

---

### 75.8 Environment & Level Shield (`@themis/environment-shield`)

Protects generated game levels, virtual worlds, and architectural designs across
Maya, Hathor, Yemaya.

#### 75.8.1 Project Setup & Implementation

- [x] **75.8.1.1** Create `libs/themis/environment-shield/` project scaffolding
      (project.json, package.json as `@themis/environment-shield`,
      tsconfig.json, vitest.config.ts, src/index.ts)
- [x] **75.8.1.2** Define environment shield types (EnvironmentScan with
      levelData — navigation graph or mesh, screenshots array, metadata
      including gameGenre; EnvironmentScanResult with overallRisk, layoutScore,
      aestheticScore, architectureScore, matches; NavigationGraph with nodes
      array of {id, position3D, type 'room'| 'corridor'|'open_area'|'hub'},
      edges array of {from, to, type 'door'|'passage'|'ladder'|'portal'})
- [x] **75.8.1.3** Implement level layout comparison (convert level data to
      NavigationGraph; compare graph topology using graph edit distance; also
      compare: node degree distribution, clustering coefficient, average path
      length, betweenness centrality distribution; similar topological
      properties suggest copied level design; filter common structures —
      hub-and-spoke, linear corridor, arena are generic)
- [x] **75.8.1.4** Implement environmental aesthetics comparison (extract
      aesthetic features from level screenshots — color palette, lighting mood,
      vegetation density, weather, architectural style, material palette;
      compare against database of copyrighted game environments; detect when
      generated environment closely reproduces the distinctive aesthetics of a
      specific copyrighted game — e.g., Hollow Knight's distinctive muted
      blue-green underground aesthetic)
- [x] **75.8.1.5** Implement architectural detection (for virtual buildings:
      extract architectural features — facade patterns, window arrangements,
      roof forms, decorative elements, structural proportions; compare against
      database of copyrighted real buildings and famous fictional architecture;
      flag reproduction of post-1990 copyrighted buildings and recognizable
      fictional structures)
- [x] **75.8.1.6** Write environment shield tests (test level layout — copied
      graph topology detected; test aesthetics — specific game environment style
      matched; test architecture — real building reproduction flagged; test
      generic layout — hub-and-spoke NOT flagged; minimum 20 tests)

---

### 75.9 Cross-Media Compound Detection (`@themis/compound-detector`)

Detects when multiple media types from the same generated content simultaneously
match the same copyrighted source — the strongest evidence of infringement.

#### 75.9.1 Project Setup & Implementation

- [x] **75.9.1.1** Create `libs/themis/compound-detector/` project scaffolding
      (project.json, package.json as `@themis/compound-detector`, tsconfig.json,
      vitest.config.ts, src/index.ts)
- [x] **75.9.1.2** Define compound detection types (CompoundScanRequest with
      contentType 'music_video'|'game_level'|'film_scene'|'educational_lesson'|
      'avatar_interaction'|'virtual_world'|'fashion_presentation'|'interactive',
      components map of mediaType → scan result from that media's shield;
      CompoundScanResult with compoundMatches array of CompoundMatch each with
      referenceWorkId, matchedMediaTypes array, perMediaScores map,
      compoundMultiplier, aggregateCompoundScore, riskLevel)
- [x] **75.9.1.3** Implement media decomposition (accept multi-modal content;
      decompose into component media types: music video → audio track + video
      frames + lyrics text + character visuals; game level → 3D environment +
      narrative text + audio + character models; educational lesson → text +
      images + diagrams + audio; route each component to its appropriate shield
      for independent scanning)
- [x] **75.9.1.4** Implement cross-correlation engine (after all component scans
      complete, correlate matches across media types; group matches by reference
      work ID; for each reference work with matches across 2+ media types,
      create CompoundMatch; apply escalation multipliers: 2 media types × 1.5, 3
      types × 2.5, 4+ types × 4.0; a music video where audio matches Song X AND
      visuals match Song X's music video AND lyrics match Song X's lyrics =
      3-way compound × 2.5)
- [x] **75.9.1.5** Implement IP holder cross-reference (resolve matched works to
      IP holders; compound matches against works owned by the same entity carry
      additional risk — a single rights holder is more likely to litigate when
      multiple elements are copied; flag when compound matches are concentrated
      on a single rights holder)
- [x] **75.9.1.6** Write compound detection tests (test 2-way compound — music +
      visual matching same work escalates; test 3-way compound — music +
      visual + text matching same work escalates more; test independent matches
      — music matches Work A, visual matches Work B, no compound escalation;
      test IP holder concentration — multiple matches to same label flagged;
      minimum 25 tests)

---

### 75.10 Universal Reference Database (`@themis/universal-reference-db`)

Single unified database infrastructure serving all media-specific shields.

#### 75.10.1 Project Setup & Schema

- [x] **75.10.1.1** Create `libs/themis/universal-reference-db/` project
      scaffolding (project.json, package.json as
      `@themis/universal-reference-db`, tsconfig.json, vitest.config.ts,
      src/index.ts)
- [x] **75.10.1.2** Define universal schema extending Music Shield's schema
      (VisualReference table: id, referenceWorkId FK, clipEmbedding vector(768),
      dinoEmbedding vector(1024), sscdEmbedding vector(512), pHash bytea, dHash
      bytea, imageType 'artwork'|'photo'|'illustration'|'screenshot', width,
      height; CharacterReference table: id, characterName, franchise,
      copyrightHolder, visualEmbeddings array, profileEmbedding vector(768),
      silhouetteDescriptor, aliases text array; FaceReference table: id,
      personName, faceEmbedding vector(512), consentStatus, jurisdiction;
      TrademarkReference table: id, markName, owner, registrationNumber,
      visualEmbedding vector(768), markType
      'logo'|'word'|'design'|'trade_dress'; TextReference table: id,
      referenceWorkId FK, ngramHashes text array, passageEmbeddings vector
      array, fullText, contentType, language; Model3DReference table: id,
      referenceWorkId FK, pointCloudEmbedding vector(512), multiViewEmbeddings
      array; FictionalUniverse table: id, universeName, franchise, characters
      text array, locations text array, rules text array, embedding vector(768))
- [x] **75.10.1.3** Implement Drizzle ORM schema and migrations for all new
      tables (pgvector indexes on all embedding columns using HNSW; GIN indexes
      on array columns; composite indexes; migration chain from Music Shield
      schema)

#### 75.10.2 Multi-Media Ingestion Pipelines

- [x] **75.10.2.1** Implement visual reference ingestion pipeline (sources:
      WikiArt 250K+ artworks, museum API collections — MET, Rijksmuseum,
      Europeana; stock photo libraries via API; album cover databases; movie
      poster databases; game art databases; extract CLIP + DINOv2 + SSCD
      embeddings + perceptual hashes; batch processing via BullMQ workers;
      target: 50M+ visual references indexed)
- [x] **75.10.2.2** Implement character database population (curate character
      profiles for major franchises; sources: fan wikis — structured data
      extraction, official franchise databases, manually curated profiles for
      top 1,000 characters; extract visual embeddings from multiple reference
      images per character; compute profile embeddings from text descriptions;
      target: 50,000+ characters)
- [x] **75.10.2.3** Implement face database population (sources: open face
      datasets for public figures — CelebA, VGGFace2 for research; licensed
      celebrity image databases; extract ArcFace/AdaFace embeddings;
      GDPR-compliant handling — purpose limitation, consent tracking; opt-out
      support — individuals can request removal; target: 1M+ faces)
- [x] **75.10.2.4** Implement trademark database population (sources: USPTO
      Trademark Electronic Search System, EUIPO eSearch, WIPO Global Brand
      Database; extract visual representations of registered marks; compute
      visual embeddings; index by classification — Nice classification for
      trademark classes; target: 100,000+ marks)
- [x] **75.10.2.5** Implement text reference corpus building (sources: Project
      Gutenberg for public domain — 70,000+ books; licensed excerpt databases;
      news article APIs — AP, Reuters — rolling 90-day index; academic paper
      abstracts — Semantic Scholar API; fictional universe structured databases
      — manually curated; compute n-gram hashes and passage embeddings; target:
      10M+ passages)
- [x] **75.10.2.6** Implement 3D model reference ingestion (sources: Sketchfab —
      publicly available 3D models; asset library catalogs; extract point cloud
      embeddings and multi-view renderings; focus on commercially significant
      models — popular game characters, branded products, architectural works;
      target: 5M+ models)
- [x] **75.10.2.7** Implement unified query interface (single API for querying
      across all reference collections; media-type-aware routing — visual query
      → visual reference tables, text query → text reference tables; support
      cross-media queries — 'find all references for this IP holder across all
      media types'; pagination, filtering, sorting)
- [x] **75.10.2.8** Write reference database tests (test visual ingestion —
      artwork correctly indexed with embeddings; test character population —
      character profile searchable; test face database — celebrity found by
      embedding similarity; test trademark — logo matched; test text — passage
      found by n-gram and by embedding; test unified query — cross- media
      results returned; minimum 35 tests)

---

### 75.11 Universal Risk Scoring (`@themis/universal-risk-scoring`)

Extends Music Shield risk scoring to all media types with cross-media compound
escalation.

#### 75.11.1 Implementation

- [x] **75.11.1.1** Create `libs/themis/universal-risk-scoring/` project
      scaffolding (project.json, package.json as
      `@themis/universal-risk-scoring`, tsconfig.json, vitest.config.ts,
      src/index.ts)
- [x] **75.11.1.2** Implement media-type-specific weight tables (configurable
      element weights per media type based on legal protectability: Visual:
      composition 0.15, neural embedding 0.25, character 0.25, face 0.20,
      trademark 0.10, memorization 0.05; Text: verbatim 0.30, semantic 0.25,
      narrative 0.20, character 0.10, brand 0.10, citation 0.05; Video: frame
      0.25, scene 0.25, dialogue 0.20, audio 0.20, deepfake 0.10; 3D: shape
      0.30, texture 0.15, character 0.25, product 0.20, architecture 0.10;
      Character: visual 0.30, name 0.20, profile 0.25, abilities 0.15,
      cross-media 0.10; Motion: trajectory 0.30, choreography 0.30, style 0.20,
      consent 0.20; Fashion: pattern 0.30, trade_dress 0.30, design_patent 0.25,
      brand 0.15; Environment: layout 0.30, aesthetics 0.35, architecture 0.35)
- [x] **75.11.1.3** Implement cross-media compound risk aggregation (accept
      compound detection results; integrate compound scores into overall risk;
      compound matches escalate the overall risk level even when individual
      media-type scans are below threshold; a music video where music is
      ADVISORY + visual is ADVISORY + text is ADVISORY but all target the same
      work should escalate to FLAG or higher)
- [x] **75.11.1.4** Implement per-jurisdiction rules for all media types (extend
      Music Shield's jurisdiction engine: US — apply relevant test per media
      type, Arnstein for music, abstraction-filtration for text/ narrative,
      substantial similarity for visual; EU — author's own intellectual creation
      standard plus TDM opt-out; UK — substantial part test; add
      media-type-specific considerations — US Architectural Works Act for 3D
      buildings, Star Athletica separability for fashion, choreography
      registration requirement for dance)
- [x] **75.11.1.5** Write universal risk scoring tests (test per-media weights —
      visual character match contributes 25% of visual score; test cross-media
      compound — compound escalates overall risk; test per-jurisdiction —
      different risk levels for US vs EU on same content; test threshold
      classification — boundary cases correct; minimum 30 tests)

---

### 75.12 Universal Provenance System (`@themis/universal-provenance`)

Extends Music Shield provenance to all media types with cross-media linkage.

#### 75.12.1 Implementation

- [x] **75.12.1.1** Create `libs/themis/universal-provenance/` project
      scaffolding (project.json, package.json as `@themis/universal-provenance`,
      tsconfig.json, vitest.config.ts, src/index.ts)
- [x] **75.12.1.2** Implement content-addressed storage (every generated content
      piece — image, text, video, 3D model, character profile, motion sequence —
      receives a SHA-256 content hash; all provenance events reference this
      hash; enables tamper detection and deduplication; content hash is the
      universal identifier across all shield systems)
- [x] **75.12.1.3** Implement cross-media project linkage (when a creative
      project produces multiple media outputs — e.g., a music video produces
      audio file + video file + lyrics text + character art; link all outputs to
      a single project record; project-level provenance view shows all media
      components and their individual scan results; enables holistic legal
      review of compound content)
- [x] **75.12.1.4** Implement legal discovery interface (single query endpoint:
      given a content hash, generation ID, or project ID, return the complete
      provenance chain — generation parameters, model provenance, scan results,
      decision chain, human review records; output as structured JSON and
      human-readable PDF report; sufficient for legal discovery in litigation)
- [x] **75.12.1.5** Write provenance tests (test content hashing — same content
      same hash, modified content different hash; test cross-media linkage — all
      components of a project linked; test legal discovery — complete chain
      reconstructable from any entry point; minimum 20 tests)

---

### 75.13 Universal Human Review (`@themis/universal-review`)

Shared human review infrastructure for all media types.

#### 75.13.1 Implementation

- [x] **75.13.1.1** Create `libs/themis/universal-review/` project scaffolding
      (project.json, package.json as `@themis/universal-review`, tsconfig.json,
      vitest.config.ts, src/index.ts)
- [x] **75.13.1.2** Extend review queue to support all media types (unified
      BullMQ priority queue; review items include media type and applicable
      comparison tools; priority calculation includes media-type-specific risk
      factors — visual deepfake of celebrity = P1, text near-duplicate = P3;
      same SLA across all media types)
- [x] **75.13.1.3** Implement specialized reviewer pool management (reviewer
      expertise types: musicologist, art_historian, film_analyst, game_designer,
      ip_attorney, journalist, fashion_expert, 3d_artist, choreographer,
      literary_analyst; route review items to qualified reviewers; support
      multi-expert review for compound content — a flagged music video may need
      musicologist + art historian + IP attorney)
- [x] **75.13.1.4** Implement cross-media review interface API (for compound
      content: serve all media components side by side with their respective
      matches; synchronized playback for audio/video; split-screen for visual
      comparison; diff view for text comparison; 3D model viewer with reference
      model overlay; timeline view for motion comparison)
- [x] **75.13.1.5** Write universal review tests (test multi-media routing —
      flagged music video assigned to musicologist + art historian; test
      cross-media review data — all components served with matches; test unified
      SLA — items from all media types tracked; minimum 20 tests)

---

### 75.14 Universal Remediation (`@themis/universal-remediation`)

Media-specific remediation with shared orchestration.

#### 75.14.1 Implementation

- [x] **75.14.1.1** Create `libs/themis/universal-remediation/` project
      scaffolding (project.json, package.json as
      `@themis/universal-remediation`, tsconfig.json, vitest.config.ts,
      src/index.ts)
- [x] **75.14.1.2** Implement visual remediation engine (when image is flagged:
      composition modification — shift subject position, alter framing; color
      palette shift; character redesign — modify defining features to break
      match; face modification — adjust features to reduce likeness; trademark
      removal — inpaint over detected logos; regenerate with negative
      constraints — 'do not generate [matched character/person]'; re-scan
      through Visual Shield to verify clearance)
- [x] **75.14.1.3** Implement text remediation engine (when text is flagged:
      rewrite flagged passages preserving meaning — synonym substitution,
      sentence restructuring; character renaming and trait modification; plot
      divergence — alter flagged plot events while preserving narrative arc;
      world-building modification — change setting details to diverge from
      copyrighted universe; brand removal — replace trademarked phrases with
      generic alternatives; re-scan through Text Shield to verify)
- [x] **75.14.1.4** Implement video remediation engine (when video is flagged:
      re-render flagged scenes with modified composition; replace detected
      character/face appearances; modify dialogue — regenerate or re-voice;
      re-grade color to diverge from matched scene; re-scan through Video Shield
      to verify; handle audio track remediation via Music Shield)
- [x] **75.14.1.5** Implement 3D remediation engine (when 3D model is flagged:
      mesh deformation — alter proportions to break shape match; texture
      regeneration — replace flagged textures; character redesign — modify
      defining features; product modification — alter design elements that
      trigger trademark match; re-scan through 3D Shield to verify)
- [x] **75.14.1.6** Implement remediation orchestrator (accept flagged content
      of any media type; route to appropriate media-specific remediation engine;
      run remediation → re-scan loop — max 5 iterations; if still flagged after
      5 attempts, escalate to human review; track remediation success rate per
      media type; preserve creative intent metadata for all remediations)
- [x] **75.14.1.7** Write remediation tests (test visual — character redesigned
      clears scan; test text — rewritten passage clears scan; test 3D — deformed
      mesh clears scan; test iterative loop — converges within 5 attempts; test
      creative intent preservation; minimum 25 tests)

---

### 75.15 Universal Analytics (`@themis/universal-analytics`)

Cross-media monitoring and continuous improvement.

#### 75.15.1 Implementation

- [x] **75.15.1.1** Create `libs/themis/universal-analytics/` project
      scaffolding (project.json, package.json as `@themis/universal-analytics`,
      tsconfig.json, vitest.config.ts, src/index.ts)
- [x] **75.15.1.2** Implement cross-media analytics dashboard data provider
      (aggregated metrics across all media shields: total scans per media type,
      risk level distribution per media type, average/P95/P99 latency per media
      type, FP/FN rates per media type, most frequently matched reference works,
      match distribution by element type; Prometheus metrics export for Grafana;
      time-series aggregation by hour/day/week/month)
- [x] **75.15.1.3** Implement media-type risk comparison (which media types
      produce the most flags? which generation models across which domains
      produce the most flagged content? which reference works are most
      frequently matched? trend analysis — is a specific media type's flag rate
      increasing or decreasing? alert when a media type's flag rate exceeds 2×
      its historical average)
- [x] **75.15.1.4** Implement cross-media legal landscape monitor (extend Music
      Shield's legal monitor to track: visual art AI cases — Andersen v.
      Stability AI, Getty v. Stability AI; text AI cases — NYT v. OpenAI; voice
      AI legislation — NO FAKES Act, ELVIS Act; deepfake legislation;
      fashion/design patent cases; choreography cases; alert when new decisions
      or legislation may affect any media shield's thresholds)
- [x] **75.15.1.5** Write analytics tests (test cross-media metrics — correct
      aggregation across media types; test risk comparison — highest flag media
      type correctly identified; test legal monitor — new case triggers alert;
      minimum 15 tests)

---

### 75.16 Watermarking & Content Authentication (`@themis/watermarking`)

Protect Oshun's own generated content and provide AI generation transparency.

#### 75.16.1 Implementation

- [x] **75.16.1.1** Create `libs/themis/watermarking/` project scaffolding
      (project.json, package.json as `@themis/watermarking`, tsconfig.json,
      vitest.config.ts, src/index.ts)
- [x] **75.16.1.2** Implement C2PA content provenance for all media types (embed
      Coalition for Content Provenance and Authenticity metadata into: images —
      EXIF/XMP C2PA manifest; video — MP4 container C2PA metadata; audio —
      ID3/FLAC C2PA tags; 3D models — glTF extras; text — document metadata
      JSON; each manifest includes: generator 'oshun', model ID, timestamp,
      generation parameters; signed with Oshun platform key; required by EU AI
      Act Article 50 for synthetic media)
- [x] **75.16.1.3** Implement invisible audio watermarking (extend existing @aja
      watermarking; embed inaudible watermark in all generated audio; watermark
      encodes: generation ID, timestamp, model ID; robust against MP3 encoding,
      volume changes, mild EQ; detectable by Oshun's extraction tool; purpose:
      trace leaked content back to generation source)
- [x] **75.16.1.4** Implement invisible image watermarking (embed invisible
      watermark in all generated images using DCT-domain spread spectrum;
      watermark encodes: generation ID, timestamp; robust against JPEG
      compression, resizing, cropping, mild filters; not robust against
      screenshot — that's acceptable, forensic purpose not DRM)
- [x] **75.16.1.5** Implement video watermarking (extend existing @aja and
      @aphrodite video watermarking; per-frame invisible watermark + temporal
      watermark across frames; watermark encodes generation ID; robust against
      transcoding and reasonable compression)
- [x] **75.16.1.6** Implement watermark extraction service (accept any Oshun-
      generated content; detect and extract embedded watermark; return
      generation ID, timestamp, model ID; support all media types — audio,
      image, video; used by leak detection and provenance verification)
- [x] **75.16.1.7** Implement leak detection pipeline (periodically scan public
      platforms for Oshun-watermarked content appearing without authorization;
      integrate with: YouTube via Content ID API, social media platform APIs
      where available, web crawling for image reverse search; when unauthorized
      use detected: log in provenance system, alert content team, optionally
      auto-generate DMCA takedown notice with full provenance evidence)
- [x] **75.16.1.8** Write watermarking tests (test C2PA — metadata embedded and
      extractable for each media type; test audio watermark — survives MP3
      encoding; test image watermark — survives JPEG + resize; test video
      watermark — survives transcoding; test extraction service — correct
      generation ID recovered; test leak detection pipeline — mock leaked
      content triggers alert; minimum 30 tests)

---

### 75.17 Cross-Media Model Governance (`@themis/cross-media-governance`)

Extends model governance to all generation models across all domains.

#### 75.17.1 Implementation

- [x] **75.17.1.1** Create `libs/themis/cross-media-governance/` project
      scaffolding (project.json, package.json as
      `@themis/cross-media-governance`, tsconfig.json, vitest.config.ts,
      src/index.ts)
- [x] **75.17.1.2** Implement cross-media training data audit framework (extend
      Music Shield's training data audit to: image models — audit LAION/CC12M
      for copyright, verify Getty/Shutterstock content excluded or licensed;
      text models — audit training corpora for copyrighted books/articles,
      verify fair use analysis; video models — audit clip datasets for
      copyrighted film/TV; 3D models — audit asset library licensing; motion
      models — audit mocap performer consent; output per-model compliance report
      across all data types)
- [x] **75.17.1.3** Implement cross-media memorization testing framework (extend
      Music Shield's memorization testing: image models — feed prompts designed
      to reproduce training images, measure SSCD; text models — feed prompts to
      reproduce training text, measure n-gram overlap; video models — measure
      per-frame similarity; 3D models — measure shape similarity; per-model
      memorization report with flagged high-memorization content areas)
- [x] **75.17.1.4** Implement cross-media red-teaming framework (systematic
      adversarial testing before deployment for ALL generation models: image
      models — can it generate copyrighted characters? real people? trademarked
      products? text models — can it reproduce copyrighted passages verbatim?
      specific plots? video models — can it reproduce copyrighted scenes? 3D
      models — can it reproduce copyrighted assets? per-model vulnerability
      report with pass/fail per category)
- [x] **75.17.1.5** Implement unified opt-out registry (single registry for all
      opt-out requests: artists opting out of visual AI training, musicians
      opting out of music AI training, authors opting out of text AI training,
      performers opting out of motion AI training, individuals opting out of
      face/voice replication; cross-referenced against all model training
      manifests; compliance verification before model deployment)
- [x] **75.17.1.6** Write cross-media governance tests (test training audit —
      non-compliant dataset flagged across media types; test memorization —
      known memorized content detected per media type; test red-team —
      copyrighted character reproduction caught; test opt-out — opted-out artist
      excluded from all relevant training; minimum 25 tests)

---

### 75.18 Domain Integration Adapters

Connect every generating domain to the appropriate shields.

#### 75.18.1 Implementation

- [x] **75.18.1.1** Implement universal shield gateway (single entry point for
      all domains; accepts content of any media type; auto-detects media type
      from content or accepts explicit type; routes to appropriate shield(s);
      for multi-modal content, decomposes and routes components to multiple
      shields then runs compound detection; returns unified scan result; HTTP
      API + TypeScript SDK)
- [x] **75.18.1.2** Implement Calliope universal adapter (Calliope generates:
      music → Music Shield, visual identity → Visual Shield, music videos →
      Video Shield + Music Shield + Visual Shield, artist bios/social → Text
      Shield, character personas → Character Shield, dance animations → Motion
      Shield, fashion/style → Fashion Shield; configure per-artist based on
      their creative outputs; scan everything before publication)
- [x] **75.18.1.3** Implement Isis universal adapter (Isis generates: images →
      Visual Shield, video → Video Shield, 3D models → 3D Shield, audio → Music
      Shield, text → Text Shield; batch mode for factory runs; all outputs
      gated)
- [x] **75.18.1.4** Implement Hathor adapter (Hathor generates: dialogue/
      narrative → Text Shield, character profiles → Character Shield, quest
      designs → Text Shield narrative analysis, world-building → Text Shield
      world-building detection, game environments → Environment Shield)
- [x] **75.18.1.5** Implement Veritas adapter (Veritas generates: articles →
      Text Shield with journalism weighting, news video → Video Shield, images →
      Visual Shield, social posts → Text Shield, newsletters → Text Shield; hot
      news detection active for all news content)
- [x] **75.18.1.6** Implement Maya/Yemaya adapter (Maya/Yemaya generate: game
      environments → Environment Shield, 3D assets → 3D Shield, character models
      → Character Shield + 3D Shield, cinematics → Video Shield, game audio →
      Music Shield, game animations → Motion Shield)
- [x] **75.18.1.7** Implement remaining domain adapters (Aja → Motion Shield;
      Galatea/Aglaea → Fashion Shield + Visual Shield; Psyche → Character
      Shield + Text Shield + Motion Shield; Iris → Text Shield; Nous → Music
      Shield; Metis/Nisaba → Text Shield with educational/scholarly weighting;
      Aphrodite → all shields as applicable; Bellona → 3D Shield; Hestia → Text
      Shield + Visual Shield)
- [x] **75.18.1.8** Write domain adapter tests (test Calliope — music video
      routes to 3 shields + compound; test Isis — image routes to Visual Shield;
      test Hathor — narrative routes to Text Shield + Character Shield; test
      gateway auto-detection — image/text/audio correctly classified; minimum 25
      tests)

---

### 75.19 Regulatory Compliance Automation

Automate compliance with AI content regulations across jurisdictions.

#### 75.19.1 Implementation

- [x] **75.19.1.1** Implement EU AI Act compliance engine (verify all
      AI-generated synthetic media carries required transparency labeling — C2PA
      metadata, watermarks; verify risk assessment documentation exists for
      high-risk AI systems; generate compliance reports per Article 50
      requirements; track compliance status per generated content piece)
- [x] **75.19.1.2** Implement NO FAKES Act compliance engine (when generating
      voice or likeness: verify consent status in consent database; if no
      consent, verify no protected person matched above threshold; generate
      compliance attestation per content piece; track pending legislation and
      auto-adjust when enacted)
- [x] **75.19.1.3** Implement DMCA safe harbor compliance (maintain repeat
      infringer policy — track users/agents that repeatedly generate infringing
      content; implement automated DMCA takedown processing — receive notices,
      evaluate, remove content, notify generator; implement counter-notification
      support; maintain designated agent registration)
- [x] **75.19.1.4** Implement GDPR biometric data compliance (face embeddings
      and voice prints are biometric data under GDPR; implement: purpose
      limitation — embeddings used only for IP protection; storage limitation —
      configurable retention; right to erasure — individuals can request removal
      of their face/voice from databases; data protection impact assessment
      documentation; lawful basis recording)
- [x] **75.19.1.5** Write compliance tests (test EU AI Act — generated content
      has C2PA metadata; test NO FAKES — unconsented voice replica blocked; test
      DMCA — repeat infringer tracked; test GDPR — face embedding deletable on
      request; minimum 20 tests)

---

### 75.20 Cross-Media Integration Testing & Validation

End-to-end testing across all media types and shields.

#### 75.20.1 Integration Testing

- [x] **75.20.1.1** Implement cross-media integration test suite (create test
      fixtures for each media type: 10 reference images with known copyrighted
      content, 10 reference text passages, 10 reference 3D models, 5 reference
      video clips, 5 reference character profiles, 5 reference motion sequences;
      index all in reference database; generate 50 test queries across all media
      types with known ground truth — copies, near-copies, and originals; run
      full universal shield scan; verify correct classification for all)
- [x] **75.20.1.2** Implement compound content integration tests (create
      multi-modal test content: music video with matching audio + visual +
      lyrics from same source; game level with matching 3D + narrative +
      environment from same source; run compound detection; verify compound
      escalation correctly applied; verify independent matches not escalated)
- [x] **75.20.1.3** Implement domain adapter integration tests (for each major
      domain — Calliope, Isis, Hathor, Veritas, Maya, Yemaya: submit
      representative content through the adapter; verify correct shield routing;
      verify scan results returned; verify decision applied; end-to-end from
      generation to publication decision)
- [x] **75.20.1.4** Implement known infringement validation corpus (collect or
      synthesize examples approximating real-world infringement cases across
      media types: visual — image closely reproducing copyrighted painting; text
      — passage closely paraphrasing copyrighted book; character — character
      matching copyrighted franchise character; run through shields; verify
      detected; maintain as regression test corpus; grow over time)
- [x] **75.20.1.5** Implement performance benchmarks (benchmark scan latency per
      media type — target: image < 5s, text < 10s, video < 60s, 3D < 15s;
      benchmark compound detection latency — target: < 90s for music video;
      benchmark throughput — concurrent scans per media type; measure memory
      usage; generate performance regression baseline)
- [x] **75.20.1.6** Implement continuous validation pipeline (run full test
      corpus as CI job on every shield code change; track accuracy metrics —
      true positive rate for known infringements, true negative rate for known
      originals; alert if any update degrades accuracy below baseline; run
      nightly full regression)

---

### 75.21 Documentation

- [x] **75.21.1** Write universal shield developer integration guide (how to
      integrate any domain with the shield; step-by-step for each media type;
      SDK usage examples; configuration options; error handling; performance
      tuning)
- [x] **75.21.2** Write reviewer guide for all media types (how to review
      flagged content across media types; media-specific review techniques;
      using comparison tools; interpreting similarity scores per media type;
      escalation procedures)
- [x] **75.21.3** Write regulatory compliance guide (per-jurisdiction
      requirements; how the shield satisfies each requirement; compliance report
      generation; audit trail usage for legal discovery)
- [x] **75.21.4** Write reference database administration guide (how to manage
      ingestion pipelines for each media type; database maintenance procedures;
      monitoring; scaling)

---

### Phase 75 Summary — Themis Universal Originality Shield

| Section                                     | Number | Tasks   |
| ------------------------------------------- | ------ | ------- |
| 75.1 Visual Originality Shield              | 75.1   | 35      |
| 75.2 Text Originality Shield                | 75.2   | 24      |
| 75.3 Video Originality Shield               | 75.3   | 16      |
| 75.4 3D Asset Originality Shield            | 75.4   | 12      |
| 75.5 Character Originality Shield           | 75.5   | 8       |
| 75.6 Motion & Animation Shield              | 75.6   | 9       |
| 75.7 Fashion & Design Shield                | 75.7   | 7       |
| 75.8 Environment & Level Shield             | 75.8   | 6       |
| 75.9 Cross-Media Compound Detection         | 75.9   | 6       |
| 75.10 Universal Reference Database          | 75.10  | 11      |
| 75.11 Universal Risk Scoring                | 75.11  | 5       |
| 75.12 Universal Provenance System           | 75.12  | 5       |
| 75.13 Universal Human Review                | 75.13  | 5       |
| 75.14 Universal Remediation                 | 75.14  | 7       |
| 75.15 Universal Analytics                   | 75.15  | 5       |
| 75.16 Watermarking & Content Authentication | 75.16  | 8       |
| 75.17 Cross-Media Model Governance          | 75.17  | 6       |
| 75.18 Domain Integration Adapters           | 75.18  | 8       |
| 75.19 Regulatory Compliance Automation      | 75.19  | 5       |
| 75.20 Cross-Media Integration Testing       | 75.20  | 6       |
| 75.21 Documentation                         | 75.21  | 4       |
| **TOTAL Phase 75**                          |        | **222** |

---

**Phase 75 establishes the Themis Universal Originality Shield — extending the
Music Shield (Phase 74) to protect ALL media generated across the entire Oshun
ecosystem. 222 tasks across 21 sections covering: Visual Shield with CLIP/
DINOv2/SSCD neural embeddings, character recognition, face detection with GDPR
compliance, trademark/logo detection, and training data memorization detection;
Text Shield with verbatim/semantic/cross-language matching, narrative structure
analysis with plot/character-graph/world-building extraction, and source
attribution; Video Shield with per-frame analysis, scene comparison, dialogue
extraction via ASR, deepfake detection, and C2PA content provenance labeling; 3D
Shield with point cloud/voxel/neural shape comparison, multi-view rendering, and
product/architectural detection; Character Shield with cross-media compound
matching across visual+name+profile+abilities; Motion Shield with joint
trajectory DTW, choreography sequence matching, performer style analysis, and
consent verification; Fashion Shield with textile pattern, trade dress, and
design patent comparison; Environment Shield with level layout topology, game
aesthetic matching, and architectural detection; Cross-Media Compound Detection
with non-linear escalation when multiple media types match the same source;
Universal Reference Database targeting 100M+ works across all media types with
Qdrant/pgvector; Universal Risk Scoring with per-media-type weights and
jurisdiction-aware assessment; Universal Provenance with content-addressed
storage and cross-media project linkage; Universal Human Review with multi-
expert assignment for compound content; Universal Remediation with media-
specific engines and iterative re-scan loops; Watermarking with C2PA metadata
for EU AI Act compliance, invisible audio/image/video watermarks, and leak
detection; Cross-Media Model Governance with training data audit, memorization
testing, red-teaming, and unified opt-out registry across all media; Domain
Integration Adapters connecting all 18+ generating domains to appropriate
shields; Regulatory Compliance Automation for EU AI Act, NO FAKES Act, DMCA, and
GDPR; and comprehensive cross-media integration testing with known infringement
validation corpus. Combined with Phase 74 (232 music tasks), this establishes
454 total tasks for the complete Themis IP protection system. Every pixel, every
note, every word, every polygon, every frame, every character, every motion —
must be defensible.**
