diff --git a/CONTEXT.md b/CONTEXT.md
new file mode 100644
index 0000000000..b8598415c2
--- /dev/null
+++ b/CONTEXT.md
@@ -0,0 +1,97 @@
+# Chronicle Map
+
+A first-class chronicle system inside Wiki.js for pinning historical (or fictional) events onto era-specific maps, with page embeds and a master overview.
+
+## Language
+
+**Chronicle**:
+A first-class aggregate that owns era maps, events, and its own tags. Wiki pages embed or link to it; they do not own its data.
+_Avoid_: Map collection, project, atlas (as the top-level container)
+
+**Event**:
+A pin-able record inside a Chronicle — title, summary, when/where it occurred, and tags. May optionally link to one or more Wiki Pages for long-form detail; the pin itself is not a Page.
+_Avoid_: Page (for the pin), marker-only stub with no domain identity
+
+**Era Map**:
+A dated basemap (2D imagery or 3D scene) owned by a Chronicle, covering a time range. Multiple Era Maps coexist; each can be aligned to a shared spatial reference so the same Event can appear across eras despite scale and position drift.
+_Avoid_: Layer (as the map entity), basemap-only asset with no era identity
+
+**Canonical Position**:
+The Event's single authoritative location in the Chronicle's shared spatial reference (typically modern lat/lng, or a custom CRS for fictional worlds). Default source for projecting pins onto every Era Map.
+_Avoid_: Per-map coordinates (as the primary store), "roughly around here" without a stored point
+
+**Alignment**:
+A transform on an Era Map (control points / warp) that maps Canonical Positions onto that basemap's pixel or local space, correcting scale and position drift between eras.
+_Avoid_: Manual re-pinning every Event per map, ad-hoc UI pan/zoom offsets
+
+**Pin Override**:
+An optional per–Event-per–Era-Map position that replaces the Alignment projection when the default transform is wrong for that pin. Escape hatch only — Canonical Position remains the default.
+_Avoid_: Making per-map pins the normal path for every Event
+
+**Occurrence**:
+When an Event happened — a point or interval on the Chronicle timeline (may be approximate). Used to decide default Era Map visibility by intersection with each Era Map's time range.
+_Avoid_: "Date" alone when an interval or fuzzy span is meant; publication date of the wiki page
+
+**Visibility Override**:
+An optional per–Event-per–Era-Map force include or force exclude that replaces the default Occurrence∩Era-Map time-range rule.
+_Avoid_: Manually listing every Era Map for every Event as the normal path
+
+**Chronicle Tag**:
+A Chronicle-scoped label for filtering and grouping Events on maps (e.g. haunt, traffic death, urban, outlying islands). Independent of Wiki.js Page Tags.
+_Avoid_: Page Tag (for map filters), global taxonomy shared across unrelated Chronicles
+
+**Page Tag**:
+The existing Wiki.js flat tag on a Wiki Page. Used only for wiki content; not the primary map filter. An Event's linked Pages keep their own Page Tags.
+_Avoid_: Reusing Page Tags as the Chronicle's event taxonomy
+
+**Chronicle Overlay**:
+An optional map view mode that shows Events (and optionally Era Maps) from more than one Chronicle on the same canvas, with each Chronicle toggleable. Chronicles remain separate aggregates; overlay is a view concern, not a merge of data.
+_Avoid_: World Layer inside a single Chronicle; permanently merging taxonomies or alignments across Chronicles
+
+**Map View**:
+The single interactive map experience for exploring Chronicles — Era Maps, Event pins, filters, overlays, and (for editors) alignment tools. Reused everywhere; not duplicated per surface.
+_Avoid_: Separate “simple embed map” and “full map” products with different data rules
+
+**Chronicle Embed**:
+A Map View instance placed inside a Wiki Page, usually with a locked or narrowed scope (one Chronicle, Era Map, Tag set, or Event focus). Same underlying Map View as the master route.
+_Avoid_: Static thumbnail that is not a Map View; treating the embed as a second data store
+
+**Event Draft**:
+A proposed Event (from Ingest API or AI Analysis) that is not yet a live pin. Becomes an Event only after human confirmation. Same fields as Event, different lifecycle.
+_Avoid_: Writing AI/API output straight to live Events; a separate parallel data model unrelated to Event
+
+**Ingest API**:
+An HTTP/GraphQL API for submitting structured Event or Event Draft payloads from external systems. Does not bypass confirmation when the payload is marked as draft/AI-sourced.
+_Avoid_: Ad-hoc DB inserts; scraping hooks that publish live pins with no review path
+
+**AI Analysis**:
+A process that turns unstructured input (text, URL, bulk notes) into one or more Event Drafts — suggested title, Occurrence, Canonical Position, Chronicle Tags — for human review.
+_Avoid_: AI as the source of truth; AI that only fills a form with no draft record
+
+**Map Mode**:
+How an Era Map is presented in Map View: `2d`, `3d`, or `both` (user-switchable). Events still use a 2D Canonical Position by default; 3D is primarily a presentation concern, with optional elevation later.
+_Avoid_: Separate 2D-only and 3D-only Era Map entity types; treating 3D as a different aggregate
+
+**Basemap Source**:
+Where an Era Map's imagery or tiles come from. One of: Public Basemap, Uploaded Basemap, or Derived Basemap. Source type lives on the Era Map; it is not a separate aggregate.
+_Avoid_: Iframe-only external maps outside the Chronicle model; one-off assets with no source metadata
+
+**Public Basemap**:
+A Basemap Source that connects to an open or configured tile/map provider (e.g. OSM, satellite, government open layers) by provider id or URL. Preferred for real-world geographies already in a known CRS.
+_Avoid_: Re-uploading public tiles as static images when a provider works
+
+**Uploaded Basemap**:
+A Basemap Source from manually uploaded imagery or tile packs — fantasy maps, scanned historical maps, custom art. Usually requires Alignment.
+_Avoid_: Treating uploads as already georeferenced without Alignment
+
+**Derived Basemap**:
+A Basemap Source produced by AI/API conversion from an image or other map (e.g. suggested Alignment control points, cleaned tile asset). Stored as a draft asset until a human confirms and attaches it to an Era Map.
+_Avoid_: AI silently publishing live basemaps; calling this a third aggregate beside Era Map
+
+**Footprint**:
+Optional line or polygon geometry on an Event that shows extent (building, road stretch, district). Canonical Position remains required; Footprint does not replace it for alignment, overrides, or default AI geocoding.
+_Avoid_: Polygon-only Events with no point; treating Footprint as the primary pin
+
+**Chronicle Permission**:
+Access rules owned by the Chronicle domain — read map data, write Events, approve Event Drafts / Derived Basemaps, and manage Era Maps / Alignment. Independent of Wiki Page permissions; may be global or per-Chronicle via groups.
+_Avoid_: Inferring Chronicle edit rights from “can edit this wiki page”; admin-only as the only write model
diff --git a/client/client-app.js b/client/client-app.js
index f3dc05a8b6..88f40853f3 100644
--- a/client/client-app.js
+++ b/client/client-app.js
@@ -170,6 +170,7 @@ Vue.component('Register', () => import(/* webpackChunkName: "register" */ './com
 Vue.component('SearchResults', () => import(/* webpackPrefetch: true, webpackChunkName: "ui-extra" */ './components/common/search-results.vue'))
 Vue.component('SocialSharing', () => import(/* webpackPrefetch: true, webpackChunkName: "ui-extra" */ './components/common/social-sharing.vue'))
 Vue.component('Tags', () => import(/* webpackChunkName: "tags" */ './components/tags.vue'))
+Vue.component('ChronicleMap', () => import(/* webpackChunkName: "chronicle" */ './components/chronicle-map.vue'))
 Vue.component('Unauthorized', () => import(/* webpackChunkName: "unauthorized" */ './components/unauthorized.vue'))
 Vue.component('VCardChin', () => import(/* webpackPrefetch: true, webpackChunkName: "ui-extra" */ './components/common/v-card-chin.vue'))
 Vue.component('VCardInfo', () => import(/* webpackPrefetch: true, webpackChunkName: "ui-extra" */ './components/common/v-card-info.vue'))
diff --git a/client/components/admin.vue b/client/components/admin.vue
index aa6ad23c01..6721398309 100644
--- a/client/components/admin.vue
+++ b/client/components/admin.vue
@@ -39,6 +39,9 @@
                   :dark='pendingReviewsCount > 0'
                 )
                   .caption(:class='pendingReviewsCount > 0 ? `` : `grey--text`') {{ pendingReviewsCount }}
+            v-list-item(to='/chronicles', color='primary', v-if='hasPermission([`manage:system`, `manage:chronicles`])')
+              v-list-item-avatar(size='24', tile): v-icon mdi-map-clock-outline
+              v-list-item-title Chronicles
             v-list-item(to='/tags', v-if='hasPermission([`manage:system`])')
               v-list-item-avatar(size='24', tile): v-icon mdi-tag-multiple
               v-list-item-title {{ $t('admin:tags.title') }}
@@ -163,6 +166,7 @@ const router = new VueRouter({
     { path: '/pages/:id(\\d+)', component: () => import(/* webpackChunkName: "admin" */ './admin/admin-pages-edit.vue') },
     { path: '/pages/visualize', component: () => import(/* webpackChunkName: "admin" */ './admin/admin-pages-visualize.vue') },
     { path: '/page-reviews', component: () => import(/* webpackChunkName: "admin" */ './admin/admin-page-reviews.vue') },
+    { path: '/chronicles', component: () => import(/* webpackChunkName: "admin" */ './admin/admin-chronicles.vue') },
     { path: '/tags', component: () => import(/* webpackChunkName: "admin" */ './admin/admin-tags.vue') },
     { path: '/theme', component: () => import(/* webpackChunkName: "admin" */ './admin/admin-theme.vue') },
     { path: '/groups', component: () => import(/* webpackChunkName: "admin" */ './admin/admin-groups.vue') },
diff --git a/client/components/admin/admin-chronicles.vue b/client/components/admin/admin-chronicles.vue
new file mode 100644
index 0000000000..a61f50d356
--- /dev/null
+++ b/client/components/admin/admin-chronicles.vue
@@ -0,0 +1,574 @@
+<template lang='pug'>
+  v-container(fluid, grid-list-lg)
+    v-layout(row wrap)
+      v-flex(xs12)
+        .admin-header
+          img.animated.fadeInUp(src='/_assets/svg/icon-file.svg', alt='Chronicles', style='width: 80px;')
+          .admin-header-title
+            .headline.blue--text.text--darken-2.animated.fadeInLeft Chronicles
+            .subtitle-1.grey--text.animated.fadeInLeft.wait-p2s Era maps, events, AI drafts
+          v-spacer
+          v-btn.mr-2.animated.fadeInDown(outlined, color='primary', href='/chronicle', target='_blank')
+            v-icon(left) mdi-map
+            span Open map
+          v-btn.animated.fadeInDown(color='primary', dark, @click='openCreate')
+            v-icon(left) mdi-plus
+            span New Chronicle
+        v-card.mt-3.animated.fadeInUp
+          v-data-table(
+            :items='chronicles'
+            :headers='headers'
+            :loading='loading'
+            hide-default-footer
+            :items-per-page='50'
+          )
+            template(slot='item', slot-scope='props')
+              tr.is-clickable(@click='openEdit(props.item)')
+                td {{ props.item.id }}
+                td
+                  .body-2: strong {{ props.item.title }}
+                  .caption /chronicle/{{ props.item.slug }}
+                td
+                  v-chip(small, :color='props.item.isPublished ? `green` : `grey`', dark) {{ props.item.isPublished ? 'published' : 'draft' }}
+                td {{ props.item.updatedAt | moment('calendar') }}
+            template(slot='no-data')
+              v-alert.ma-3(icon='mdi-map-outline', :value='true', outlined) No chronicles yet.
+
+    //- Chronicle editor
+    v-dialog(v-model='dialog', max-width='960', scrollable)
+      v-card(v-if='form')
+        v-card-title {{ form.id ? 'Edit Chronicle' : 'New Chronicle' }}
+        v-divider
+        v-card-text
+          v-text-field(v-model='form.title', label='Title', outlined, dense)
+          v-text-field(v-model='form.slug', label='Slug', outlined, dense, hint='Used in /chronicle/{slug}', persistent-hint)
+          v-textarea(v-model='form.description', label='Description', outlined, dense, rows='2')
+          v-switch(v-model='form.isPublished', label='Published', inset)
+          template(v-if='form.id')
+            v-tabs(v-model='tab')
+              v-tab Era Maps
+              v-tab Events
+              v-tab AI / Text ingest
+              v-tab-item.pt-3
+                v-list(dense)
+                  v-list-item(v-for='em in eraMaps', :key='em.id', @click='openEraMap(em)')
+                    v-list-item-content
+                      v-list-item-title {{ em.title }}
+                      v-list-item-subtitle {{ em.timeStart || '…' }} → {{ em.timeEnd || '…' }} · {{ em.basemapSource }} · {{ em.mapMode }} · {{ em.status }}
+                    v-list-item-action
+                      v-btn(icon, small, @click.stop='deleteEraMap(em.id)')
+                        v-icon mdi-delete-outline
+                v-btn.mt-2(small, outlined, color='primary', @click='openEraMap(null)') Add Era Map
+              v-tab-item.pt-3
+                v-list(dense)
+                  v-list-item(v-for='ev in events', :key='ev.id', @click='openEvent(ev)')
+                    v-list-item-content
+                      v-list-item-title {{ ev.title }}
+                      v-list-item-subtitle {{ ev.occurrenceStart || '?' }} · {{ ev.lat }}, {{ ev.lng }} · {{ ev.status }}
+                    v-list-item-action
+                      v-btn(v-if='ev.status === `draft`', icon, small, color='green', @click.stop='approveDraft(ev.id)')
+                        v-icon mdi-check
+                      v-btn(icon, small, @click.stop='deleteEvent(ev.id)')
+                        v-icon mdi-delete-outline
+                v-btn.mt-2.mr-2(small, outlined, color='primary', @click='openEvent(null)') Add Event
+                v-btn.mt-2(small, text, @click='addSampleEvent') Sample HK pin
+              v-tab-item.pt-3
+                .caption.grey--text.mb-2 Heuristic analysis (no external LLM). Parses places/years from text into Event Drafts.
+                v-textarea(v-model='aiText', label='Paste notes / articles (one event per line)', outlined, rows='6')
+                v-btn(color='primary', dark, :loading='acting', :disabled='!aiText', @click='runAnalyze') Analyze → Drafts
+        v-divider
+        v-card-actions
+          v-btn(v-if='form.id', text, color='error', :loading='acting', @click='remove') Delete
+          v-spacer
+          v-btn(text, @click='dialog = false') Close
+          v-btn(color='primary', dark, :loading='acting', @click='save') Save Chronicle
+
+    //- Era Map editor
+    v-dialog(v-model='eraDialog', max-width='720', scrollable)
+      v-card(v-if='eraForm')
+        v-card-title {{ eraForm.id ? 'Edit Era Map' : 'New Era Map' }}
+        v-divider
+        v-card-text
+          v-text-field(v-model='eraForm.title', label='Title', outlined, dense)
+          v-layout(row, wrap)
+            v-flex(xs6, class='pr-2')
+              v-text-field(v-model='eraForm.timeStart', label='Time start (year)', outlined, dense)
+            v-flex(xs6, class='pl-2')
+              v-text-field(v-model='eraForm.timeEnd', label='Time end (year)', outlined, dense)
+          v-select(v-model='eraForm.mapMode', :items='mapModes', label='Map Mode', outlined, dense)
+          v-select(v-model='eraForm.basemapSource', :items='basemapSources', label='Basemap Source', outlined, dense, @change='onBasemapSourceChange')
+          v-select(v-model='eraForm.status', :items='["live", "draft"]', label='Status', outlined, dense)
+          template(v-if='eraForm.basemapSource === "public"')
+            v-text-field(v-model='eraForm.tileUrl', label='Tile URL template', outlined, dense)
+            v-text-field(v-model='eraForm.centerLat', label='Center lat', outlined, dense, type='number', step='any')
+            v-text-field(v-model='eraForm.centerLng', label='Center lng', outlined, dense, type='number', step='any')
+            v-text-field(v-model='eraForm.zoom', label='Zoom', outlined, dense, type='number')
+          template(v-else)
+            v-text-field(v-model='eraForm.imageUrl', label='Image URL (uploaded / derived asset)', outlined, dense)
+            v-text-field(v-model='eraForm.boundSouth', label='Bounds south', outlined, dense, type='number', step='any')
+            v-text-field(v-model='eraForm.boundWest', label='Bounds west', outlined, dense, type='number', step='any')
+            v-text-field(v-model='eraForm.boundNorth', label='Bounds north', outlined, dense, type='number', step='any')
+            v-text-field(v-model='eraForm.boundEast', label='Bounds east', outlined, dense, type='number', step='any')
+          v-select(v-model='eraForm.alignmentType', :items='alignmentTypes', label='Alignment', outlined, dense)
+          v-textarea(
+            v-if='eraForm.alignmentType === "controlPoints"'
+            v-model='eraForm.alignmentJson'
+            label='Alignment JSON (control points)'
+            outlined
+            dense
+            rows='4'
+            hint='{"type":"controlPoints","points":[{"canonical":{"lat":22.3,"lng":114.2},"map":{"x":0.5,"y":0.4}}]}'
+            persistent-hint
+          )
+        v-divider
+        v-card-actions
+          v-spacer
+          v-btn(text, @click='eraDialog = false') Cancel
+          v-btn(color='primary', dark, :loading='acting', @click='saveEraMap') Save Era Map
+
+    //- Event editor
+    v-dialog(v-model='eventDialog', max-width='720', scrollable)
+      v-card(v-if='eventForm')
+        v-card-title {{ eventForm.id ? 'Edit Event' : 'New Event' }}
+        v-divider
+        v-card-text
+          v-text-field(v-model='eventForm.title', label='Title', outlined, dense)
+          v-textarea(v-model='eventForm.summary', label='Summary', outlined, dense, rows='3')
+          v-layout(row, wrap)
+            v-flex(xs6, class='pr-2')
+              v-text-field(v-model='eventForm.occurrenceStart', label='Occurrence start', outlined, dense)
+            v-flex(xs6, class='pl-2')
+              v-text-field(v-model='eventForm.occurrenceEnd', label='Occurrence end', outlined, dense)
+          v-switch(v-model='eventForm.occurrenceFuzzy', label='Fuzzy date', inset)
+          v-layout(row, wrap)
+            v-flex(xs6, class='pr-2')
+              v-text-field(v-model.number='eventForm.lat', label='Canonical lat', outlined, dense, type='number', step='any')
+            v-flex(xs6, class='pl-2')
+              v-text-field(v-model.number='eventForm.lng', label='Canonical lng', outlined, dense, type='number', step='any')
+          v-combobox(v-model='eventForm.tags', label='Chronicle Tags', multiple, chips, small-chips, outlined, dense, hint='haunt, urban, outlying…', persistent-hint)
+          v-select(v-model='eventForm.status', :items='["live", "draft"]', label='Status', outlined, dense)
+        v-divider
+        v-card-actions
+          v-spacer
+          v-btn(text, @click='eventDialog = false') Cancel
+          v-btn(color='primary', dark, :loading='acting', @click='saveEvent') Save Event
+</template>
+
+<script>
+import _ from 'lodash'
+import gql from 'graphql-tag'
+
+const LIST_QUERY = gql`
+  query ($includeUnpublished: Boolean) {
+    chronicles {
+      list(includeUnpublished: $includeUnpublished) {
+        id slug title description isPublished updatedAt
+      }
+    }
+  }
+`
+
+const SINGLE_QUERY = gql`
+  query ($id: Int!) {
+    chronicles {
+      single(id: $id) {
+        id slug title description isPublished
+        eraMaps {
+          id title timeStart timeEnd mapMode basemapSource basemapConfig alignment status sortIndex
+        }
+        events {
+          id title summary occurrenceStart occurrenceEnd occurrenceFuzzy lat lng status
+          tags { tag }
+        }
+      }
+    }
+  }
+`
+
+const DEFAULT_OSM = {
+  provider: 'osm',
+  url: 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
+  attribution: '&copy; OpenStreetMap contributors',
+  center: [22.3193, 114.1694],
+  zoom: 11
+}
+
+export default {
+  data() {
+    return {
+      loading: false,
+      acting: false,
+      chronicles: [],
+      dialog: false,
+      form: null,
+      tab: 0,
+      eraMaps: [],
+      events: [],
+      aiText: '',
+      eraDialog: false,
+      eraForm: null,
+      eventDialog: false,
+      eventForm: null,
+      mapModes: ['2d', '3d', 'both'],
+      basemapSources: [
+        { text: 'Public (tiles)', value: 'public' },
+        { text: 'Uploaded', value: 'uploaded' },
+        { text: 'Derived (AI/API)', value: 'derived' }
+      ],
+      alignmentTypes: [
+        { text: 'Identity (lat/lng = map)', value: 'identity' },
+        { text: 'Control points', value: 'controlPoints' }
+      ],
+      headers: [
+        { text: 'ID', value: 'id', width: 80 },
+        { text: 'Chronicle', value: 'title' },
+        { text: 'Status', value: 'isPublished', width: 120 },
+        { text: 'Updated', value: 'updatedAt', width: 160 }
+      ]
+    }
+  },
+  methods: {
+    async refresh() {
+      this.loading = true
+      try {
+        const resp = await this.$apollo.query({
+          query: LIST_QUERY,
+          fetchPolicy: 'network-only',
+          variables: { includeUnpublished: true }
+        })
+        this.chronicles = _.get(resp, 'data.chronicles.list', [])
+      } catch (err) {
+        this.notify(err.message, 'red')
+      }
+      this.loading = false
+    },
+    notify(message, style = 'success') {
+      this.$store.commit('showNotification', {
+        style,
+        message,
+        icon: style === 'red' ? 'alert' : 'check'
+      })
+    },
+    openCreate() {
+      this.form = { id: null, title: '', slug: '', description: '', isPublished: true }
+      this.eraMaps = []
+      this.events = []
+      this.aiText = ''
+      this.tab = 0
+      this.dialog = true
+    },
+    async openEdit(item) {
+      const resp = await this.$apollo.query({
+        query: SINGLE_QUERY,
+        fetchPolicy: 'network-only',
+        variables: { id: item.id }
+      })
+      const c = _.get(resp, 'data.chronicles.single')
+      if (!c) { return }
+      this.form = {
+        id: c.id,
+        title: c.title,
+        slug: c.slug,
+        description: c.description,
+        isPublished: c.isPublished
+      }
+      this.eraMaps = c.eraMaps || []
+      this.events = c.events || []
+      this.dialog = true
+    },
+    async save() {
+      this.acting = true
+      try {
+        if (this.form.id) {
+          await this.$apollo.mutate({
+            mutation: gql`mutation ($id: Int!, $slug: String, $title: String, $description: String, $isPublished: Boolean) {
+              chronicles { update(id: $id, slug: $slug, title: $title, description: $description, isPublished: $isPublished) {
+                responseResult { succeeded message } chronicle { id slug }
+              }}
+            }`,
+            variables: { ...this.form }
+          })
+        } else {
+          const resp = await this.$apollo.mutate({
+            mutation: gql`mutation ($title: String!, $slug: String, $description: String, $isPublished: Boolean) {
+              chronicles { create(title: $title, slug: $slug, description: $description, isPublished: $isPublished) {
+                responseResult { succeeded message } chronicle { id slug }
+              }}
+            }`,
+            variables: {
+              title: this.form.title,
+              slug: this.form.slug || undefined,
+              description: this.form.description,
+              isPublished: this.form.isPublished
+            }
+          })
+          const created = _.get(resp, 'data.chronicles.create.chronicle')
+          if (created) {
+            this.form.id = created.id
+            this.form.slug = created.slug
+          }
+        }
+        this.notify('Chronicle saved')
+        await this.refresh()
+        if (this.form.id) { await this.openEdit({ id: this.form.id }) }
+      } catch (err) {
+        this.notify(err.message, 'red')
+      }
+      this.acting = false
+    },
+    async remove() {
+      if (!this.form.id || !confirm('Delete this chronicle and all its maps/events?')) { return }
+      this.acting = true
+      try {
+        await this.$apollo.mutate({
+          mutation: gql`mutation ($id: Int!) { chronicles { delete(id: $id) { responseResult { succeeded message } } } }`,
+          variables: { id: this.form.id }
+        })
+        this.dialog = false
+        await this.refresh()
+      } catch (err) {
+        this.notify(err.message, 'red')
+      }
+      this.acting = false
+    },
+    openEraMap(em) {
+      let config = {}
+      let alignment = { type: 'identity' }
+      try { config = em && em.basemapConfig ? JSON.parse(em.basemapConfig) : { ...DEFAULT_OSM } } catch (e) { config = { ...DEFAULT_OSM } }
+      try { alignment = em && em.alignment ? JSON.parse(em.alignment) : { type: 'identity' } } catch (e) { alignment = { type: 'identity' } }
+      const bounds = config.bounds || [[22.15, 113.8], [22.55, 114.45]]
+      this.eraForm = {
+        id: em ? em.id : null,
+        title: em ? em.title : 'Modern Hong Kong',
+        timeStart: em ? em.timeStart : '1997',
+        timeEnd: em ? em.timeEnd : '2030',
+        mapMode: em ? em.mapMode : '2d',
+        basemapSource: em ? em.basemapSource : 'public',
+        status: em ? em.status : 'live',
+        tileUrl: config.url || DEFAULT_OSM.url,
+        centerLat: (config.center && config.center[0]) || 22.3193,
+        centerLng: (config.center && config.center[1]) || 114.1694,
+        zoom: config.zoom || 11,
+        imageUrl: config.imageUrl || '',
+        boundSouth: bounds[0][0],
+        boundWest: bounds[0][1],
+        boundNorth: bounds[1][0],
+        boundEast: bounds[1][1],
+        alignmentType: alignment.type || 'identity',
+        alignmentJson: JSON.stringify(alignment, null, 2)
+      }
+      this.eraDialog = true
+    },
+    onBasemapSourceChange() {
+      if (this.eraForm.basemapSource === 'derived' && this.eraForm.status === 'live') {
+        this.eraForm.status = 'draft'
+      }
+    },
+    buildBasemapConfig() {
+      if (this.eraForm.basemapSource === 'public') {
+        return {
+          provider: 'osm',
+          url: this.eraForm.tileUrl || DEFAULT_OSM.url,
+          attribution: DEFAULT_OSM.attribution,
+          center: [Number(this.eraForm.centerLat), Number(this.eraForm.centerLng)],
+          zoom: Number(this.eraForm.zoom) || 11
+        }
+      }
+      return {
+        imageUrl: this.eraForm.imageUrl,
+        bounds: [
+          [Number(this.eraForm.boundSouth), Number(this.eraForm.boundWest)],
+          [Number(this.eraForm.boundNorth), Number(this.eraForm.boundEast)]
+        ]
+      }
+    },
+    buildAlignment() {
+      if (this.eraForm.alignmentType === 'identity') {
+        return { type: 'identity' }
+      }
+      try {
+        return JSON.parse(this.eraForm.alignmentJson || '{"type":"controlPoints","points":[]}')
+      } catch (e) {
+        throw new Error('Invalid alignment JSON')
+      }
+    },
+    async saveEraMap() {
+      this.acting = true
+      try {
+        const basemapConfig = JSON.stringify(this.buildBasemapConfig())
+        const alignment = JSON.stringify(this.buildAlignment())
+        if (this.eraForm.id) {
+          await this.$apollo.mutate({
+            mutation: gql`mutation ($id: Int!, $title: String, $timeStart: String, $timeEnd: String, $mapMode: String, $basemapSource: String, $basemapConfig: String, $alignment: String, $status: String) {
+              chronicles { updateEraMap(id: $id, title: $title, timeStart: $timeStart, timeEnd: $timeEnd, mapMode: $mapMode, basemapSource: $basemapSource, basemapConfig: $basemapConfig, alignment: $alignment, status: $status) {
+                responseResult { succeeded message }
+              }}
+            }`,
+            variables: {
+              id: this.eraForm.id,
+              title: this.eraForm.title,
+              timeStart: this.eraForm.timeStart,
+              timeEnd: this.eraForm.timeEnd,
+              mapMode: this.eraForm.mapMode,
+              basemapSource: this.eraForm.basemapSource,
+              basemapConfig,
+              alignment,
+              status: this.eraForm.status
+            }
+          })
+        } else {
+          await this.$apollo.mutate({
+            mutation: gql`mutation ($chronicleId: Int!, $title: String!, $timeStart: String, $timeEnd: String, $mapMode: String, $basemapSource: String, $basemapConfig: String, $alignment: String, $status: String) {
+              chronicles { createEraMap(chronicleId: $chronicleId, title: $title, timeStart: $timeStart, timeEnd: $timeEnd, mapMode: $mapMode, basemapSource: $basemapSource, basemapConfig: $basemapConfig, alignment: $alignment, status: $status) {
+                responseResult { succeeded message }
+              }}
+            }`,
+            variables: {
+              chronicleId: this.form.id,
+              title: this.eraForm.title,
+              timeStart: this.eraForm.timeStart,
+              timeEnd: this.eraForm.timeEnd,
+              mapMode: this.eraForm.mapMode,
+              basemapSource: this.eraForm.basemapSource,
+              basemapConfig,
+              alignment,
+              status: this.eraForm.status
+            }
+          })
+        }
+        this.eraDialog = false
+        this.notify('Era Map saved')
+        await this.openEdit({ id: this.form.id })
+      } catch (err) {
+        this.notify(err.message, 'red')
+      }
+      this.acting = false
+    },
+    async deleteEraMap(id) {
+      await this.$apollo.mutate({
+        mutation: gql`mutation ($id: Int!) { chronicles { deleteEraMap(id: $id) { responseResult { succeeded message } } } }`,
+        variables: { id }
+      })
+      await this.openEdit({ id: this.form.id })
+    },
+    openEvent(ev) {
+      this.eventForm = {
+        id: ev ? ev.id : null,
+        title: ev ? ev.title : '',
+        summary: ev ? ev.summary : '',
+        occurrenceStart: ev ? ev.occurrenceStart : '',
+        occurrenceEnd: ev ? ev.occurrenceEnd : '',
+        occurrenceFuzzy: ev ? !!ev.occurrenceFuzzy : false,
+        lat: ev ? ev.lat : 22.3193,
+        lng: ev ? ev.lng : 114.1694,
+        tags: ev && ev.tags ? ev.tags.map(t => t.tag) : [],
+        status: ev ? ev.status : 'live'
+      }
+      this.eventDialog = true
+    },
+    async saveEvent() {
+      this.acting = true
+      try {
+        const vars = {
+          title: this.eventForm.title,
+          summary: this.eventForm.summary,
+          occurrenceStart: this.eventForm.occurrenceStart,
+          occurrenceEnd: this.eventForm.occurrenceEnd,
+          occurrenceFuzzy: this.eventForm.occurrenceFuzzy,
+          lat: Number(this.eventForm.lat),
+          lng: Number(this.eventForm.lng),
+          tags: this.eventForm.tags,
+          status: this.eventForm.status
+        }
+        if (this.eventForm.id) {
+          await this.$apollo.mutate({
+            mutation: gql`mutation ($id: Int!, $title: String, $summary: String, $occurrenceStart: String, $occurrenceEnd: String, $occurrenceFuzzy: Boolean, $lat: Float, $lng: Float, $tags: [String], $status: String) {
+              chronicles { updateEvent(id: $id, title: $title, summary: $summary, occurrenceStart: $occurrenceStart, occurrenceEnd: $occurrenceEnd, occurrenceFuzzy: $occurrenceFuzzy, lat: $lat, lng: $lng, tags: $tags, status: $status) {
+                responseResult { succeeded message }
+              }}
+            }`,
+            variables: { id: this.eventForm.id, ...vars }
+          })
+        } else {
+          await this.$apollo.mutate({
+            mutation: gql`mutation ($chronicleId: Int!, $title: String!, $summary: String, $occurrenceStart: String, $occurrenceEnd: String, $occurrenceFuzzy: Boolean, $lat: Float!, $lng: Float!, $tags: [String], $status: String) {
+              chronicles { createEvent(chronicleId: $chronicleId, title: $title, summary: $summary, occurrenceStart: $occurrenceStart, occurrenceEnd: $occurrenceEnd, occurrenceFuzzy: $occurrenceFuzzy, lat: $lat, lng: $lng, tags: $tags, status: $status) {
+                responseResult { succeeded message }
+              }}
+            }`,
+            variables: { chronicleId: this.form.id, ...vars }
+          })
+        }
+        this.eventDialog = false
+        this.notify('Event saved')
+        await this.openEdit({ id: this.form.id })
+      } catch (err) {
+        this.notify(err.message, 'red')
+      }
+      this.acting = false
+    },
+    async addSampleEvent() {
+      this.openEvent({
+        id: null,
+        title: 'Sample paranormal sighting',
+        summary: 'Example pin near Central, Hong Kong.',
+        occurrenceStart: '2005',
+        occurrenceEnd: '2005',
+        occurrenceFuzzy: false,
+        lat: 22.2819,
+        lng: 114.1556,
+        tags: [{ tag: 'haunt' }, { tag: 'urban' }],
+        status: 'live'
+      })
+    },
+    async deleteEvent(id) {
+      await this.$apollo.mutate({
+        mutation: gql`mutation ($id: Int!) { chronicles { deleteEvent(id: $id) { responseResult { succeeded message } } } }`,
+        variables: { id }
+      })
+      await this.openEdit({ id: this.form.id })
+    },
+    async approveDraft(id) {
+      await this.$apollo.mutate({
+        mutation: gql`mutation ($id: Int!) { chronicles { approveEventDraft(id: $id) { responseResult { succeeded message } } } }`,
+        variables: { id }
+      })
+      this.notify('Draft approved')
+      await this.openEdit({ id: this.form.id })
+    },
+    async runAnalyze() {
+      this.acting = true
+      try {
+        const resp = await this.$apollo.mutate({
+          mutation: gql`mutation ($chronicleId: Int!, $text: String!, $persist: Boolean) {
+            chronicles { analyzeText(chronicleId: $chronicleId, text: $text, persist: $persist) {
+              responseResult { succeeded message }
+              events { id title }
+            }}
+          }`,
+          variables: {
+            chronicleId: this.form.id,
+            text: this.aiText,
+            persist: true
+          }
+        })
+        const msg = _.get(resp, 'data.chronicles.analyzeText.responseResult.message', 'Done')
+        const count = _.get(resp, 'data.chronicles.analyzeText.events', []).length
+        this.notify(`${msg} (${count} drafts saved)`)
+        this.tab = 1
+        await this.openEdit({ id: this.form.id })
+      } catch (err) {
+        this.notify(err.message, 'red')
+      }
+      this.acting = false
+    }
+  },
+  mounted() {
+    this.refresh()
+  }
+}
+</script>
+
+<style scoped>
+.is-clickable { cursor: pointer; }
+</style>
diff --git a/client/components/admin/admin-groups-edit-permissions.vue b/client/components/admin/admin-groups-edit-permissions.vue
index 0e955c7053..5f5d9cabd9 100644
--- a/client/components/admin/admin-groups-edit-permissions.vue
+++ b/client/components/admin/admin-groups-edit-permissions.vue
@@ -155,6 +155,34 @@ export default {
               warning: false,
               restrictedForSystem: true,
               disabled: false
+            },
+            {
+              permission: 'read:chronicles',
+              hint: 'Can view Chronicle maps and event pins',
+              warning: false,
+              restrictedForSystem: false,
+              disabled: false
+            },
+            {
+              permission: 'write:chronicles',
+              hint: 'Can create and edit Chronicle events (and submit drafts)',
+              warning: false,
+              restrictedForSystem: true,
+              disabled: false
+            },
+            {
+              permission: 'approve:chronicles',
+              hint: 'Can approve Event Drafts and Derived Basemaps',
+              warning: true,
+              restrictedForSystem: true,
+              disabled: false
+            },
+            {
+              permission: 'manage:chronicles',
+              hint: 'Can create Chronicles, Era Maps, Alignment, and manage all chronicle data',
+              warning: true,
+              restrictedForSystem: true,
+              disabled: false
             }
           ]
         },
diff --git a/client/components/chronicle-map.vue b/client/components/chronicle-map.vue
new file mode 100644
index 0000000000..0935c552b3
--- /dev/null
+++ b/client/components/chronicle-map.vue
@@ -0,0 +1,346 @@
+<template lang='pug'>
+  component(:is='embedded ? "div" : "v-app"', :dark='!embedded && $vuetify.theme.dark')
+    nav-header(v-if='!embedded')
+    .chronicle-map-view(:class='{ "chronicle-map-view--page": !embedded }')
+      .chronicle-map-toolbar
+        .chronicle-map-title {{ title }}
+        v-select.chronicle-select(
+          v-if='chronicleOptions.length'
+          v-model='slug'
+          :items='chronicleOptions'
+          item-text='title'
+          item-value='slug'
+          dense
+          outlined
+          hide-details
+          label='Chronicle'
+          style='max-width: 280px;'
+          @change='reload'
+        )
+        v-select.chronicle-select(
+          v-if='eraMapOptions.length'
+          v-model='eraMapId'
+          :items='eraMapOptions'
+          item-text='title'
+          item-value='id'
+          dense
+          outlined
+          hide-details
+          label='Era Map'
+          style='max-width: 240px;'
+          @change='reload'
+        )
+        v-select.chronicle-select(
+          v-if='!embedded && overlayChoices.length'
+          v-model='activeOverlays'
+          :items='overlayChoices'
+          item-text='title'
+          item-value='slug'
+          dense
+          outlined
+          hide-details
+          multiple
+          chips
+          small-chips
+          label='Overlay Chronicles'
+          style='max-width: 320px;'
+          @change='reload'
+        )
+        v-chip-group(v-if='tagOptions.length', column)
+          v-chip(
+            v-for='t in tagOptions'
+            :key='t'
+            filter
+            :input-value='selectedTags.includes(t)'
+            @click='toggleTag(t)'
+          ) {{ t }}
+      .chronicle-map-canvas(ref='mapEl')
+      .chronicle-map-sidebar(v-if='selected')
+        .subtitle-1 {{ selected.title }}
+        .caption.grey--text {{ selected.occurrenceStart }}{{ selected.occurrenceEnd && selected.occurrenceEnd !== selected.occurrenceStart ? ' – ' + selected.occurrenceEnd : '' }}
+        p.body-2.mt-2 {{ selected.summary }}
+        .caption(v-if='selected.tags && selected.tags.length') Tags: {{ selected.tags.map(t => t.tag).join(', ') }}
+        v-btn.mt-3(v-if='embedded', text, small, color='primary', :href='`/chronicle/${slug}`') Open full map
+</template>
+
+<script>
+import _ from 'lodash'
+import gql from 'graphql-tag'
+
+const MAP_VIEW_QUERY = gql`
+  query ($slug: String!, $eraMapId: Int, $tags: [String], $overlaySlugs: [String]) {
+    chronicles {
+      mapView(slug: $slug, eraMapId: $eraMapId, tags: $tags, overlaySlugs: $overlaySlugs) {
+        chronicles {
+          id
+          slug
+          title
+          tags { tag }
+          eraMaps {
+            id
+            title
+            timeStart
+            timeEnd
+            basemapSource
+            basemapConfig
+            alignment
+            status
+          }
+        }
+        activeEraMap {
+          id
+          title
+          basemapSource
+          basemapConfig
+          alignment
+        }
+        pins {
+          id
+          title
+          summary
+          occurrenceStart
+          occurrenceEnd
+          displayLat
+          displayLng
+          lat
+          lng
+          tags { tag }
+          status
+        }
+      }
+    }
+  }
+`
+
+const LIST_QUERY = gql`
+  query {
+    chronicles {
+      list {
+        id
+        slug
+        title
+      }
+    }
+  }
+`
+
+let leafletPromise = null
+
+function loadLeaflet () {
+  if (window.L) {
+    return Promise.resolve(window.L)
+  }
+  if (leafletPromise) {
+    return leafletPromise
+  }
+  leafletPromise = new Promise((resolve, reject) => {
+    const css = document.createElement('link')
+    css.rel = 'stylesheet'
+    css.href = 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.css'
+    document.head.appendChild(css)
+    const script = document.createElement('script')
+    script.src = 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.js'
+    script.onload = () => resolve(window.L)
+    script.onerror = reject
+    document.head.appendChild(script)
+  })
+  return leafletPromise
+}
+
+export default {
+  props: {
+    initialSlug: { type: String, default: '' },
+    initialTags: { type: Array, default: () => [] },
+    initialEraMapId: { type: Number, default: null },
+    overlaySlugs: { type: Array, default: () => [] },
+    embedded: { type: Boolean, default: false },
+    height: { type: String, default: '70vh' }
+  },
+  data () {
+    return {
+      slug: this.initialSlug || '',
+      eraMapId: this.initialEraMapId,
+      selectedTags: [...(this.initialTags || [])],
+      activeOverlays: [...(this.overlaySlugs || [])],
+      chronicleOptions: [],
+      eraMapOptions: [],
+      tagOptions: [],
+      title: 'Chronicle Map',
+      pins: [],
+      selected: null,
+      map: null,
+      layerGroup: null,
+      tileLayer: null
+    }
+  },
+  computed: {
+    overlayChoices () {
+      return (this.chronicleOptions || []).filter(c => c.slug !== this.slug)
+    }
+  },
+  methods: {
+    toggleTag (t) {
+      if (this.selectedTags.includes(t)) {
+        this.selectedTags = this.selectedTags.filter(x => x !== t)
+      } else {
+        this.selectedTags = [...this.selectedTags, t]
+      }
+      this.reload()
+    },
+    async loadChronicleList () {
+      const resp = await this.$apollo.query({
+        query: LIST_QUERY,
+        fetchPolicy: 'network-only'
+      })
+      this.chronicleOptions = _.get(resp, 'data.chronicles.list', [])
+    },
+    async ensureSlug () {
+      if (!this.chronicleOptions.length) {
+        await this.loadChronicleList()
+      }
+      if (this.slug) { return }
+      if (this.chronicleOptions.length) {
+        this.slug = this.chronicleOptions[0].slug
+      }
+    },
+    async reload () {
+      await this.ensureSlug()
+      if (!this.slug) { return }
+      const overlays = (this.activeOverlays || []).filter(s => s && s !== this.slug)
+      const resp = await this.$apollo.query({
+        query: MAP_VIEW_QUERY,
+        fetchPolicy: 'network-only',
+        variables: {
+          slug: this.slug,
+          eraMapId: this.eraMapId || undefined,
+          tags: this.selectedTags.length ? this.selectedTags : undefined,
+          overlaySlugs: overlays.length ? overlays : undefined
+        }
+      })
+      const view = _.get(resp, 'data.chronicles.mapView')
+      if (!view) { return }
+      const primary = (view.chronicles || [])[0]
+      this.title = primary ? primary.title : 'Chronicle Map'
+      this.eraMapOptions = primary ? (primary.eraMaps || []).filter(e => e.status === 'live' || !e.status) : []
+      this.tagOptions = primary ? (primary.tags || []).map(t => t.tag) : []
+      if (!this.eraMapId && view.activeEraMap) {
+        this.eraMapId = view.activeEraMap.id
+      }
+      this.pins = view.pins || []
+      await this.renderMap(view.activeEraMap)
+    },
+    async renderMap (eraMap) {
+      const L = await loadLeaflet()
+      if (!this.map) {
+        this.map = L.map(this.$refs.mapEl, { scrollWheelZoom: !this.embedded })
+        this.layerGroup = L.layerGroup().addTo(this.map)
+      }
+      if (this.tileLayer) {
+        this.map.removeLayer(this.tileLayer)
+        this.tileLayer = null
+      }
+      this.layerGroup.clearLayers()
+
+      let config = {}
+      try {
+        config = eraMap && eraMap.basemapConfig ? JSON.parse(eraMap.basemapConfig) : {}
+      } catch (e) {
+        config = {}
+      }
+
+      const useImage = eraMap && ['uploaded', 'derived'].includes(eraMap.basemapSource) && config.imageUrl && config.bounds
+      if (useImage) {
+        this.tileLayer = L.imageOverlay(config.imageUrl, config.bounds).addTo(this.map)
+        this.map.fitBounds(config.bounds)
+      } else {
+        const url = config.url || 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png'
+        this.tileLayer = L.tileLayer(url, {
+          attribution: config.attribution || '&copy; OpenStreetMap contributors',
+          maxZoom: 19
+        }).addTo(this.map)
+        const center = config.center || [22.3193, 114.1694]
+        const zoom = config.zoom || 11
+        this.map.setView(center, zoom)
+      }
+
+      this.pins.forEach(pin => {
+        const lat = pin.displayLat != null ? pin.displayLat : pin.lat
+        const lng = pin.displayLng != null ? pin.displayLng : pin.lng
+        if (lat == null || lng == null) { return }
+        const marker = L.marker([lat, lng])
+        marker.bindPopup(`<strong>${_.escape(pin.title)}</strong><br>${_.escape(pin.summary || '')}`)
+        marker.on('click', () => { this.selected = pin })
+        marker.addTo(this.layerGroup)
+      })
+
+      this.$nextTick(() => {
+        if (this.map) {
+          this.map.invalidateSize()
+        }
+      })
+    }
+  },
+  async mounted () {
+    this.$refs.mapEl.style.height = this.embedded ? (this.height || '420px') : this.height
+    if (!this.slug && !this.embedded) {
+      const parts = window.location.pathname.replace(/^\/+|\/+$/g, '').split('/')
+      if (parts[0] === 'chronicle' && parts[1]) {
+        this.slug = decodeURIComponent(parts[1])
+      }
+    }
+    await this.loadChronicleList()
+    await this.reload()
+  },
+  beforeDestroy () {
+    if (this.map) {
+      this.map.remove()
+      this.map = null
+    }
+  }
+}
+</script>
+
+<style scoped>
+.chronicle-map-view {
+  display: flex;
+  flex-direction: column;
+  position: relative;
+  width: 100%;
+  min-height: 320px;
+}
+.chronicle-map-view--page {
+  height: calc(100vh - 64px);
+}
+.chronicle-map-toolbar {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+  padding: 8px 12px;
+  background: rgba(255,255,255,0.92);
+  border-bottom: 1px solid rgba(0,0,0,0.08);
+  z-index: 500;
+}
+.chronicle-map-title {
+  font-weight: 600;
+  margin-right: 8px;
+}
+.chronicle-map-canvas {
+  flex: 1;
+  min-height: 320px;
+  width: 100%;
+  z-index: 1;
+}
+.chronicle-map-sidebar {
+  position: absolute;
+  right: 12px;
+  top: 72px;
+  width: 280px;
+  max-width: calc(100% - 24px);
+  background: #fff;
+  border-radius: 4px;
+  box-shadow: 0 2px 8px rgba(0,0,0,0.18);
+  padding: 12px 14px;
+  z-index: 600;
+}
+</style>
diff --git a/client/themes/default/components/chronicle-embed.vue b/client/themes/default/components/chronicle-embed.vue
new file mode 100644
index 0000000000..4547b53cb4
--- /dev/null
+++ b/client/themes/default/components/chronicle-embed.vue
@@ -0,0 +1,31 @@
+<template lang='pug'>
+  chronicle-map(
+    :initial-slug='slug'
+    :initial-tags='tagList'
+    :initial-era-map-id='eraMapIdNum'
+    :embedded='true'
+    :height='height || "420px"'
+  )
+</template>
+
+<script>
+export default {
+  props: {
+    slug: { type: String, required: true },
+    tags: { type: String, default: '' },
+    eraMapId: { type: [String, Number], default: null },
+    height: { type: String, default: '420px' }
+  },
+  computed: {
+    tagList () {
+      if (!this.tags) { return [] }
+      return String(this.tags).split(',').map(t => t.trim()).filter(Boolean)
+    },
+    eraMapIdNum () {
+      if (this.eraMapId == null || this.eraMapId === '') { return null }
+      const n = Number(this.eraMapId)
+      return Number.isFinite(n) ? n : null
+    }
+  }
+}
+</script>
diff --git a/client/themes/default/components/page.vue b/client/themes/default/components/page.vue
index 73f314f671..d3836bb314 100644
--- a/client/themes/default/components/page.vue
+++ b/client/themes/default/components/page.vue
@@ -393,6 +393,7 @@
 <script>
 import { StatusIndicator } from 'vue-status-indicator'
 import Tabset from './tabset.vue'
+import ChronicleEmbed from './chronicle-embed.vue'
 import NavSidebar from './nav-sidebar.vue'
 import Prism from 'prismjs'
 import mermaid from 'mermaid'
@@ -405,6 +406,7 @@ import gql from 'graphql-tag'
 /* global siteLangs */
 
 Vue.component('Tabset', Tabset)
+Vue.component('ChronicleEmbed', ChronicleEmbed)
 
 Prism.plugins.autoloader.languages_path = '/_assets/js/prism/'
 Prism.plugins.NormalizeWhitespace.setDefaults({
diff --git a/docs/adr/0001-chronicle-as-first-class-aggregate.md b/docs/adr/0001-chronicle-as-first-class-aggregate.md
new file mode 100644
index 0000000000..5bdbe1396d
--- /dev/null
+++ b/docs/adr/0001-chronicle-as-first-class-aggregate.md
@@ -0,0 +1,3 @@
+# Chronicle as a first-class aggregate
+
+Wiki pages must not own chronicle map data. A Chronicle is its own aggregate (Era Maps, Events, Chronicle Tags, drafts). Pages only embed or link via Map View / Chronicle Embed. This keeps master-map, overlays, and cross-page reuse from being trapped in `page.render`, at the cost of a new module surface beside pages.
diff --git a/docs/adr/0002-hybrid-event-placement.md b/docs/adr/0002-hybrid-event-placement.md
new file mode 100644
index 0000000000..10e696d16c
--- /dev/null
+++ b/docs/adr/0002-hybrid-event-placement.md
@@ -0,0 +1,3 @@
+# Hybrid event placement across Era Maps
+
+Each Event stores one Canonical Position in the Chronicle’s shared spatial reference. Each Era Map carries an Alignment transform to project that position onto the basemap. When projection fails for a specific pin, an optional Pin Override stores a per–Event-per–Era-Map position. Chosen over per-map-only pins (no cross-era reuse) and pure automatic projection (too brittle for scanned or fantasy maps).
diff --git a/docs/adr/0003-event-drafts-for-ingest.md b/docs/adr/0003-event-drafts-for-ingest.md
new file mode 100644
index 0000000000..8b06b4acad
--- /dev/null
+++ b/docs/adr/0003-event-drafts-for-ingest.md
@@ -0,0 +1,3 @@
+# Event Drafts for API and AI ingest
+
+Manual create may write Events directly (subject to Chronicle Permissions). Ingest API and AI Analysis produce Event Drafts (and Derived Basemap drafts) that become live only after human approval. Chosen so paranormal/fiction sources can be bulk-imported without letting geocoding or tag mistakes publish unchecked, mirroring the site’s existing pending-review mindset for pages.
diff --git a/docs/adr/0004-independent-chronicle-permissions.md b/docs/adr/0004-independent-chronicle-permissions.md
new file mode 100644
index 0000000000..5a3b80fd44
--- /dev/null
+++ b/docs/adr/0004-independent-chronicle-permissions.md
@@ -0,0 +1,3 @@
+# Independent Chronicle Permissions
+
+Chronicle read/write/approve/manage rights are separate from Wiki Page permissions. Page edit rights must not imply chronicle edit rights. This lets public maps stay world-readable while draft approval and alignment stay with trusted groups, and avoids coupling access to whichever page happens to embed the map.
diff --git a/docs/adr/0005-leaflet-for-2d-map-view.md b/docs/adr/0005-leaflet-for-2d-map-view.md
new file mode 100644
index 0000000000..349a8fcefb
--- /dev/null
+++ b/docs/adr/0005-leaflet-for-2d-map-view.md
@@ -0,0 +1,3 @@
+# Hybrid 2D Map View uses Leaflet
+
+v1 Map View renders in 2D with Leaflet (OSM/public tiles, image overlays for uploaded/derived basemaps). Map Mode still stores `2d|3d|both`, but 3D presentation is deferred. Leaflet was chosen over MapLibre for a smaller dependency and straightforward image-overlay georeferencing; revisit if vector-tile era borders become primary.
diff --git a/docs/adr/0006-heuristic-ai-analysis-v1.md b/docs/adr/0006-heuristic-ai-analysis-v1.md
new file mode 100644
index 0000000000..2355976c40
--- /dev/null
+++ b/docs/adr/0006-heuristic-ai-analysis-v1.md
@@ -0,0 +1,3 @@
+# Heuristic AI Analysis for Event Drafts
+
+v1 ships a local heuristic analyzer (`chronicle-ai`) that extracts candidate Event Drafts from free text (HK place names, years, haunt keywords) without calling an external LLM. Drafts still require human approval. A real provider can replace this behind the same `analyzeText` mutation and `aiMeta.provider` field later.
diff --git a/server/controllers/common.js b/server/controllers/common.js
index f6380ab329..ba08bfefe5 100644
--- a/server/controllers/common.js
+++ b/server/controllers/common.js
@@ -560,6 +560,18 @@ router.get(['/t', '/t/*'], (req, res, next) => {
   res.render('tags')
 })
 
+/**
+ * Chronicle Map
+ */
+router.get(['/chronicle', '/chronicle/*'], (req, res, next) => {
+  if (!WIKI.auth.checkAccess(req.user, ['read:chronicles', 'manage:system'])) {
+    seoHelper.applyPageMeta(res, { title: 'Unauthorized', schema: 'WebPage' })
+    return res.status(403).render('unauthorized')
+  }
+  seoHelper.applyPageMeta(res, { title: 'Chronicle Map', schema: 'WebPage' })
+  res.render('chronicle')
+})
+
 /**
  * User Avatar
  */
diff --git a/server/db/migrations-sqlite/2.5.133.js b/server/db/migrations-sqlite/2.5.133.js
new file mode 100644
index 0000000000..704671893e
--- /dev/null
+++ b/server/db/migrations-sqlite/2.5.133.js
@@ -0,0 +1,112 @@
+exports.up = async knex => {
+  await knex.schema
+    .createTable('chronicles', table => {
+      table.increments('id').primary()
+      table.string('slug', 255).notNullable().unique()
+      table.string('title').notNullable()
+      table.string('description', 2000).notNullable().defaultTo('')
+      table.boolean('isPublished').notNullable().defaultTo(true)
+      table.integer('createdById').unsigned().references('id').inTable('users').onDelete('SET NULL')
+      table.string('createdAt').notNullable()
+      table.string('updatedAt').notNullable()
+    })
+    .createTable('chronicleTags', table => {
+      table.increments('id').primary()
+      table.integer('chronicleId').unsigned().notNullable().references('id').inTable('chronicles').onDelete('CASCADE')
+      table.string('tag', 255).notNullable()
+      table.string('title').notNullable().defaultTo('')
+      table.unique(['chronicleId', 'tag'])
+    })
+    .createTable('chronicleEraMaps', table => {
+      table.increments('id').primary()
+      table.integer('chronicleId').unsigned().notNullable().references('id').inTable('chronicles').onDelete('CASCADE')
+      table.string('title').notNullable()
+      table.string('timeStart', 64).notNullable().defaultTo('')
+      table.string('timeEnd', 64).notNullable().defaultTo('')
+      table.string('mapMode', 16).notNullable().defaultTo('2d')
+      table.string('basemapSource', 32).notNullable().defaultTo('public')
+      table.json('basemapConfig').notNullable()
+      table.json('alignment').notNullable()
+      table.string('status', 20).notNullable().defaultTo('live')
+      table.integer('sortIndex').notNullable().defaultTo(0)
+      table.string('createdAt').notNullable()
+      table.string('updatedAt').notNullable()
+      table.index(['chronicleId', 'status'])
+    })
+    .createTable('chronicleEvents', table => {
+      table.increments('id').primary()
+      table.integer('chronicleId').unsigned().notNullable().references('id').inTable('chronicles').onDelete('CASCADE')
+      table.string('title').notNullable()
+      table.string('summary', 4000).notNullable().defaultTo('')
+      table.string('occurrenceStart', 64).notNullable().defaultTo('')
+      table.string('occurrenceEnd', 64).notNullable().defaultTo('')
+      table.boolean('occurrenceFuzzy').notNullable().defaultTo(false)
+      table.float('lat').notNullable()
+      table.float('lng').notNullable()
+      table.float('elevation').nullable()
+      table.json('footprint').nullable()
+      table.string('status', 20).notNullable().defaultTo('live')
+      table.json('aiMeta').nullable()
+      table.integer('createdById').unsigned().references('id').inTable('users').onDelete('SET NULL')
+      table.integer('approvedById').unsigned().references('id').inTable('users').onDelete('SET NULL')
+      table.string('createdAt').notNullable()
+      table.string('updatedAt').notNullable()
+      table.string('approvedAt').nullable()
+      table.index(['chronicleId', 'status'])
+      table.index(['occurrenceStart', 'occurrenceEnd'])
+    })
+    .createTable('chronicleEventTags', table => {
+      table.integer('eventId').unsigned().notNullable().references('id').inTable('chronicleEvents').onDelete('CASCADE')
+      table.integer('tagId').unsigned().notNullable().references('id').inTable('chronicleTags').onDelete('CASCADE')
+      table.primary(['eventId', 'tagId'])
+    })
+    .createTable('chronicleEventPages', table => {
+      table.integer('eventId').unsigned().notNullable().references('id').inTable('chronicleEvents').onDelete('CASCADE')
+      table.integer('pageId').unsigned().notNullable().references('id').inTable('pages').onDelete('CASCADE')
+      table.primary(['eventId', 'pageId'])
+    })
+    .createTable('chroniclePinOverrides', table => {
+      table.increments('id').primary()
+      table.integer('eventId').unsigned().notNullable().references('id').inTable('chronicleEvents').onDelete('CASCADE')
+      table.integer('eraMapId').unsigned().notNullable().references('id').inTable('chronicleEraMaps').onDelete('CASCADE')
+      table.float('lat').nullable()
+      table.float('lng').nullable()
+      table.float('mapX').nullable()
+      table.float('mapY').nullable()
+      table.unique(['eventId', 'eraMapId'])
+    })
+    .createTable('chronicleVisibilityOverrides', table => {
+      table.increments('id').primary()
+      table.integer('eventId').unsigned().notNullable().references('id').inTable('chronicleEvents').onDelete('CASCADE')
+      table.integer('eraMapId').unsigned().notNullable().references('id').inTable('chronicleEraMaps').onDelete('CASCADE')
+      table.string('mode', 16).notNullable()
+      table.unique(['eventId', 'eraMapId'])
+    })
+
+  const guests = await knex('groups').where('name', 'Guests').first()
+  if (guests) {
+    let permissions = guests.permissions
+    if (typeof permissions === 'string') {
+      permissions = JSON.parse(permissions)
+    }
+    if (!permissions.includes('read:chronicles')) {
+      permissions.push('read:chronicles')
+      await knex('groups').where('id', guests.id).update({
+        permissions: JSON.stringify(permissions),
+        updatedAt: new Date().toISOString()
+      })
+    }
+  }
+}
+
+exports.down = async knex => {
+  await knex.schema
+    .dropTableIfExists('chronicleVisibilityOverrides')
+    .dropTableIfExists('chroniclePinOverrides')
+    .dropTableIfExists('chronicleEventPages')
+    .dropTableIfExists('chronicleEventTags')
+    .dropTableIfExists('chronicleEvents')
+    .dropTableIfExists('chronicleEraMaps')
+    .dropTableIfExists('chronicleTags')
+    .dropTableIfExists('chronicles')
+}
diff --git a/server/db/migrations/2.5.133.js b/server/db/migrations/2.5.133.js
new file mode 100644
index 0000000000..7fa9d09ee4
--- /dev/null
+++ b/server/db/migrations/2.5.133.js
@@ -0,0 +1,126 @@
+/* global WIKI */
+
+exports.up = async knex => {
+  const dbCompat = {
+    charset: (WIKI.config.db.type === `mysql` || WIKI.config.db.type === `mariadb`)
+  }
+
+  await knex.schema
+    .createTable('chronicles', table => {
+      if (dbCompat.charset) { table.charset('utf8mb4') }
+      table.increments('id').primary()
+      table.string('slug', 255).notNullable().unique()
+      table.string('title').notNullable()
+      table.string('description', 2000).notNullable().defaultTo('')
+      table.boolean('isPublished').notNullable().defaultTo(true)
+      table.integer('createdById').unsigned().references('id').inTable('users').onDelete('SET NULL')
+      table.string('createdAt').notNullable()
+      table.string('updatedAt').notNullable()
+    })
+    .createTable('chronicleTags', table => {
+      if (dbCompat.charset) { table.charset('utf8mb4') }
+      table.increments('id').primary()
+      table.integer('chronicleId').unsigned().notNullable().references('id').inTable('chronicles').onDelete('CASCADE')
+      table.string('tag', 255).notNullable()
+      table.string('title').notNullable().defaultTo('')
+      table.unique(['chronicleId', 'tag'])
+    })
+    .createTable('chronicleEraMaps', table => {
+      if (dbCompat.charset) { table.charset('utf8mb4') }
+      table.increments('id').primary()
+      table.integer('chronicleId').unsigned().notNullable().references('id').inTable('chronicles').onDelete('CASCADE')
+      table.string('title').notNullable()
+      table.string('timeStart', 64).notNullable().defaultTo('')
+      table.string('timeEnd', 64).notNullable().defaultTo('')
+      table.string('mapMode', 16).notNullable().defaultTo('2d')
+      table.string('basemapSource', 32).notNullable().defaultTo('public')
+      table.json('basemapConfig').notNullable()
+      table.json('alignment').notNullable()
+      table.string('status', 20).notNullable().defaultTo('live')
+      table.integer('sortIndex').notNullable().defaultTo(0)
+      table.string('createdAt').notNullable()
+      table.string('updatedAt').notNullable()
+      table.index(['chronicleId', 'status'])
+    })
+    .createTable('chronicleEvents', table => {
+      if (dbCompat.charset) { table.charset('utf8mb4') }
+      table.increments('id').primary()
+      table.integer('chronicleId').unsigned().notNullable().references('id').inTable('chronicles').onDelete('CASCADE')
+      table.string('title').notNullable()
+      table.string('summary', 4000).notNullable().defaultTo('')
+      table.string('occurrenceStart', 64).notNullable().defaultTo('')
+      table.string('occurrenceEnd', 64).notNullable().defaultTo('')
+      table.boolean('occurrenceFuzzy').notNullable().defaultTo(false)
+      table.float('lat').notNullable()
+      table.float('lng').notNullable()
+      table.float('elevation').nullable()
+      table.json('footprint').nullable()
+      table.string('status', 20).notNullable().defaultTo('live')
+      table.json('aiMeta').nullable()
+      table.integer('createdById').unsigned().references('id').inTable('users').onDelete('SET NULL')
+      table.integer('approvedById').unsigned().references('id').inTable('users').onDelete('SET NULL')
+      table.string('createdAt').notNullable()
+      table.string('updatedAt').notNullable()
+      table.string('approvedAt').nullable()
+      table.index(['chronicleId', 'status'])
+      table.index(['occurrenceStart', 'occurrenceEnd'])
+    })
+    .createTable('chronicleEventTags', table => {
+      if (dbCompat.charset) { table.charset('utf8mb4') }
+      table.integer('eventId').unsigned().notNullable().references('id').inTable('chronicleEvents').onDelete('CASCADE')
+      table.integer('tagId').unsigned().notNullable().references('id').inTable('chronicleTags').onDelete('CASCADE')
+      table.primary(['eventId', 'tagId'])
+    })
+    .createTable('chronicleEventPages', table => {
+      if (dbCompat.charset) { table.charset('utf8mb4') }
+      table.integer('eventId').unsigned().notNullable().references('id').inTable('chronicleEvents').onDelete('CASCADE')
+      table.integer('pageId').unsigned().notNullable().references('id').inTable('pages').onDelete('CASCADE')
+      table.primary(['eventId', 'pageId'])
+    })
+    .createTable('chroniclePinOverrides', table => {
+      if (dbCompat.charset) { table.charset('utf8mb4') }
+      table.increments('id').primary()
+      table.integer('eventId').unsigned().notNullable().references('id').inTable('chronicleEvents').onDelete('CASCADE')
+      table.integer('eraMapId').unsigned().notNullable().references('id').inTable('chronicleEraMaps').onDelete('CASCADE')
+      table.float('lat').nullable()
+      table.float('lng').nullable()
+      table.float('mapX').nullable()
+      table.float('mapY').nullable()
+      table.unique(['eventId', 'eraMapId'])
+    })
+    .createTable('chronicleVisibilityOverrides', table => {
+      if (dbCompat.charset) { table.charset('utf8mb4') }
+      table.increments('id').primary()
+      table.integer('eventId').unsigned().notNullable().references('id').inTable('chronicleEvents').onDelete('CASCADE')
+      table.integer('eraMapId').unsigned().notNullable().references('id').inTable('chronicleEraMaps').onDelete('CASCADE')
+      table.string('mode', 16).notNullable()
+      table.unique(['eventId', 'eraMapId'])
+    })
+
+  const guests = await knex('groups').where('name', 'Guests').first()
+  if (guests) {
+    let permissions = guests.permissions
+    if (typeof permissions === 'string') {
+      permissions = JSON.parse(permissions)
+    }
+    if (!permissions.includes('read:chronicles')) {
+      permissions.push('read:chronicles')
+      await knex('groups').where('id', guests.id).update({
+        permissions: JSON.stringify(permissions),
+        updatedAt: new Date().toISOString()
+      })
+    }
+  }
+}
+
+exports.down = async knex => {
+  await knex.schema
+    .dropTableIfExists('chronicleVisibilityOverrides')
+    .dropTableIfExists('chroniclePinOverrides')
+    .dropTableIfExists('chronicleEventPages')
+    .dropTableIfExists('chronicleEventTags')
+    .dropTableIfExists('chronicleEvents')
+    .dropTableIfExists('chronicleEraMaps')
+    .dropTableIfExists('chronicleTags')
+    .dropTableIfExists('chronicles')
+}
diff --git a/server/graph/resolvers/chronicle.js b/server/graph/resolvers/chronicle.js
new file mode 100644
index 0000000000..9395abda70
--- /dev/null
+++ b/server/graph/resolvers/chronicle.js
@@ -0,0 +1,571 @@
+const graphHelper = require('../../helpers/graph')
+const chronicleAi = require('../../helpers/chronicle-ai')
+const _ = require('lodash')
+
+/* global WIKI */
+
+function parseJsonArg (value, fallback = null) {
+  if (value == null || value === '') {
+    return fallback
+  }
+  if (_.isObject(value)) {
+    return value
+  }
+  try {
+    return JSON.parse(value)
+  } catch (err) {
+    throw new Error('INVALID_JSON')
+  }
+}
+
+function mapTag (tag) {
+  if (!tag) { return null }
+  return {
+    id: tag.id,
+    tag: tag.tag,
+    title: tag.title || tag.tag
+  }
+}
+
+function mapEraMap (eraMap) {
+  if (!eraMap) { return null }
+  return {
+    id: eraMap.id,
+    chronicleId: eraMap.chronicleId,
+    title: eraMap.title,
+    timeStart: eraMap.timeStart || '',
+    timeEnd: eraMap.timeEnd || '',
+    mapMode: eraMap.mapMode,
+    basemapSource: eraMap.basemapSource,
+    basemapConfig: JSON.stringify(eraMap.basemapConfig || {}),
+    alignment: JSON.stringify(eraMap.alignment || { type: 'identity' }),
+    status: eraMap.status,
+    sortIndex: eraMap.sortIndex || 0,
+    createdAt: eraMap.createdAt,
+    updatedAt: eraMap.updatedAt
+  }
+}
+
+function mapEvent (event) {
+  if (!event) { return null }
+  return {
+    id: event.id,
+    chronicleId: event.chronicleId,
+    title: event.title,
+    summary: event.summary || '',
+    occurrenceStart: event.occurrenceStart || '',
+    occurrenceEnd: event.occurrenceEnd || '',
+    occurrenceFuzzy: !!event.occurrenceFuzzy,
+    lat: event.lat,
+    lng: event.lng,
+    elevation: event.elevation,
+    footprint: event.footprint ? JSON.stringify(event.footprint) : null,
+    status: event.status,
+    tags: (event.tags || []).map(mapTag),
+    pageIds: (event.pages || []).map(p => p.id || p),
+    pinOverrides: (event.pinOverrides || []).map(p => ({
+      id: p.id,
+      eventId: p.eventId,
+      eraMapId: p.eraMapId,
+      lat: p.lat,
+      lng: p.lng,
+      mapX: p.mapX,
+      mapY: p.mapY
+    })),
+    visibilityOverrides: (event.visibilityOverrides || []).map(v => ({
+      id: v.id,
+      eventId: v.eventId,
+      eraMapId: v.eraMapId,
+      mode: v.mode
+    })),
+    displayLat: event.displayLat,
+    displayLng: event.displayLng,
+    positionSource: event.positionSource,
+    aiMeta: event.aiMeta ? JSON.stringify(event.aiMeta) : null,
+    createdAt: event.createdAt,
+    updatedAt: event.updatedAt,
+    approvedAt: event.approvedAt
+  }
+}
+
+function mapChronicle (chronicle) {
+  if (!chronicle) { return null }
+  return {
+    id: chronicle.id,
+    slug: chronicle.slug,
+    title: chronicle.title,
+    description: chronicle.description || '',
+    isPublished: !!chronicle.isPublished,
+    tags: (chronicle.tags || []).map(mapTag),
+    eraMaps: (chronicle.eraMaps || []).map(mapEraMap),
+    events: (chronicle.events || []).map(mapEvent),
+    createdAt: chronicle.createdAt,
+    updatedAt: chronicle.updatedAt
+  }
+}
+
+function canManage (user) {
+  return WIKI.auth.checkAccess(user, ['manage:chronicles', 'manage:system'])
+}
+
+function canWrite (user) {
+  return WIKI.auth.checkAccess(user, ['write:chronicles', 'manage:chronicles', 'manage:system'])
+}
+
+function canApprove (user) {
+  return WIKI.auth.checkAccess(user, ['approve:chronicles', 'manage:chronicles', 'manage:system'])
+}
+
+function canRead (user) {
+  return WIKI.auth.checkAccess(user, ['read:chronicles', 'write:chronicles', 'manage:chronicles', 'manage:system'])
+}
+
+function filterChronicleForViewer (chronicle, { includeDrafts = false, includeUnpublished = false } = {}) {
+  if (!chronicle) { return null }
+  const clone = { ...chronicle }
+  clone.eraMaps = (chronicle.eraMaps || []).filter(em => {
+    if (em.status === 'live') { return true }
+    return includeDrafts || includeUnpublished
+  })
+  clone.events = (chronicle.events || []).filter(ev => {
+    if (ev.status === 'live') { return true }
+    return includeDrafts
+  })
+  return clone
+}
+
+module.exports = {
+  Query: {
+    async chronicles () { return {} }
+  },
+  Mutation: {
+    async chronicles () { return {} }
+  },
+  ChronicleQuery: {
+    async list (obj, args, context) {
+      if (!canRead(context.req.user)) {
+        throw new Error('Forbidden')
+      }
+      const includeUnpublished = !!args.includeUnpublished && canManage(context.req.user)
+      return WIKI.models.chronicles.list({ includeUnpublished })
+    },
+    async single (obj, args, context) {
+      if (!canRead(context.req.user)) {
+        throw new Error('Forbidden')
+      }
+      const includeUnpublished = canManage(context.req.user)
+      const includeDrafts = canApprove(context.req.user)
+      let chronicle = null
+      if (args.id) {
+        chronicle = await WIKI.models.chronicles.query()
+          .findById(args.id)
+          .withGraphFetched('[tags, eraMaps, events.[tags, pinOverrides, visibilityOverrides, pages]]')
+          .modifyGraph('eraMaps', b => b.orderBy('sortIndex').orderBy('id'))
+      } else if (args.slug) {
+        chronicle = await WIKI.models.chronicles.getBySlug(args.slug, { includeUnpublished })
+      }
+      if (!chronicle) {
+        return null
+      }
+      if (!chronicle.isPublished && !includeUnpublished) {
+        return null
+      }
+      return mapChronicle(filterChronicleForViewer(chronicle, { includeDrafts, includeUnpublished }))
+    },
+    async mapView (obj, args, context) {
+      if (!canRead(context.req.user)) {
+        throw new Error('Forbidden')
+      }
+      const includeUnpublished = canManage(context.req.user)
+      const includeDrafts = canApprove(context.req.user)
+      const slugs = [args.slug, ...(args.overlaySlugs || [])].filter(Boolean)
+      const chronicles = []
+      for (const slug of slugs) {
+        const c = await WIKI.models.chronicles.getBySlug(slug, { includeUnpublished })
+        if (c) {
+          chronicles.push(filterChronicleForViewer(c, { includeDrafts, includeUnpublished }))
+        }
+      }
+      if (!chronicles.length) {
+        return { chronicles: [], activeEraMap: null, pins: [] }
+      }
+      const primary = chronicles[0]
+      let eraMap = null
+      if (args.eraMapId) {
+        eraMap = (primary.eraMaps || []).find(e => e.id === args.eraMapId) || null
+      }
+      if (!eraMap) {
+        eraMap = (primary.eraMaps || []).find(e => e.status === 'live') || null
+      }
+
+      const pins = []
+      for (const c of chronicles) {
+        // Overlay chronicles project onto the primary Era Map when available,
+        // so pins share one spatial frame (Canonical Position / overrides).
+        const active = (c.id === primary.id ? eraMap : null) ||
+          (c.eraMaps || []).find(e => e.status === 'live') ||
+          null
+        if (!active) {
+          continue
+        }
+        const projected = WIKI.models.chronicleEvents.projectForEraMap(c.events || [], active, {
+          tags: args.tags,
+          includeDrafts
+        })
+        pins.push(...projected)
+      }
+
+      return {
+        chronicles: chronicles.map(mapChronicle),
+        activeEraMap: mapEraMap(eraMap),
+        pins: pins.map(mapEvent)
+      }
+    },
+    async drafts (obj, args, context) {
+      if (!canApprove(context.req.user)) {
+        throw new Error('Forbidden')
+      }
+      const drafts = await WIKI.models.chronicleEvents.query()
+        .where({
+          chronicleId: args.chronicleId,
+          status: 'draft'
+        })
+        .withGraphFetched('[tags, pages, pinOverrides, visibilityOverrides]')
+        .orderBy('createdAt', 'desc')
+      return drafts.map(mapEvent)
+    }
+  },
+  ChronicleMutation: {
+    async create (obj, args, context) {
+      try {
+        const chronicle = await WIKI.models.chronicles.create({
+          ...args,
+          userId: context.req.user.id
+        })
+        const full = await WIKI.models.chronicles.getBySlug(chronicle.slug, { includeUnpublished: true })
+        return {
+          responseResult: graphHelper.generateSuccess('Chronicle created'),
+          chronicle: mapChronicle(full)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async update (obj, args, context) {
+      try {
+        await WIKI.models.chronicles.update(args.id, args)
+        const chronicle = await WIKI.models.chronicles.query()
+          .findById(args.id)
+          .withGraphFetched('[tags, eraMaps, events.[tags, pinOverrides, visibilityOverrides, pages]]')
+        return {
+          responseResult: graphHelper.generateSuccess('Chronicle updated'),
+          chronicle: mapChronicle(chronicle)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async delete (obj, args) {
+      try {
+        await WIKI.models.chronicles.remove(args.id)
+        return {
+          responseResult: graphHelper.generateSuccess('Chronicle deleted')
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async createEraMap (obj, args) {
+      try {
+        const eraMap = await WIKI.models.chronicleEraMaps.create({
+          ...args,
+          basemapConfig: parseJsonArg(args.basemapConfig, undefined),
+          alignment: parseJsonArg(args.alignment, undefined)
+        })
+        return {
+          responseResult: graphHelper.generateSuccess('Era Map created'),
+          eraMap: mapEraMap(eraMap)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async updateEraMap (obj, args) {
+      try {
+        const patch = { ...args }
+        if (args.basemapConfig !== undefined) {
+          patch.basemapConfig = parseJsonArg(args.basemapConfig, {})
+        }
+        if (args.alignment !== undefined) {
+          patch.alignment = parseJsonArg(args.alignment, { type: 'identity' })
+        }
+        const eraMap = await WIKI.models.chronicleEraMaps.update(args.id, patch)
+        return {
+          responseResult: graphHelper.generateSuccess('Era Map updated'),
+          eraMap: mapEraMap(eraMap)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async deleteEraMap (obj, args) {
+      try {
+        await WIKI.models.chronicleEraMaps.remove(args.id)
+        return {
+          responseResult: graphHelper.generateSuccess('Era Map deleted')
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async createEvent (obj, args, context) {
+      try {
+        if (args.status === 'live' && !canWrite(context.req.user)) {
+          throw new Error('Forbidden')
+        }
+        const event = await WIKI.models.chronicleEvents.create({
+          ...args,
+          footprint: parseJsonArg(args.footprint, null),
+          aiMeta: parseJsonArg(args.aiMeta, null),
+          userId: context.req.user.id,
+          status: args.status || 'live'
+        })
+        return {
+          responseResult: graphHelper.generateSuccess('Event created'),
+          event: mapEvent(event)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async updateEvent (obj, args, context) {
+      try {
+        const existing = await WIKI.models.chronicleEvents.query().findById(args.id)
+        if (!existing) {
+          throw new Error('EVENT_NOT_FOUND')
+        }
+        const patch = { ...args }
+        if (args.footprint !== undefined) {
+          patch.footprint = parseJsonArg(args.footprint, null)
+        }
+        if (args.aiMeta !== undefined) {
+          patch.aiMeta = parseJsonArg(args.aiMeta, null)
+        }
+        // Promoting draft → live requires approve (or manage), not write alone.
+        if (args.status === 'live' && existing.status === 'draft' && !canApprove(context.req.user)) {
+          throw new Error('Forbidden')
+        }
+        const event = await WIKI.models.chronicleEvents.update(args.id, patch)
+        return {
+          responseResult: graphHelper.generateSuccess('Event updated'),
+          event: mapEvent(event)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async approveEventDraft (obj, args, context) {
+      try {
+        const event = await WIKI.models.chronicleEvents.approveDraft(args.id, context.req.user.id)
+        return {
+          responseResult: graphHelper.generateSuccess('Event draft approved'),
+          event: mapEvent(event)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async deleteEvent (obj, args) {
+      try {
+        await WIKI.models.chronicleEvents.remove(args.id)
+        return {
+          responseResult: graphHelper.generateSuccess('Event deleted')
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async setPinOverride (obj, args) {
+      try {
+        const event = await WIKI.models.chronicleEvents.query().findById(args.eventId)
+        if (!event) {
+          throw new Error('EVENT_NOT_FOUND')
+        }
+        const eraMap = await WIKI.models.chronicleEraMaps.query().findById(args.eraMapId)
+        if (!eraMap || eraMap.chronicleId !== event.chronicleId) {
+          throw new Error('ERA_MAP_MISMATCH')
+        }
+        const existing = await WIKI.models.chroniclePinOverrides.query()
+          .where({ eventId: args.eventId, eraMapId: args.eraMapId })
+          .first()
+        if (existing) {
+          await WIKI.models.chroniclePinOverrides.query().findById(existing.id).patch({
+            lat: args.lat != null ? args.lat : null,
+            lng: args.lng != null ? args.lng : null,
+            mapX: args.mapX != null ? args.mapX : null,
+            mapY: args.mapY != null ? args.mapY : null
+          })
+        } else {
+          await WIKI.models.chroniclePinOverrides.query().insert({
+            eventId: args.eventId,
+            eraMapId: args.eraMapId,
+            lat: args.lat != null ? args.lat : null,
+            lng: args.lng != null ? args.lng : null,
+            mapX: args.mapX != null ? args.mapX : null,
+            mapY: args.mapY != null ? args.mapY : null
+          })
+        }
+        const updated = await WIKI.models.chronicleEvents.query()
+          .findById(args.eventId)
+          .withGraphFetched('[tags, pages, pinOverrides, visibilityOverrides]')
+        return {
+          responseResult: graphHelper.generateSuccess('Pin override saved'),
+          event: mapEvent(updated)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async clearPinOverride (obj, args) {
+      try {
+        await WIKI.models.chroniclePinOverrides.query()
+          .where({ eventId: args.eventId, eraMapId: args.eraMapId })
+          .delete()
+        const event = await WIKI.models.chronicleEvents.query()
+          .findById(args.eventId)
+          .withGraphFetched('[tags, pages, pinOverrides, visibilityOverrides]')
+        return {
+          responseResult: graphHelper.generateSuccess('Pin override cleared'),
+          event: mapEvent(event)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async setVisibilityOverride (obj, args) {
+      try {
+        if (!['include', 'exclude'].includes(args.mode)) {
+          throw new Error('INVALID_MODE')
+        }
+        const event = await WIKI.models.chronicleEvents.query().findById(args.eventId)
+        if (!event) {
+          throw new Error('EVENT_NOT_FOUND')
+        }
+        const eraMap = await WIKI.models.chronicleEraMaps.query().findById(args.eraMapId)
+        if (!eraMap || eraMap.chronicleId !== event.chronicleId) {
+          throw new Error('ERA_MAP_MISMATCH')
+        }
+        const existing = await WIKI.models.chronicleVisibilityOverrides.query()
+          .where({ eventId: args.eventId, eraMapId: args.eraMapId })
+          .first()
+        if (existing) {
+          await WIKI.models.chronicleVisibilityOverrides.query().findById(existing.id).patch({ mode: args.mode })
+        } else {
+          await WIKI.models.chronicleVisibilityOverrides.query().insert({
+            eventId: args.eventId,
+            eraMapId: args.eraMapId,
+            mode: args.mode
+          })
+        }
+        const updated = await WIKI.models.chronicleEvents.query()
+          .findById(args.eventId)
+          .withGraphFetched('[tags, pages, pinOverrides, visibilityOverrides]')
+        return {
+          responseResult: graphHelper.generateSuccess('Visibility override saved'),
+          event: mapEvent(updated)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async clearVisibilityOverride (obj, args) {
+      try {
+        await WIKI.models.chronicleVisibilityOverrides.query()
+          .where({ eventId: args.eventId, eraMapId: args.eraMapId })
+          .delete()
+        const event = await WIKI.models.chronicleEvents.query()
+          .findById(args.eventId)
+          .withGraphFetched('[tags, pages, pinOverrides, visibilityOverrides]')
+        return {
+          responseResult: graphHelper.generateSuccess('Visibility override cleared'),
+          event: mapEvent(event)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async ingestEventDraft (obj, args, context) {
+      try {
+        const event = await WIKI.models.chronicleEvents.create({
+          ...args,
+          status: 'draft',
+          aiMeta: parseJsonArg(args.aiMeta, { source: 'ingest' }),
+          userId: context.req.user.id
+        })
+        return {
+          responseResult: graphHelper.generateSuccess('Event draft ingested'),
+          event: mapEvent(event)
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    },
+    async analyzeText (obj, args, context) {
+      try {
+        const chronicle = await WIKI.models.chronicles.query().findById(args.chronicleId)
+        if (!chronicle) {
+          throw new Error('CHRONICLE_NOT_FOUND')
+        }
+        const suggestions = chronicleAi.analyzeTextToDrafts(args.text)
+        const mappedSuggestions = suggestions.map((s, idx) => mapEvent({
+          id: -(idx + 1),
+          chronicleId: args.chronicleId,
+          title: s.title,
+          summary: s.summary,
+          occurrenceStart: s.occurrenceStart,
+          occurrenceEnd: s.occurrenceEnd,
+          occurrenceFuzzy: s.occurrenceFuzzy,
+          lat: s.lat,
+          lng: s.lng,
+          status: 'draft',
+          tags: (s.tags || []).map((t, i) => ({ id: i, tag: t, title: t })),
+          pages: [],
+          pinOverrides: [],
+          visibilityOverrides: [],
+          aiMeta: s.aiMeta,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        }))
+
+        const events = []
+        if (args.persist !== false) {
+          for (const s of suggestions) {
+            const event = await WIKI.models.chronicleEvents.create({
+              chronicleId: args.chronicleId,
+              title: s.title,
+              summary: s.summary,
+              occurrenceStart: s.occurrenceStart,
+              occurrenceEnd: s.occurrenceEnd,
+              occurrenceFuzzy: s.occurrenceFuzzy,
+              lat: s.lat,
+              lng: s.lng,
+              tags: s.tags,
+              status: 'draft',
+              aiMeta: s.aiMeta,
+              userId: context.req.user.id
+            })
+            events.push(mapEvent(event))
+          }
+        }
+
+        return {
+          responseResult: graphHelper.generateSuccess(`Analyzed ${suggestions.length} candidate event(s)`),
+          suggestions: mappedSuggestions,
+          events
+        }
+      } catch (err) {
+        return graphHelper.generateError(err)
+      }
+    }
+  }
+}
diff --git a/server/graph/schemas/chronicle.graphql b/server/graph/schemas/chronicle.graphql
new file mode 100644
index 0000000000..ff46591596
--- /dev/null
+++ b/server/graph/schemas/chronicle.graphql
@@ -0,0 +1,297 @@
+# ===============================================
+# CHRONICLES
+# ===============================================
+
+extend type Query {
+  chronicles: ChronicleQuery
+}
+
+extend type Mutation {
+  chronicles: ChronicleMutation
+}
+
+# -----------------------------------------------
+# QUERIES
+# -----------------------------------------------
+
+type ChronicleQuery {
+  list(
+    includeUnpublished: Boolean
+  ): [ChronicleListItem]! @auth(requires: ["read:chronicles", "write:chronicles", "manage:chronicles", "manage:system"])
+
+  single(
+    id: Int
+    slug: String
+  ): Chronicle @auth(requires: ["read:chronicles", "write:chronicles", "manage:chronicles", "manage:system"])
+
+  mapView(
+    slug: String!
+    eraMapId: Int
+    tags: [String]
+    overlaySlugs: [String]
+  ): ChronicleMapView @auth(requires: ["read:chronicles", "manage:system"])
+
+  drafts(
+    chronicleId: Int!
+  ): [ChronicleEvent]! @auth(requires: ["approve:chronicles", "manage:chronicles", "manage:system"])
+}
+
+# -----------------------------------------------
+# MUTATIONS
+# -----------------------------------------------
+
+type ChronicleMutation {
+  create(
+    slug: String
+    title: String!
+    description: String
+    isPublished: Boolean
+  ): ChronicleResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 20, duration: 60)
+
+  update(
+    id: Int!
+    slug: String
+    title: String
+    description: String
+    isPublished: Boolean
+  ): ChronicleResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 30, duration: 60)
+
+  delete(
+    id: Int!
+  ): DefaultResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 10, duration: 60)
+
+  createEraMap(
+    chronicleId: Int!
+    title: String!
+    timeStart: String
+    timeEnd: String
+    mapMode: String
+    basemapSource: String
+    basemapConfig: String
+    alignment: String
+    status: String
+    sortIndex: Int
+  ): ChronicleEraMapResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 30, duration: 60)
+
+  updateEraMap(
+    id: Int!
+    title: String
+    timeStart: String
+    timeEnd: String
+    mapMode: String
+    basemapSource: String
+    basemapConfig: String
+    alignment: String
+    status: String
+    sortIndex: Int
+  ): ChronicleEraMapResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 30, duration: 60)
+
+  deleteEraMap(
+    id: Int!
+  ): DefaultResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 10, duration: 60)
+
+  createEvent(
+    chronicleId: Int!
+    title: String!
+    summary: String
+    occurrenceStart: String
+    occurrenceEnd: String
+    occurrenceFuzzy: Boolean
+    lat: Float!
+    lng: Float!
+    elevation: Float
+    footprint: String
+    tags: [String]
+    pageIds: [Int]
+    status: String
+    aiMeta: String
+  ): ChronicleEventResponse @auth(requires: ["write:chronicles", "manage:chronicles", "manage:system"]) @rateLimit(limit: 60, duration: 60)
+
+  updateEvent(
+    id: Int!
+    title: String
+    summary: String
+    occurrenceStart: String
+    occurrenceEnd: String
+    occurrenceFuzzy: Boolean
+    lat: Float
+    lng: Float
+    elevation: Float
+    footprint: String
+    tags: [String]
+    pageIds: [Int]
+    status: String
+    aiMeta: String
+  ): ChronicleEventResponse @auth(requires: ["write:chronicles", "manage:chronicles", "manage:system"]) @rateLimit(limit: 60, duration: 60)
+
+  approveEventDraft(
+    id: Int!
+  ): ChronicleEventResponse @auth(requires: ["approve:chronicles", "manage:chronicles", "manage:system"]) @rateLimit(limit: 30, duration: 60)
+
+  deleteEvent(
+    id: Int!
+  ): DefaultResponse @auth(requires: ["write:chronicles", "manage:chronicles", "manage:system"]) @rateLimit(limit: 30, duration: 60)
+
+  setPinOverride(
+    eventId: Int!
+    eraMapId: Int!
+    lat: Float
+    lng: Float
+    mapX: Float
+    mapY: Float
+  ): ChronicleEventResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 60, duration: 60)
+
+  clearPinOverride(
+    eventId: Int!
+    eraMapId: Int!
+  ): ChronicleEventResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 30, duration: 60)
+
+  setVisibilityOverride(
+    eventId: Int!
+    eraMapId: Int!
+    mode: String!
+  ): ChronicleEventResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 60, duration: 60)
+
+  clearVisibilityOverride(
+    eventId: Int!
+    eraMapId: Int!
+  ): ChronicleEventResponse @auth(requires: ["manage:chronicles", "manage:system"]) @rateLimit(limit: 30, duration: 60)
+
+  ingestEventDraft(
+    chronicleId: Int!
+    title: String!
+    summary: String
+    occurrenceStart: String
+    occurrenceEnd: String
+    occurrenceFuzzy: Boolean
+    lat: Float!
+    lng: Float!
+    tags: [String]
+    aiMeta: String
+  ): ChronicleEventResponse @auth(requires: ["write:chronicles", "manage:chronicles", "manage:system"]) @rateLimit(limit: 30, duration: 60)
+
+  analyzeText(
+    chronicleId: Int!
+    text: String!
+    persist: Boolean
+  ): ChronicleAnalyzeResponse @auth(requires: ["write:chronicles", "manage:chronicles", "manage:system"]) @rateLimit(limit: 10, duration: 60)
+}
+
+# -----------------------------------------------
+# TYPES
+# -----------------------------------------------
+
+type ChronicleListItem {
+  id: Int!
+  slug: String!
+  title: String!
+  description: String!
+  isPublished: Boolean!
+  createdAt: Date!
+  updatedAt: Date!
+}
+
+type Chronicle {
+  id: Int!
+  slug: String!
+  title: String!
+  description: String!
+  isPublished: Boolean!
+  tags: [ChronicleTag]!
+  eraMaps: [ChronicleEraMap]!
+  events: [ChronicleEvent]!
+  createdAt: Date!
+  updatedAt: Date!
+}
+
+type ChronicleTag {
+  id: Int!
+  tag: String!
+  title: String!
+}
+
+type ChronicleEraMap {
+  id: Int!
+  chronicleId: Int!
+  title: String!
+  timeStart: String!
+  timeEnd: String!
+  mapMode: String!
+  basemapSource: String!
+  basemapConfig: String!
+  alignment: String!
+  status: String!
+  sortIndex: Int!
+  createdAt: Date!
+  updatedAt: Date!
+}
+
+type ChronicleEvent {
+  id: Int!
+  chronicleId: Int!
+  title: String!
+  summary: String!
+  occurrenceStart: String!
+  occurrenceEnd: String!
+  occurrenceFuzzy: Boolean!
+  lat: Float!
+  lng: Float!
+  elevation: Float
+  footprint: String
+  status: String!
+  tags: [ChronicleTag]!
+  pageIds: [Int]!
+  pinOverrides: [ChroniclePinOverride]!
+  visibilityOverrides: [ChronicleVisibilityOverride]!
+  displayLat: Float
+  displayLng: Float
+  positionSource: String
+  aiMeta: String
+  createdAt: Date!
+  updatedAt: Date!
+  approvedAt: Date
+}
+
+type ChroniclePinOverride {
+  id: Int!
+  eventId: Int!
+  eraMapId: Int!
+  lat: Float
+  lng: Float
+  mapX: Float
+  mapY: Float
+}
+
+type ChronicleVisibilityOverride {
+  id: Int!
+  eventId: Int!
+  eraMapId: Int!
+  mode: String!
+}
+
+type ChronicleMapView {
+  chronicles: [Chronicle]!
+  activeEraMap: ChronicleEraMap
+  pins: [ChronicleEvent]!
+}
+
+type ChronicleResponse {
+  responseResult: ResponseStatus
+  chronicle: Chronicle
+}
+
+type ChronicleEraMapResponse {
+  responseResult: ResponseStatus
+  eraMap: ChronicleEraMap
+}
+
+type ChronicleEventResponse {
+  responseResult: ResponseStatus
+  event: ChronicleEvent
+}
+
+type ChronicleAnalyzeResponse {
+  responseResult: ResponseStatus
+  suggestions: [ChronicleEvent]!
+  events: [ChronicleEvent]!
+}
diff --git a/server/helpers/chronicle-ai.js b/server/helpers/chronicle-ai.js
new file mode 100644
index 0000000000..e2f66a3d36
--- /dev/null
+++ b/server/helpers/chronicle-ai.js
@@ -0,0 +1,121 @@
+/**
+ * Heuristic "AI Analysis" stub for Chronicle Event Drafts.
+ * Produces structured draft suggestions from free text without an external LLM.
+ * Replace/extend later with a real provider via aiMeta.provider.
+ */
+
+const HK_PLACES = [
+  { names: ['中環', 'central'], lat: 22.2819, lng: 114.1556, tag: 'urban' },
+  { names: ['旺角', 'mong kok', 'mongkok'], lat: 22.3193, lng: 114.1694, tag: 'urban' },
+  { names: ['尖沙咀', 'tsim sha tsui', 'tst'], lat: 22.2976, lng: 114.1722, tag: 'urban' },
+  { names: ['銅鑼灣', 'causeway bay'], lat: 22.2800, lng: 114.1850, tag: 'urban' },
+  { names: ['灣仔', 'wan chai', 'wanchai'], lat: 22.2770, lng: 114.1733, tag: 'urban' },
+  { names: ['油麻地', 'yau ma tei'], lat: 22.3120, lng: 114.1700, tag: 'urban' },
+  { names: ['深水埗', 'sham shui po'], lat: 22.3307, lng: 114.1622, tag: 'urban' },
+  { names: ['觀塘', 'kwun tong'], lat: 22.3120, lng: 114.2265, tag: 'urban' },
+  { names: ['荃灣', 'tsuen wan'], lat: 22.3714, lng: 114.1139, tag: 'urban' },
+  { names: ['沙田', 'sha tin', 'shatin'], lat: 22.3870, lng: 114.1910, tag: 'urban' },
+  { names: ['大嶼山', 'lantau'], lat: 22.2669, lng: 113.9420, tag: 'outlying' },
+  { names: ['長洲', 'cheung chau'], lat: 22.2092, lng: 114.0286, tag: 'outlying' },
+  { names: ['西貢', 'sai kung'], lat: 22.3819, lng: 114.2733, tag: 'outlying' },
+  { names: ['太平山', 'victoria peak', 'the peak'], lat: 22.2759, lng: 114.1455, tag: 'haunt' },
+  { names: ['新娘潭', 'bride\'s pool', 'brides pool'], lat: 22.5040, lng: 114.2500, tag: 'haunt' },
+  { names: ['南丫島', 'lamma'], lat: 22.2000, lng: 114.1350, tag: 'outlying' },
+  { names: ['薄扶林', 'pok fu lam', 'pokfulam'], lat: 22.2600, lng: 114.1380, tag: 'haunt' },
+  { names: ['衙前圍', 'nga tsin wai'], lat: 22.3350, lng: 114.1950, tag: 'haunt' },
+  { names: ['香港', 'hong kong'], lat: 22.3193, lng: 114.1694, tag: 'urban' }
+]
+
+const HAUNT_KEYWORDS = ['鬼', '靈異', '凶宅', 'haunt', 'ghost', 'paranormal', '靈', '冤', '自殺', '命案']
+
+function findPlace (text) {
+  const lower = text.toLowerCase()
+  for (const place of HK_PLACES) {
+    for (const name of place.names) {
+      if (lower.includes(name.toLowerCase()) || text.includes(name)) {
+        return { ...place, matchedName: name }
+      }
+    }
+  }
+  return null
+}
+
+function findYear (text) {
+  const m = text.match(/(?:公元)?\s*((?:1[6-9]|20)\d{2})\s*年?|(?:in\s+)?((?:1[6-9]|20)\d{2})\b/i)
+  if (!m) {
+    return { start: '', end: '', fuzzy: true }
+  }
+  const year = m[1] || m[2]
+  return { start: year, end: year, fuzzy: /約|左右|大概|around|circa|~|～/.test(text) }
+}
+
+function looksHaunted (text) {
+  const lower = text.toLowerCase()
+  return HAUNT_KEYWORDS.some(k => lower.includes(k.toLowerCase()) || text.includes(k))
+}
+
+/**
+ * Split free text into candidate event lines/paragraphs and suggest drafts.
+ * @param {string} text
+ * @param {object} [opts]
+ * @returns {Array<object>} draft payloads (not yet persisted)
+ */
+function analyzeTextToDrafts (text, opts = {}) {
+  const raw = String(text || '').trim()
+  if (!raw) {
+    return []
+  }
+
+  const chunks = raw
+    .split(/\n+/)
+    .map(s => s.trim())
+    .filter(s => s.length >= 4)
+
+  const drafts = []
+  for (const chunk of chunks) {
+    const place = findPlace(chunk)
+    const year = findYear(chunk)
+    const haunt = looksHaunted(chunk)
+    if (!place && !haunt && !year.start) {
+      continue
+    }
+    const lat = place ? place.lat : (opts.defaultLat != null ? opts.defaultLat : 22.3193)
+    const lng = place ? place.lng : (opts.defaultLng != null ? opts.defaultLng : 114.1694)
+    const tags = []
+    if (haunt) { tags.push('haunt') }
+    if (place && place.tag) { tags.push(place.tag) }
+
+    let title = chunk
+    if (title.length > 80) {
+      title = title.slice(0, 77) + '…'
+    }
+    if (place) {
+      title = `${place.matchedName} — ${title}`.slice(0, 120)
+    }
+
+    drafts.push({
+      title,
+      summary: chunk,
+      occurrenceStart: year.start,
+      occurrenceEnd: year.end,
+      occurrenceFuzzy: year.fuzzy || !year.start,
+      lat,
+      lng,
+      tags: [...new Set(tags)],
+      aiMeta: {
+        provider: 'heuristic-v1',
+        matchedPlace: place ? place.matchedName : null,
+        confidence: place && year.start ? 0.75 : (place || year.start ? 0.55 : 0.35),
+        sourceExcerpt: chunk
+      }
+    })
+  }
+  return drafts
+}
+
+module.exports = {
+  HK_PLACES,
+  analyzeTextToDrafts,
+  findPlace,
+  findYear
+}
diff --git a/server/helpers/chronicle-map.js b/server/helpers/chronicle-map.js
new file mode 100644
index 0000000000..fed017835b
--- /dev/null
+++ b/server/helpers/chronicle-map.js
@@ -0,0 +1,106 @@
+/**
+ * Chronicle map domain helpers — visibility + pin projection.
+ */
+
+function parseYear (value) {
+  if (value === null || value === undefined || value === '') {
+    return null
+  }
+  const n = Number(String(value).trim())
+  return Number.isFinite(n) ? n : null
+}
+
+/**
+ * Does Occurrence intersect an Era Map time range?
+ * Empty bounds on either side mean "unbounded".
+ */
+function timeRangesIntersect (occurrenceStart, occurrenceEnd, mapStart, mapEnd) {
+  const oStart = parseYear(occurrenceStart)
+  const oEnd = parseYear(occurrenceEnd !== '' && occurrenceEnd != null ? occurrenceEnd : occurrenceStart)
+  const mStart = parseYear(mapStart)
+  const mEnd = parseYear(mapEnd)
+
+  if (oStart == null && oEnd == null) {
+    return true
+  }
+  const eventStart = oStart != null ? oStart : oEnd
+  const eventEnd = oEnd != null ? oEnd : oStart
+
+  if (mStart == null && mEnd == null) {
+    return true
+  }
+  const eraStart = mStart != null ? mStart : Number.NEGATIVE_INFINITY
+  const eraEnd = mEnd != null ? mEnd : Number.POSITIVE_INFINITY
+
+  return eventStart <= eraEnd && eventEnd >= eraStart
+}
+
+/**
+ * Resolve whether an Event is visible on an Era Map.
+ * @param {object} opts
+ * @param {string} opts.occurrenceStart
+ * @param {string} opts.occurrenceEnd
+ * @param {string} opts.mapTimeStart
+ * @param {string} opts.mapTimeEnd
+ * @param {'include'|'exclude'|null|undefined} opts.visibilityOverride
+ */
+function isEventVisibleOnEraMap (opts) {
+  if (opts.visibilityOverride === 'include') {
+    return true
+  }
+  if (opts.visibilityOverride === 'exclude') {
+    return false
+  }
+  return timeRangesIntersect(
+    opts.occurrenceStart,
+    opts.occurrenceEnd,
+    opts.mapTimeStart,
+    opts.mapTimeEnd
+  )
+}
+
+/**
+ * Resolve display position for an Event on an Era Map.
+ * Pin Override wins; otherwise Canonical Position (identity alignment)
+ * or a simple bilinear estimate from control points when provided.
+ */
+function resolveEventPosition (opts) {
+  const { event, eraMap, pinOverride } = opts
+
+  if (pinOverride) {
+    if (pinOverride.lat != null && pinOverride.lng != null) {
+      return { lat: pinOverride.lat, lng: pinOverride.lng, source: 'override' }
+    }
+    if (pinOverride.mapX != null && pinOverride.mapY != null && eraMap.basemapConfig) {
+      const bounds = eraMap.basemapConfig.bounds
+      if (bounds && bounds.length === 2) {
+        const [[south, west], [north, east]] = bounds
+        return {
+          lat: south + (north - south) * (1 - pinOverride.mapY),
+          lng: west + (east - west) * pinOverride.mapX,
+          source: 'override-xy'
+        }
+      }
+    }
+  }
+
+  const alignment = eraMap.alignment || { type: 'identity' }
+  if (!alignment.type || alignment.type === 'identity') {
+    return { lat: event.lat, lng: event.lng, source: 'canonical' }
+  }
+
+  // Control-point alignment: if we have bounds on the image overlay in lat/lng
+  // space already (post-warped), treat as identity for display.
+  if (alignment.type === 'controlPoints' && eraMap.basemapConfig && eraMap.basemapConfig.bounds) {
+    return { lat: event.lat, lng: event.lng, source: 'canonical-aligned' }
+  }
+
+  return { lat: event.lat, lng: event.lng, source: 'canonical' }
+}
+
+module.exports = {
+  parseYear,
+  timeRangesIntersect,
+  isEventVisibleOnEraMap,
+  resolveEventPosition
+}
diff --git a/server/models/chronicleEraMaps.js b/server/models/chronicleEraMaps.js
new file mode 100644
index 0000000000..f199ee2d45
--- /dev/null
+++ b/server/models/chronicleEraMaps.js
@@ -0,0 +1,117 @@
+const Model = require('objection').Model
+
+/* global WIKI */
+
+const DEFAULT_ALIGNMENT = { type: 'identity' }
+const DEFAULT_BASEMAP = {
+  provider: 'osm',
+  url: 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
+  attribution: '&copy; OpenStreetMap contributors',
+  center: [22.3193, 114.1694],
+  zoom: 11
+}
+
+module.exports = class ChronicleEraMap extends Model {
+  static get tableName() { return 'chronicleEraMaps' }
+
+  static get jsonAttributes() {
+    return ['basemapConfig', 'alignment']
+  }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['chronicleId', 'title'],
+      properties: {
+        id: { type: 'integer' },
+        chronicleId: { type: 'integer' },
+        title: { type: 'string' },
+        timeStart: { type: 'string' },
+        timeEnd: { type: 'string' },
+        mapMode: { type: 'string' },
+        basemapSource: { type: 'string' },
+        basemapConfig: { type: 'object' },
+        alignment: { type: 'object' },
+        status: { type: 'string' },
+        sortIndex: { type: 'integer' }
+      }
+    }
+  }
+
+  static get relationMappings() {
+    return {
+      chronicle: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: require('./chronicles'),
+        join: {
+          from: 'chronicleEraMaps.chronicleId',
+          to: 'chronicles.id'
+        }
+      }
+    }
+  }
+
+  $beforeInsert() {
+    this.createdAt = new Date().toISOString()
+    this.updatedAt = new Date().toISOString()
+    if (!this.basemapConfig) {
+      this.basemapConfig = { ...DEFAULT_BASEMAP }
+    }
+    if (!this.alignment) {
+      this.alignment = { ...DEFAULT_ALIGNMENT }
+    }
+    if (!this.mapMode) {
+      this.mapMode = '2d'
+    }
+    if (!this.basemapSource) {
+      this.basemapSource = 'public'
+    }
+    if (!this.status) {
+      this.status = 'live'
+    }
+    if (this.sortIndex == null) {
+      this.sortIndex = 0
+    }
+    if (!this.timeStart) {
+      this.timeStart = ''
+    }
+    if (!this.timeEnd) {
+      this.timeEnd = ''
+    }
+  }
+
+  $beforeUpdate() {
+    this.updatedAt = new Date().toISOString()
+  }
+
+  static async create (opts) {
+    const status = opts.status || (opts.basemapSource === 'derived' ? 'draft' : 'live')
+    return WIKI.models.chronicleEraMaps.query().insertAndFetch({
+      chronicleId: opts.chronicleId,
+      title: opts.title,
+      timeStart: opts.timeStart || '',
+      timeEnd: opts.timeEnd || '',
+      mapMode: opts.mapMode || '2d',
+      basemapSource: opts.basemapSource || 'public',
+      basemapConfig: opts.basemapConfig || { ...DEFAULT_BASEMAP },
+      alignment: opts.alignment || { ...DEFAULT_ALIGNMENT },
+      status,
+      sortIndex: opts.sortIndex || 0
+    })
+  }
+
+  static async update (id, opts) {
+    const patch = {}
+    ;['title', 'timeStart', 'timeEnd', 'mapMode', 'basemapSource', 'basemapConfig', 'alignment', 'status', 'sortIndex'].forEach(k => {
+      if (opts[k] !== undefined) {
+        patch[k] = opts[k]
+      }
+    })
+    await WIKI.models.chronicleEraMaps.query().findById(id).patch(patch)
+    return WIKI.models.chronicleEraMaps.query().findById(id)
+  }
+
+  static async remove (id) {
+    return WIKI.models.chronicleEraMaps.query().deleteById(id)
+  }
+}
diff --git a/server/models/chronicleEvents.js b/server/models/chronicleEvents.js
new file mode 100644
index 0000000000..c49c5644e3
--- /dev/null
+++ b/server/models/chronicleEvents.js
@@ -0,0 +1,243 @@
+const Model = require('objection').Model
+const _ = require('lodash')
+const chronicleMapHelper = require('../helpers/chronicle-map')
+
+/* global WIKI */
+
+module.exports = class ChronicleEvent extends Model {
+  static get tableName() { return 'chronicleEvents' }
+
+  static get jsonAttributes() {
+    return ['footprint', 'aiMeta']
+  }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['chronicleId', 'title', 'lat', 'lng'],
+      properties: {
+        id: { type: 'integer' },
+        chronicleId: { type: 'integer' },
+        title: { type: 'string' },
+        summary: { type: 'string' },
+        occurrenceStart: { type: 'string' },
+        occurrenceEnd: { type: 'string' },
+        occurrenceFuzzy: { type: 'boolean' },
+        lat: { type: 'number' },
+        lng: { type: 'number' },
+        elevation: { type: ['number', 'null'] },
+        footprint: { type: ['object', 'null'] },
+        status: { type: 'string' },
+        aiMeta: { type: ['object', 'null'] },
+        createdById: { type: ['integer', 'null'] },
+        approvedById: { type: ['integer', 'null'] }
+      }
+    }
+  }
+
+  static get relationMappings() {
+    return {
+      chronicle: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: require('./chronicles'),
+        join: {
+          from: 'chronicleEvents.chronicleId',
+          to: 'chronicles.id'
+        }
+      },
+      tags: {
+        relation: Model.ManyToManyRelation,
+        modelClass: require('./chronicleTags'),
+        join: {
+          from: 'chronicleEvents.id',
+          through: {
+            from: 'chronicleEventTags.eventId',
+            to: 'chronicleEventTags.tagId'
+          },
+          to: 'chronicleTags.id'
+        }
+      },
+      pages: {
+        relation: Model.ManyToManyRelation,
+        modelClass: require('./pages'),
+        join: {
+          from: 'chronicleEvents.id',
+          through: {
+            from: 'chronicleEventPages.eventId',
+            to: 'chronicleEventPages.pageId'
+          },
+          to: 'pages.id'
+        }
+      },
+      pinOverrides: {
+        relation: Model.HasManyRelation,
+        modelClass: require('./chroniclePinOverrides'),
+        join: {
+          from: 'chronicleEvents.id',
+          to: 'chroniclePinOverrides.eventId'
+        }
+      },
+      visibilityOverrides: {
+        relation: Model.HasManyRelation,
+        modelClass: require('./chronicleVisibilityOverrides'),
+        join: {
+          from: 'chronicleEvents.id',
+          to: 'chronicleVisibilityOverrides.eventId'
+        }
+      }
+    }
+  }
+
+  $beforeInsert() {
+    this.createdAt = new Date().toISOString()
+    this.updatedAt = new Date().toISOString()
+    if (!this.summary) {
+      this.summary = ''
+    }
+    if (!this.occurrenceStart) {
+      this.occurrenceStart = ''
+    }
+    if (!this.occurrenceEnd) {
+      this.occurrenceEnd = ''
+    }
+    if (this.occurrenceFuzzy == null) {
+      this.occurrenceFuzzy = false
+    }
+    if (!this.status) {
+      this.status = 'live'
+    }
+  }
+
+  $beforeUpdate() {
+    this.updatedAt = new Date().toISOString()
+  }
+
+  static async create (opts) {
+    const status = opts.status || 'live'
+    const event = await WIKI.models.chronicleEvents.query().insertAndFetch({
+      chronicleId: opts.chronicleId,
+      title: opts.title,
+      summary: opts.summary || '',
+      occurrenceStart: opts.occurrenceStart || '',
+      occurrenceEnd: opts.occurrenceEnd || '',
+      occurrenceFuzzy: !!opts.occurrenceFuzzy,
+      lat: opts.lat,
+      lng: opts.lng,
+      elevation: opts.elevation != null ? opts.elevation : null,
+      footprint: opts.footprint || null,
+      status,
+      aiMeta: opts.aiMeta || null,
+      createdById: opts.userId || null,
+      approvedById: status === 'live' ? (opts.userId || null) : null,
+      approvedAt: status === 'live' ? new Date().toISOString() : null
+    })
+
+    if (opts.tags && opts.tags.length) {
+      const tags = await WIKI.models.chronicleTags.ensureTags(opts.chronicleId, opts.tags)
+      await event.$relatedQuery('tags').relate(tags.map(t => t.id))
+    }
+    if (opts.pageIds && opts.pageIds.length) {
+      await event.$relatedQuery('pages').relate(opts.pageIds)
+    }
+
+    return WIKI.models.chronicleEvents.query()
+      .findById(event.id)
+      .withGraphFetched('[tags, pages, pinOverrides, visibilityOverrides]')
+  }
+
+  static async update (id, opts) {
+    const event = await WIKI.models.chronicleEvents.query().findById(id)
+    if (!event) {
+      throw new Error('EVENT_NOT_FOUND')
+    }
+    const patch = _.pick(opts, [
+      'title', 'summary', 'occurrenceStart', 'occurrenceEnd', 'occurrenceFuzzy',
+      'lat', 'lng', 'elevation', 'footprint', 'status', 'aiMeta'
+    ])
+    await WIKI.models.chronicleEvents.query().findById(id).patch(patch)
+
+    if (opts.tags) {
+      const tags = await WIKI.models.chronicleTags.ensureTags(event.chronicleId, opts.tags)
+      await event.$relatedQuery('tags').unrelate()
+      if (tags.length) {
+        await event.$relatedQuery('tags').relate(tags.map(t => t.id))
+      }
+    }
+    if (opts.pageIds) {
+      await event.$relatedQuery('pages').unrelate()
+      if (opts.pageIds.length) {
+        await event.$relatedQuery('pages').relate(opts.pageIds)
+      }
+    }
+
+    return WIKI.models.chronicleEvents.query()
+      .findById(id)
+      .withGraphFetched('[tags, pages, pinOverrides, visibilityOverrides]')
+  }
+
+  static async approveDraft (id, userId) {
+    const event = await WIKI.models.chronicleEvents.query().findById(id)
+    if (!event) {
+      throw new Error('EVENT_NOT_FOUND')
+    }
+    if (event.status !== 'draft') {
+      throw new Error('NOT_A_DRAFT')
+    }
+    await WIKI.models.chronicleEvents.query().findById(id).patch({
+      status: 'live',
+      approvedById: userId,
+      approvedAt: new Date().toISOString()
+    })
+    return WIKI.models.chronicleEvents.query()
+      .findById(id)
+      .withGraphFetched('[tags, pages, pinOverrides, visibilityOverrides]')
+  }
+
+  static async remove (id) {
+    return WIKI.models.chronicleEvents.query().deleteById(id)
+  }
+
+  /**
+   * Events visible on an Era Map after Occurrence ∩ range + Visibility Override,
+   * with resolved pin positions.
+   */
+  static projectForEraMap (events, eraMap, { tags = null, includeDrafts = false } = {}) {
+    const tagFilter = tags && tags.length ?
+      new Set(tags.map(t => String(t).toLowerCase())) :
+      null
+
+    return events
+      .filter(ev => includeDrafts || ev.status === 'live')
+      .filter(ev => {
+        if (!tagFilter) {
+          return true
+        }
+        const evTags = (ev.tags || []).map(t => t.tag || t)
+        return evTags.some(t => tagFilter.has(String(t).toLowerCase()))
+      })
+      .filter(ev => {
+        const override = (ev.visibilityOverrides || []).find(v => v.eraMapId === eraMap.id)
+        return chronicleMapHelper.isEventVisibleOnEraMap({
+          occurrenceStart: ev.occurrenceStart,
+          occurrenceEnd: ev.occurrenceEnd,
+          mapTimeStart: eraMap.timeStart,
+          mapTimeEnd: eraMap.timeEnd,
+          visibilityOverride: override ? override.mode : null
+        })
+      })
+      .map(ev => {
+        const pinOverride = (ev.pinOverrides || []).find(p => p.eraMapId === eraMap.id)
+        const pos = chronicleMapHelper.resolveEventPosition({
+          event: ev,
+          eraMap,
+          pinOverride
+        })
+        return {
+          ...ev,
+          displayLat: pos.lat,
+          displayLng: pos.lng,
+          positionSource: pos.source
+        }
+      })
+  }
+}
diff --git a/server/models/chroniclePinOverrides.js b/server/models/chroniclePinOverrides.js
new file mode 100644
index 0000000000..6dbca0f020
--- /dev/null
+++ b/server/models/chroniclePinOverrides.js
@@ -0,0 +1,21 @@
+const Model = require('objection').Model
+
+module.exports = class ChroniclePinOverride extends Model {
+  static get tableName() { return 'chroniclePinOverrides' }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['eventId', 'eraMapId'],
+      properties: {
+        id: { type: 'integer' },
+        eventId: { type: 'integer' },
+        eraMapId: { type: 'integer' },
+        lat: { type: ['number', 'null'] },
+        lng: { type: ['number', 'null'] },
+        mapX: { type: ['number', 'null'] },
+        mapY: { type: ['number', 'null'] }
+      }
+    }
+  }
+}
diff --git a/server/models/chronicleTags.js b/server/models/chronicleTags.js
new file mode 100644
index 0000000000..3606da973d
--- /dev/null
+++ b/server/models/chronicleTags.js
@@ -0,0 +1,64 @@
+const Model = require('objection').Model
+
+/* global WIKI */
+
+module.exports = class ChronicleTag extends Model {
+  static get tableName() { return 'chronicleTags' }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['chronicleId', 'tag'],
+      properties: {
+        id: { type: 'integer' },
+        chronicleId: { type: 'integer' },
+        tag: { type: 'string' },
+        title: { type: 'string' }
+      }
+    }
+  }
+
+  static get relationMappings() {
+    return {
+      chronicle: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: require('./chronicles'),
+        join: {
+          from: 'chronicleTags.chronicleId',
+          to: 'chronicles.id'
+        }
+      },
+      events: {
+        relation: Model.ManyToManyRelation,
+        modelClass: require('./chronicleEvents'),
+        join: {
+          from: 'chronicleTags.id',
+          through: {
+            from: 'chronicleEventTags.tagId',
+            to: 'chronicleEventTags.eventId'
+          },
+          to: 'chronicleEvents.id'
+        }
+      }
+    }
+  }
+
+  static async ensureTags (chronicleId, tags = []) {
+    const normalized = [...new Set(tags.map(t => String(t).trim().toLowerCase()).filter(Boolean))]
+    const existing = await WIKI.models.chronicleTags.query().where('chronicleId', chronicleId)
+    const byTag = new Map(existing.map(t => [t.tag, t]))
+    const result = []
+    for (const tag of normalized) {
+      if (byTag.has(tag)) {
+        result.push(byTag.get(tag))
+      } else {
+        result.push(await WIKI.models.chronicleTags.query().insertAndFetch({
+          chronicleId,
+          tag,
+          title: tag
+        }))
+      }
+    }
+    return result
+  }
+}
diff --git a/server/models/chronicleVisibilityOverrides.js b/server/models/chronicleVisibilityOverrides.js
new file mode 100644
index 0000000000..e09962022c
--- /dev/null
+++ b/server/models/chronicleVisibilityOverrides.js
@@ -0,0 +1,18 @@
+const Model = require('objection').Model
+
+module.exports = class ChronicleVisibilityOverride extends Model {
+  static get tableName() { return 'chronicleVisibilityOverrides' }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['eventId', 'eraMapId', 'mode'],
+      properties: {
+        id: { type: 'integer' },
+        eventId: { type: 'integer' },
+        eraMapId: { type: 'integer' },
+        mode: { type: 'string' }
+      }
+    }
+  }
+}
diff --git a/server/models/chronicles.js b/server/models/chronicles.js
new file mode 100644
index 0000000000..5f5417f900
--- /dev/null
+++ b/server/models/chronicles.js
@@ -0,0 +1,150 @@
+const Model = require('objection').Model
+const _ = require('lodash')
+
+/* global WIKI */
+
+/**
+ * Chronicle aggregate root
+ */
+module.exports = class Chronicle extends Model {
+  static get tableName() { return 'chronicles' }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['slug', 'title'],
+      properties: {
+        id: { type: 'integer' },
+        slug: { type: 'string' },
+        title: { type: 'string' },
+        description: { type: 'string' },
+        isPublished: { type: 'boolean' },
+        createdById: { type: ['integer', 'null'] }
+      }
+    }
+  }
+
+  static get relationMappings() {
+    return {
+      eraMaps: {
+        relation: Model.HasManyRelation,
+        modelClass: require('./chronicleEraMaps'),
+        join: {
+          from: 'chronicles.id',
+          to: 'chronicleEraMaps.chronicleId'
+        }
+      },
+      events: {
+        relation: Model.HasManyRelation,
+        modelClass: require('./chronicleEvents'),
+        join: {
+          from: 'chronicles.id',
+          to: 'chronicleEvents.chronicleId'
+        }
+      },
+      tags: {
+        relation: Model.HasManyRelation,
+        modelClass: require('./chronicleTags'),
+        join: {
+          from: 'chronicles.id',
+          to: 'chronicleTags.chronicleId'
+        }
+      },
+      createdBy: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: require('./users'),
+        join: {
+          from: 'chronicles.createdById',
+          to: 'users.id'
+        }
+      }
+    }
+  }
+
+  $beforeInsert() {
+    this.createdAt = new Date().toISOString()
+    this.updatedAt = new Date().toISOString()
+    if (this.isPublished == null) {
+      this.isPublished = true
+    }
+    if (!this.description) {
+      this.description = ''
+    }
+  }
+
+  $beforeUpdate() {
+    this.updatedAt = new Date().toISOString()
+  }
+
+  static normalizeSlug (slug) {
+    return _.chain(slug)
+      .toLower()
+      .trim()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-|-$/g, '')
+      .value()
+  }
+
+  static async list ({ includeUnpublished = false } = {}) {
+    let q = WIKI.models.chronicles.query().orderBy('title')
+    if (!includeUnpublished) {
+      q = q.where('isPublished', true)
+    }
+    return q
+  }
+
+  static async getBySlug (slug, { includeUnpublished = false } = {}) {
+    let q = WIKI.models.chronicles.query()
+      .where('slug', slug)
+      .withGraphFetched('[tags, eraMaps, events.[tags, pinOverrides, visibilityOverrides, pages]]')
+      .modifyGraph('eraMaps', b => b.orderBy('sortIndex').orderBy('id'))
+      .modifyGraph('events', b => b.orderBy('occurrenceStart').orderBy('id'))
+      .first()
+    const chronicle = await q
+    if (!chronicle) {
+      return null
+    }
+    if (!includeUnpublished && !chronicle.isPublished) {
+      return null
+    }
+    return chronicle
+  }
+
+  static async create (opts) {
+    const slug = this.normalizeSlug(opts.slug || opts.title)
+    if (!slug) {
+      throw new Error('INVALID_SLUG')
+    }
+    const existing = await WIKI.models.chronicles.query().where('slug', slug).first()
+    if (existing) {
+      throw new Error('SLUG_EXISTS')
+    }
+    return WIKI.models.chronicles.query().insertAndFetch({
+      slug,
+      title: opts.title,
+      description: opts.description || '',
+      isPublished: opts.isPublished !== false,
+      createdById: opts.userId || null
+    })
+  }
+
+  static async update (id, opts) {
+    const patch = _.pick(opts, ['title', 'description', 'isPublished'])
+    if (opts.slug) {
+      patch.slug = this.normalizeSlug(opts.slug)
+      const clash = await WIKI.models.chronicles.query()
+        .where('slug', patch.slug)
+        .whereNot('id', id)
+        .first()
+      if (clash) {
+        throw new Error('SLUG_EXISTS')
+      }
+    }
+    await WIKI.models.chronicles.query().findById(id).patch(patch)
+    return WIKI.models.chronicles.query().findById(id)
+  }
+
+  static async remove (id) {
+    return WIKI.models.chronicles.query().deleteById(id)
+  }
+}
diff --git a/server/modules/rendering/html-chronicle-embed/definition.yml b/server/modules/rendering/html-chronicle-embed/definition.yml
new file mode 100644
index 0000000000..5a6f0637c8
--- /dev/null
+++ b/server/modules/rendering/html-chronicle-embed/definition.yml
@@ -0,0 +1,8 @@
+key: htmlChronicleEmbed
+title: Chronicle Embed
+description: Embed a Chronicle Map View from a fenced chronicle-embed code block
+author: hktrpg
+icon: mdi-map-marker-radius
+enabledDefault: true
+dependsOn: htmlCore
+props: {}
diff --git a/server/modules/rendering/html-chronicle-embed/renderer.js b/server/modules/rendering/html-chronicle-embed/renderer.js
new file mode 100644
index 0000000000..b984739765
--- /dev/null
+++ b/server/modules/rendering/html-chronicle-embed/renderer.js
@@ -0,0 +1,39 @@
+module.exports = {
+  async init($, config) {
+    $('pre.chronicle-embed > code, code.chronicle-embed, pre > code.language-chronicle-embed').each((idx, elm) => {
+      let raw = $(elm).text() || ''
+      let slug = ''
+      let tags = ''
+      let eraMapId = ''
+      let height = '420px'
+      try {
+        const parsed = JSON.parse(raw)
+        slug = parsed.slug || ''
+        tags = Array.isArray(parsed.tags) ? parsed.tags.join(',') : (parsed.tags || '')
+        eraMapId = parsed.eraMapId != null ? String(parsed.eraMapId) : ''
+        height = parsed.height || height
+      } catch (err) {
+        raw.split(/\n/).forEach(line => {
+          const m = line.match(/^\s*([a-zA-Z]+)\s*:\s*(.+)\s*$/)
+          if (!m) { return }
+          const key = m[1].toLowerCase()
+          const val = m[2].trim()
+          if (key === 'slug') { slug = val }
+          if (key === 'tags') { tags = val }
+          if (key === 'eramapid' || key === 'era_map_id') { eraMapId = val }
+          if (key === 'height') { height = val }
+        })
+      }
+      if (!slug) { return }
+      const attrs = [
+        `slug="${slug.replace(/"/g, '&quot;')}"`,
+        tags ? `tags="${String(tags).replace(/"/g, '&quot;')}"` : '',
+        eraMapId ? `era-map-id="${eraMapId}"` : '',
+        `height="${height.replace(/"/g, '&quot;')}"`
+      ].filter(Boolean).join(' ')
+      const parent = $(elm).closest('pre')
+      const target = parent.length ? parent : $(elm)
+      target.replaceWith(`<chronicle-embed ${attrs}></chronicle-embed>`)
+    })
+  }
+}
diff --git a/server/modules/rendering/html-security/renderer.js b/server/modules/rendering/html-security/renderer.js
index b57aaf1b88..cac30167e2 100644
--- a/server/modules/rendering/html-security/renderer.js
+++ b/server/modules/rendering/html-security/renderer.js
@@ -7,8 +7,8 @@ module.exports = {
       const window = new JSDOM('').window
       const DOMPurify = createDOMPurify(window)
 
-      const allowedAttrs = ['v-pre', 'v-slot:tabs', 'v-slot:content', 'target']
-      const allowedTags = ['tabset', 'template']
+      const allowedAttrs = ['v-pre', 'v-slot:tabs', 'v-slot:content', 'target', 'slug', 'tags', 'era-map-id', 'height']
+      const allowedTags = ['tabset', 'template', 'chronicle-embed']
 
       if (config.allowDrawIoUnsafe) {
         allowedTags.push('foreignObject')
diff --git a/server/setup.js b/server/setup.js
index f4d1296766..2c86a8c718 100644
--- a/server/setup.js
+++ b/server/setup.js
@@ -248,7 +248,7 @@ module.exports = () => {
       })
       const guestGroup = await WIKI.models.groups.query().insert({
         name: 'Guests',
-        permissions: JSON.stringify(['read:pages', 'read:assets', 'read:comments', 'write:comments', 'write:pages:pending']),
+        permissions: JSON.stringify(['read:pages', 'read:assets', 'read:comments', 'write:comments', 'write:pages:pending', 'read:chronicles']),
         pageRules: JSON.stringify([
           { id: 'guest', roles: ['read:pages', 'read:assets', 'read:comments', 'write:comments', 'write:pages:pending'], match: 'START', deny: false, path: '', locales: [] }
         ]),
diff --git a/server/test/helpers/chronicle-ai.test.js b/server/test/helpers/chronicle-ai.test.js
new file mode 100644
index 0000000000..1bcfdc5d2d
--- /dev/null
+++ b/server/test/helpers/chronicle-ai.test.js
@@ -0,0 +1,27 @@
+const { analyzeTextToDrafts, findPlace, findYear } = require('../../helpers/chronicle-ai')
+
+describe('chronicle-ai heuristic analysis', () => {
+  test('extracts HK place and year into a draft', () => {
+    const drafts = analyzeTextToDrafts('1920年中環有靈異傳聞，行人夜半聽見腳步聲。')
+    expect(drafts.length).toBe(1)
+    expect(drafts[0].lat).toBeCloseTo(22.2819, 3)
+    expect(drafts[0].occurrenceStart).toBe('1920')
+    expect(drafts[0].tags).toEqual(expect.arrayContaining(['haunt', 'urban']))
+    expect(drafts[0].aiMeta.provider).toBe('heuristic-v1')
+  })
+
+  test('skips unrelated short noise', () => {
+    expect(analyzeTextToDrafts('hi\nok')).toEqual([])
+  })
+
+  test('findPlace matches english aliases', () => {
+    const p = findPlace('A ghost story near Bride\'s Pool')
+    expect(p.matchedName.toLowerCase()).toContain('bride')
+  })
+
+  test('findYear detects fuzzy markers', () => {
+    const y = findYear('約 1985 年附近')
+    expect(y.start).toBe('1985')
+    expect(y.fuzzy).toBe(true)
+  })
+})
diff --git a/server/test/helpers/chronicle-map.test.js b/server/test/helpers/chronicle-map.test.js
new file mode 100644
index 0000000000..d55e916888
--- /dev/null
+++ b/server/test/helpers/chronicle-map.test.js
@@ -0,0 +1,67 @@
+const {
+  timeRangesIntersect,
+  isEventVisibleOnEraMap,
+  resolveEventPosition
+} = require('../../helpers/chronicle-map')
+
+describe('chronicle-map helpers', () => {
+  describe('timeRangesIntersect', () => {
+    test('overlaps when event falls inside era', () => {
+      expect(timeRangesIntersect('1920', '1925', '1900', '1950')).toBe(true)
+    })
+
+    test('no overlap when event is outside era', () => {
+      expect(timeRangesIntersect('1980', '1985', '1900', '1950')).toBe(false)
+    })
+
+    test('point occurrence uses start as end', () => {
+      expect(timeRangesIntersect('1941', '', '1939', '1945')).toBe(true)
+    })
+
+    test('unbounded era accepts any dated event', () => {
+      expect(timeRangesIntersect('1800', '1801', '', '')).toBe(true)
+    })
+  })
+
+  describe('isEventVisibleOnEraMap', () => {
+    test('force include wins over non-overlap', () => {
+      expect(isEventVisibleOnEraMap({
+        occurrenceStart: '2000',
+        occurrenceEnd: '2001',
+        mapTimeStart: '1800',
+        mapTimeEnd: '1850',
+        visibilityOverride: 'include'
+      })).toBe(true)
+    })
+
+    test('force exclude wins over overlap', () => {
+      expect(isEventVisibleOnEraMap({
+        occurrenceStart: '1920',
+        occurrenceEnd: '1921',
+        mapTimeStart: '1900',
+        mapTimeEnd: '1950',
+        visibilityOverride: 'exclude'
+      })).toBe(false)
+    })
+  })
+
+  describe('resolveEventPosition', () => {
+    test('uses canonical position with identity alignment', () => {
+      const pos = resolveEventPosition({
+        event: { lat: 22.3, lng: 114.2 },
+        eraMap: { alignment: { type: 'identity' } },
+        pinOverride: null
+      })
+      expect(pos).toEqual({ lat: 22.3, lng: 114.2, source: 'canonical' })
+    })
+
+    test('pin override replaces projection', () => {
+      const pos = resolveEventPosition({
+        event: { lat: 22.3, lng: 114.2 },
+        eraMap: { alignment: { type: 'identity' } },
+        pinOverride: { lat: 22.4, lng: 114.1 }
+      })
+      expect(pos).toEqual({ lat: 22.4, lng: 114.1, source: 'override' })
+    })
+  })
+})
diff --git a/server/views/chronicle.pug b/server/views/chronicle.pug
new file mode 100644
index 0000000000..87715745ff
--- /dev/null
+++ b/server/views/chronicle.pug
@@ -0,0 +1,5 @@
+extends master.pug
+
+block body
+  #root
+    chronicle-map