feat: system detection and character field templates (F-3)

Enable Foundry module to detect game system and match against Chronicle.
Prerequisite for actor/character sheet sync in F-4.

Server:
- Expand dnd5e character preset from 4 to 15 fields (ability scores, HP, AC, speed, proficiency)
- Add pf2e character preset with 15 PF2e-specific fields (ancestry, heritage, ability mods, etc)
- Add CharacterPreset() helper on SystemManifest for finding character presets
- New GET /api/v1/campaigns/:id/systems endpoint returning systems with enabled flag
- Inject AddonChecker into APIHandler via SetAddonChecker()

Foundry module:
- SYSTEM_MAP table mapping Foundry game.system.id to Chronicle system IDs
- SyncManager._detectSystem() queries systems API on start, stores matched system
- New syncCharacters boolean setting and detectedSystem internal setting
- Dashboard Status tab shows system match info and character sync availability
- i18n keys for system detection UI

https://claude.ai/code/session_01XMwxFR8BCi5XvgaSVMSBZB

Author: claude

.ai/status.md

@@ -8,7 +8,14 @@
 <!-- ====================================================================== -->
 
 ## Last Updated
-2026-03-12 -- **Foundry enhancements planning + documentation capture.**
+2026-03-12 -- **Sprint F-3: System Detection & Character Field Templates.**
+
+33. **Sprint F-3: System detection & character field templates (DONE).**
+    - **Server: Manifest expansion** — dnd5e character preset expanded from 4 to 15 fields (added ability scores, HP, AC, speed, proficiency_bonus). New pf2e character preset with 15 PF2e-specific fields (ancestry, heritage, ability mods, perception, etc). Added `CharacterPreset()` method on `SystemManifest`.
+    - **Server: Systems API** — New `GET /api/v1/campaigns/:id/systems` endpoint returning all registered systems with `enabled` flag per campaign (via `AddonChecker`). `addonChecker` injected into `APIHandler` via `SetAddonChecker()`.
+    - **Foundry: System detection** — `SYSTEM_MAP` maps Foundry `game.system.id` → Chronicle system IDs (`dnd5e`, `pf2e`, `drawsteel`). `SyncManager._detectSystem()` queries systems API on start, stores matched system in `detectedSystem` setting. New `syncCharacters` boolean setting (gated on system match).
+    - **Foundry: Dashboard** — Status tab shows Foundry system, Chronicle system match (green check/red X), and character sync availability.
+    - **Next:** F-4 (Actor ↔ Entity Sync) — new `actor-sync.mjs` with system-specific adapters.
 
 32. **Foundry enhancements — planning + F-1/F-2 implementation.**
     - **Planning:** Captured Phase F roadmap (F-1 through F-7) in `.ai/todo.md` and `foundry-module/.ai.md`.

.ai/todo.md

@@ -285,7 +285,7 @@ _Improve Foundry VTT sync fidelity. Add system-aware character sheet sync. Build
 
 - [x] **Sprint F-1: Journal Sync Fidelity** — Multi-page journal sync (split entity `entry_html` by headings into Foundry pages, concatenate pages back on Foundry→Chronicle). Ownership change hook (detect ownership changes in `updateJournalEntry` hook, push to Chronicle). Helpers: `_splitByHeadings`, `_collectTextPages`, `_syncPagesToJournal`.
 - [x] **Sprint F-2: Granular Permission Mapping** — Map Chronicle `visibility: 'custom'` + `entity_permissions` to Foundry per-user ownership levels (view→OBSERVER, edit→OWNER). New syncapi endpoints: `GET /entities/:eid/permissions`, `PUT /entities/:eid/permissions`. Reverse-map Foundry ownership changes back to Chronicle. Helpers: `_buildOwnership`, `_pushPermissions`. User-specific grants stored in flags but not mapped to Foundry users (requires user ID mapping table — deferred).
-- [ ] **Sprint F-3: System Detection & Character Field Templates** — Foundry module reads `game.system.id`, matches against Chronicle campaign systems via `GET /campaigns/:id/systems`. System ID mapping table (`dnd5e→dnd5e`, `pf2e→pathfinder2e`). `CharacterFields()` on System interface. Per-system `character_fields.json` (D&D 5e: abilities, HP, AC, level, class, skills; PF2e: equivalent). Apply field template to "Character" entity type on system enable.
+- [x] **Sprint F-3: System Detection & Character Field Templates** — Expanded dnd5e character preset (15 fields: class, level, race, alignment + 6 ability scores + HP/AC/speed/proficiency). Added pf2e character preset (15 fields: class, level, ancestry, heritage + 6 ability mods + HP/AC/perception/speed). `CharacterPreset()` helper on `SystemManifest`. New `GET /api/v1/campaigns/:id/systems` endpoint returns available systems with enabled flag. Foundry module: `syncCharacters` + `detectedSystem` settings, `SYSTEM_MAP` table, `_detectSystem()` on start, `getMatchedSystem()` accessor. Dashboard Status tab shows system match info and character sync availability.
 - [ ] **Sprint F-4: Actor ↔ Entity Sync** — New `actor-sync.mjs` module. Foundry Actor (type: "character") ↔ Chronicle entity (type: "character"). System-specific adapters (`dnd5e-adapter.mjs`, `pf2e-adapter.mjs`) with `toChronicleFields(actor)` / `fromChronicleFields(entity)`. Hooks: `createActor`, `updateActor`, `deleteActor`. WebSocket: `entity.updated` with character type. Same `_syncing` guard pattern. Dashboard "Characters" tab.
 - [ ] **Sprint F-5: NPC Viewer / Hall** — Campaign route `/campaigns/:id/npcs`. Gallery/grid of revealed NPCs (non-private character entities). Portrait, name, description, location, faction. Filters by location/organization/relation. "Reveal" = DM toggles `is_private`. Foundry integration: ownership change on NPC journal → auto-reveal on Chronicle. Long-term: NPC relationship map (filtered relation graph).
 - [ ] **Sprint F-6: Armory / Inventory System** — Items as entities with game-mechanic fields (weight, cost, rarity, damage, properties). Character "Inventory" tab/block via entity relations. Relation metadata: equipped, quantity, attunement. System-specific item templates (dnd5e ≠ pf2e). Foundry sync: Actor inventory ↔ Chronicle inventory relations. "Armory" campaign page showing all catalogued items.

foundry-module/.ai.md

@@ -39,7 +39,7 @@ All sync modules use a `_syncing` boolean flag to prevent infinite loops:
 |------|---------|
 | `module.json` | Module manifest. Foundry v12-v13 compatible. Optional deps: Calendaria, Monk's Enhanced Journal |
 | `scripts/module.mjs` | Entry point. Registers settings on `init`, starts SyncManager on `ready` (GM only) |
-| `scripts/settings.mjs` | 7 world-scoped settings: apiUrl, apiKey, campaignId, syncEnabled, feature toggles |
+| `scripts/settings.mjs` | 9 world-scoped settings: apiUrl, apiKey, campaignId, syncEnabled, syncJournals, syncMaps, syncCalendar, syncCharacters + 3 internal: lastSyncTime, syncExclusions, detectedSystem |
 | `scripts/api-client.mjs` | REST client (Bearer auth) + WebSocket (auto-reconnect, message queue, event emitter) |
 | `scripts/sync-manager.mjs` | Orchestrator. Owns API client, routes WS messages, manages sync mapping lookups |
 | `scripts/journal-sync.mjs` | Entity ↔ JournalEntry bidirectional sync. Monk's Enhanced Journal support |
@@ -92,32 +92,33 @@ All sync modules use a `_syncing` boolean flag to prevent infinite loops:
 - **Shop icon field**: Always returns null (`shop-widget.mjs:146`)
 - **Single scene**: Only the active Foundry scene syncs (no multi-scene)
 - **GM only**: Full sync runs only for GM users; players get passive updates via Foundry
-- **Single text page**: Only first text page synced; multi-page journals lose content
-- **Binary permissions**: Only `is_private` mapped to ownership; granular permissions ignored
-- **No ownership push**: Foundry ownership changes not pushed to Chronicle
-- **No actor/character sync**: No character sheet sync between Foundry actors and Chronicle entities
+- **No actor/character sync**: Character sheet sync requires matching game system (F-3 detection done, F-4 sync pending)
 
 ## Planned Features (Phase F)
 
 See `.ai/todo.md` Phase F for full sprint breakdown.
 
-### F-1: Journal Sync Fidelity
+### F-1: Journal Sync Fidelity (DONE)
 - Split entity `entry_html` by `<h1>`/`<h2>` headings into multiple Foundry pages
 - Concatenate all text pages back into single `entry` for Foundry→Chronicle
 - Track page mapping via `chronicle-sync.pageMap` flag
 - Detect ownership changes in `updateJournalEntry` hook, push to Chronicle
 
-### F-2: Granular Permission Mapping
+### F-2: Granular Permission Mapping (DONE)
 - Map Chronicle `visibility: 'custom'` + `entity_permissions` to per-user Foundry ownership
   - Chronicle `view` → Foundry `OBSERVER`, `edit` → `OWNER`
 - New syncapi endpoints: `GET/PUT /entities/:eid/permissions`
 - Reverse-map Foundry ownership changes to Chronicle entity permissions
 
-### F-3: System Detection & Character Field Templates
-- Read `game.system.id` on init, match against Chronicle campaign systems
-- System ID mapping: `{ dnd5e: "dnd5e", pf2e: "pathfinder2e" }`
-- Only enable actor sync when systems match
-- Per-system `character_fields.json` defining expected Character entity fields
+### F-3: System Detection & Character Field Templates (DONE)
+- `SYSTEM_MAP` in sync-manager.mjs: `{ dnd5e: "dnd5e", pf2e: "pathfinder2e", drawsteel: "drawsteel" }`
+- `SyncManager._detectSystem()` queries `GET /api/v1/campaigns/:id/systems` on start
+- Matches Foundry `game.system.id` to Chronicle system, stores in `detectedSystem` setting
+- `syncCharacters` boolean setting (gated on system match)
+- Dashboard Status tab shows system match info and character sync availability
+- Server: Expanded dnd5e character preset (15 fields), added pf2e character preset (15 fields)
+- Server: `CharacterPreset()` helper on `SystemManifest`
+- Server: New `GET /systems` API endpoint with `enabled` flag per campaign
 
 ### F-4: Actor ↔ Entity Sync (new `actor-sync.mjs`)
 - Foundry Actors (type: "character") ↔ Chronicle entities (type: "character")

foundry-module/lang/en.json

@@ -29,6 +29,10 @@
       "SyncCalendar": {
         "Name": "Sync Calendar",
         "Hint": "Sync Chronicle calendar with Calendaria or Simple Calendar module"
+      },
+      "SyncCharacters": {
+        "Name": "Sync Characters",
+        "Hint": "Sync Foundry actors with Chronicle character entities (requires matching game system)"
       }
     },
     "Status": {
@@ -113,6 +117,16 @@
         "EntitiesSynced": "Entities Synced",
         "MapsLinked": "Maps Linked",
         "LastSync": "Last sync",
+        "GameSystem": "Game System",
+        "FoundrySystem": "Foundry System",
+        "ChronicleSystem": "Chronicle System",
+        "SystemMatched": "Matched",
+        "SystemNoMatch": "No Match",
+        "SystemNone": "None detected",
+        "CharacterSync": "Character Sync",
+        "CharacterSyncEnabled": "Enabled",
+        "CharacterSyncDisabled": "Disabled",
+        "CharacterSyncNoSystem": "Requires matching game system",
         "RecentActivity": "Recent Activity",
         "NoActivity": "No recent activity.",
         "ClearLog": "Clear Log",

foundry-module/scripts/settings.mjs

@@ -83,6 +83,24 @@ export function registerSettings() {
     default: false,
   });
 
+  // Character sync toggle (requires matching game system).
+  game.settings.register(MODULE_ID, 'syncCharacters', {
+    name: game.i18n.localize('CHRONICLE.Settings.SyncCharacters.Name'),
+    hint: game.i18n.localize('CHRONICLE.Settings.SyncCharacters.Hint'),
+    scope: 'world',
+    config: true,
+    type: Boolean,
+    default: false,
+  });
+
+  // Internal: detected Chronicle system ID matched from Foundry's game.system.id.
+  game.settings.register(MODULE_ID, 'detectedSystem', {
+    scope: 'world',
+    config: false,
+    type: String,
+    default: '',
+  });
+
   // Internal: last sync timestamp (not shown in UI).
   game.settings.register(MODULE_ID, 'lastSyncTime', {
     scope: 'world',

foundry-module/scripts/sync-dashboard.mjs

@@ -543,12 +543,22 @@ export class SyncDashboard extends HandlebarsApplicationMixin(ApplicationV2) {
       s => s.getFlag(FLAG_SCOPE, 'mapId')
     ).length;
 
+    // System detection info.
+    const foundrySystem = this._syncManager?.getFoundrySystemId() || null;
+    const matchedSystem = this._syncManager?.getMatchedSystem() || null;
+    const syncCharacters = getSetting('syncCharacters');
+
     return {
       connectionState: state,
       connectionLabel: this._connectionLabel(state),
       lastSyncTime: getSetting('lastSyncTime') || 'Never',
       syncedEntities,
       linkedScenes,
+      foundrySystem,
+      matchedSystem,
+      systemMatched: !!matchedSystem,
+      syncCharacters,
+      characterSyncAvailable: !!matchedSystem,
       activityLog: activityLog.slice(0, 50),
     };
   }

foundry-module/scripts/sync-manager.mjs

@@ -9,6 +9,16 @@
 import { ChronicleAPI } from './api-client.mjs';
 import { getSetting, setSetting, isConfigured } from './settings.mjs';
 
+/**
+ * Maps Foundry game.system.id values to Chronicle system IDs.
+ * Only systems with an explicit mapping can enable character sync.
+ */
+const SYSTEM_MAP = {
+  dnd5e: 'dnd5e',
+  pf2e: 'pathfinder2e',
+  drawsteel: 'drawsteel',
+};
+
 /**
  * SyncManager coordinates all Chronicle sync operations.
  * It owns the API client and delegates to feature-specific sync modules.
@@ -29,6 +39,12 @@ export class SyncManager {
 
     /** @type {number} Maximum activity log entries. */
     this._maxLogEntries = 100;
+
+    /** @type {string|null} Matched Chronicle system ID, or null if no match. */
+    this._matchedSystem = null;
+
+    /** @type {string|null} Foundry's game.system.id. */
+    this._foundrySystemId = null;
   }
 
   /**
@@ -61,6 +77,9 @@ export class SyncManager {
       return;
     }
 
+    // Detect game system and match against Chronicle systems.
+    await this._detectSystem();
+
     // Initialize all registered modules.
     for (const mod of this._modules) {
       if (typeof mod.init === 'function') {
@@ -100,6 +119,68 @@ export class SyncManager {
     console.log('Chronicle: Sync manager stopped');
   }
 
+  /**
+   * Returns the matched Chronicle system ID, or null if no match.
+   * @returns {string|null}
+   */
+  getMatchedSystem() {
+    return this._matchedSystem;
+  }
+
+  /**
+   * Returns Foundry's game.system.id.
+   * @returns {string|null}
+   */
+  getFoundrySystemId() {
+    return this._foundrySystemId;
+  }
+
+  /**
+   * Detect the Foundry game system and match it against Chronicle systems.
+   * Queries the /systems API endpoint to verify the match is enabled
+   * for this campaign. Stores the result in the detectedSystem setting.
+   * @private
+   */
+  async _detectSystem() {
+    this._foundrySystemId = game.system?.id || null;
+
+    if (!this._foundrySystemId) {
+      console.log('Chronicle: No Foundry game system detected');
+      return;
+    }
+
+    const chronicleId = SYSTEM_MAP[this._foundrySystemId];
+    if (!chronicleId) {
+      console.log(`Chronicle: Foundry system "${this._foundrySystemId}" has no Chronicle mapping`);
+      await setSetting('detectedSystem', '');
+      return;
+    }
+
+    try {
+      // Query Chronicle for available systems and check if the mapped one is enabled.
+      const result = await this.api.get('/systems');
+      const systems = result.data || [];
+      const match = systems.find((s) => s.id === chronicleId && s.enabled);
+
+      if (match) {
+        this._matchedSystem = chronicleId;
+        await setSetting('detectedSystem', chronicleId);
+        this.logActivity('connect', `Game system matched: ${match.name}`);
+        console.log(`Chronicle: System matched — Foundry "${this._foundrySystemId}" → Chronicle "${chronicleId}"`);
+      } else {
+        await setSetting('detectedSystem', '');
+        console.log(`Chronicle: System "${chronicleId}" not enabled for this campaign`);
+      }
+    } catch (err) {
+      console.warn('Chronicle: Failed to detect system match', err);
+      // Fall back to local setting if API call fails.
+      const cached = getSetting('detectedSystem');
+      if (cached) {
+        this._matchedSystem = cached;
+      }
+    }
+  }
+
   /**
    * Perform initial sync: pull all changes since last sync time.
    * @private

foundry-module/templates/sync-dashboard.hbs

@@ -377,6 +377,41 @@
           </div>
         </div>
 
+        {{!-- Game system detection --}}
+        <div class="system-detection">
+          <h3 class="section-heading">Game System</h3>
+          <div class="system-info-grid">
+            <div class="system-info-row">
+              <span class="system-label">Foundry System:</span>
+              <span class="system-value">{{#if foundrySystem}}{{foundrySystem}}{{else}}<em>None</em>{{/if}}</span>
+            </div>
+            <div class="system-info-row">
+              <span class="system-label">Chronicle System:</span>
+              {{#if systemMatched}}
+              <span class="system-value system-matched">
+                <i class="fa-solid fa-check-circle" style="color: #4ade80"></i> {{matchedSystem}} — Matched
+              </span>
+              {{else}}
+              <span class="system-value system-no-match">
+                <i class="fa-solid fa-circle-xmark" style="color: #f87171"></i> No Match
+              </span>
+              {{/if}}
+            </div>
+            <div class="system-info-row">
+              <span class="system-label">Character Sync:</span>
+              {{#if characterSyncAvailable}}
+                {{#if syncCharacters}}
+                <span class="system-value"><i class="fa-solid fa-toggle-on" style="color: #4ade80"></i> Enabled</span>
+                {{else}}
+                <span class="system-value"><i class="fa-solid fa-toggle-off"></i> Disabled</span>
+                {{/if}}
+              {{else}}
+              <span class="system-value hint">Requires matching game system</span>
+              {{/if}}
+            </div>
+          </div>
+        </div>
+
         <div class="last-sync-info">
           Last sync: <span>{{lastSyncTime}}</span>
         </div>

internal/plugins/syncapi/api_handler.go

@@ -12,17 +12,19 @@ import (
 	"github.com/keyxmakerx/chronicle/internal/apperror"
 	"github.com/keyxmakerx/chronicle/internal/plugins/campaigns"
 	"github.com/keyxmakerx/chronicle/internal/plugins/entities"
+	"github.com/keyxmakerx/chronicle/internal/systems"
 	"github.com/keyxmakerx/chronicle/internal/widgets/relations"
 )
 
 // APIHandler serves the versioned REST API for external tool integration.
 // External clients (Foundry VTT, custom scripts) use these endpoints to
 // read and write campaign data programmatically via API key authentication.
 type APIHandler struct {
-	syncSvc     SyncAPIService
-	entitySvc   entities.EntityService
-	campaignSvc campaigns.CampaignService
-	relationSvc relations.RelationService
+	syncSvc      SyncAPIService
+	entitySvc    entities.EntityService
+	campaignSvc  campaigns.CampaignService
+	relationSvc  relations.RelationService
+	addonChecker AddonChecker
 }
 
 // NewAPIHandler creates a new API handler with the required service dependencies.
@@ -641,3 +643,56 @@ func (h *APIHandler) SetEntityPermissions(c echo.Context) error {
 
 	return c.JSON(http.StatusOK, map[string]string{"status": "ok"})
 }
+
+// SetAddonChecker injects the addon checker for system-aware endpoints.
+// Called after construction because the addon service is wired separately.
+func (h *APIHandler) SetAddonChecker(ac AddonChecker) {
+	h.addonChecker = ac
+}
+
+// --- Systems ---
+
+// systemInfoResponse is the API-safe representation of a game system.
+type systemInfoResponse struct {
+	ID                 string `json:"id"`
+	Name               string `json:"name"`
+	Status             string `json:"status"`
+	HasCharacterFields bool   `json:"has_character_fields"`
+	Enabled            bool   `json:"enabled"`
+}
+
+// ListSystems returns game systems available for the campaign.
+// Includes built-in systems from the global registry with an enabled flag
+// based on per-campaign addon state. Used by the Foundry module to detect
+// whether the current game system matches a Chronicle system.
+// GET /api/v1/campaigns/:id/systems
+func (h *APIHandler) ListSystems(c echo.Context) error {
+	campaignID := c.Param("id")
+	ctx := c.Request().Context()
+
+	registry := systems.Registry()
+	result := make([]systemInfoResponse, 0, len(registry))
+
+	for _, manifest := range registry {
+		enabled := false
+		if h.addonChecker != nil {
+			ok, err := h.addonChecker.IsEnabledForCampaign(ctx, campaignID, manifest.ID)
+			if err == nil && ok {
+				enabled = true
+			}
+		}
+
+		result = append(result, systemInfoResponse{
+			ID:                 manifest.ID,
+			Name:               manifest.Name,
+			Status:             string(manifest.Status),
+			HasCharacterFields: manifest.CharacterPreset() != nil,
+			Enabled:            enabled,
+		})
+	}
+
+	return c.JSON(http.StatusOK, map[string]any{
+		"data":  result,
+		"total": len(result),
+	})
+}