diff --git a/.gitignore b/.gitignore
index 2137a8aa..fc9e9a6e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -124,6 +124,7 @@ DerivedData/
 .classpath
 .settings/
 .devcontainer/
+.devcontainer
 
 # JetBrains
 *.iws
diff --git a/src/lib/components/vault/prompts/PromptPackEditor.svelte b/src/lib/components/vault/prompts/PromptPackEditor.svelte
index 025e4396..0f455811 100644
--- a/src/lib/components/vault/prompts/PromptPackEditor.svelte
+++ b/src/lib/components/vault/prompts/PromptPackEditor.svelte
@@ -1,7 +1,8 @@
 <script lang="ts">
   import { untrack } from 'svelte'
   import type { FullPack } from '$lib/services/packs/types'
-  import { systemSamples, runtimeSamples } from './sampleContext'
+  import { getSamplesForTemplate, getSampleAtPath, stringifySample } from './sampleContext'
+  import { getVariablesForTemplate } from '$lib/services/templates/templateContextMap'
   import { packService } from '$lib/services/packs/pack-service'
   import { createIsMobile } from '$lib/hooks/is-mobile.svelte'
   import TemplateGroupList from './TemplateGroupList.svelte'
@@ -71,11 +72,18 @@
   $effect(() => {
     const vars = fullPack?.variables
     if (!vars) return
-    // Build complete defaults: system + runtime samples + custom variable defaults
-    const defaults: Record<string, string> = { ...systemSamples, ...runtimeSamples }
+    // Build complete defaults: registry variable samples (by declared path) + custom variable defaults
+    const samples = selectedTemplateId ? getSamplesForTemplate(selectedTemplateId) : {}
+    const registryVars = selectedTemplateId ? getVariablesForTemplate(selectedTemplateId) : []
+    const defaults: Record<string, string> = {}
+    for (const v of registryVars) {
+      const sample = getSampleAtPath(samples, v.name)
+      if (sample === null || sample === undefined) continue
+      defaults[v.name] = stringifySample(sample)
+    }
     for (const v of vars) {
       if (v.defaultValue) {
-        defaults[v.variableName] = v.defaultValue
+        defaults['packVariables.' + v.variableName] = v.defaultValue
       }
     }
     // Read current testValues without creating a dependency (avoid infinite loop)
@@ -308,6 +316,7 @@
           {/if}
 
           <VariablePalette
+            templateId={selectedTemplateId}
             iconOnly
             customVariables={fullPack?.variables ?? []}
             onInsert={(name) => editorRef?.insertVariable(name)}
@@ -405,6 +414,7 @@
         {/if}
 
         <VariablePalette
+          templateId={selectedTemplateId}
           customVariables={fullPack?.variables ?? []}
           onInsert={(name) => editorRef?.insertVariable(name)}
         />
@@ -628,14 +638,18 @@
   </Drawer.Root>
 {/if}
 
-<!-- Test Variables modal -->
-<TestVariablesModal
-  open={showTestVars}
-  customVariables={fullPack?.variables ?? []}
-  {testValues}
-  onOpenChange={(open) => (showTestVars = open)}
-  onTestValuesChange={handleTestValuesChange}
-/>
+<!-- Test Variables modal — only mounted when a template is selected to avoid
+     rendering an empty palette with no context. -->
+{#if selectedTemplateId}
+  <TestVariablesModal
+    templateId={selectedTemplateId}
+    open={showTestVars}
+    customVariables={fullPack?.variables ?? []}
+    {testValues}
+    onOpenChange={(open) => (showTestVars = open)}
+    onTestValuesChange={handleTestValuesChange}
+  />
+{/if}
 
 <!-- Dirty guard dialog -->
 <Dialog.Root bind:open={showDirtyDialog}>
diff --git a/src/lib/components/vault/prompts/TemplateEditor.svelte b/src/lib/components/vault/prompts/TemplateEditor.svelte
index 64c04eb1..819e54e0 100644
--- a/src/lib/components/vault/prompts/TemplateEditor.svelte
+++ b/src/lib/components/vault/prompts/TemplateEditor.svelte
@@ -8,11 +8,11 @@
   import { database } from '$lib/services/database'
   import { packService } from '$lib/services/packs/pack-service'
   import { validateTemplate } from '$lib/services/templates/validator'
-  import { variableRegistry } from '$lib/services/templates/variables'
+  import { getVariablesForTemplate } from '$lib/services/templates/templateContextMap'
+  import { getSamplesForTemplate } from './sampleContext'
   import type { ValidationError, VariableDefinition } from '$lib/services/templates/types'
   import type { CustomVariable } from '$lib/services/packs/types'
   import type { Completion } from '@codemirror/autocomplete'
-  import { allSamples } from './sampleContext'
   import { AlertTriangle, CircleCheck, FlaskConical } from 'lucide-svelte'
   import { Button } from '$lib/components/ui/button'
   import TemplatePreview from './TemplatePreview.svelte'
@@ -123,7 +123,7 @@
         vals.textContent = `Values: ${v.enumValues.join(', ')}`
       } else if (v.type === 'text' || v.type === 'number') {
         // text/number variables show example value from sampleContext
-        const sample = allSamples[v.name]
+        const sample = getSamplesForTemplate(templateId)[v.name]
         if (sample != null) {
           const example = dom.appendChild(document.createElement('p'))
           example.className = 'cm-var-hint'
@@ -138,17 +138,17 @@
   // Build variable completions for CodeMirror autocomplete
   let completions: Completion[] = $derived.by(() => {
     const result: Completion[] = []
-    for (const v of variableRegistry.getAll()) {
+    for (const v of getVariablesForTemplate(templateId)) {
       result.push({
         label: v.name,
         type: 'variable',
-        detail: v.category,
+        detail: v.type,
         info: buildTooltipInfo(v),
       })
     }
     for (const v of customVariables) {
       result.push({
-        label: v.variableName,
+        label: 'packVariables.' + v.variableName,
         type: 'variable',
         detail: 'custom',
         info: v.displayName,
@@ -335,8 +335,8 @@
   function validateContent(content: string) {
     clearTimeout(validationTimer)
     validationTimer = setTimeout(() => {
-      const additionalVarNames = customVariables.map((v) => v.variableName)
-      const result = validateTemplate(content, additionalVarNames)
+      const additionalVarNames = customVariables.map((v) => 'packVariables.' + v.variableName)
+      const result = validateTemplate(content, templateId, additionalVarNames)
       validationErrors = result.errors
     }, 500)
   }
@@ -494,6 +494,7 @@
         class:hidden={isMobile.current && mobileView === 'editor'}
       >
         <TemplatePreview
+          {templateId}
           content={currentContent}
           {customVariables}
           hideHeader={isMobile.current}
diff --git a/src/lib/components/vault/prompts/TemplatePreview.svelte b/src/lib/components/vault/prompts/TemplatePreview.svelte
index 97e13766..fa2e4205 100644
--- a/src/lib/components/vault/prompts/TemplatePreview.svelte
+++ b/src/lib/components/vault/prompts/TemplatePreview.svelte
@@ -1,54 +1,91 @@
 <script lang="ts">
   import { templateEngine } from '$lib/services/templates/engine'
-  import { variableRegistry } from '$lib/services/templates/variables'
-  import { allSamples } from './sampleContext'
+  import { getSamplesForTemplate } from './sampleContext'
+  import { getVariablesForTemplate } from '$lib/services/templates/templateContextMap'
   import type { CustomVariable } from '$lib/services/packs/types'
-  import type { TemplateContext } from '$lib/services/templates/types'
+  import type { TemplateContext, VariableType } from '$lib/services/templates/types'
   import { AlertTriangle } from 'lucide-svelte'
 
   interface Props {
+    templateId: string
     content: string
     customVariables: CustomVariable[]
     hideHeader?: boolean
     testValues?: Record<string, string>
   }
 
-  let { content, customVariables, hideHeader = false, testValues }: Props = $props()
+  let { templateId, content, customVariables, hideHeader = false, testValues }: Props = $props()
 
-  function buildSampleContext(
-    vars: CustomVariable[],
-    overrides?: Record<string, string>,
-  ): TemplateContext {
-    // Start with rich sample data (includes structured arrays/objects)
-    const context: TemplateContext = { ...allSamples }
+  function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown) {
+    const parts = path.split('.')
+    let current: Record<string, unknown> = obj
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!(parts[i] in current) || typeof current[parts[i]] !== 'object') {
+        current[parts[i]] = {}
+      }
+      current = current[parts[i]] as Record<string, unknown>
+    }
+    current[parts[parts.length - 1]] = value
+  }
 
-    // Bracket-name fallback only for variables missing from allSamples
-    for (const v of variableRegistry.getByCategory('system')) {
-      if (!(v.name in context)) {
-        context[v.name] = `[${v.name}]`
+  type ParseResult = { ok: true; value: unknown } | { ok: false; error: string }
+
+  function parseOverride(value: string, type: VariableType | undefined): ParseResult {
+    if (type === 'array' || type === 'object') {
+      try {
+        return { ok: true, value: JSON.parse(value) }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        return { ok: false, error: msg }
+      }
+    }
+    if (type === 'number') {
+      const n = Number(value)
+      if (!Number.isFinite(n)) {
+        return { ok: false, error: `'${value}' is not a valid number` }
       }
+      return { ok: true, value: n }
     }
-    for (const v of variableRegistry.getByCategory('runtime')) {
+    if (type === 'boolean') {
+      return { ok: true, value: value === 'true' }
+    }
+    return { ok: true, value }
+  }
+
+  function buildSampleContext(
+    vars: CustomVariable[],
+    overrides: Record<string, string> | undefined,
+  ): { context: TemplateContext; overrideErrors: string[] } {
+    const context: TemplateContext = { ...getSamplesForTemplate(templateId) }
+    const registryVars = getVariablesForTemplate(templateId)
+    const typesByName = new Map(registryVars.map((v) => [v.name, v.type]))
+    for (const v of registryVars) {
       if (!(v.name in context)) {
         context[v.name] = `[${v.name}]`
       }
     }
+    // Custom pack variables: place under packVariables namespace
     for (const v of vars) {
-      if (!(v.variableName in context)) {
-        context[v.variableName] = `[${v.displayName}]`
-      }
+      const path = 'packVariables.' + v.variableName
+      setNestedValue(context, path, `[${v.displayName}]`)
     }
-
-    // Apply test value overrides (string overrides from TestVariablesModal)
+    const overrideErrors: string[] = []
     if (overrides) {
       for (const [key, value] of Object.entries(overrides)) {
-        if (value !== '') {
-          context[key] = value
+        if (value === '') continue
+        const result = parseOverride(value, typesByName.get(key))
+        if (!result.ok) {
+          overrideErrors.push(`${key}: ${result.error}`)
+          continue
+        }
+        if (key.includes('.')) {
+          setNestedValue(context, key, result.value)
+        } else {
+          context[key] = result.value
         }
       }
     }
-
-    return context
+    return { context, overrideErrors }
   }
 
   // Debounced rendering
@@ -70,7 +107,7 @@
         return
       }
 
-      const context = buildSampleContext(currentVars, currentTestValues)
+      const { context, overrideErrors } = buildSampleContext(currentVars, currentTestValues)
       const result = templateEngine.render(currentContent, context)
 
       if (result === null) {
@@ -78,7 +115,10 @@
         previewOutput = ''
       } else {
         previewOutput = result
-        previewError = ''
+        previewError =
+          overrideErrors.length > 0
+            ? `Ignored invalid test override${overrideErrors.length === 1 ? '' : 's'}: ${overrideErrors.join('; ')}`
+            : ''
       }
     }, 300)
 
diff --git a/src/lib/components/vault/prompts/TestVariablesModal.svelte b/src/lib/components/vault/prompts/TestVariablesModal.svelte
index c3f87170..d2957e80 100644
--- a/src/lib/components/vault/prompts/TestVariablesModal.svelte
+++ b/src/lib/components/vault/prompts/TestVariablesModal.svelte
@@ -1,7 +1,11 @@
 <script lang="ts">
   import type { CustomVariable } from '$lib/services/packs/types'
   import type { VariableDefinition } from '$lib/services/templates/types'
-  import { variableRegistry } from '$lib/services/templates/variables'
+  import {
+    getDisplayGroupsForTemplate,
+    getVariablesForTemplate,
+  } from '$lib/services/templates/templateContextMap'
+  import { getSamplesForTemplate, getSampleAtPath } from './sampleContext'
   import * as ResponsiveModal from '$lib/components/ui/responsive-modal'
   import * as Collapsible from '$lib/components/ui/collapsible'
   import * as Select from '$lib/components/ui/select'
@@ -13,6 +17,7 @@
   import { RotateCcw, Search, ChevronDown } from 'lucide-svelte'
 
   interface Props {
+    templateId: string
     open: boolean
     customVariables: CustomVariable[]
     testValues: Record<string, string>
@@ -20,157 +25,43 @@
     onTestValuesChange: (values: Record<string, string>) => void
   }
 
-  let { open, customVariables, testValues, onOpenChange, onTestValuesChange }: Props = $props()
+  let { templateId, open, customVariables, testValues, onOpenChange, onTestValuesChange }: Props =
+    $props()
 
   let draft = $state<Record<string, string>>({})
   let searchQuery = $state('')
 
   // Collapsible open states
-  let systemOpen = $state(true)
   let customOpen = $state(true)
-  const systemVars = variableRegistry.getByCategory('system')
-  const runtimeVars = variableRegistry.getByCategory('runtime')
+  let groupOpenStates = $state<Record<string, boolean>>({})
 
-  // Runtime variable groupings
-  const RUNTIME_GROUPS: { name: string; varNames: string[] }[] = [
-    {
-      name: 'Narrative',
-      varNames: [
-        'recentContent',
-        'lorebookEntries',
-        'chapters',
-        'storyEntries',
-        'timelineFill',
-        'styleReview',
-        'agenticReasoning',
-        'agenticChapterSummary',
-        'agenticSelectedEntries',
-        'visualProseMode',
-        'inlineImageMode',
-      ],
-    },
-    {
-      name: 'Classifier',
-      varNames: [
-        'entityCounts',
-        'currentTimeInfo',
-        'chatHistory',
-        'characters',
-        'storyBeats',
-        'runtimeVariables',
-        'inputLabel',
-        'userAction',
-        'narrativeResponse',
-        'storyBeatTypes',
-        'itemLocationOptions',
-        'defaultItemLocation',
-      ],
-    },
-    {
-      name: 'Memory',
-      varNames: [
-        'chapterEntries',
-        'previousChapters',
-        'messagesInRange',
-        'firstValidId',
-        'lastValidId',
-        'recentEntries',
-        'maxChaptersPerRetrieval',
-      ],
-    },
-    {
-      name: 'Suggestions & Actions',
-      varNames: [
-        'activeThreads',
-        'npcsPresent',
-        'inventory',
-        'activeQuests',
-        'protagonistDescription',
-        'povInstruction',
-        'lengthInstruction',
-        'userInput',
-      ],
-    },
-    {
-      name: 'Style & Lore',
-      varNames: ['passageCount', 'passages'],
-    },
-    {
-      name: 'Retrieval',
-      varNames: ['chaptersCount', 'entriesCount', 'loreEntries', 'loreChapters'],
-    },
-    {
-      name: 'Translation',
-      varNames: [
-        'targetLanguage',
-        'sourceLanguage',
-        'content',
-        'elementsJson',
-        'suggestionsJson',
-        'choicesJson',
-      ],
-    },
-    {
-      name: 'Image',
-      varNames: [
-        'imageStylePrompt',
-        'sceneCharacters',
-        'narrationEntries',
-        'lastNarrationIndex',
-        'maxImages',
-        'chatHistory',
-        'translatedNarrativeBlock',
-        'visualDescriptors',
-      ],
-    },
-    {
-      name: 'Wizard',
-      varNames: [
-        'genreLabel',
-        'seed',
-        'customInstruction',
-        'currentSetting',
-        'toneInstruction',
-        'settingInstruction',
-        'characterInput',
-        'settingContext',
-        'currentCharacter',
-        'settingName',
-        'count',
-        'protagonist',
-        'title',
-        'atmosphere',
-        'supportingCharacters',
-        'tenseInstruction',
-        'currentOpening',
-        'openingGuidance',
-        'settingAtmosphere',
-        'settingThemesText',
-        'cardContent',
-        'lorebookName',
-        'entriesJson',
-        'entryCount',
-      ],
-    },
-    {
-      name: 'Timeline',
-      varNames: ['chapters', 'storyEntries', 'query'],
-    },
-  ]
+  function isGroupOpen(label: string): boolean {
+    return groupOpenStates[label] ?? true
+  }
 
-  const runtimeGroups = $derived.by(() =>
-    RUNTIME_GROUPS.map((g) => ({
-      name: g.name,
-      variables: g.varNames
-        .map((name) => runtimeVars.find((v) => v.name === name))
-        .filter((v): v is VariableDefinition => v != null),
-    })).filter((g) => g.variables.length > 0),
-  )
+  function setGroupOpen(label: string, open: boolean) {
+    groupOpenStates = { ...groupOpenStates, [label]: open }
+  }
 
-  // Initialize runtime open states (all collapsed)
-  let runtimeOpenStates = $state<Record<string, boolean>>(
-    Object.fromEntries(RUNTIME_GROUPS.map((g) => [g.name, false])),
-  )
+  let samples = $derived(getSamplesForTemplate(templateId))
+
+  function shouldUseTextarea(name: string, type?: string): boolean {
+    if (type === 'array' || type === 'object') return true
+    const sample = getSampleAtPath(samples, name)
+    return typeof sample === 'string' && (sample.length > 80 || sample.includes('\n'))
+  }
+
+  let displayGroups = $derived.by(() => {
+    const groups = getDisplayGroupsForTemplate(templateId)
+    const allVars = getVariablesForTemplate(templateId)
+    const varMap = new Map(allVars.map((v) => [v.name, v]))
+    return groups.map((g) => ({
+      label: g.label,
+      variables: g.variables
+        .map((name) => varMap.get(name))
+        .filter((v): v is VariableDefinition => v != null),
+    }))
+  })
 
   // Sync draft when modal opens
   $effect(() => {
@@ -195,20 +86,19 @@
     return name.toLowerCase().includes(q) || description.toLowerCase().includes(q)
   }
 
-  let filteredSystem = $derived(systemVars.filter((v) => matchesSearch(v.name, v.description)))
-  let filteredCustom = $derived(
-    customVariables.filter((v) =>
-      matchesSearch(v.variableName, v.displayName + ' ' + (v.description ?? '')),
-    ),
-  )
-  let filteredRuntimeGroups = $derived(
-    runtimeGroups
+  let filteredGroups = $derived(
+    displayGroups
       .map((g) => ({
         ...g,
         variables: g.variables.filter((v) => matchesSearch(v.name, v.description)),
       }))
       .filter((g) => g.variables.length > 0),
   )
+  let filteredCustom = $derived(
+    customVariables.filter((v) =>
+      matchesSearch(v.variableName, v.displayName + ' ' + (v.description ?? '')),
+    ),
+  )
   let overrideCount = $derived(Object.values(draft).filter((v) => v !== '').length)
 </script>
 
@@ -254,6 +144,14 @@
           oninput={(e) => updateDraft(name, e.currentTarget.value)}
           class="h-7 text-xs"
         />
+      {:else if type === 'array' || type === 'object'}
+        <Textarea
+          value={draft[name] ?? ''}
+          oninput={(e) => updateDraft(name, e.currentTarget.value)}
+          rows={6}
+          class="font-mono text-[11px]"
+          placeholder="JSON"
+        />
       {:else if useTextarea}
         <Textarea
           value={draft[name] ?? ''}
@@ -301,31 +199,41 @@
     <!-- Scrollable variable list -->
     <div class="max-h-[60vh] overflow-y-auto px-6 py-3">
       <div class="divide-border divide-y">
-        <!-- System -->
-        {#if filteredSystem.length > 0}
-          <Collapsible.Root bind:open={systemOpen}>
+        {#each filteredGroups as group (group.label)}
+          <Collapsible.Root
+            open={isGroupOpen(group.label)}
+            onOpenChange={(v) => setGroupOpen(group.label, v)}
+          >
             <Collapsible.Trigger class="flex w-full">
               <div class="flex w-full items-center gap-2 py-1.5">
                 <ChevronDown
-                  class="text-muted-foreground h-4 w-4 shrink-0 transition-transform duration-200 {systemOpen
+                  class="text-muted-foreground h-4 w-4 shrink-0 transition-transform duration-200 {isGroupOpen(
+                    group.label,
+                  )
                     ? ''
                     : '-rotate-90'}"
                 />
-                <span class="text-sm font-medium">System</span>
-                <Badge variant="default" class="text-[10px]">{filteredSystem.length}</Badge>
+                <span class="text-sm font-medium">{group.label}</span>
+                <Badge variant="secondary" class="text-[10px]">{group.variables.length}</Badge>
               </div>
             </Collapsible.Trigger>
             <Collapsible.Content>
               <div class="divide-border/50 divide-y pl-6">
-                {#each filteredSystem as v (v.name)}
-                  {@render varInput(v.name, v.description, v.type, v.enumValues)}
+                {#each group.variables as v (v.name)}
+                  {@render varInput(
+                    v.name,
+                    v.description,
+                    v.type,
+                    v.enumValues,
+                    shouldUseTextarea(v.name, v.type),
+                  )}
                 {/each}
               </div>
             </Collapsible.Content>
           </Collapsible.Root>
-        {/if}
+        {/each}
 
-        <!-- Custom -->
+        <!-- Custom (Pack Variables) -->
         {#if filteredCustom.length > 0}
           <Collapsible.Root bind:open={customOpen}>
             <Collapsible.Trigger class="flex w-full">
@@ -335,7 +243,7 @@
                     ? ''
                     : '-rotate-90'}"
                 />
-                <span class="text-sm font-medium">Custom</span>
+                <span class="text-sm font-medium">Custom (Pack Variables)</span>
                 <Badge variant="default" class="text-[10px]">{filteredCustom.length}</Badge>
               </div>
             </Collapsible.Trigger>
@@ -343,7 +251,7 @@
               <div class="divide-border/50 divide-y pl-6">
                 {#each filteredCustom as v (v.id)}
                   {@render varInput(
-                    v.variableName,
+                    'packVariables.' + v.variableName,
                     v.displayName + (v.description ? ` — ${v.description}` : ''),
                     v.variableType,
                     v.enumOptions?.map((o) => o.value),
@@ -354,32 +262,6 @@
             </Collapsible.Content>
           </Collapsible.Root>
         {/if}
-
-        <!-- Runtime groups -->
-        {#each filteredRuntimeGroups as group (group.name)}
-          <Collapsible.Root bind:open={runtimeOpenStates[group.name]}>
-            <Collapsible.Trigger class="flex w-full">
-              <div class="flex w-full items-center gap-2 py-1.5">
-                <ChevronDown
-                  class="text-muted-foreground h-4 w-4 shrink-0 transition-transform duration-200 {runtimeOpenStates[
-                    group.name
-                  ]
-                    ? ''
-                    : '-rotate-90'}"
-                />
-                <span class="text-sm font-medium">{group.name}</span>
-                <Badge variant="secondary" class="text-[10px]">{group.variables.length}</Badge>
-              </div>
-            </Collapsible.Trigger>
-            <Collapsible.Content>
-              <div class="divide-border/50 divide-y pl-6">
-                {#each group.variables as v (v.name)}
-                  {@render varInput(v.name, v.description, v.type, v.enumValues)}
-                {/each}
-              </div>
-            </Collapsible.Content>
-          </Collapsible.Root>
-        {/each}
       </div>
     </div>
 
diff --git a/src/lib/components/vault/prompts/VariablePalette.svelte b/src/lib/components/vault/prompts/VariablePalette.svelte
index 4e289f1c..55767058 100644
--- a/src/lib/components/vault/prompts/VariablePalette.svelte
+++ b/src/lib/components/vault/prompts/VariablePalette.svelte
@@ -1,22 +1,33 @@
 <script lang="ts">
-  import { variableRegistry } from '$lib/services/templates/variables'
+  import {
+    getDisplayGroupsForTemplate,
+    getVariablesForTemplate,
+  } from '$lib/services/templates/templateContextMap'
   import type { CustomVariable } from '$lib/services/packs/types'
   import * as Popover from '$lib/components/ui/popover'
   import * as Command from '$lib/components/ui/command'
   import { Braces } from 'lucide-svelte'
 
   interface Props {
+    templateId: string
     customVariables: CustomVariable[]
     onInsert: (variableName: string) => void
     iconOnly?: boolean
   }
 
-  let { customVariables, onInsert, iconOnly = false }: Props = $props()
+  let { templateId, customVariables, onInsert, iconOnly = false }: Props = $props()
 
   let open = $state(false)
 
-  const systemVars = variableRegistry.getByCategory('system')
-  const runtimeVars = variableRegistry.getByCategory('runtime')
+  let displayGroups = $derived.by(() => {
+    const groups = getDisplayGroupsForTemplate(templateId)
+    const allVars = getVariablesForTemplate(templateId)
+    const varMap = new Map(allVars.map((v) => [v.name, v]))
+    return groups.map((g) => ({
+      label: g.label,
+      variables: g.variables.map((name) => varMap.get(name)).filter((v) => v != null),
+    }))
+  })
 
   function handleSelect(variableName: string) {
     onInsert(variableName)
@@ -54,32 +65,26 @@
       <Command.List class="max-h-75">
         <Command.Empty>No variable found.</Command.Empty>
 
-        <Command.Group heading="System">
-          {#each systemVars as v (v.name)}
-            <Command.Item value={v.name} onSelect={() => handleSelect(v.name)}>
-              <span class="font-mono text-xs">{v.name}</span>
-              <span class="text-muted-foreground ml-auto truncate text-xs">{v.description}</span>
-            </Command.Item>
-          {/each}
-        </Command.Group>
-
-        <Command.Separator />
-
-        <Command.Group heading="Runtime">
-          {#each runtimeVars as v (v.name)}
-            <Command.Item value={v.name} onSelect={() => handleSelect(v.name)}>
-              <span class="font-mono text-xs">{v.name}</span>
-              <span class="text-muted-foreground ml-auto truncate text-xs">{v.description}</span>
-            </Command.Item>
-          {/each}
-        </Command.Group>
+        {#each displayGroups as group (group.label)}
+          <Command.Group heading={group.label}>
+            {#each group.variables as v (v.name)}
+              <Command.Item value={v.name} onSelect={() => handleSelect(v.name)}>
+                <span class="font-mono text-xs">{v.name}</span>
+                <span class="text-muted-foreground ml-auto truncate text-xs">{v.description}</span>
+              </Command.Item>
+            {/each}
+          </Command.Group>
+          <Command.Separator />
+        {/each}
 
         {#if customVariables.length > 0}
-          <Command.Separator />
-          <Command.Group heading="Custom">
+          <Command.Group heading="Custom (Pack Variables)">
             {#each customVariables as v (v.id)}
-              <Command.Item value={v.variableName} onSelect={() => handleSelect(v.variableName)}>
-                <span class="font-mono text-xs">{v.variableName}</span>
+              <Command.Item
+                value={'packVariables.' + v.variableName}
+                onSelect={() => handleSelect('packVariables.' + v.variableName)}
+              >
+                <span class="font-mono text-xs">packVariables.{v.variableName}</span>
                 <span class="text-muted-foreground ml-auto truncate text-xs">{v.displayName}</span>
               </Command.Item>
             {/each}
diff --git a/src/lib/components/vault/prompts/sampleContext.test.ts b/src/lib/components/vault/prompts/sampleContext.test.ts
index bd26a1a5..4a5a1361 100644
--- a/src/lib/components/vault/prompts/sampleContext.test.ts
+++ b/src/lib/components/vault/prompts/sampleContext.test.ts
@@ -1,23 +1,46 @@
 import { describe, it, expect } from 'vitest'
 import { templateEngine } from '$lib/services/templates/engine'
 import { PROMPT_TEMPLATES } from '$lib/services/prompts/templates/index'
-import { allSamples } from './sampleContext'
+import { getContextGroup } from '$lib/services/templates/templateContextMap'
+import { getSamplesForTemplate } from './sampleContext'
+
+function hasVariableReferences(template: string): boolean {
+  return /\{\{\s*\w/.test(template)
+}
+
+describe.each(PROMPT_TEMPLATES)('$id template renders with samples', (template) => {
+  // staticContent partials (e.g. image-style-*) are variable-less by design —
+  // rendering returns the same string, so the "substitution happened" check
+  // doesn't apply to them.
+  const isStaticContent = getContextGroup(template.id) === 'staticContent'
 
-describe.each(PROMPT_TEMPLATES)('$id template renders with allSamples', (template) => {
   it('content field renders non-empty without [object Object] or undefined', () => {
-    const result = templateEngine.render(template.content, allSamples)
+    const samples = getSamplesForTemplate(template.id)
+    const result = templateEngine.render(template.content, samples)
     expect(result).not.toBeNull()
     expect(result!.length).toBeGreaterThan(0)
     expect(result).not.toContain('[object Object]')
     expect(result).not.toContain('undefined')
+
+    // Guard against silent regressions where samples shrink to {} or variables
+    // are renamed: if the template references a variable, at least one must
+    // have actually been substituted (rendered output differs from the raw).
+    if (!isStaticContent && hasVariableReferences(template.content)) {
+      expect(result).not.toBe(template.content)
+    }
   })
 
   if (template.userContent) {
     it('userContent field renders without [object Object] or undefined', () => {
-      const result = templateEngine.render(template.userContent!, allSamples)
+      const samples = getSamplesForTemplate(template.id)
+      const result = templateEngine.render(template.userContent!, samples)
       expect(result).not.toBeNull()
       expect(result).not.toContain('[object Object]')
       expect(result).not.toContain('undefined')
+
+      if (!isStaticContent && hasVariableReferences(template.userContent!)) {
+        expect(result).not.toBe(template.userContent!)
+      }
     })
   }
 })
diff --git a/src/lib/components/vault/prompts/sampleContext.ts b/src/lib/components/vault/prompts/sampleContext.ts
index 159303f3..a9d2b34f 100644
--- a/src/lib/components/vault/prompts/sampleContext.ts
+++ b/src/lib/components/vault/prompts/sampleContext.ts
@@ -1,254 +1,267 @@
 /**
  * Sample values for template preview rendering.
- * Used by both TemplatePreview (rendering) and TestVariablesModal (pre-filling inputs).
+ * Organized per context group to match actual runtime shapes.
  */
 
-export const systemSamples: Record<string, string> = {
-  protagonistName: 'Aria',
-  currentLocation: 'The Whispering Woods',
-  storyTime: 'Year 1, Day 15, 14:30',
-  genre: 'Fantasy',
-  tone: 'Mysterious',
-  settingDescription: 'A vast magical realm where ancient forests conceal forgotten ruins.',
-  themes: 'courage, discovery, friendship',
+import { getContextGroup, type ContextGroupName } from '$lib/services/templates/templateContextMap'
+import type { TemplateContext } from '$lib/services/templates/types'
+
+// ---------------------------------------------------------------------------
+// Reusable sample data fragments
+// ---------------------------------------------------------------------------
+
+const sampleCharacters = [
+  {
+    name: 'Theron',
+    relationship: 'companion',
+    description: 'A seasoned ranger who has guided Aria through the Whispering Woods.',
+    traits: ['loyal', 'perceptive', 'cautious'],
+    appearance: ['rugged leather armor', 'shortbow', 'weathered cloak'],
+    tier: 1,
+    status: 'active',
+  },
+  {
+    name: 'Lyra',
+    relationship: 'rival',
+    description: 'A rival mage who seeks the same ancient artifacts as Aria.',
+    traits: ['ambitious', 'cunning', 'talented'],
+    appearance: ['dark robes', 'silver staff', 'cold eyes'],
+    tier: 2,
+    status: 'active',
+  },
+]
+
+const sampleLocations = [
+  {
+    name: 'Crystal Caverns',
+    description: 'Shimmering caverns of magical crystal beneath the mountains.',
+    visited: false,
+    tier: 2,
+  },
+  {
+    name: 'Thornhold Castle',
+    description: 'Ancient fortress occupied by the Order of the Iron Veil.',
+    visited: true,
+    tier: 3,
+  },
+]
+
+const sampleItems = [
+  {
+    name: 'Enchanted Compass',
+    description: 'Points toward hidden magical sources.',
+    quantity: 1,
+    equipped: false,
+  },
+  {
+    name: 'Shadow Cloak',
+    description: 'Grants partial invisibility in dim light.',
+    quantity: 1,
+    equipped: true,
+  },
+  {
+    name: 'Healing Potion',
+    description: 'Restores 2d4+2 health points.',
+    quantity: 2,
+    equipped: false,
+  },
+]
+
+const sampleStoryBeats = [
+  {
+    title: 'Discovered the Hidden Map',
+    description: 'Found a map leading to the Crystal Caverns.',
+    type: 'discovery',
+    status: 'completed',
+  },
+  {
+    title: 'Confrontation with Lyra',
+    description: 'Lyra demands the compass at the forest edge.',
+    type: 'conflict',
+    status: 'active',
+  },
+]
+
+const sampleChapters = [
+  {
+    number: 1,
+    title: 'Into the Woods',
+    summary: 'Aria entered the Whispering Woods and encountered her first magical creature.',
+    startTime: 'Year 1, Day 1',
+    endTime: 'Year 1, Day 3',
+    characters: ['Aria', 'Theron'],
+    locations: ['The Whispering Woods'],
+    emotionalTone: 'curious',
+  },
+  {
+    number: 2,
+    title: 'The Map Revealed',
+    summary: 'Aria discovered the hidden map leading to the Crystal Caverns.',
+    startTime: 'Year 1, Day 4',
+    endTime: 'Year 1, Day 10',
+    characters: ['Aria', 'Theron', 'Elder Maren'],
+    locations: ['The Whispering Woods', 'Crystal Caverns entrance'],
+    emotionalTone: 'hopeful',
+  },
+]
+
+const sampleLorebookEntries = [
+  {
+    name: 'The Whispering Woods',
+    type: 'location',
+    description: 'Ancient forest where trees carry memories of the world.',
+    tier: 1,
+  },
+  {
+    name: 'The Moonstone Pendant',
+    type: 'item',
+    description: 'A pendant that glows under moonlight, said to reveal hidden paths.',
+    tier: 1,
+  },
+  {
+    name: 'Elder Maren',
+    type: 'character',
+    description: 'A wandering sage who guards forgotten knowledge.',
+    tier: 2,
+    disposition: 'cautiously helpful',
+  },
+]
+
+const sampleStoryEntries = [
+  { type: 'user_action', content: 'I draw my sword and step into the shadows.' },
+  {
+    type: 'narration',
+    content:
+      'The forest falls silent as Aria moves into the darkness, her blade catching the last slivers of moonlight.',
+  },
+  { type: 'user_action', content: 'I whisper to Theron to flank left.' },
+]
+
+const sampleWorldStateRelevantItems = [
+  {
+    name: 'Enchanted Compass',
+    description: 'Points toward the nearest ley line convergence',
+    tier: 2,
+  },
+  {
+    name: 'Faded Map Fragment',
+    description: 'Partial map of the Thornwood labyrinth',
+    tier: 3,
+  },
+]
+
+const sampleWorldStateRelatedBeats = [
+  {
+    title: 'The Missing Apprentice',
+    description: 'Rumors of a sorcerer apprentice who vanished near the old ruins',
+    type: 'quest',
+    status: 'active',
+    tier: 2,
+  },
+  {
+    title: 'Harvest Festival Preparations',
+    description: 'The village is preparing for the annual harvest celebration',
+    type: 'discovery',
+    status: 'active',
+    tier: 3,
+  },
+]
+
+const sampleVisualDescriptors = {
+  face: 'angular features, sharp cheekbones',
+  hair: 'silver, flowing to shoulders',
+  eyes: 'violet, luminous',
+  build: 'athletic, graceful',
+  clothing: 'leather armor with arcane engravings',
+  accessories: 'enchanted compass on a chain',
+  distinguishing: 'scar across left cheek',
+}
+
+// ---------------------------------------------------------------------------
+// promptContext samples — matches StoryPromptContext shape
+// ---------------------------------------------------------------------------
+
+const PROMPT_CONTEXT_SAMPLES: TemplateContext = {
+  // Story Config (flat scalars)
   mode: 'adventure',
   pov: 'second',
   tense: 'present',
-}
-
-export const runtimeSamples: Record<string, string> = {
-  // Narrative Service
-  recentContent: '[Recent story content would appear here...]',
-  visualProseMode: 'false',
-  inlineImageMode: 'false',
-
-  // Classifier Service
-  entityCounts: 'Characters: 3, Locations: 5, Items: 4',
-  currentTimeInfo: 'Year 1, Day 15, 14:30',
-  inputLabel: 'Player Action',
-  userAction: 'I want to explore the ancient ruins to the north.',
-  narrativeResponse: '[The narrative response text...]',
-  existingLocations: 'The Whispering Woods, Crystal Caverns, Thornhold Castle',
-  existingItems: 'Enchanted Compass, Shadow Cloak, Moonstone Pendant',
-  storyBeatTypes: 'discovery, encounter, revelation, conflict, resolution',
-  itemLocationOptions: 'inventory, equipped, location, npc',
-  defaultItemLocation: 'location',
-
-  // Memory Service
-  firstValidId: '1',
-  lastValidId: '25',
-  maxChaptersPerRetrieval: '3',
-
-  // Suggestions Service
-  activeThreads: 'Finding the lost artifact, Resolving the conflict with Lyra',
-
-  // Action Choices Service
-  npcsPresent: 'Theron the Ranger, Old Sage Maren',
-  inventory: 'Enchanted Compass, Shadow Cloak, Healing Potion x2',
-  activeQuests: 'Find the Moonstone Pendant, Explore the Crystal Caverns',
+  protagonistName: 'Aria',
   protagonistDescription: 'A young woman with silver hair and violet eyes',
-  povInstruction: 'Write in second person perspective.',
-  lengthInstruction: 'Write 2-3 paragraphs.',
+  genre: 'Fantasy',
+  settingDescription: 'A vast magical realm where ancient forests conceal forgotten ruins.',
+  tone: 'Mysterious',
+  themes: ['courage', 'discovery', 'friendship'],
 
-  // Shared / Common
+  // Story Content
+  storyEntries: sampleStoryEntries,
+  storyEntriesRaw: sampleStoryEntries.map((e, i) => ({ ...e, id: `entry-${i}` })),
+  storyEntriesVisible: sampleStoryEntries,
+  storyEntriesVisibleRaw: sampleStoryEntries.map((e, i) => ({ ...e, id: `entry-${i}` })),
   userInput: 'I want to explore the ancient ruins to the north.',
+  userActionOriginal: 'I want to explore the ancient ruins to the north.',
+  narrationEntryId: 'entry-1',
+  lastNarrativeEntry: {
+    type: 'narration',
+    content:
+      'The forest falls silent as Aria moves into the darkness, her blade catching the last slivers of moonlight.',
+  },
 
-  // Style Reviewer
-  passageCount: '5',
-
-  // Agentic Retrieval
-  chaptersCount: '8',
-  chapterList: '[Formatted chapter list for retrieval...]',
-  entriesCount: '15',
-  entryList: '[Formatted lorebook entry list...]',
-
-  // Timeline Fill
-  query: 'What happened between the forest encounter and arriving at the castle?',
-
-  // Translation
-  targetLanguage: 'Spanish',
-  sourceLanguage: 'English',
-  content: '[Content to translate or process...]',
-  elementsJson: '[JSON of UI elements for translation...]',
-  suggestionsJson: '[JSON of suggestions for translation...]',
-  choicesJson: '[JSON of action choices for translation...]',
-
-  // Image Services
-  imageStylePrompt: '[Style prompt for image generation...]',
-  maxImages: '3',
-  translatedNarrativeBlock: '[Translated narrative for image analysis...]',
-
-  // Wizard Service
-  genreLabel: 'Fantasy',
-  seed: 'A world where magic flows through ancient ley lines...',
-  customInstruction: 'Make it feel epic and mysterious.',
-  toneInstruction: 'Maintain a mysterious and wonder-filled tone.',
-  settingInstruction: 'Set in a high fantasy world with elemental magic.',
-  settingContext: 'A high fantasy world with elemental magic and feudal kingdoms.',
-  settingName: 'The Shattered Realms',
-  count: '3',
-  title: 'Echoes of the Forgotten',
-  atmosphere: 'A sense of ancient mystery pervades the land...',
-  tenseInstruction: 'Write in present tense.',
-  openingGuidance: 'Begin with the protagonist arriving at the forest edge.',
-  settingAtmosphere: 'Eerie and mystical, where the air hums with ancient power.',
-  settingThemesText: 'magic, discovery, redemption',
-  cardContent: '[Character card content for import...]',
-  lorebookName: 'The Shattered Realms Lore',
-  entriesJson: '[Lorebook entries JSON for vault import...]',
-  entryCount: '12',
-
-  // Interactive Lorebook (scalar counts)
-  characterCount: '12',
-  lorebookCount: '3',
-  totalEntryCount: '47',
-  scenarioCount: '5',
-  lastNarrationIndex: '2',
-
-  // Interactive Lorebook (chat)
-  userMessage: 'Tell me about the Crystal Caverns.',
-  conversationHistory: '[Conversation history for interactive lorebook...]',
-
-  // Agentic Retrieval Output
-  agenticReasoning:
-    '[Agent reasoning: selected entries for current context based on scene relevance and character proximity...]',
-  agenticChapterSummary:
-    '[Chapter facts: protagonist learned about the ancient prophecy in chapter 3, encountered Elder Maren in chapter 5...]',
-}
+  // Entity Data
+  characters: sampleCharacters,
+  locations: sampleLocations,
+  items: sampleItems,
+  storyBeats: sampleStoryBeats,
+  chapters: sampleChapters,
+  lorebookEntries: sampleLorebookEntries,
+
+  // World State (nested)
+  relevantWorldState: {
+    characters: sampleCharacters,
+    inventory: sampleItems,
+    storyBeats: sampleStoryBeats,
+    locations: sampleLocations,
+    relevantItems: sampleWorldStateRelevantItems,
+    relatedStoryBeats: sampleWorldStateRelatedBeats,
+  },
 
-/**
- * Structured sample arrays for the 9 new context-layer array variables.
- * Uses the Aventura fantasy world (Aria, Theron, Lyra, Whispering Woods, Crystal Caverns).
- */
-export const structuredSamples: Record<string, unknown> = {
-  worldStateCharacters: [
-    {
-      name: 'Theron',
-      relationship: 'companion',
-      description: 'A seasoned ranger who has guided Aria through the Whispering Woods.',
-      traits: ['loyal', 'perceptive', 'cautious'],
-      appearance: ['rugged leather armor', 'shortbow', 'weathered cloak'],
-      tier: 1,
-      status: 'active',
-    },
-    {
-      name: 'Lyra',
-      relationship: 'rival',
-      description: 'A rival mage who seeks the same ancient artifacts as Aria.',
-      traits: ['ambitious', 'cunning', 'talented'],
-      appearance: ['dark robes', 'silver staff', 'cold eyes'],
-      tier: 2,
-      status: 'active',
-    },
-  ],
-  worldStateInventory: [
-    {
-      name: 'Enchanted Compass',
-      description: 'Points toward hidden magical sources.',
-      quantity: 1,
-      equipped: false,
-    },
-    {
-      name: 'Shadow Cloak',
-      description: 'Grants partial invisibility in dim light.',
-      quantity: 1,
-      equipped: true,
-    },
-    {
-      name: 'Healing Potion',
-      description: 'Restores 2d4+2 health points.',
-      quantity: 2,
-      equipped: false,
-    },
-  ],
-  worldStateBeats: [
-    {
-      title: 'Discovered the Hidden Map',
-      description: 'Found a map leading to the Crystal Caverns.',
-      type: 'discovery',
-      status: 'completed',
-    },
-    {
-      title: 'Confrontation with Lyra',
-      description: 'Lyra demands the compass at the forest edge.',
-      type: 'conflict',
-      status: 'active',
-    },
-  ],
-  worldStateLocations: [
-    {
-      name: 'Crystal Caverns',
-      description: 'Shimmering caverns of magical crystal beneath the mountains.',
-      visited: false,
-      tier: 2,
-    },
-    {
-      name: 'Thornhold Castle',
-      description: 'Ancient fortress occupied by the Order of the Iron Veil.',
-      visited: true,
-      tier: 3,
-    },
-  ],
-  lorebookEntries: [
-    {
-      name: 'The Whispering Woods',
-      type: 'location',
-      description: 'Ancient forest where trees carry memories of the world.',
-      tier: 1,
-    },
-    {
-      name: 'The Moonstone Pendant',
-      type: 'item',
-      description: 'A pendant that glows under moonlight, said to reveal hidden paths.',
-      tier: 1,
-    },
-    {
-      name: 'Elder Maren',
-      type: 'character',
-      description: 'A wandering sage who guards forgotten knowledge.',
-      tier: 2,
-      disposition: 'cautiously helpful',
-    },
-  ],
-  chapters: [
-    {
-      number: 1,
-      title: 'Into the Woods',
-      summary: 'Aria entered the Whispering Woods and encountered her first magical creature.',
-      startTime: 'Year 1, Day 1',
-      endTime: 'Year 1, Day 3',
-      characters: ['Aria', 'Theron'],
-      locations: ['The Whispering Woods'],
-      emotionalTone: 'curious',
-    },
-    {
-      number: 2,
-      title: 'The Map Revealed',
-      summary: 'Aria discovered the hidden map leading to the Crystal Caverns.',
-      startTime: 'Year 1, Day 4',
-      endTime: 'Year 1, Day 10',
-      characters: ['Aria', 'Theron', 'Elder Maren'],
-      locations: ['The Whispering Woods', 'Crystal Caverns entrance'],
-      emotionalTone: 'hopeful',
-    },
-  ],
-  timelineFill: [
-    {
-      query: 'What happened between the forest encounter and arriving at the caverns?',
-      answer:
-        'Aria and Theron tracked a faint magical signal through three days of dense forest, camping near the Silver Creek.',
-      chapterNumbers: [1, 2],
+  // Entry Selection
+  loreEntriesForTier3: sampleLorebookEntries,
+  worldStateForTier3: sampleCharacters,
+
+  // Settings (nested)
+  userSettings: {
+    visualProseMode: false,
+    classifier: { maxEntries: 20 },
+    retrieval: { maxStoryEntries: 50 },
+    agenticRetrieval: {
+      recentEntriesCount: 5,
+      maxChapters: 3,
+      summaryCharLimit: 500,
+      maxLorebookEntries: 10,
+    },
+    memoryConfig: {
+      chapterLength: 20,
+      maxProtectedEntries: 5,
+    },
+    lorebookConfig: {
+      maxTier1Entries: 5,
+      maxTier2Entries: 10,
+      maxTier3Entries: 3,
+    },
+    imageGeneration: {
+      inlineImageMode: false,
+      referenceMode: false,
+      maxImages: 3,
+      stylePrompt: '[Style prompt for image generation...]',
+    },
+    translationSettings: {
+      targetLanguage: { name: 'Spanish', code: 'es' },
+      sourceLanguage: { name: 'English', code: 'en' },
     },
-  ],
-  storyEntries: [
-    { type: 'user_action', content: 'I draw my sword and step into the shadows.' },
-    {
-      type: 'narration',
-      content:
-        'The forest falls silent as Aria moves into the darkness, her blade catching the last slivers of moonlight.',
-    },
-    { type: 'user_action', content: 'I whisper to Theron to flank left.' },
-  ],
+  },
+
+  // Generation Results
   styleReview: {
     phrases: [
       {
@@ -267,278 +280,87 @@ export const structuredSamples: Record<string, unknown> = {
     overallAssessment: 'Writing is clear but relies on sudden-transition clich\u00e9s.',
     reviewedEntryCount: 12,
   },
-  worldStateRelevantItems: [
-    {
-      name: 'Enchanted Compass',
-      description: 'Points toward the nearest ley line convergence',
-      tier: 2,
-    },
-    {
-      name: 'Faded Map Fragment',
-      description: 'Partial map of the Thornwood labyrinth',
-      tier: 3,
-    },
-  ],
-  worldStateRelatedBeats: [
-    {
-      title: 'The Missing Apprentice',
-      description: 'Rumors of a sorcerer apprentice who vanished near the old ruins',
-      type: 'quest',
-      status: 'active',
-      tier: 2,
-    },
-    {
-      title: 'Harvest Festival Preparations',
-      description: 'The village is preparing for the annual harvest celebration',
-      type: 'discovery',
-      status: 'active',
-      tier: 3,
-    },
-  ],
-  currentLocationObject: {
-    name: 'The Silver Stag Inn',
-    description:
-      'A cozy tavern at the crossroads, known for its warm hearth and loose-lipped travelers',
+  retrievalResult: null,
+  classificationResult: null,
+  narrativeResult: {
+    content: '[The narrative response text...]',
   },
+  translationResult: null,
+
+  // Memory
+  chapterAnalysis: {
+    analysisEntries: sampleStoryEntries,
+    chapterEntries: [
+      { type: 'narration', content: 'Aria and Theron entered the Crystal Caverns at dawn.' },
+      { type: 'user_action', content: 'I run my hand along the glowing crystal wall.' },
+      {
+        type: 'narration',
+        content:
+          'The crystals hum under your touch, resonating with a frequency you feel in your bones.',
+      },
+    ],
+  },
+  lastChapterEndIndex: 25,
 
-  // Style Reviewer
-  passages: [
-    {
-      content:
-        'Aria stepped into the clearing, her breath catching as the moonlight spilled across the ancient stone altar.',
-      entryId: 'entry-001',
-    },
-    {
-      content:
-        'The forest whispered around them — a language older than words, older than the kingdom itself.',
-      entryId: 'entry-002',
-    },
-    {
-      content:
-        "Theron's hand tightened on his bow. 'Something moved out there,' he said, his voice barely audible.",
-      entryId: 'entry-003',
-    },
-  ],
-
-  // Entry Retrieval (Tier 3)
-  availableEntries: [
-    {
-      name: 'The Whispering Woods',
-      type: 'location',
-      description: 'Ancient forest where trees carry memories of the world.',
-      keywords: 'forest, ancient, magic, trees, memory',
-    },
-    {
-      name: 'The Moonstone Pendant',
-      type: 'item',
-      description: 'A pendant that glows under moonlight, said to reveal hidden paths.',
-      keywords: 'pendant, moonstone, glow, path',
-    },
-    {
-      name: 'Elder Maren',
-      type: 'character',
-      description: 'A wandering sage who guards forgotten knowledge.',
-    },
-  ],
-
-  // Agentic Retrieval (recentEntries)
-  recentEntries: [
-    {
-      type: 'narration',
-      content: 'The lantern flickered as shadows crept along the walls.',
-    },
-    {
-      type: 'user_action',
-      content: 'I cautiously step forward, hand on my sword.',
-    },
-  ],
-
-  // Agentic Retrieval Output (agenticSelectedEntries)
-  agenticSelectedEntries: [
-    {
-      name: 'The Moonstone Pendant',
-      type: 'item',
-      description: 'A pendant that glows under moonlight, said to reveal hidden paths.',
-    },
-    {
-      name: 'Elder Maren',
-      type: 'character',
-      description: 'A wandering sage who guards forgotten knowledge.',
-    },
-  ],
-
-  // Classifier (chatHistory — Omit<StoryEntry> + timeStart)
-  chatHistory: [
-    {
-      type: 'user_action',
-      content: 'I examine the Moonstone Pendant carefully.',
-      timeStart: 'Y1D15 13:45',
-      metadata: null,
-    },
-    {
-      type: 'narration',
-      content: 'The pendant pulses with a soft blue light in your hands.',
-      timeStart: 'Y1D15 13:45',
-      metadata: null,
-    },
-    {
-      type: 'user_action',
-      content: 'I ask Theron if he has ever seen anything like this.',
-      timeStart: 'Y1D15 13:50',
-      metadata: null,
-    },
-  ],
-
-  // Chapter Analysis (messagesInRange — same shape as storyEntries)
-  messagesInRange: [
-    { type: 'user_action', content: 'I draw my sword and step into the shadows.' },
-    {
-      type: 'narration',
-      content:
-        'The forest falls silent as Aria moves into the darkness, her blade catching the last slivers of moonlight.',
-    },
-    { type: 'user_action', content: 'I whisper to Theron to flank left.' },
-  ],
-
-  // Chapter Summarization
-  chapterEntries: [
-    { type: 'narration', content: 'Aria and Theron entered the Crystal Caverns at dawn.' },
-    { type: 'user_action', content: 'I run my hand along the glowing crystal wall.' },
-    {
-      type: 'narration',
-      content:
-        'The crystals hum under your touch, resonating with a frequency you feel in your bones.',
-    },
-  ],
-
-  // Chapter Summarization (previousChapters — same shape as chapters)
-  previousChapters: [
-    {
-      number: 1,
-      title: 'Into the Woods',
-      summary: 'Aria entered the Whispering Woods and encountered her first magical creature.',
-      startTime: 'Year 1, Day 1',
-      endTime: 'Year 1, Day 3',
-      characters: ['Aria', 'Theron'],
-      locations: ['The Whispering Woods'],
-      emotionalTone: 'curious',
-    },
-  ],
-
-  // Lore Management
-  loreEntries: [
-    {
-      name: 'The Whispering Woods',
-      type: 'location',
-      description: 'Ancient forest where trees carry memories of the world.',
-      state: 'Partially explored — southern trails mapped by Aria and Theron.',
-    },
-    {
-      name: 'The Moonstone Pendant',
-      type: 'item',
-      description: 'A pendant that glows under moonlight, said to reveal hidden paths.',
-    },
-    {
-      name: 'Elder Maren',
-      type: 'character',
-      description: 'A wandering sage who guards forgotten knowledge.',
-      state: 'Last seen at the Crystal Caverns entrance, offering cryptic guidance.',
+  // Pack Variables
+  packVariables: {
+    runtimeVariables: {
+      character: [
+        {
+          variableName: 'loyalty',
+          variableType: 'number',
+          minValue: 0,
+          maxValue: 100,
+          defaultValue: '50',
+          description: 'Character loyalty level toward the protagonist',
+        },
+        {
+          variableName: 'mood',
+          variableType: 'enum',
+          enumOptions: [{ value: 'happy' }, { value: 'neutral' }, { value: 'hostile' }],
+          defaultValue: 'neutral',
+          description: 'Current emotional state',
+        },
+      ],
+      item: [
+        {
+          variableName: 'durability',
+          variableType: 'number',
+          minValue: 0,
+          maxValue: 100,
+          defaultValue: undefined,
+          description: 'Item condition as a percentage',
+        },
+      ],
     },
-  ],
+  },
 
-  // Lore Management (loreChapters)
-  loreChapters: [
-    {
-      number: 1,
-      title: 'Into the Woods',
-      summary: 'Aria entered the Whispering Woods and encountered her first magical creature.',
-    },
-    {
-      number: 2,
-      title: 'The Map Revealed',
-      summary: 'Aria discovered the hidden map leading to the Crystal Caverns.',
-    },
-    {
-      number: 3,
-      title: 'Crystal Dawn',
-      summary: 'Aria and Theron reached the Crystal Caverns entrance and met Elder Maren.',
-    },
+  // Translation Data
+  suggestionsToTranslate: [{ text: 'Explore the ruins' }, { text: 'Talk to the stranger' }],
+  actionChoicesToTranslate: [
+    { text: 'Draw your sword', description: 'Prepare for combat' },
+    { text: 'Attempt to sneak past', description: 'Use stealth' },
   ],
-
-  // Agentic Retrieval (agenticChapters — same shape as loreChapters)
-  agenticChapters: [
-    {
-      number: 1,
-      title: 'Into the Woods',
-      summary: 'Aria entered the Whispering Woods and encountered her first magical creature.',
-    },
-    {
-      number: 2,
-      title: 'The Map Revealed',
-      summary: 'Aria discovered the hidden map leading to the Crystal Caverns.',
-    },
-    {
-      number: 3,
-      title: 'Crystal Dawn',
-      summary: 'Aria and Theron reached the Crystal Caverns entrance and met Elder Maren.',
-    },
+  uiElementsToTranslate: [
+    { key: 'continue', text: 'Continue' },
+    { key: 'undo', text: 'Undo' },
   ],
 
-  // Agentic Retrieval (agenticEntries — name and type only)
-  agenticEntries: [
-    { name: 'The Whispering Woods', type: 'location' },
-    { name: 'The Moonstone Pendant', type: 'item' },
-    { name: 'Elder Maren', type: 'character' },
-  ],
+  // Time
+  timeTracker: {
+    years: 1,
+    days: 15,
+    hours: 14,
+    minutes: 30,
+  },
+}
 
-  // Image Analysis (sceneCharacters — mixed portrait state)
-  sceneCharacters: [
-    {
-      name: 'Theron',
-      relationship: 'companion',
-      description: 'A seasoned ranger who has guided Aria through the Whispering Woods.',
-      traits: ['loyal', 'perceptive', 'cautious'],
-      status: 'active',
-      portrait: null,
-      visualDescriptors: {
-        face: 'weathered, strong jaw, high cheekbones',
-        hair: 'dark brown, shoulder-length',
-        eyes: 'amber, watchful',
-        build: 'lean and athletic',
-        clothing: 'worn leather armor, forest-green cloak',
-        accessories: 'shortbow, quiver of black-fletched arrows',
-        distinguishing: 'faint scar above left brow',
-      },
-    },
-    {
-      name: 'Lyra',
-      relationship: 'rival',
-      description: 'A rival mage who seeks the same ancient artifacts as Aria.',
-      traits: ['ambitious', 'cunning', 'talented'],
-      status: 'active',
-      portrait: 'portrait://lyra.png',
-      visualDescriptors: {
-        face: 'sharp features, pale complexion',
-        hair: 'raven black, pulled back tightly',
-        eyes: 'ice blue, calculating',
-        build: 'slender',
-        clothing: 'dark robes with silver trim',
-        accessories: 'silver staff',
-        distinguishing: '',
-      },
-    },
-    {
-      name: 'Elder Maren',
-      relationship: 'neutral',
-      description: 'A wandering sage who guards forgotten knowledge.',
-      traits: ['wise', 'cryptic', 'ancient'],
-      status: 'active',
-      portrait: null,
-      visualDescriptors: {},
-    },
-  ],
+// ---------------------------------------------------------------------------
+// timelineFillAnswer samples — promptContext + extras
+// ---------------------------------------------------------------------------
 
-  // Timeline Fill Answer (answerChapters — dual-mode)
+const TIMELINE_FILL_ANSWER_SAMPLES: TemplateContext = {
+  ...PROMPT_CONTEXT_SAMPLES,
   answerChapters: [
     {
       number: 1,
@@ -561,65 +383,37 @@ export const structuredSamples: Record<string, unknown> = {
       summary: 'Aria discovered the hidden map leading to the Crystal Caverns.',
     },
   ],
+  query: 'What happened between the forest encounter and arriving at the castle?',
+}
 
-  // Background Image (narrationEntries — all type narration)
-  narrationEntries: [
-    {
-      type: 'narration',
-      content:
-        'The Crystal Caverns stretch endlessly before you, each surface faceted like a gemstone.',
-    },
-    {
-      type: 'narration',
-      content:
-        'Pale blue light pulses from deep within the cave, casting long shadows across the floor.',
-    },
-    {
-      type: 'narration',
-      content:
-        'A low hum fills the air — the crystals are singing, resonating with some ancient frequency.',
-    },
-  ],
-
-  // Classifier (characters — same shape as worldStateCharacters)
-  characters: [
-    {
-      name: 'Theron',
-      relationship: 'companion',
-      description: 'A seasoned ranger who has guided Aria through the Whispering Woods.',
-      traits: ['loyal', 'perceptive', 'cautious'],
-      appearance: ['rugged leather armor', 'shortbow', 'weathered cloak'],
-      tier: 1,
-      status: 'active',
-    },
-    {
-      name: 'Lyra',
-      relationship: 'rival',
-      description: 'A rival mage who seeks the same ancient artifacts as Aria.',
-      traits: ['ambitious', 'cunning', 'talented'],
-      appearance: ['dark robes', 'silver staff', 'cold eyes'],
-      tier: 2,
-      status: 'active',
-    },
-  ],
+// ---------------------------------------------------------------------------
+// wizard samples
+// ---------------------------------------------------------------------------
 
-  // Classifier (storyBeats — same shape as worldStateBeats)
-  storyBeats: [
-    {
-      title: 'Discovered the Hidden Map',
-      description: 'Found a map leading to the Crystal Caverns.',
-      type: 'discovery',
-      status: 'completed',
-    },
-    {
-      title: 'Confrontation with Lyra',
-      description: 'Lyra demands the compass at the forest edge.',
-      type: 'conflict',
-      status: 'active',
-    },
-  ],
+const WIZARD_SAMPLES: TemplateContext = {
+  // Story Setup (scalars)
+  genreLabel: 'Fantasy',
+  seed: 'A world where magic flows through ancient ley lines...',
+  customInstruction: 'Make it feel epic and mysterious.',
+  toneInstruction: 'Maintain a mysterious and wonder-filled tone.',
+  settingInstruction: 'Set in a high fantasy world with elemental magic.',
+  settingContext: 'A high fantasy world with elemental magic and feudal kingdoms.',
+  settingName: 'The Shattered Realms',
+  settingDescription: 'A vast magical realm where ancient forests conceal forgotten ruins.',
+  settingAtmosphere: 'Eerie and mystical, where the air hums with ancient power.',
+  settingThemesText: 'magic, discovery, redemption',
+  count: 3,
+  title: 'Echoes of the Forgotten',
+  atmosphere: 'A sense of ancient mystery pervades the land...',
+  tenseInstruction: 'Write in present tense.',
+  openingGuidance: 'Begin with the protagonist arriving at the forest edge.',
+  mode: 'adventure',
+  pov: 'second',
+  tone: 'Mysterious',
+  protagonistName: 'Aria',
+  protagonistDescription: 'A young woman with silver hair and violet eyes',
 
-  // Wizard Service (structured objects replacing scalar strings)
+  // Setting (object)
   currentSetting: {
     name: 'The Whispering Woods',
     description: 'An ancient forest where trees carry memories of the world.',
@@ -630,6 +424,15 @@ export const structuredSamples: Record<string, unknown> = {
       { name: 'Elder Tree', description: 'A massive ancient oak at the heart of the woods.' },
     ],
   },
+
+  // Character (objects)
+  characterInput: {
+    name: 'Aria',
+    description: 'A young woman with silver hair and violet eyes',
+    background: 'Raised in the hidden village of Thornhollow...',
+    motivation: '',
+    traits: [],
+  },
   currentCharacter: {
     name: 'Aria',
     description: 'A young woman with silver hair and violet eyes',
@@ -638,18 +441,26 @@ export const structuredSamples: Record<string, unknown> = {
     traits: ['curious', 'brave', 'compassionate'],
     appearance: "Silver hair, violet eyes, slender build, wears a traveler's cloak",
   },
-  characterInput: {
-    name: 'Aria',
-    description: 'A young woman with silver hair and violet eyes',
-    background: 'Raised in the hidden village of Thornhollow...',
-    motivation: '',
-    traits: [],
-  },
   protagonist: {
     name: 'Kael',
     description: 'A brave warrior with a troubled past',
     motivation: 'To protect the realm from the encroaching darkness',
   },
+
+  // Opening (object)
+  currentOpening: {
+    title: 'The Journey Begins',
+    scene: 'The morning mist clings to the tree line as the sun crests the distant hills...',
+    initialLocation: {
+      name: 'Forest Edge',
+      description: 'Where the ancient trees begin and civilization ends.',
+    },
+  },
+
+  // Lorebook
+  lorebookEntries: sampleLorebookEntries,
+
+  // Supporting Characters
   supportingCharacters: [
     {
       name: 'Theron',
@@ -666,68 +477,137 @@ export const structuredSamples: Record<string, unknown> = {
       traits: ['ambitious', 'clever'],
     },
   ],
-  currentOpening: {
-    title: 'The Journey Begins',
-    scene: 'The morning mist clings to the tree line as the sun crests the distant hills...',
-    initialLocation: {
-      name: 'Forest Edge',
-      description: 'Where the ancient trees begin and civilization ends.',
-    },
-  },
+}
 
-  // Classifier (runtimeVariables - grouped by entity type)
-  runtimeVariables: {
-    character: [
-      {
-        variableName: 'loyalty',
-        variableType: 'number',
-        minValue: 0,
-        maxValue: 100,
-        defaultValue: '50',
-        description: 'Character loyalty level toward the protagonist',
-      },
-      {
-        variableName: 'mood',
-        variableType: 'enum',
-        enumOptions: [{ value: 'happy' }, { value: 'neutral' }, { value: 'hostile' }],
-        defaultValue: 'neutral',
-        description: 'Current emotional state',
-      },
-    ],
-    item: [
-      {
-        variableName: 'durability',
-        variableType: 'number',
-        minValue: 0,
-        maxValue: 100,
-        defaultValue: undefined,
-        description: 'Item condition as a percentage',
-      },
-    ],
-  },
+// ---------------------------------------------------------------------------
+// vault samples
+// ---------------------------------------------------------------------------
 
-  // Interactive Lorebook (focusedEntity object)
+const VAULT_SAMPLES: TemplateContext = {
+  characterCount: 12,
+  lorebookCount: 3,
+  totalEntryCount: 47,
+  scenarioCount: 5,
   focusedEntity: {
     entityType: 'character',
     entityName: 'Theron',
     entityId: 'char-001',
   },
+}
 
-  // Image Portrait (visualDescriptors object)
-  visualDescriptors: {
-    face: 'angular features, sharp cheekbones',
-    hair: 'silver, flowing to shoulders',
-    eyes: 'violet, luminous',
-    build: 'athletic, graceful',
-    clothing: 'leather armor with arcane engravings',
-    accessories: 'enchanted compass on a chain',
-    distinguishing: 'scar across left cheek',
-  },
+// ---------------------------------------------------------------------------
+// lore samples
+// ---------------------------------------------------------------------------
+
+const LORE_SAMPLES: TemplateContext = {
+  loreEntries: [
+    {
+      name: 'The Whispering Woods',
+      type: 'location',
+      description: 'Ancient forest where trees carry memories of the world.',
+      state: 'Partially explored — southern trails mapped by Aria and Theron.',
+    },
+    {
+      name: 'The Moonstone Pendant',
+      type: 'item',
+      description: 'A pendant that glows under moonlight, said to reveal hidden paths.',
+    },
+    {
+      name: 'Elder Maren',
+      type: 'character',
+      description: 'A wandering sage who guards forgotten knowledge.',
+      state: 'Last seen at the Crystal Caverns entrance, offering cryptic guidance.',
+    },
+  ],
+  loreChapters: [
+    {
+      number: 1,
+      title: 'Into the Woods',
+      summary: 'Aria entered the Whispering Woods and encountered her first magical creature.',
+    },
+    {
+      number: 2,
+      title: 'The Map Revealed',
+      summary: 'Aria discovered the hidden map leading to the Crystal Caverns.',
+    },
+    {
+      number: 3,
+      title: 'Crystal Dawn',
+      summary: 'Aria and Theron reached the Crystal Caverns entrance and met Elder Maren.',
+    },
+  ],
+}
+
+// ---------------------------------------------------------------------------
+// import samples
+// ---------------------------------------------------------------------------
+
+const IMPORT_SAMPLES: TemplateContext = {
+  genre: 'Fantasy',
+  title: 'Echoes of the Forgotten',
+  cardContent: '[Character card content for import...]',
+  entriesJson: '[Lorebook entries JSON for vault import...]',
+}
+
+// ---------------------------------------------------------------------------
+// portrait samples
+// ---------------------------------------------------------------------------
+
+const PORTRAIT_SAMPLES: TemplateContext = {
+  imageStylePrompt: '[Style prompt for image generation...]',
+  visualDescriptors: sampleVisualDescriptors,
+}
+
+// ---------------------------------------------------------------------------
+// translateWizard samples
+// ---------------------------------------------------------------------------
+
+const TRANSLATE_WIZARD_SAMPLES: TemplateContext = {
+  targetLanguage: 'Spanish',
+  content: '[Content to translate or process...]',
+}
+
+// ---------------------------------------------------------------------------
+// Group name -> sample data
+// ---------------------------------------------------------------------------
+
+const GROUP_SAMPLES: Record<ContextGroupName, TemplateContext> = {
+  promptContext: PROMPT_CONTEXT_SAMPLES,
+  timelineFillAnswer: TIMELINE_FILL_ANSWER_SAMPLES,
+  wizard: WIZARD_SAMPLES,
+  vault: VAULT_SAMPLES,
+  lore: LORE_SAMPLES,
+  import: IMPORT_SAMPLES,
+  portrait: PORTRAIT_SAMPLES,
+  translateWizard: TRANSLATE_WIZARD_SAMPLES,
+  staticContent: {},
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns sample context data for a given template ID.
+ * Returns an empty object if the template has no mapped context group.
+ */
+export function getSamplesForTemplate(templateId: string): TemplateContext {
+  const group = getContextGroup(templateId)
+  if (!group) return {}
+  return GROUP_SAMPLES[group]
+}
+
+export function getSampleAtPath(samples: unknown, path: string): unknown {
+  let current: unknown = samples
+  for (const part of path.split('.')) {
+    if (current == null || typeof current !== 'object') return undefined
+    current = (current as Record<string, unknown>)[part]
+  }
+  return current
 }
 
-/** All sample values combined — system strings, runtime strings, and structured arrays */
-export const allSamples: Record<string, unknown> = {
-  ...systemSamples,
-  ...runtimeSamples,
-  ...structuredSamples,
+export function stringifySample(value: unknown): string {
+  if (typeof value === 'string') return value
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value)
+  return JSON.stringify(value, null, 2)
 }
diff --git a/src/lib/services/prompts/templates/analysis.test.ts b/src/lib/services/prompts/templates/analysis.test.ts
index 36eff60b..bccf8666 100644
--- a/src/lib/services/prompts/templates/analysis.test.ts
+++ b/src/lib/services/prompts/templates/analysis.test.ts
@@ -118,7 +118,7 @@ describe('classifier', () => {
 
     it('renders time display from entry metadata', async () => {
       const result = await renderTemplate('classifier', promptContext)
-      expect(result.user).toContain('at Year 1, Day 42, 14:0')
+      expect(result.user).toContain('at Y1D42 14:00')
     })
 
     it('renders enum runtime variables with pipe-separated options', async () => {
diff --git a/src/lib/services/prompts/templates/analysis/classifier.liquid b/src/lib/services/prompts/templates/analysis/classifier.liquid
index 2418c29b..e3cbe6a8 100644
--- a/src/lib/services/prompts/templates/analysis/classifier.liquid
+++ b/src/lib/services/prompts/templates/analysis/classifier.liquid
@@ -148,7 +148,7 @@ Already tracking: {{ characters.size }} characters, {{ locations.size }} locatio
 {%- if recentEntries.size > 0 %}
 
 ## Recent Chat History
-{% for entry in recentEntries %}{% if entry.type == 'user_action' %}[ACTION]{% else %}[NARRATIVE]{% endif %}{% if entry.metadata.timeStart %} (at Year {{ entry.metadata.timeStart.years }}, Day {{ entry.metadata.timeStart.days }}, {{ entry.metadata.timeStart.hours }}:{{ entry.metadata.timeStart.minutes }}){% endif %} {{ entry.content }}
+{% for entry in recentEntries %}{% if entry.type == 'user_action' %}[ACTION]{% else %}[NARRATIVE]{% endif %}{% if entry.metadata.timeStart %} (at Y{{ entry.metadata.timeStart.years }}D{{ entry.metadata.timeStart.days }} {% if entry.metadata.timeStart.hours < 10 %}0{% endif %}{{ entry.metadata.timeStart.hours }}:{% if entry.metadata.timeStart.minutes < 10 %}0{% endif %}{{ entry.metadata.timeStart.minutes }}){% endif %} {{ entry.content | truncate: 500 }}
 
 {% endfor %}
 {%- endif %}
diff --git a/src/lib/services/prompts/templates/generation/action-choices.liquid b/src/lib/services/prompts/templates/generation/action-choices.liquid
index a8edafaa..5a1d5111 100644
--- a/src/lib/services/prompts/templates/generation/action-choices.liquid
+++ b/src/lib/services/prompts/templates/generation/action-choices.liquid
@@ -31,7 +31,7 @@ Do NOT generate actions for {{ protagonistName }} as if they were a separate cha
 ## Current Scene
 {%- assign currentLocation = locations | where: "current" -%}
 Location: {{ currentLocation }}
-{%- assign npcsPresent = c | reject: "relationship", "self" | where: "status", "active" | map: "name" | join: ", " | default: "None" -%}
+{%- assign npcsPresent = characters | reject: "relationship", "self" | where: "status", "active" | map: "name" | join: ", " | default: "None" -%}
 NPCs Present: {{ npcsPresent }}
 {%- assign inventory = items | where: "equipped" | map: "name" | join: "," | default: "None" -%}
 {{ protagonistName }}'s Inventory: {{ inventory }}
diff --git a/src/lib/services/prompts/templates/narrative/adventure.liquid b/src/lib/services/prompts/templates/narrative/adventure.liquid
index f22588dd..0238cf29 100644
--- a/src/lib/services/prompts/templates/narrative/adventure.liquid
+++ b/src/lib/services/prompts/templates/narrative/adventure.liquid
@@ -203,7 +203,7 @@ Elena drew her blade, firelight dancing along the steel edge as she faced the cr
 </InlineImages>{% endif %}
 [CURRENT STORY TIME]
 Year {{ timeTracker.years }}, Day {{ timeTracker.days }}, {{ timeTracker.hours }} hours {{ timeTracker.minutes }} minutes
-{% assign currentLocationObject = location | where: "curent", true | first -%}
+{% assign currentLocationObject = locations | where: "current", true | first -%}
 {%- if currentLocationObject %}
 
 [CURRENT LOCATION]
diff --git a/src/lib/services/prompts/templates/narrative/creative-writing.liquid b/src/lib/services/prompts/templates/narrative/creative-writing.liquid
index e2a87e4b..b49cff3f 100644
--- a/src/lib/services/prompts/templates/narrative/creative-writing.liquid
+++ b/src/lib/services/prompts/templates/narrative/creative-writing.liquid
@@ -239,7 +239,7 @@ Elena drew her blade, firelight dancing along the steel edge as she faced the cr
 </InlineImages>{% endif %}
 [CURRENT STORY TIME]
 Year {{ timeTracker.years }}, Day {{ timeTracker.days }}, {{ timeTracker.hours }} hours {{ timeTracker.minutes }} minutes
-{% assign currentLocationObject = location | where: "curent", true | first -%}
+{% assign currentLocationObject = locations | where: "current", true | first -%}
 {%- if currentLocationObject %}
 
 [CURRENT LOCATION]
diff --git a/src/lib/services/prompts/templates/wizard/character-card-import.liquid b/src/lib/services/prompts/templates/wizard/character-card-import.liquid
index 357765eb..839173c1 100644
--- a/src/lib/services/prompts/templates/wizard/character-card-import.liquid
+++ b/src/lib/services/prompts/templates/wizard/character-card-import.liquid
@@ -8,20 +8,20 @@ description: Cleans SillyTavern character cards and converts them to Aventura sc
 You are cleaning a SillyTavern character card for use as a scenario setting in interactive fiction.
 
 ## Your Task
-1. IDENTIFY who "{{char}}" refers to based on the content (the actual character name - NOT the card title)
+1. IDENTIFY who "{% raw %}{{char}}{% endraw %}" refers to based on the content (the actual character name - NOT the card title)
 2. IDENTIFY ALL NPCs/characters mentioned in the card content
-3. REPLACE all instances of "{{char}}" with the actual character name in your output
-4. KEEP all instances of "{{user}}" as-is - this placeholder will be replaced with the player's character name later
+3. REPLACE all instances of "{% raw %}{{char}}{% endraw %}" with the actual character name in your output
+4. KEEP all instances of "{% raw %}{{user}}{% endraw %}" as-is - this placeholder will be replaced with the player's character name later
 5. REMOVE specific meta-content patterns (see below)
 6. PRESERVE the original text as much as possible - do NOT summarize or condense
 
-The "{{user}}" refers to the player's character (protagonist). Characters identified from the card will become NPCs.
+The "{% raw %}{{user}}{% endraw %}" refers to the player's character (protagonist). Characters identified from the card will become NPCs.
 
 ## REMOVE THESE PATTERNS (delete entirely):
 
 ### Roleplay Instructions (DELETE):
-- "You are {{char}}", "You will portray...", "Play as..."
-- "Do not speak for {{user}}", "Never speak for {{user}}"
+- "You are {% raw %}{{char}}{% endraw %}", "You will portray...", "Play as..."
+- "Do not speak for {% raw %}{{user}}{% endraw %}", "Never speak for {% raw %}{{user}}{% endraw %}"
 - "Stay in character", "Never break character"
 - "Always respond as...", "You must..."
 - Any instruction telling the AI HOW to behave
@@ -52,23 +52,23 @@ The "{{user}}" refers to the player's character (protagonist). Characters identi
 - Relationship dynamics
 - Scenario/situation setup
 - Any lore, world rules, or setting details
-- All {{user}} placeholders (keep them exactly as {{user}})
+- All {% raw %}{{user}}{% endraw %} placeholders (keep them exactly as {% raw %}{{user}}{% endraw %})
 
-Note: Include ALL significant characters mentioned in the card as NPCs. The primary character ({{char}}) should be the first NPC in the array.
+Note: Include ALL significant characters mentioned in the card as NPCs. The primary character ({% raw %}{{char}}{% endraw %}) should be the first NPC in the array.
 ---USER---
 
 Clean this character card for use as a {{genre}} scenario setting.
 
-The {{user}} will be the protagonist (their name will be filled in later) interacting with the NPCs in an interactive story.
+The {% raw %}{{user}}{% endraw %} will be the protagonist (their name will be filled in later) interacting with the NPCs in an interactive story.
 
 IMPORTANT:
-- Identify who "{{char}}" refers to based on the content (NOT the card title "{{title}}")
-- Replace all {{char}} with the actual character name
-- KEEP all {{user}} placeholders as-is (they will be replaced with the player's character name later)
+- Identify who "{% raw %}{{char}}{% endraw %}" refers to based on the content (NOT the card title "{{title}}")
+- Replace all {% raw %}{{char}}{% endraw %} with the actual character name
+- KEEP all {% raw %}{{user}}{% endraw %} placeholders as-is (they will be replaced with the player's character name later)
 - Preserve the original text - only REMOVE meta-instructions and roleplay guidelines
 - Do NOT summarize or condense - the output should be nearly as long as the input
 
 ## CARD CONTENT
 {{cardContent}}
 
-Clean the above content. Identify all NPCs, replace {{char}} with the actual name, keep {{user}} as-is, and remove meta-content.
+Clean the above content. Identify all NPCs, replace {% raw %}{{char}}{% endraw %} with the actual name, keep {% raw %}{{user}}{% endraw %} as-is, and remove meta-content.
diff --git a/src/lib/services/prompts/templates/wizard/vault-character-import.liquid b/src/lib/services/prompts/templates/wizard/vault-character-import.liquid
index 91c879d8..e5522e90 100644
--- a/src/lib/services/prompts/templates/wizard/vault-character-import.liquid
+++ b/src/lib/services/prompts/templates/wizard/vault-character-import.liquid
@@ -8,7 +8,7 @@ description: Cleans SillyTavern character cards and extracts structured characte
 You are extracting and cleaning character data from a SillyTavern character card for storage in a character vault.
 
 ## Your Task
-1. IDENTIFY who "{{char}}" refers to based on the content (the actual character name)
+1. IDENTIFY who "{% raw %}{{char}}{% endraw %}" refers to based on the content (the actual character name)
 2. EXTRACT clean, prose-format character information
 3. REMOVE all roleplay instructions, meta-content, and formatting artifacts
 4. Convert any structured formats (PList, W++, etc.) to natural prose
@@ -16,8 +16,8 @@ You are extracting and cleaning character data from a SillyTavern character card
 ## REMOVE THESE PATTERNS (delete entirely):
 
 ### Roleplay Instructions:
-- "You are {{char}}", "You will portray...", "Play as..."
-- "Do not speak for {{user}}", "Never speak for {{user}}"
+- "You are {% raw %}{{char}}{% endraw %}", "You will portray...", "Play as..."
+- "Do not speak for {% raw %}{{user}}{% endraw %}", "Never speak for {% raw %}{{user}}{% endraw %}"
 - "Stay in character", "Never break character"
 - Instructions telling an AI how to behave
 
@@ -29,7 +29,7 @@ You are extracting and cleaning character data from a SillyTavern character card
 - Section headers like "=== Narration ===" or "=== Scenario ==="
 
 ### User References:
-- Replace "{{user}}" with "the protagonist" or remove sentences that only make sense in a roleplay context
+- Replace "{% raw %}{{user}}{% endraw %}" with "the protagonist" or remove sentences that only make sense in a roleplay context
 
 ## CONVERT TO NATURAL PROSE:
 - [Character: trait1, trait2; clothes: x] → Natural sentences
diff --git a/src/lib/services/templates/templateContextMap.test.ts b/src/lib/services/templates/templateContextMap.test.ts
new file mode 100644
index 00000000..df8ab21f
--- /dev/null
+++ b/src/lib/services/templates/templateContextMap.test.ts
@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest'
+import { PROMPT_TEMPLATES } from '$lib/services/prompts/templates/index'
+import {
+  getContextGroup,
+  getDisplayGroupsForTemplate,
+  getVariableNamesForTemplate,
+  getVariablesForTemplate,
+  validateContextMapIntegrity,
+} from './templateContextMap'
+
+describe('templateContextMap integrity', () => {
+  const report = validateContextMapIntegrity(PROMPT_TEMPLATES.map((t) => t.id))
+
+  it('every loaded PROMPT_TEMPLATES id has a mapped context group', () => {
+    expect(report.unmappedTemplateIds).toEqual([])
+  })
+
+  it('every display-group variable name exists in the group VARS list', () => {
+    expect(report.orphanedDisplayVariables).toEqual([])
+  })
+
+  it('unmapped templateId returns null / empty collections', () => {
+    expect(getContextGroup('does-not-exist')).toBeNull()
+    expect(getVariablesForTemplate('does-not-exist')).toEqual([])
+    expect(getDisplayGroupsForTemplate('does-not-exist')).toEqual([])
+    expect(getVariableNamesForTemplate('does-not-exist')).toEqual([])
+  })
+
+  it('known templateId resolves to its group with non-empty variables', () => {
+    expect(getContextGroup('adventure')).toBe('promptContext')
+    expect(getVariablesForTemplate('adventure').length).toBeGreaterThan(0)
+    expect(getDisplayGroupsForTemplate('adventure').length).toBeGreaterThan(0)
+  })
+})
diff --git a/src/lib/services/templates/templateContextMap.ts b/src/lib/services/templates/templateContextMap.ts
new file mode 100644
index 00000000..fae92d15
--- /dev/null
+++ b/src/lib/services/templates/templateContextMap.ts
@@ -0,0 +1,914 @@
+/**
+ * Template Context Map
+ *
+ * Maps each templateId to a context group name and defines the variables
+ * available in that group. This is the single source of truth for which
+ * variables each template family can reference at render time.
+ */
+
+import type { VariableDefinition, VariableFieldInfo } from './types'
+import { createLogger } from '$lib/log'
+
+const log = createLogger('TemplateContextMap')
+const warnedUnmappedIds = new Set<string>()
+
+// ---------------------------------------------------------------------------
+// Context group names
+// ---------------------------------------------------------------------------
+
+export type ContextGroupName =
+  | 'promptContext'
+  | 'timelineFillAnswer'
+  | 'wizard'
+  | 'vault'
+  | 'lore'
+  | 'import'
+  | 'portrait'
+  | 'translateWizard'
+  | 'staticContent'
+
+// ---------------------------------------------------------------------------
+// Display group (semantic UI grouping)
+// ---------------------------------------------------------------------------
+
+export interface DisplayGroup {
+  label: string
+  variables: readonly string[]
+}
+
+// ---------------------------------------------------------------------------
+// Template -> context group mapping
+// ---------------------------------------------------------------------------
+
+const TEMPLATE_GROUP_MAP: Record<string, ContextGroupName> = {
+  // promptContext
+  adventure: 'promptContext',
+  'creative-writing': 'promptContext',
+  classifier: 'promptContext',
+  suggestions: 'promptContext',
+  'action-choices': 'promptContext',
+  'style-reviewer': 'promptContext',
+  'chapter-analysis': 'promptContext',
+  'chapter-summarization': 'promptContext',
+  'agentic-retrieval': 'promptContext',
+  'timeline-fill': 'promptContext',
+  'tier3-entry-selection': 'promptContext',
+  'image-prompt-analysis': 'promptContext',
+  'image-prompt-analysis-reference': 'promptContext',
+  'background-image-prompt-analysis': 'promptContext',
+  'translate-narration': 'promptContext',
+  'translate-input': 'promptContext',
+  'translate-ui': 'promptContext',
+  'translate-suggestions': 'promptContext',
+  'translate-action-choices': 'promptContext',
+
+  // timelineFillAnswer — same variables as promptContext plus `answerChapters`
+  // and `query`, which only exist during the second stage of timeline fill.
+  'timeline-fill-answer': 'timelineFillAnswer',
+
+  // wizard
+  'setting-expansion': 'wizard',
+  'setting-refinement': 'wizard',
+  'character-elaboration': 'wizard',
+  'character-refinement': 'wizard',
+  'protagonist-generation': 'wizard',
+  'supporting-characters': 'wizard',
+  'opening-generation-adventure': 'wizard',
+  'opening-generation-creative': 'wizard',
+  'opening-refinement-adventure': 'wizard',
+  'opening-refinement-creative': 'wizard',
+
+  // vault
+  'interactive-lorebook': 'vault',
+
+  // lore
+  'lore-management': 'lore',
+
+  // import
+  'character-card-import': 'import',
+  'vault-character-import': 'import',
+  'lorebook-classifier': 'import',
+
+  // portrait
+  'image-portrait-generation': 'portrait',
+
+  // translateWizard
+  'translate-wizard-content': 'translateWizard',
+
+  // staticContent (partials with no variables, included by other templates)
+  'image-style-photorealistic': 'staticContent',
+  'image-style-semi-realistic': 'staticContent',
+  'image-style-soft-anime': 'staticContent',
+}
+
+// ---------------------------------------------------------------------------
+// Helper to build VariableDefinition concisely
+// ---------------------------------------------------------------------------
+
+function v(
+  name: string,
+  type: VariableDefinition['type'],
+  description: string,
+  opts?: {
+    required?: boolean
+    category?: VariableDefinition['category']
+    enumValues?: string[]
+    infoFields?: VariableFieldInfo[]
+  },
+): VariableDefinition {
+  return {
+    name,
+    type,
+    category: opts?.category ?? 'runtime',
+    description,
+    required: opts?.required ?? false,
+    ...(opts?.enumValues ? { enumValues: opts.enumValues } : {}),
+    ...(opts?.infoFields ? { infoFields: opts.infoFields } : {}),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Shared infoFields used across multiple groups
+// ---------------------------------------------------------------------------
+
+const storyEntryFields: VariableFieldInfo[] = [
+  { name: 'type', type: 'string', description: 'user_action or narration' },
+  { name: 'content', type: 'string', description: 'Entry text' },
+]
+
+const storyEntryRawFields: VariableFieldInfo[] = [
+  { name: 'type', type: 'string', description: 'Entry type' },
+  { name: 'content', type: 'string', description: 'Entry text' },
+  { name: 'id', type: 'string', description: 'Entry ID' },
+]
+
+const characterFields: VariableFieldInfo[] = [
+  { name: 'name', type: 'string', description: 'Character name' },
+  { name: 'relationship', type: 'string', description: 'e.g. companion, rival, ally (nullable)' },
+  { name: 'description', type: 'string', description: 'Character description (nullable)' },
+  { name: 'traits', type: 'string[]', description: 'Personality traits' },
+  { name: 'appearance', type: 'string[]', description: 'Visual appearance details' },
+  { name: 'status', type: 'string', description: 'active, inactive, or deceased' },
+]
+
+const locationFields: VariableFieldInfo[] = [
+  { name: 'name', type: 'string', description: 'Location name' },
+  { name: 'description', type: 'string', description: 'Location description' },
+  { name: 'visited', type: 'boolean', description: 'Whether the protagonist has visited' },
+  { name: 'current', type: 'boolean', description: 'Whether this is the current location' },
+]
+
+const itemFields: VariableFieldInfo[] = [
+  { name: 'name', type: 'string', description: 'Item name' },
+  { name: 'description', type: 'string', description: 'Item description (nullable)' },
+  { name: 'quantity', type: 'number', description: 'Quantity held' },
+  { name: 'equipped', type: 'boolean', description: 'Whether equipped' },
+  { name: 'location', type: 'string', description: 'Item location' },
+]
+
+const storyBeatFields: VariableFieldInfo[] = [
+  { name: 'title', type: 'string', description: 'Beat title' },
+  { name: 'description', type: 'string', description: 'Beat description' },
+  { name: 'type', type: 'string', description: 'e.g. discovery, conflict, quest' },
+  { name: 'status', type: 'string', description: 'e.g. active, completed, failed' },
+]
+
+const chapterFields: VariableFieldInfo[] = [
+  { name: 'number', type: 'number', description: 'Chapter number' },
+  { name: 'title', type: 'string', description: 'Chapter title' },
+  { name: 'summary', type: 'string', description: 'Chapter summary text' },
+  { name: 'startTime', type: 'string', description: 'Formatted time or null' },
+  { name: 'endTime', type: 'string', description: 'Formatted time or null' },
+  { name: 'characters', type: 'string[]', description: 'Character names' },
+  { name: 'locations', type: 'string[]', description: 'Location names' },
+  { name: 'emotionalTone', type: 'string', description: 'Emotional tone' },
+]
+
+const lorebookEntryFields: VariableFieldInfo[] = [
+  { name: 'name', type: 'string', description: 'Entry name' },
+  { name: 'type', type: 'string', description: 'e.g. character, location, item, faction' },
+  { name: 'description', type: 'string', description: 'Entry description' },
+  { name: 'tier', type: 'number', description: 'Retrieval tier 1-3 (optional)' },
+  {
+    name: 'disposition',
+    type: 'string',
+    description: 'Current disposition (character-only, optional)',
+  },
+  { name: 'hiddenInfo', type: 'string', description: 'Hidden lore (optional)' },
+]
+
+// Wizard runs before retrieval tiers are assigned, so `tier` is meaningless
+// there — drop it from the documented fields to avoid misleading authors.
+const lorebookEntryWizardFields: VariableFieldInfo[] = lorebookEntryFields.filter(
+  (f) => f.name !== 'tier',
+)
+
+// ---------------------------------------------------------------------------
+// promptContext variable definitions
+// ---------------------------------------------------------------------------
+
+const PROMPT_CONTEXT_VARS: VariableDefinition[] = [
+  // Story Config
+  v('mode', 'enum', 'Story mode', {
+    required: true,
+    category: 'system',
+    enumValues: ['adventure', 'creative-writing'],
+  }),
+  v('pov', 'enum', 'Point of view', {
+    required: true,
+    category: 'system',
+    enumValues: ['first', 'second', 'third'],
+  }),
+  v('tense', 'enum', 'Narrative tense', {
+    required: true,
+    category: 'system',
+    enumValues: ['past', 'present'],
+  }),
+  v('protagonistName', 'text', 'Name of the main character', {
+    required: true,
+    category: 'system',
+  }),
+  v('protagonistDescription', 'text', 'Physical/personality description of the protagonist', {
+    category: 'system',
+  }),
+  v('genre', 'text', 'Story genre', { category: 'system' }),
+  v('settingDescription', 'text', 'World/setting description', { category: 'system' }),
+  v('tone', 'text', 'Story tone/mood', { category: 'system' }),
+  v('themes', 'array', 'Story themes', { category: 'system' }),
+
+  // Story Content
+  v('storyEntries', 'array', 'Story entries (type + content pairs)', {
+    infoFields: storyEntryFields,
+  }),
+  v('storyEntriesRaw', 'array', 'Full StoryEntry objects (unfiltered)', {
+    infoFields: storyEntryRawFields,
+  }),
+  v('storyEntriesVisible', 'array', 'Visible story entries (filtered)', {
+    infoFields: storyEntryFields,
+  }),
+  v('storyEntriesVisibleRaw', 'array', 'Visible story entries (full objects)', {
+    infoFields: storyEntryRawFields,
+  }),
+  v('userInput', 'text', 'Current user input text'),
+  v('userActionOriginal', 'text', 'Original user action before processing'),
+  v(
+    'narrationEntryId',
+    'text',
+    'ID of the narration entry currently being classified (used to exclude it from chat history)',
+  ),
+  v('lastNarrativeEntry', 'object', 'Most recent narrative entry', {
+    infoFields: [
+      { name: 'type', type: 'string', description: 'Always narration' },
+      { name: 'content', type: 'string', description: 'Narration text' },
+    ],
+  }),
+
+  // Entity Data
+  v('characters', 'array', 'Story characters', { infoFields: characterFields }),
+  v('locations', 'array', 'Known story locations', { infoFields: locationFields }),
+  v('items', 'array', 'Player inventory items', { infoFields: itemFields }),
+  v('storyBeats', 'array', 'Active story beats/threads', { infoFields: storyBeatFields }),
+  v('chapters', 'array', 'Story chapters', { infoFields: chapterFields }),
+  v('lorebookEntries', 'array', 'Lorebook entries', { infoFields: lorebookEntryFields }),
+
+  // World State
+  v('relevantWorldState', 'object', 'Tiered world state from EntryInjector', {
+    infoFields: [
+      {
+        name: 'characters',
+        type: 'array',
+        description: 'Tiered characters with visual descriptors',
+      },
+      { name: 'inventory', type: 'array', description: 'Player inventory items' },
+      { name: 'storyBeats', type: 'array', description: 'Active story threads' },
+      { name: 'locations', type: 'array', description: 'Known locations' },
+      { name: 'relevantItems', type: 'array', description: 'Tier 2/3 relevant items' },
+      { name: 'relatedStoryBeats', type: 'array', description: 'Tier 2/3 related beats' },
+    ],
+  }),
+
+  // Entry Selection
+  v('loreEntriesForTier3', 'array', 'Lorebook entries for tier-3 LLM selection'),
+  v('worldStateForTier3', 'array', 'World state candidates for tier-3 selection'),
+
+  // Settings
+  v('userSettings', 'object', 'User and story settings', {
+    infoFields: [
+      {
+        name: 'visualProseMode',
+        type: 'boolean',
+        description: 'Whether visual prose mode is enabled',
+      },
+      {
+        name: 'classifier.maxEntries',
+        type: 'number',
+        description: 'Max entries for classifier',
+      },
+      {
+        name: 'retrieval.maxStoryEntries',
+        type: 'number',
+        description: 'Max story entries for retrieval',
+      },
+      {
+        name: 'agenticRetrieval.recentEntriesCount',
+        type: 'number',
+        description: 'Recent entries count',
+      },
+      {
+        name: 'agenticRetrieval.maxChapters',
+        type: 'number',
+        description: 'Max chapters per retrieval',
+      },
+      {
+        name: 'agenticRetrieval.summaryCharLimit',
+        type: 'number',
+        description: 'Summary character limit',
+      },
+      {
+        name: 'agenticRetrieval.maxLorebookEntries',
+        type: 'number',
+        description: 'Max lorebook entries',
+      },
+      { name: 'memoryConfig', type: 'object', description: 'Memory configuration' },
+      { name: 'lorebookConfig', type: 'object', description: 'Lorebook limits settings' },
+      {
+        name: 'imageGeneration.inlineImageMode',
+        type: 'boolean',
+        description: 'Inline image mode enabled',
+      },
+      {
+        name: 'imageGeneration.referenceMode',
+        type: 'boolean',
+        description: 'Reference mode enabled',
+      },
+      {
+        name: 'imageGeneration.maxImages',
+        type: 'number',
+        description: 'Max images per message',
+      },
+      {
+        name: 'imageGeneration.stylePrompt',
+        type: 'string',
+        description: 'Style prompt for image generation',
+      },
+      {
+        name: 'translationSettings.targetLanguage.code',
+        type: 'string',
+        description: 'Target language code',
+      },
+      {
+        name: 'translationSettings.targetLanguage.name',
+        type: 'string',
+        description: 'Target language name',
+      },
+      {
+        name: 'translationSettings.sourceLanguage.code',
+        type: 'string',
+        description: 'Source language code',
+      },
+      {
+        name: 'translationSettings.sourceLanguage.name',
+        type: 'string',
+        description: 'Source language name',
+      },
+    ],
+  }),
+
+  // Generation Results
+  v('styleReview', 'object', 'Style analysis result', {
+    infoFields: [
+      { name: 'phrases', type: 'array', description: 'Array of PhraseAnalysis objects' },
+      { name: 'phrases[].phrase', type: 'string', description: 'The overused phrase' },
+      { name: 'phrases[].frequency', type: 'number', description: 'Times used' },
+      { name: 'phrases[].severity', type: 'string', description: 'low, medium, or high' },
+      { name: 'phrases[].alternatives', type: 'string[]', description: 'Suggested replacements' },
+      { name: 'overallAssessment', type: 'string', description: 'Overall style assessment' },
+      { name: 'reviewedEntryCount', type: 'number', description: 'Entries analyzed' },
+    ],
+  }),
+  v('retrievalResult', 'object', 'Lorebook retrieval results'),
+  v('classificationResult', 'object', 'World state classification results'),
+  v('narrativeResult', 'object', 'Narrative generation result', {
+    infoFields: [{ name: 'content', type: 'string', description: 'Generated narrative text' }],
+  }),
+  v('translationResult', 'object', 'Translation results'),
+
+  // Memory
+  v('chapterAnalysis', 'object', 'Chapter analysis context', {
+    infoFields: [
+      { name: 'result', type: 'object', description: 'Chapter analysis result' },
+      { name: 'protectedEntryCount', type: 'number', description: 'Protected entry count' },
+      {
+        name: 'analysisEntries',
+        type: 'array',
+        description: 'Entries for analysis (StoryEntry[])',
+      },
+      {
+        name: 'chapterEntries',
+        type: 'array',
+        description: 'Entries within chapter (StoryEntry[])',
+      },
+    ],
+  }),
+  v('lastChapterEndIndex', 'number', 'Index of last chapter end'),
+
+  // Pack Variables (classifier uses packVariables.runtimeVariables for extraction instructions)
+  v(
+    'packVariables.runtimeVariables',
+    'object',
+    'Runtime variable definitions grouped by entity type (for classifier)',
+    {
+      infoFields: [
+        {
+          name: 'character',
+          type: 'RuntimeVariable[]',
+          description: 'Variables for character entities',
+        },
+        {
+          name: 'location',
+          type: 'RuntimeVariable[]',
+          description: 'Variables for location entities',
+        },
+        { name: 'item', type: 'RuntimeVariable[]', description: 'Variables for item entities' },
+        {
+          name: 'story_beat',
+          type: 'RuntimeVariable[]',
+          description: 'Variables for story beat entities',
+        },
+      ],
+    },
+  ),
+
+  // Translation Data
+  v('suggestionsToTranslate', 'array', 'Suggestions for translation'),
+  v('actionChoicesToTranslate', 'array', 'Action choices for translation'),
+  v('uiElementsToTranslate', 'array', 'UI elements for translation'),
+
+  // Time
+  v('timeTracker', 'object', 'In-story time tracking'),
+]
+
+// ---------------------------------------------------------------------------
+// timelineFillAnswer variable definitions
+// (all promptContext vars + extras)
+// ---------------------------------------------------------------------------
+
+const TIMELINE_FILL_ANSWER_EXTRA_VARS: VariableDefinition[] = [
+  v('answerChapters', 'array', 'Chapters with optional embedded entries', {
+    infoFields: [
+      { name: 'number', type: 'number', description: 'Chapter number' },
+      { name: 'title', type: 'string', description: 'Chapter title' },
+      { name: 'summary', type: 'string', description: 'Chapter summary' },
+      { name: 'entries', type: 'array', description: 'Optional story entries within chapter' },
+    ],
+  }),
+  v('query', 'text', 'Query for timeline fill answer'),
+]
+
+const TIMELINE_FILL_ANSWER_VARS: VariableDefinition[] = [
+  ...PROMPT_CONTEXT_VARS,
+  ...TIMELINE_FILL_ANSWER_EXTRA_VARS,
+]
+
+// ---------------------------------------------------------------------------
+// wizard variable definitions
+// ---------------------------------------------------------------------------
+
+const WIZARD_VARS: VariableDefinition[] = [
+  // Story Setup (scalars)
+  v('genreLabel', 'text', 'Genre label for display'),
+  v('seed', 'text', 'Seed text or idea for generation'),
+  v('customInstruction', 'text', 'Custom user instruction'),
+  v('toneInstruction', 'text', 'Tone instruction text'),
+  v('settingInstruction', 'text', 'Setting instruction text'),
+  v('settingContext', 'text', 'Setting context text'),
+  v('settingName', 'text', 'Setting name'),
+  v('settingDescription', 'text', 'Setting description'),
+  v('settingAtmosphere', 'text', 'Setting atmosphere and mood'),
+  v('settingThemesText', 'text', 'Setting themes as text'),
+  v('count', 'number', 'Number of items to generate'),
+  v('title', 'text', 'Title for generation'),
+  v('atmosphere', 'text', 'Atmosphere description'),
+  v('openingGuidance', 'text', 'Guidance for opening generation'),
+  v('tenseInstruction', 'text', 'Tense instruction text'),
+  v('mode', 'enum', 'Story mode', {
+    enumValues: ['adventure', 'creative-writing'],
+  }),
+  v('pov', 'enum', 'Point of view', {
+    enumValues: ['first', 'second', 'third'],
+  }),
+  v('tone', 'text', 'Story tone/mood'),
+  v('protagonistName', 'text', 'Protagonist name'),
+  v('protagonistDescription', 'text', 'Protagonist description'),
+
+  // Setting (objects)
+  v('currentSetting', 'object', 'Current setting data', {
+    infoFields: [
+      { name: 'name', type: 'string', description: 'Setting name' },
+      { name: 'description', type: 'string', description: 'Setting description' },
+      { name: 'atmosphere', type: 'string', description: 'Atmosphere and mood' },
+      { name: 'themes', type: 'string[]', description: 'Thematic elements' },
+      { name: 'potentialConflicts', type: 'string[]', description: 'Potential story conflicts' },
+      {
+        name: 'keyLocations',
+        type: 'array',
+        description: 'Key locations ({name, description})',
+      },
+    ],
+  }),
+
+  // Character (objects)
+  v('characterInput', 'object', 'Character input for elaboration', {
+    infoFields: [
+      { name: 'name', type: 'string', description: 'Character name' },
+      { name: 'description', type: 'string', description: 'Physical description' },
+      { name: 'background', type: 'string', description: 'Backstory' },
+      { name: 'motivation', type: 'string', description: 'Goals' },
+      { name: 'traits', type: 'string[]', description: 'Personality traits' },
+    ],
+  }),
+  v('currentCharacter', 'object', 'Current character data for refinement', {
+    infoFields: [
+      { name: 'name', type: 'string', description: 'Character name' },
+      { name: 'description', type: 'string', description: 'Physical description' },
+      { name: 'background', type: 'string', description: 'Backstory' },
+      { name: 'motivation', type: 'string', description: 'Goals' },
+      { name: 'traits', type: 'string[]', description: 'Personality traits' },
+      { name: 'appearance', type: 'string', description: 'Detailed appearance' },
+    ],
+  }),
+  v('protagonist', 'object', 'Protagonist data', {
+    infoFields: [
+      { name: 'name', type: 'string', description: 'Protagonist name' },
+      { name: 'description', type: 'string', description: 'Description' },
+      { name: 'motivation', type: 'string', description: 'Motivation' },
+    ],
+  }),
+
+  // Opening (object)
+  v('currentOpening', 'object', 'Current opening data for refinement', {
+    infoFields: [
+      { name: 'title', type: 'string', description: 'Opening title' },
+      { name: 'scene', type: 'string', description: 'Opening scene prose' },
+      {
+        name: 'initialLocation',
+        type: 'object',
+        description: 'Starting location ({name, description})',
+      },
+    ],
+  }),
+
+  // Lorebook
+  v('lorebookEntries', 'array', 'Lorebook entries', { infoFields: lorebookEntryWizardFields }),
+
+  // Supporting Characters
+  v('supportingCharacters', 'array', 'Supporting characters', {
+    infoFields: [
+      { name: 'name', type: 'string', description: 'Character name' },
+      { name: 'role', type: 'string', description: 'Role (ally, antagonist, etc.)' },
+      { name: 'description', type: 'string', description: 'Character description' },
+      { name: 'relationship', type: 'string', description: 'Relationship to protagonist' },
+      { name: 'traits', type: 'string[]', description: 'Personality traits' },
+    ],
+  }),
+]
+
+// ---------------------------------------------------------------------------
+// vault variable definitions
+// ---------------------------------------------------------------------------
+
+const VAULT_VARS: VariableDefinition[] = [
+  v('characterCount', 'number', 'Number of vault characters'),
+  v('lorebookCount', 'number', 'Number of lorebook entries'),
+  v('totalEntryCount', 'number', 'Total number of vault entries'),
+  v('scenarioCount', 'number', 'Number of scenarios'),
+  v('focusedEntity', 'object', 'Currently focused vault entity', {
+    infoFields: [
+      { name: 'entityType', type: 'string', description: 'Entity type' },
+      { name: 'entityName', type: 'string', description: 'Entity name' },
+      { name: 'entityId', type: 'string', description: 'Entity ID' },
+    ],
+  }),
+]
+
+// ---------------------------------------------------------------------------
+// lore variable definitions
+// ---------------------------------------------------------------------------
+
+const LORE_VARS: VariableDefinition[] = [
+  v('loreEntries', 'array', 'Lorebook entries for management', {
+    infoFields: [
+      { name: 'name', type: 'string', description: 'Entry name' },
+      { name: 'type', type: 'string', description: 'Entry type' },
+      { name: 'description', type: 'string', description: 'Entry description' },
+      { name: 'state', type: 'string', description: 'Current dynamic state (optional)' },
+    ],
+  }),
+  v('loreChapters', 'array', 'Chapters for lore context', {
+    infoFields: [
+      { name: 'number', type: 'number', description: 'Chapter number' },
+      { name: 'title', type: 'string', description: 'Chapter title' },
+      { name: 'summary', type: 'string', description: 'Chapter summary' },
+    ],
+  }),
+]
+
+// ---------------------------------------------------------------------------
+// import variable definitions
+// ---------------------------------------------------------------------------
+
+const IMPORT_VARS: VariableDefinition[] = [
+  v('genre', 'text', 'Genre for import context'),
+  v('title', 'text', 'Title of imported content'),
+  v('cardContent', 'text', 'Raw character card content'),
+  v('entriesJson', 'text', 'Entries as JSON string'),
+]
+
+// ---------------------------------------------------------------------------
+// portrait variable definitions
+// ---------------------------------------------------------------------------
+
+const PORTRAIT_VARS: VariableDefinition[] = [
+  v('imageStylePrompt', 'text', 'Style prompt for portrait generation'),
+  v('visualDescriptors', 'object', 'Character visual descriptors', {
+    infoFields: [
+      { name: 'face', type: 'string', description: 'Skin tone, facial features, expression' },
+      { name: 'hair', type: 'string', description: 'Color, length, style' },
+      { name: 'eyes', type: 'string', description: 'Color, shape, notable features' },
+      { name: 'build', type: 'string', description: 'Height, body type, posture' },
+      { name: 'clothing', type: 'string', description: 'Full outfit description' },
+      { name: 'accessories', type: 'string', description: 'Jewelry, weapons, bags' },
+      { name: 'distinguishing', type: 'string', description: 'Scars, tattoos, birthmarks' },
+    ],
+  }),
+]
+
+// ---------------------------------------------------------------------------
+// translateWizard variable definitions
+// ---------------------------------------------------------------------------
+
+const TRANSLATE_WIZARD_VARS: VariableDefinition[] = [
+  v('targetLanguage', 'text', 'Target language for translation'),
+  v('content', 'text', 'Content to translate'),
+]
+
+// ---------------------------------------------------------------------------
+// Group name -> variable definitions
+// ---------------------------------------------------------------------------
+
+const GROUP_VARIABLES: Record<ContextGroupName, VariableDefinition[]> = {
+  promptContext: PROMPT_CONTEXT_VARS,
+  timelineFillAnswer: TIMELINE_FILL_ANSWER_VARS,
+  wizard: WIZARD_VARS,
+  vault: VAULT_VARS,
+  lore: LORE_VARS,
+  import: IMPORT_VARS,
+  portrait: PORTRAIT_VARS,
+  translateWizard: TRANSLATE_WIZARD_VARS,
+  staticContent: [],
+}
+
+// ---------------------------------------------------------------------------
+// Display groups per context group
+// ---------------------------------------------------------------------------
+
+const PROMPT_CONTEXT_DISPLAY_GROUPS: DisplayGroup[] = [
+  {
+    label: 'Story Config',
+    variables: [
+      'mode',
+      'pov',
+      'tense',
+      'protagonistName',
+      'protagonistDescription',
+      'genre',
+      'settingDescription',
+      'tone',
+      'themes',
+    ],
+  },
+  {
+    label: 'Story Content',
+    variables: [
+      'storyEntries',
+      'storyEntriesRaw',
+      'storyEntriesVisible',
+      'storyEntriesVisibleRaw',
+      'userInput',
+      'userActionOriginal',
+      'narrationEntryId',
+      'lastNarrativeEntry',
+    ],
+  },
+  {
+    label: 'Entities',
+    variables: ['characters', 'locations', 'items', 'storyBeats', 'chapters', 'lorebookEntries'],
+  },
+  {
+    label: 'World State',
+    variables: ['relevantWorldState'],
+  },
+  {
+    label: 'Entry Selection',
+    variables: ['loreEntriesForTier3', 'worldStateForTier3'],
+  },
+  {
+    label: 'Settings',
+    variables: ['userSettings'],
+  },
+  {
+    label: 'Generation Results',
+    variables: [
+      'styleReview',
+      'retrievalResult',
+      'classificationResult',
+      'narrativeResult',
+      'translationResult',
+    ],
+  },
+  {
+    label: 'Memory',
+    variables: ['chapterAnalysis', 'lastChapterEndIndex'],
+  },
+  {
+    label: 'Pack Variables',
+    variables: ['packVariables.runtimeVariables'],
+  },
+  {
+    label: 'Translation Data',
+    variables: ['suggestionsToTranslate', 'actionChoicesToTranslate', 'uiElementsToTranslate'],
+  },
+  {
+    label: 'Time',
+    variables: ['timeTracker'],
+  },
+]
+
+const TIMELINE_FILL_ANSWER_DISPLAY_GROUPS: DisplayGroup[] = [
+  ...PROMPT_CONTEXT_DISPLAY_GROUPS,
+  {
+    label: 'Timeline Fill',
+    variables: ['answerChapters', 'query'],
+  },
+]
+
+const WIZARD_DISPLAY_GROUPS: DisplayGroup[] = [
+  {
+    label: 'Story Setup',
+    variables: [
+      'genreLabel',
+      'seed',
+      'customInstruction',
+      'toneInstruction',
+      'settingInstruction',
+      'settingContext',
+      'settingName',
+      'settingDescription',
+      'settingAtmosphere',
+      'settingThemesText',
+      'count',
+      'title',
+      'atmosphere',
+      'openingGuidance',
+      'tenseInstruction',
+      'mode',
+      'pov',
+      'tone',
+      'protagonistName',
+      'protagonistDescription',
+    ],
+  },
+  {
+    label: 'Setting',
+    variables: ['currentSetting'],
+  },
+  {
+    label: 'Character',
+    variables: ['characterInput', 'currentCharacter', 'protagonist', 'supportingCharacters'],
+  },
+  {
+    label: 'Opening',
+    variables: ['currentOpening'],
+  },
+  {
+    label: 'Lorebook',
+    variables: ['lorebookEntries'],
+  },
+]
+
+const VAULT_DISPLAY_GROUPS: DisplayGroup[] = [
+  {
+    label: 'Vault',
+    variables: [
+      'characterCount',
+      'lorebookCount',
+      'totalEntryCount',
+      'scenarioCount',
+      'focusedEntity',
+    ],
+  },
+]
+
+const LORE_DISPLAY_GROUPS: DisplayGroup[] = [
+  {
+    label: 'Lore',
+    variables: ['loreEntries', 'loreChapters'],
+  },
+]
+
+const IMPORT_DISPLAY_GROUPS: DisplayGroup[] = [
+  {
+    label: 'Import',
+    variables: ['genre', 'title', 'cardContent', 'entriesJson'],
+  },
+]
+
+const PORTRAIT_DISPLAY_GROUPS: DisplayGroup[] = [
+  {
+    label: 'Portrait',
+    variables: ['imageStylePrompt', 'visualDescriptors'],
+  },
+]
+
+const TRANSLATE_WIZARD_DISPLAY_GROUPS: DisplayGroup[] = [
+  {
+    label: 'Translate Wizard',
+    variables: ['targetLanguage', 'content'],
+  },
+]
+
+const GROUP_DISPLAY_GROUPS: Record<ContextGroupName, DisplayGroup[]> = {
+  promptContext: PROMPT_CONTEXT_DISPLAY_GROUPS,
+  timelineFillAnswer: TIMELINE_FILL_ANSWER_DISPLAY_GROUPS,
+  wizard: WIZARD_DISPLAY_GROUPS,
+  vault: VAULT_DISPLAY_GROUPS,
+  lore: LORE_DISPLAY_GROUPS,
+  import: IMPORT_DISPLAY_GROUPS,
+  portrait: PORTRAIT_DISPLAY_GROUPS,
+  translateWizard: TRANSLATE_WIZARD_DISPLAY_GROUPS,
+  staticContent: [],
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export function getContextGroup(templateId: string): ContextGroupName | null {
+  const group = TEMPLATE_GROUP_MAP[templateId]
+  if (group) return group
+  if (templateId && !warnedUnmappedIds.has(templateId)) {
+    warnedUnmappedIds.add(templateId)
+    log('unmapped templateId — no context group registered', { templateId })
+  }
+  return null
+}
+
+export function getVariablesForTemplate(templateId: string): readonly VariableDefinition[] {
+  const group = getContextGroup(templateId)
+  if (!group) return EMPTY_VARS
+  return GROUP_VARIABLES[group]
+}
+
+export function getDisplayGroupsForTemplate(templateId: string): readonly DisplayGroup[] {
+  const group = getContextGroup(templateId)
+  if (!group) return EMPTY_DISPLAY_GROUPS
+  return GROUP_DISPLAY_GROUPS[group]
+}
+
+export function getVariableNamesForTemplate(templateId: string): string[] {
+  return getVariablesForTemplate(templateId).map((def) => def.name)
+}
+
+const EMPTY_VARS: readonly VariableDefinition[] = Object.freeze([])
+const EMPTY_DISPLAY_GROUPS: readonly DisplayGroup[] = Object.freeze([])
+
+/**
+ * Integrity report used by tests and dev tooling to surface map drift:
+ * templateIds loaded from .liquid files that lack a group entry, and
+ * display-group variable names that don't match any definition.
+ */
+export interface ContextMapIntegrityReport {
+  unmappedTemplateIds: string[]
+  orphanedDisplayVariables: { group: ContextGroupName; label: string; name: string }[]
+}
+
+export function validateContextMapIntegrity(
+  templateIds: readonly string[],
+): ContextMapIntegrityReport {
+  const unmappedTemplateIds = templateIds.filter((id) => !(id in TEMPLATE_GROUP_MAP))
+  const orphanedDisplayVariables: ContextMapIntegrityReport['orphanedDisplayVariables'] = []
+  for (const [group, displayGroups] of Object.entries(GROUP_DISPLAY_GROUPS) as [
+    ContextGroupName,
+    DisplayGroup[],
+  ][]) {
+    const definedNames = new Set(GROUP_VARIABLES[group].map((v) => v.name))
+    for (const dg of displayGroups) {
+      for (const name of dg.variables) {
+        if (!definedNames.has(name)) {
+          orphanedDisplayVariables.push({ group, label: dg.label, name })
+        }
+      }
+    }
+  }
+  return { unmappedTemplateIds, orphanedDisplayVariables }
+}
diff --git a/src/lib/services/templates/validator.test.ts b/src/lib/services/templates/validator.test.ts
new file mode 100644
index 00000000..77113943
--- /dev/null
+++ b/src/lib/services/templates/validator.test.ts
@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest'
+import { validateTemplate } from './validator'
+
+describe('validateTemplate — templateId parameter', () => {
+  it('accepts variables that belong to the mapped context group', () => {
+    const result = validateTemplate('Hello {{ protagonistName }}', 'adventure')
+    expect(result.valid).toBe(true)
+    expect(result.errors).toEqual([])
+  })
+
+  it('flags variables that do not belong to the mapped context group', () => {
+    const result = validateTemplate('{{ bogusVariable }}', 'adventure')
+    expect(result.valid).toBe(false)
+    expect(result.errors.some((e) => e.type === 'unknown_variable')).toBe(true)
+  })
+
+  it('emits a single warning for an unmapped templateId and skips per-variable errors', () => {
+    const result = validateTemplate('{{ anything }} {{ else }}', 'does-not-exist')
+    const warnings = result.errors.filter((e) => e.severity === 'warning')
+    expect(warnings).toHaveLength(1)
+    expect(warnings[0].message).toContain('does-not-exist')
+    // Template still considered valid because the issue is a warning, not an error.
+    expect(result.valid).toBe(true)
+  })
+
+  it('seeds namespaced roots so dotted access resolves (packVariables.foo)', () => {
+    const result = validateTemplate('{{ packVariables.runtimeVariables.anything }}', 'adventure', [
+      'packVariables.runtimeVariables',
+    ])
+    expect(result.valid).toBe(true)
+    expect(result.errors).toEqual([])
+  })
+
+  it('without templateId, only additionalVariables are considered valid', () => {
+    const unknown = validateTemplate('{{ freeVar }}')
+    expect(unknown.valid).toBe(false)
+
+    const passed = validateTemplate('{{ freeVar }}', undefined, ['freeVar'])
+    expect(passed.valid).toBe(true)
+  })
+})
diff --git a/src/lib/services/templates/validator.ts b/src/lib/services/templates/validator.ts
index 9e438a3b..78ec61de 100644
--- a/src/lib/services/templates/validator.ts
+++ b/src/lib/services/templates/validator.ts
@@ -6,7 +6,7 @@
  */
 
 import { templateEngine } from './engine'
-import { variableRegistry } from './variables'
+import { getContextGroup, getVariableNamesForTemplate } from './templateContextMap'
 import type { ValidationResult, ValidationError } from './types'
 import { createLogger } from '$lib/log'
 
@@ -212,6 +212,7 @@ function extractFilterNames(template: string): string[] {
  */
 export function validateTemplate(
   template: string,
+  templateId?: string,
   additionalVariables?: string[],
 ): ValidationResult {
   const errors: ValidationError[] = []
@@ -238,10 +239,30 @@ export function validateTemplate(
 
   // Step 2: Variable reference validation
   const variableNames = templateEngine.extractVariableNames(template)
-  const validVariables = new Set([
-    ...variableRegistry.getAllNames(),
-    ...(additionalVariables || []),
-  ])
+
+  // Distinguish "template has no context group registered" (a map bug) from a
+  // template whose id simply wasn't passed in. Without this branch, an unmapped
+  // id floods the caller with false unknown-variable errors for every reference.
+  const unmapped = templateId != null && getContextGroup(templateId) === null
+  if (unmapped) {
+    log('template has no registered context group', { templateId })
+    errors.push({
+      type: 'unknown_variable',
+      message: `Template '${templateId}' has no registered context group. Variable validation skipped — contact maintainers.`,
+      severity: 'warning',
+    })
+  }
+
+  const templateVarNames = templateId && !unmapped ? getVariableNamesForTemplate(templateId) : []
+  const validVariables = new Set([...templateVarNames, ...(additionalVariables || [])])
+
+  // Namespaced variables (e.g. `packVariables.runtimeVariables`) register their
+  // full path, but user input is validated by root (`packVariables`). Seed the
+  // set with those roots so dotted access like `{{ packVariables.foo }}` resolves.
+  for (const name of [...validVariables]) {
+    const dotIndex = name.indexOf('.')
+    if (dotIndex > 0) validVariables.add(name.slice(0, dotIndex))
+  }
 
   // Extract loop-scoped variables from {% for X in Y %} constructs
   const loopVars = new Set<string>()
@@ -263,7 +284,8 @@ export function validateTemplate(
   // Built-in Liquid variables available in loops and elsewhere
   const builtinRoots = new Set(['forloop', 'tablerowloop'])
 
-  for (const varName of variableNames) {
+  // Skip per-variable checks when we already surfaced the unmapped-template warning.
+  for (const varName of unmapped ? [] : variableNames) {
     // Extract root name (before first dot)
     const root = varName.split('.')[0]
 
diff --git a/src/lib/services/templates/variables.ts b/src/lib/services/templates/variables.ts
deleted file mode 100644
index d491840c..00000000
--- a/src/lib/services/templates/variables.ts
+++ /dev/null
@@ -1,1292 +0,0 @@
-/**
- * Variable Registry
- *
- * Manages variable definitions across three categories:
- * - system: Auto-filled by the application
- * - runtime: Injected by services at render time
- * - custom: User-defined variables in preset packs
- */
-
-import type { VariableDefinition, VariableCategory, VariableFieldInfo } from './types'
-
-/**
- * System variables - auto-filled by the application
- * These variables are always available in templates and are populated from story context.
- */
-export const SYSTEM_VARIABLES: VariableDefinition[] = [
-  {
-    name: 'protagonistName',
-    type: 'text',
-    category: 'system',
-    description: 'Name of the main character',
-    required: true,
-  },
-  {
-    name: 'currentLocation',
-    type: 'text',
-    category: 'system',
-    description: 'Current story location',
-    required: false,
-  },
-  {
-    name: 'storyTime',
-    type: 'text',
-    category: 'system',
-    description: 'Current in-story time',
-    required: false,
-  },
-  {
-    name: 'genre',
-    type: 'text',
-    category: 'system',
-    description: 'Story genre',
-    required: false,
-  },
-  {
-    name: 'tone',
-    type: 'text',
-    category: 'system',
-    description: 'Story tone/mood',
-    required: false,
-  },
-  {
-    name: 'settingDescription',
-    type: 'text',
-    category: 'system',
-    description: 'World/setting description',
-    required: false,
-  },
-  {
-    name: 'themes',
-    type: 'text',
-    category: 'system',
-    description: 'Story themes as comma-separated list',
-    required: false,
-  },
-  {
-    name: 'mode',
-    type: 'enum',
-    category: 'system',
-    description: 'Story mode',
-    required: true,
-    enumValues: ['adventure', 'creative-writing'],
-  },
-  {
-    name: 'pov',
-    type: 'enum',
-    category: 'system',
-    description: 'Point of view',
-    required: true,
-    enumValues: ['first', 'second', 'third'],
-  },
-  {
-    name: 'tense',
-    type: 'enum',
-    category: 'system',
-    description: 'Narrative tense',
-    required: true,
-    enumValues: ['past', 'present'],
-  },
-]
-
-/**
- * Variable Registry class
- * Manages variable definitions with lookup and categorization capabilities.
- */
-class VariableRegistry {
-  private variables: Map<string, VariableDefinition>
-
-  constructor() {
-    this.variables = new Map()
-    // Pre-populate with system variables
-    this.registerMany(SYSTEM_VARIABLES)
-  }
-
-  /**
-   * Register a single variable definition
-   *
-   * @param definition - Variable definition to register
-   * @throws Error if variable name already registered (prevents duplicates)
-   */
-  register(definition: VariableDefinition): void {
-    if (this.variables.has(definition.name)) {
-      throw new Error(`Variable '${definition.name}' is already registered`)
-    }
-    this.variables.set(definition.name, definition)
-  }
-
-  /**
-   * Register multiple variable definitions
-   *
-   * @param definitions - Array of variable definitions to register
-   */
-  registerMany(definitions: VariableDefinition[]): void {
-    for (const definition of definitions) {
-      this.register(definition)
-    }
-  }
-
-  /**
-   * Get a variable definition by name
-   *
-   * @param name - Variable name
-   * @returns Variable definition or undefined if not found
-   */
-  get(name: string): VariableDefinition | undefined {
-    return this.variables.get(name)
-  }
-
-  /**
-   * Check if a variable is registered
-   *
-   * @param name - Variable name
-   * @returns True if variable exists
-   */
-  has(name: string): boolean {
-    return this.variables.has(name)
-  }
-
-  /**
-   * Get all variables in a specific category
-   *
-   * @param category - Variable category (system, runtime, or custom)
-   * @returns Array of variable definitions in that category
-   */
-  getByCategory(category: VariableCategory): VariableDefinition[] {
-    return Array.from(this.variables.values())
-      .filter((v) => v.category === category)
-      .sort((a, b) => a.name.localeCompare(b.name))
-  }
-
-  /**
-   * Get all registered variable names
-   *
-   * @returns Array of all variable names
-   */
-  getAllNames(): string[] {
-    return Array.from(this.variables.keys())
-  }
-
-  /**
-   * Get all registered variable definitions
-   *
-   * @returns Array of all variable definitions
-   */
-  getAll(): VariableDefinition[] {
-    return Array.from(this.variables.values()).sort((a, b) => a.name.localeCompare(b.name))
-  }
-
-  /**
-   * Clear all variable definitions
-   * Useful for reinitialization.
-   */
-  clear(): void {
-    this.variables.clear()
-  }
-
-  /**
-   * Remove a single variable definition
-   *
-   * @param name - Variable name to remove
-   */
-  remove(name: string): void {
-    this.variables.delete(name)
-  }
-}
-
-/**
- * Runtime variables - injected by services at render time
- * These variables are populated by various AI services when building prompts.
- * Registered for autocomplete and validation in the template editor.
- */
-export const RUNTIME_VARIABLES: VariableDefinition[] = [
-  // === Narrative Service ===
-  {
-    name: 'recentContent',
-    type: 'text',
-    category: 'runtime',
-    description: 'Recent story content for context',
-    required: false,
-  },
-  {
-    name: 'visualProseMode',
-    type: 'boolean',
-    category: 'runtime',
-    description: 'Whether visual prose mode is enabled',
-    required: false,
-  },
-  {
-    name: 'inlineImageMode',
-    type: 'boolean',
-    category: 'runtime',
-    description: 'Whether inline image mode is enabled',
-    required: false,
-  },
-
-  // === Classifier Service ===
-  {
-    name: 'entityCounts',
-    type: 'text',
-    category: 'runtime',
-    description: 'Count of existing entities (characters, locations, items)',
-    required: false,
-  },
-  {
-    name: 'currentTimeInfo',
-    type: 'text',
-    category: 'runtime',
-    description: 'Current in-story time information',
-    required: false,
-  },
-  {
-    name: 'inputLabel',
-    type: 'text',
-    category: 'runtime',
-    description: 'Label for user input (Player Action or Author Direction)',
-    required: false,
-  },
-  {
-    name: 'userAction',
-    type: 'text',
-    category: 'runtime',
-    description: 'The user action or direction text',
-    required: false,
-  },
-  {
-    name: 'narrativeResponse',
-    type: 'text',
-    category: 'runtime',
-    description: 'The narrative response text',
-    required: false,
-  },
-  {
-    name: 'storyBeatTypes',
-    type: 'text',
-    category: 'runtime',
-    description: 'Available story beat type values',
-    required: false,
-  },
-  {
-    name: 'itemLocationOptions',
-    type: 'text',
-    category: 'runtime',
-    description: 'Valid item location options',
-    required: false,
-  },
-  {
-    name: 'defaultItemLocation',
-    type: 'text',
-    category: 'runtime',
-    description: 'Default item location',
-    required: false,
-  },
-
-  // === Memory Service ===
-  {
-    name: 'firstValidId',
-    type: 'number',
-    category: 'runtime',
-    description: 'First valid entry ID in range',
-    required: false,
-  },
-  {
-    name: 'lastValidId',
-    type: 'number',
-    category: 'runtime',
-    description: 'Last valid entry ID in range',
-    required: false,
-  },
-  {
-    name: 'recentEntries',
-    type: 'array' as const,
-    category: 'runtime' as const,
-    description: 'Recent story entries for agentic retrieval context (configurable count)',
-    required: false,
-    infoFields: [
-      { name: 'type', type: 'string', description: 'Entry type (narration, user_action)' },
-      { name: 'content', type: 'string', description: 'Entry text content' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'maxChaptersPerRetrieval',
-    type: 'text',
-    category: 'runtime',
-    description: 'Maximum chapters per retrieval decision',
-    required: false,
-  },
-
-  // === Suggestions Service ===
-  {
-    name: 'activeThreads',
-    type: 'text',
-    category: 'runtime',
-    description: 'Active plot threads for suggestions',
-    required: false,
-  },
-
-  // === Action Choices Service ===
-  {
-    name: 'npcsPresent',
-    type: 'text',
-    category: 'runtime',
-    description: 'NPCs present in the current scene',
-    required: false,
-  },
-  {
-    name: 'inventory',
-    type: 'text',
-    category: 'runtime',
-    description: 'Current inventory contents',
-    required: false,
-  },
-  {
-    name: 'activeQuests',
-    type: 'text',
-    category: 'runtime',
-    description: 'Active quests and objectives',
-    required: false,
-  },
-  {
-    name: 'protagonistDescription',
-    type: 'text',
-    category: 'runtime',
-    description: 'Description of the protagonist',
-    required: false,
-  },
-  {
-    name: 'povInstruction',
-    type: 'text',
-    category: 'runtime',
-    description: 'Point of view instruction text',
-    required: false,
-  },
-  {
-    name: 'lengthInstruction',
-    type: 'text',
-    category: 'runtime',
-    description: 'Response length instruction',
-    required: false,
-  },
-
-  // === Shared / Common ===
-  {
-    name: 'userInput',
-    type: 'text',
-    category: 'runtime',
-    description: 'User input or action text',
-    required: false,
-  },
-
-  // === Style Reviewer Service ===
-  {
-    name: 'passageCount',
-    type: 'text',
-    category: 'runtime',
-    description: 'Number of passages being reviewed',
-    required: false,
-  },
-
-  // === Agentic Retrieval Service ===
-  {
-    name: 'chaptersCount',
-    type: 'text',
-    category: 'runtime',
-    description: 'Number of available chapters',
-    required: false,
-  },
-  {
-    name: 'entriesCount',
-    type: 'text',
-    category: 'runtime',
-    description: 'Number of available lorebook entries',
-    required: false,
-  },
-  // === Timeline Fill Service ===
-  {
-    name: 'query',
-    type: 'text',
-    category: 'runtime',
-    description: 'Query for timeline fill answer',
-    required: false,
-  },
-
-  // === Translation Service ===
-  {
-    name: 'targetLanguage',
-    type: 'text',
-    category: 'runtime',
-    description: 'Target language for translation',
-    required: false,
-  },
-  {
-    name: 'sourceLanguage',
-    type: 'text',
-    category: 'runtime',
-    description: 'Source language for translation',
-    required: false,
-  },
-  {
-    name: 'content',
-    type: 'text',
-    category: 'runtime',
-    description: 'Content to translate or process',
-    required: false,
-  },
-  {
-    name: 'elementsJson',
-    type: 'text',
-    category: 'runtime',
-    description: 'JSON of UI elements for translation',
-    required: false,
-  },
-  {
-    name: 'suggestionsJson',
-    type: 'text',
-    category: 'runtime',
-    description: 'JSON of suggestions for translation',
-    required: false,
-  },
-  {
-    name: 'choicesJson',
-    type: 'text',
-    category: 'runtime',
-    description: 'JSON of action choices for translation',
-    required: false,
-  },
-
-  // === Image Services ===
-  {
-    name: 'imageStylePrompt',
-    type: 'text',
-    category: 'runtime',
-    description: 'Style prompt for image generation',
-    required: false,
-  },
-  {
-    name: 'maxImages',
-    type: 'text',
-    category: 'runtime',
-    description: 'Maximum number of images to generate',
-    required: false,
-  },
-  {
-    name: 'translatedNarrativeBlock',
-    type: 'text',
-    category: 'runtime',
-    description: 'Translated narrative for image analysis',
-    required: false,
-  },
-  {
-    name: 'visualDescriptors',
-    type: 'object',
-    category: 'runtime',
-    description:
-      'Structured visual descriptors for portrait generation (face, hair, eyes, build, clothing, accessories, distinguishing)',
-    required: false,
-    infoFields: [
-      { name: 'face', type: 'string', description: 'Skin tone, facial features, expression' },
-      { name: 'hair', type: 'string', description: 'Color, length, style, texture' },
-      { name: 'eyes', type: 'string', description: 'Color, shape, notable features' },
-      { name: 'build', type: 'string', description: 'Height, body type, posture' },
-      { name: 'clothing', type: 'string', description: 'Full outfit description' },
-      { name: 'accessories', type: 'string', description: 'Jewelry, weapons, bags' },
-      { name: 'distinguishing', type: 'string', description: 'Scars, tattoos, birthmarks' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'narrationEntries',
-    type: 'array',
-    category: 'runtime',
-    description: 'All narration entries for background image analysis',
-    required: false,
-    infoFields: [
-      { name: 'type', type: 'string', description: 'Always narration' },
-      { name: 'content', type: 'string', description: 'Narration text' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'lastNarrationIndex',
-    type: 'text',
-    category: 'runtime',
-    description: 'Index of the last element in narrationEntries (narrationEntries.length - 1)',
-    required: false,
-  },
-
-  // === Wizard Service ===
-  {
-    name: 'genreLabel',
-    type: 'text',
-    category: 'runtime',
-    description: 'Genre label for wizard generation',
-    required: false,
-  },
-  {
-    name: 'seed',
-    type: 'text',
-    category: 'runtime',
-    description: 'Seed text for setting expansion',
-    required: false,
-  },
-  {
-    name: 'customInstruction',
-    type: 'text',
-    category: 'runtime',
-    description: 'Custom user instructions for generation',
-    required: false,
-  },
-  {
-    name: 'currentSetting',
-    type: 'object',
-    category: 'runtime',
-    description: 'Current setting data for refinement (structured object)',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Setting name' },
-      { name: 'description', type: 'string', description: 'Setting description' },
-      { name: 'atmosphere', type: 'string', description: 'Atmosphere and mood' },
-      { name: 'themes', type: 'string[]', description: 'Thematic elements' },
-      { name: 'potentialConflicts', type: 'string[]', description: 'Potential story conflicts' },
-      {
-        name: 'keyLocations',
-        type: 'array',
-        description: 'Key locations ({name, description} objects)',
-      },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'toneInstruction',
-    type: 'text',
-    category: 'runtime',
-    description: 'Tone instruction for wizard generation',
-    required: false,
-  },
-  {
-    name: 'settingInstruction',
-    type: 'text',
-    category: 'runtime',
-    description: 'Setting instruction for wizard generation',
-    required: false,
-  },
-  {
-    name: 'characterInput',
-    type: 'object',
-    category: 'runtime',
-    description: 'User-provided character details for elaboration (structured object)',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Character name (empty = suggest one)' },
-      { name: 'description', type: 'string', description: 'Physical description' },
-      { name: 'background', type: 'string', description: 'Backstory and history' },
-      { name: 'motivation', type: 'string', description: 'Goals and driving motivation' },
-      { name: 'traits', type: 'string[]', description: 'Personality traits' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'settingContext',
-    type: 'text',
-    category: 'runtime',
-    description: 'Setting context for character wizard',
-    required: false,
-  },
-  {
-    name: 'currentCharacter',
-    type: 'object',
-    category: 'runtime',
-    description: 'Current character data for refinement (structured object)',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Character name' },
-      { name: 'description', type: 'string', description: 'Physical description' },
-      { name: 'background', type: 'string', description: 'Backstory and history' },
-      { name: 'motivation', type: 'string', description: 'Goals and driving motivation' },
-      { name: 'traits', type: 'string[]', description: 'Personality traits' },
-      { name: 'appearance', type: 'string', description: 'Detailed appearance description' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'settingName',
-    type: 'text',
-    category: 'runtime',
-    description: 'Setting name for wizard generation',
-    required: false,
-  },
-  {
-    name: 'count',
-    type: 'text',
-    category: 'runtime',
-    description: 'Count of supporting characters to generate',
-    required: false,
-  },
-  {
-    name: 'protagonist',
-    type: 'object',
-    category: 'runtime',
-    description: 'Protagonist summary for supporting character generation (structured object)',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Protagonist name' },
-      { name: 'description', type: 'string', description: 'Protagonist description' },
-      { name: 'motivation', type: 'string', description: 'Protagonist motivation' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'title',
-    type: 'text',
-    category: 'runtime',
-    description: 'Story title for opening generation',
-    required: false,
-  },
-  {
-    name: 'atmosphere',
-    type: 'text',
-    category: 'runtime',
-    description: 'Setting atmosphere for wizard opening templates',
-    required: false,
-  },
-  {
-    name: 'supportingCharacters',
-    type: 'array',
-    category: 'runtime',
-    description: 'Supporting characters for opening generation (structured array)',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Character name' },
-      { name: 'role', type: 'string', description: 'Role (ally, antagonist, mentor, etc.)' },
-      { name: 'description', type: 'string', description: 'Character description' },
-      { name: 'relationship', type: 'string', description: 'Relationship to protagonist' },
-      { name: 'traits', type: 'string[]', description: 'Personality traits' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'tenseInstruction',
-    type: 'text',
-    category: 'runtime',
-    description: 'Tense instruction for wizard',
-    required: false,
-  },
-  {
-    name: 'currentOpening',
-    type: 'object',
-    category: 'runtime',
-    description: 'Current opening data for refinement (structured object)',
-    required: false,
-    infoFields: [
-      { name: 'title', type: 'string', description: 'Opening title' },
-      { name: 'scene', type: 'string', description: 'Opening scene prose' },
-      {
-        name: 'initialLocation',
-        type: 'object',
-        description: 'Starting location ({name, description} object)',
-      },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'openingGuidance',
-    type: 'text',
-    category: 'runtime',
-    description: 'Author guidance for opening generation',
-    required: false,
-  },
-  {
-    name: 'settingAtmosphere',
-    type: 'text',
-    category: 'runtime',
-    description: 'Setting atmosphere for protagonist generation template',
-    required: false,
-  },
-  {
-    name: 'settingThemesText',
-    type: 'text',
-    category: 'runtime',
-    description: 'Comma-joined setting themes for protagonist generation template',
-    required: false,
-  },
-  {
-    name: 'cardContent',
-    type: 'text',
-    category: 'runtime',
-    description: 'Character card content for import',
-    required: false,
-  },
-  {
-    name: 'lorebookName',
-    type: 'text',
-    category: 'runtime',
-    description: 'Lorebook name for vault import',
-    required: false,
-  },
-  {
-    name: 'entriesJson',
-    type: 'text',
-    category: 'runtime',
-    description: 'Lorebook entries JSON for vault import',
-    required: false,
-  },
-  {
-    name: 'entryCount',
-    type: 'text',
-    category: 'runtime',
-    description: 'Number of lorebook entries in vault import',
-    required: false,
-  },
-
-  // === Interactive Vault (external template) ===
-  {
-    name: 'characterCount',
-    type: 'text',
-    category: 'runtime',
-    description: 'Number of characters in the vault',
-    required: false,
-  },
-  {
-    name: 'lorebookCount',
-    type: 'text',
-    category: 'runtime',
-    description: 'Number of lorebooks in the vault',
-    required: false,
-  },
-  {
-    name: 'totalEntryCount',
-    type: 'text',
-    category: 'runtime',
-    description: 'Total number of lorebook entries in the vault',
-    required: false,
-  },
-  {
-    name: 'scenarioCount',
-    type: 'text',
-    category: 'runtime',
-    description: 'Number of scenarios in the vault',
-    required: false,
-  },
-
-  // === Runtime Variable Context ===
-  {
-    name: 'runtimeVars_characters',
-    type: 'text',
-    category: 'runtime',
-    description: 'Runtime variable values for all characters (formatted text block)',
-    required: false,
-  },
-  {
-    name: 'runtimeVars_locations',
-    type: 'text',
-    category: 'runtime',
-    description: 'Runtime variable values for all locations (formatted text block)',
-    required: false,
-  },
-  {
-    name: 'runtimeVars_items',
-    type: 'text',
-    category: 'runtime',
-    description: 'Runtime variable values for all items (formatted text block)',
-    required: false,
-  },
-  {
-    name: 'runtimeVars_storyBeats',
-    type: 'text',
-    category: 'runtime',
-    description: 'Runtime variable values for all story beats (formatted text block)',
-    required: false,
-  },
-  {
-    name: 'runtimeVars_protagonist',
-    type: 'text',
-    category: 'runtime',
-    description: 'Runtime variable values for the protagonist only',
-    required: false,
-  },
-  {
-    name: 'runtimeVariables',
-    type: 'object',
-    category: 'runtime',
-    description:
-      'Runtime variable definitions grouped by entity type for classifier extraction instructions',
-    required: false,
-    infoFields: [
-      {
-        name: 'character',
-        type: 'RuntimeVariable[]',
-        description: 'Variables for character entity type',
-      },
-      {
-        name: 'location',
-        type: 'RuntimeVariable[]',
-        description: 'Variables for location entity type',
-      },
-      { name: 'item', type: 'RuntimeVariable[]', description: 'Variables for item entity type' },
-      {
-        name: 'story_beat',
-        type: 'RuntimeVariable[]',
-        description: 'Variables for story beat entity type',
-      },
-    ] satisfies VariableFieldInfo[],
-  },
-
-  // === Structured Context Arrays ===
-  {
-    name: 'worldStateCharacters',
-    type: 'array',
-    category: 'runtime',
-    description: 'Characters in the world state, ordered by retrieval tier',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Character name' },
-      {
-        name: 'relationship',
-        type: 'string',
-        description: 'e.g. companion, rival, ally (nullable)',
-      },
-      { name: 'description', type: 'string', description: 'Character description (nullable)' },
-      { name: 'traits', type: 'string[]', description: 'Personality traits' },
-      {
-        name: 'visualDescriptors',
-        type: 'object',
-        description:
-          'Visual appearance (face, hair, eyes, build, clothing, accessories, distinguishing)',
-      },
-      { name: 'status', type: 'string', description: 'active, inactive, or deceased' },
-      { name: 'portrait', type: 'string', description: 'Portrait data URL (nullable)' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'worldStateInventory',
-    type: 'array',
-    category: 'runtime',
-    description: 'Items in player inventory',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Item name' },
-      { name: 'description', type: 'string', description: 'Item description (nullable)' },
-      { name: 'quantity', type: 'number', description: 'Quantity held' },
-      { name: 'equipped', type: 'boolean', description: 'Whether the item is currently equipped' },
-      { name: 'location', type: 'string', description: 'Item location (inventory, world, etc.)' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'worldStateBeats',
-    type: 'array',
-    category: 'runtime',
-    description: 'Active story threads and plot beats',
-    required: false,
-    infoFields: [
-      { name: 'title', type: 'string', description: 'Beat title' },
-      { name: 'description', type: 'string', description: 'Beat description' },
-      { name: 'type', type: 'string', description: 'e.g. discovery, conflict, quest' },
-      { name: 'status', type: 'string', description: 'e.g. active, completed, failed' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'worldStateLocations',
-    type: 'array',
-    category: 'runtime',
-    description: 'Known locations (excluding current location)',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Location name' },
-      { name: 'description', type: 'string', description: 'Location description (nullable)' },
-      { name: 'visited', type: 'boolean', description: 'Whether the protagonist has visited' },
-      { name: 'current', type: 'boolean', description: 'Whether this is the current location' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'worldStateRelevantItems',
-    type: 'array',
-    category: 'runtime',
-    description: 'Tier 2/3 items relevant to current context (non-inventory)',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Item name' },
-      { name: 'description', type: 'string', description: 'Item description (nullable)' },
-      { name: 'quantity', type: 'number', description: 'Quantity held' },
-      { name: 'equipped', type: 'boolean', description: 'Whether the item is currently equipped' },
-      { name: 'location', type: 'string', description: 'Item location' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'worldStateRelatedBeats',
-    type: 'array',
-    category: 'runtime',
-    description: 'Tier 2/3 story beats related to current context',
-    required: false,
-    infoFields: [
-      { name: 'title', type: 'string', description: 'Beat title' },
-      { name: 'description', type: 'string', description: 'Beat description (nullable)' },
-      {
-        name: 'type',
-        type: 'string',
-        description: 'Beat type (milestone, quest, revelation, event, plot_point)',
-      },
-      {
-        name: 'status',
-        type: 'string',
-        description: 'Beat status (pending, active, completed, failed)',
-      },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'currentLocationObject',
-    type: 'object',
-    category: 'runtime',
-    description: 'Current location as object with name and description',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Location name' },
-      { name: 'description', type: 'string', description: 'Location description' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'lorebookEntries',
-    type: 'array',
-    category: 'runtime',
-    description: 'Retrieved lorebook entries with tier metadata (or flat wizard entries)',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Entry name' },
-      { name: 'type', type: 'string', description: 'e.g. character, location, item, faction' },
-      { name: 'description', type: 'string', description: 'Entry description' },
-      { name: 'tier', type: 'number', description: 'Retrieval tier 1-3 (omitted for wizard)' },
-      {
-        name: 'disposition',
-        type: 'string',
-        description: 'Current disposition (character-only, optional)',
-      },
-      {
-        name: 'hiddenInfo',
-        type: 'string',
-        description: 'Hidden lore shown in wizard templates (optional)',
-      },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'chapters',
-    type: 'array',
-    category: 'runtime',
-    description: 'Chapter summaries from story history',
-    required: false,
-    infoFields: [
-      { name: 'number', type: 'number', description: 'Chapter number' },
-      { name: 'title', type: 'string', description: 'Chapter title' },
-      { name: 'summary', type: 'string', description: 'Chapter summary text' },
-      { name: 'startTime', type: 'string', description: 'Formatted time or null' },
-      { name: 'endTime', type: 'string', description: 'Formatted time or null' },
-      { name: 'characters', type: 'string[]', description: 'Character names' },
-      { name: 'locations', type: 'string[]', description: 'Location names' },
-      { name: 'emotionalTone', type: 'string', description: 'Emotional tone of the chapter' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'timelineFill',
-    type: 'array',
-    category: 'runtime',
-    description: 'Timeline gap-fill Q&A results between chapters',
-    required: false,
-    infoFields: [
-      { name: 'query', type: 'string', description: 'The question posed to fill the timeline gap' },
-      { name: 'answer', type: 'string', description: 'The generated answer' },
-      { name: 'chapterNumbers', type: 'number[]', description: 'Chapter range covered' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'storyEntries',
-    type: 'array',
-    category: 'runtime',
-    description: 'Recent story entries (actions and narration)',
-    required: false,
-    infoFields: [
-      { name: 'type', type: 'string', description: 'user_action or narration' },
-      { name: 'content', type: 'string', description: 'Entry text' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'styleReview',
-    type: 'object' as const,
-    category: 'runtime' as const,
-    description: 'Style analysis result with overused phrases and assessment',
-    required: false,
-    infoFields: [
-      { name: 'phrases', type: 'array', description: 'Array of PhraseAnalysis objects' },
-      { name: 'phrases[].phrase', type: 'string', description: 'The overused phrase' },
-      { name: 'phrases[].frequency', type: 'number', description: 'Times used in recent entries' },
-      { name: 'phrases[].severity', type: 'string', description: 'low, medium, or high' },
-      {
-        name: 'phrases[].alternatives',
-        type: 'string[]',
-        description: 'Suggested replacement phrases',
-      },
-      {
-        name: 'overallAssessment',
-        type: 'string',
-        description: 'Overall style assessment summary',
-      },
-      {
-        name: 'reviewedEntryCount',
-        type: 'number',
-        description: 'Number of entries analyzed',
-      },
-    ] satisfies VariableFieldInfo[],
-  },
-  // === Agentic Retrieval Output Fields ===
-  {
-    name: 'agenticReasoning',
-    type: 'text' as const,
-    category: 'runtime' as const,
-    description: "Agent's synthesis reasoning -- why these lorebook entries were selected",
-    required: false,
-  },
-  {
-    name: 'agenticChapterSummary',
-    type: 'text' as const,
-    category: 'runtime' as const,
-    description: 'Summary of key facts gathered from past chapter queries',
-    required: false,
-  },
-  {
-    name: 'agenticSelectedEntries',
-    type: 'array' as const,
-    category: 'runtime' as const,
-    description: 'Lorebook entries selected by agentic retrieval (name, type, description)',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Entry name' },
-      { name: 'type', type: 'string', description: 'e.g. character, location, item' },
-      { name: 'description', type: 'string', description: 'Entry description' },
-    ] satisfies VariableFieldInfo[],
-  },
-
-  // === Structured Context Arrays ===
-  {
-    name: 'characters',
-    type: 'array',
-    category: 'runtime',
-    description: 'Character list for classifier templates',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Character name' },
-      { name: 'relationship', type: 'string', description: 'Relationship to protagonist' },
-      { name: 'description', type: 'string', description: 'Character description' },
-      { name: 'traits', type: 'string[]', description: 'Personality traits' },
-      { name: 'appearance', type: 'string[]', description: 'Visual appearance details' },
-      { name: 'tier', type: 'number', description: 'Retrieval tier 1-3' },
-      { name: 'status', type: 'string', description: 'active, inactive, or deceased' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'storyBeats',
-    type: 'array',
-    category: 'runtime',
-    description: 'Story beat list for classifier templates',
-    required: false,
-    infoFields: [
-      { name: 'title', type: 'string', description: 'Beat title' },
-      { name: 'description', type: 'string', description: 'Beat description' },
-      { name: 'type', type: 'string', description: 'Beat type (milestone, quest, etc.)' },
-      { name: 'status', type: 'string', description: 'pending, active, completed, or failed' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'chatHistory',
-    type: 'array',
-    category: 'runtime',
-    description: 'Chat history for classifier and image context',
-    required: false,
-    infoFields: [
-      { name: 'type', type: 'string', description: 'user_action or narration' },
-      { name: 'content', type: 'string', description: 'Entry text content' },
-      {
-        name: 'timeStart',
-        type: 'string',
-        description: "Formatted time e.g. 'Y1D3 09:30', empty string if none",
-      },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'passages',
-    type: 'array',
-    category: 'runtime',
-    description: 'Story passages for style review',
-    required: false,
-    infoFields: [
-      { name: 'content', type: 'string', description: 'Passage text content' },
-      { name: 'entryId', type: 'string', description: 'ID of the source story entry' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'availableEntries',
-    type: 'array',
-    category: 'runtime',
-    description: 'Available lorebook entries for tier-3 selection',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Entry name' },
-      { name: 'type', type: 'string', description: 'e.g. character, location, item, faction' },
-      { name: 'description', type: 'string', description: 'Entry description' },
-      { name: 'keywords', type: 'string', description: 'Comma-separated keywords (optional)' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'messagesInRange',
-    type: 'array',
-    category: 'runtime',
-    description: 'Story entries in range for chapter analysis',
-    required: false,
-    infoFields: [
-      { name: 'type', type: 'string', description: 'user_action or narration' },
-      { name: 'content', type: 'string', description: 'Entry text content' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'chapterEntries',
-    type: 'array',
-    category: 'runtime',
-    description: 'Story entries within a chapter for summarization',
-    required: false,
-    infoFields: [
-      { name: 'type', type: 'string', description: 'user_action or narration' },
-      { name: 'content', type: 'string', description: 'Entry text content' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'previousChapters',
-    type: 'array',
-    category: 'runtime',
-    description: 'Previous chapter summaries for chapter summarization context',
-    required: false,
-    infoFields: [
-      { name: 'number', type: 'number', description: 'Chapter number' },
-      { name: 'title', type: 'string', description: 'Chapter title' },
-      { name: 'summary', type: 'string', description: 'Chapter summary text' },
-      { name: 'startTime', type: 'string', description: 'Formatted start time or null' },
-      { name: 'endTime', type: 'string', description: 'Formatted end time or null' },
-      { name: 'characters', type: 'string[]', description: 'Character names in this chapter' },
-      { name: 'locations', type: 'string[]', description: 'Location names in this chapter' },
-      { name: 'emotionalTone', type: 'string', description: 'Emotional tone of the chapter' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'loreEntries',
-    type: 'array',
-    category: 'runtime',
-    description: 'Lorebook entries for lore management templates',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Entry name' },
-      { name: 'type', type: 'string', description: 'e.g. character, location, item, faction' },
-      { name: 'description', type: 'string', description: 'Entry description' },
-      { name: 'state', type: 'string', description: 'Current dynamic state (optional)' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'loreChapters',
-    type: 'array',
-    category: 'runtime',
-    description: 'Chapter summaries for lore management templates',
-    required: false,
-    infoFields: [
-      { name: 'number', type: 'number', description: 'Chapter number' },
-      { name: 'title', type: 'string', description: 'Chapter title' },
-      { name: 'summary', type: 'string', description: 'Chapter summary text' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'agenticChapters',
-    type: 'array',
-    category: 'runtime',
-    description: 'Chapter summaries for agentic retrieval templates',
-    required: false,
-    infoFields: [
-      { name: 'number', type: 'number', description: 'Chapter number' },
-      { name: 'title', type: 'string', description: 'Chapter title' },
-      { name: 'summary', type: 'string', description: 'Chapter summary text' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'agenticEntries',
-    type: 'array',
-    category: 'runtime',
-    description: 'Lorebook entries for agentic retrieval templates',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Entry name' },
-      { name: 'type', type: 'string', description: 'e.g. character, location, item, faction' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'sceneCharacters',
-    type: 'array',
-    category: 'runtime',
-    description: 'Characters in scene for image generation templates',
-    required: false,
-    infoFields: [
-      { name: 'name', type: 'string', description: 'Character name' },
-      { name: 'description', type: 'string', description: 'Character description' },
-      {
-        name: 'visualDescriptors',
-        type: 'object',
-        description: 'Visual descriptor fields for image prompts',
-      },
-      {
-        name: 'visualDescriptors.face',
-        type: 'string',
-        description: 'Skin tone, facial features, expression',
-      },
-      {
-        name: 'visualDescriptors.hair',
-        type: 'string',
-        description: 'Color, length, style, texture',
-      },
-      {
-        name: 'visualDescriptors.eyes',
-        type: 'string',
-        description: 'Color, shape, notable features',
-      },
-      {
-        name: 'visualDescriptors.build',
-        type: 'string',
-        description: 'Height, body type, posture',
-      },
-      {
-        name: 'visualDescriptors.clothing',
-        type: 'string',
-        description: 'Full outfit description',
-      },
-      {
-        name: 'visualDescriptors.accessories',
-        type: 'string',
-        description: 'Jewelry, weapons, bags',
-      },
-      {
-        name: 'visualDescriptors.distinguishing',
-        type: 'string',
-        description: 'Scars, tattoos, birthmarks',
-      },
-      { name: 'portrait', type: 'string', description: 'Portrait data URL (null if none)' },
-    ] satisfies VariableFieldInfo[],
-  },
-  {
-    name: 'answerChapters',
-    type: 'array',
-    category: 'runtime',
-    description: 'Chapters for timeline-fill-answer templates',
-    required: false,
-    infoFields: [
-      { name: 'number', type: 'number', description: 'Chapter number' },
-      { name: 'title', type: 'string', description: 'Chapter title' },
-      { name: 'summary', type: 'string', description: 'Chapter summary text' },
-      {
-        name: 'entries',
-        type: 'array',
-        description: 'Optional story entries within this chapter (ContextStoryEntry[])',
-      },
-    ] satisfies VariableFieldInfo[],
-  },
-]
-
-/**
- * Singleton variable registry instance
- * Pre-loaded with system and runtime variables. Use this throughout the application.
- */
-export const variableRegistry = new VariableRegistry()
-
-// Register runtime variables at module load time
-variableRegistry.registerMany(RUNTIME_VARIABLES)
diff --git a/src/lib/stores/story/generationContext.svelte.ts b/src/lib/stores/story/generationContext.svelte.ts
index 6a3d9155..4fb95410 100644
--- a/src/lib/stores/story/generationContext.svelte.ts
+++ b/src/lib/stores/story/generationContext.svelte.ts
@@ -54,7 +54,7 @@ interface StoryPromptContext {
   loreEntriesForTier3: Entry[]
   worldStateForTier3: Tier3Candidate[]
   userSettings: {
-    retieval: {
+    retrieval: {
       maxStoryEntries: number
     }
     agenticRetrieval: {
@@ -115,6 +115,7 @@ interface StoryPromptContext {
   }
   narrativeResult?: NarrativeResult
   userActionOriginal?: string
+  narrationEntryId?: string | null
 }
 
 export class StoryGenerationContextStore {
@@ -180,7 +181,7 @@ export class StoryGenerationContextStore {
     }
     return {
       userSettings: {
-        retieval: { maxStoryEntries: 10 },
+        retrieval: { maxStoryEntries: 10 },
         agenticRetrieval: {
           recentEntriesCount: 5,
           maxChapters: 20,
@@ -251,6 +252,7 @@ export class StoryGenerationContextStore {
       lastChapterEndIndex: this.story.chapter.lastChapterEndIndex,
       chapterAnalysis: this.chapterAnalysis,
       narrativeResult: this.narrativeResult,
+      narrationEntryId: this.narrationEntryId,
     }
   }
 
diff --git a/src/test/fixtures/promptContext.ts b/src/test/fixtures/promptContext.ts
index e7d26053..1ea02d64 100644
--- a/src/test/fixtures/promptContext.ts
+++ b/src/test/fixtures/promptContext.ts
@@ -313,9 +313,6 @@ const memoryConfig: MemoryConfig = {
 }
 
 const userSettings = {
-  // Note: interface has typo 'retieval', templates use 'retrieval'
-  // Provide both for compatibility
-  retieval: { maxStoryEntries: 10 },
   retrieval: { maxStoryEntries: 10 },
   agenticRetrieval: {
     recentEntriesCount: 5,