@ai-rpg-engine/starter-template 3.5.0 → 3.9.0

package/README.md

@@ -12,14 +12,7 @@ tests anywhere — no engine monorepo required.
 
 ## Getting started
 
-If you are reading this inside `templates/starter`, scaffold your own copy
-first (it names everything for you):
-
-```bash
-npx --package=@ai-rpg-engine/cli ai-rpg-engine create-starter my-game --out=./my-game
-```
-
-Then, from the project directory:
+From the project directory:
 
 ```bash
 npm install        # pulls @ai-rpg-engine/* plus typescript + vitest
@@ -32,8 +25,8 @@ npx vitest run     # run the pack's tests
 | File | What to edit |
 |------|--------------|
 | `package.json` | name and description |
+| `src/content.ts` | `packMeta`, the `ContentPack` (`entities` / `zones` / `placements`), plus session catalogs (`buildCatalog`, `itemCatalog`, `districts`, `progressionTree`, `statusDefinitions`). Keep each enemy's `aiProfile` paired with a profile in setup. `src/content.json` is the same world for `validate` / sidecar `--content`. |
 | `src/ruleset.ts` | your stats, resources, verbs |
-| `src/content.ts` | entities and zones — keep each enemy's `ai.profileId` paired with a profile in setup |
 | `src/setup.ts` | wire your modules alongside `buildCombatStack`; the intent profiles list lives here |
 | `src/starter.test.ts` | grows with your content — register dialogues/abilities in the integrity lists |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-rpg-engine/starter-template",
-  "version": "3.5.0",
+  "version": "3.9.0",
   "description": "Starter template for ai-rpg-engine — scaffold a standalone game project from it",
   "type": "module",
   "engines": {
@@ -20,7 +20,10 @@
   "dependencies": {
     "@ai-rpg-engine/core": "^3.0.0",
     "@ai-rpg-engine/content-schema": "^3.0.0",
-    "@ai-rpg-engine/modules": "^3.0.0"
+    "@ai-rpg-engine/modules": "^3.0.0",
+    "@ai-rpg-engine/pack-registry": "^3.0.0",
+    "@ai-rpg-engine/character-creation": "^3.0.0",
+    "@ai-rpg-engine/equipment": "^3.0.0"
   },
   "devDependencies": {
     "typescript": "^5.7.0",

package/src/content.json

@@ -0,0 +1,179 @@
+{
+  "meta": {
+    "id": "my-game",
+    "name": "My Game",
+    "tagline": "A one-line pitch for your game.",
+    "genres": ["fantasy"],
+    "difficulty": "beginner",
+    "tones": ["heroic"],
+    "tags": ["starter"],
+    "engineVersion": ">=3.8.0 <4.0.0",
+    "version": "0.1.0",
+    "description": "A brief description of your game. One to three sentences that appear as the listing subtitle.",
+    "narratorTone": "A short narrator-voice note."
+  },
+  "manifest": {
+    "id": "my-game",
+    "title": "My Game",
+    "version": "0.1.0",
+    "engineVersion": ">=3.8.0 <4.0.0",
+    "ruleset": "my-game",
+    "modules": ["traversal-core", "status-core", "combat-core"],
+    "contentPacks": ["my-game"]
+  },
+  "entities": [
+    {
+      "id": "player",
+      "type": "player",
+      "name": "Hero",
+      "tags": ["player"],
+      "baseStats": { "power": 5, "speed": 4, "grit": 3 },
+      "baseResources": { "hp": 25, "stamina": 10, "tension": 0 }
+    },
+    {
+      "id": "grunt",
+      "type": "npc",
+      "name": "Grunt",
+      "tags": ["enemy", "hostile"],
+      "baseStats": { "power": 3, "speed": 3, "grit": 2 },
+      "baseResources": { "hp": 12 },
+      "aiProfile": "aggressive"
+    }
+  ],
+  "zones": [
+    {
+      "id": "start",
+      "name": "Starting Area",
+      "tags": ["safe"],
+      "neighbors": ["danger-zone"]
+    },
+    {
+      "id": "danger-zone",
+      "name": "The Danger Zone",
+      "tags": ["hostile"],
+      "neighbors": ["start"]
+    }
+  ],
+  "placements": [
+    { "entityId": "player", "zoneId": "start" },
+    { "entityId": "grunt", "zoneId": "danger-zone" }
+  ],
+  "districts": [
+    {
+      "id": "my-game-grounds",
+      "name": "My Game Grounds",
+      "zoneIds": ["start", "danger-zone"],
+      "tags": ["starter"],
+      "controllingFaction": "my-game"
+    }
+  ],
+  "buildCatalog": {
+    "packId": "my-game",
+    "statBudget": 3,
+    "maxTraits": 2,
+    "requiredFlaws": 0,
+    "archetypes": [
+      {
+        "id": "wanderer",
+        "name": "Wanderer",
+        "description": "A wanderer in My Game.",
+        "statPriorities": { "power": 5, "speed": 4, "grit": 3 },
+        "startingTags": ["starter"],
+        "progressionTreeId": "my-game-mastery"
+      }
+    ],
+    "backgrounds": [
+      {
+        "id": "local",
+        "name": "Local",
+        "description": "Grew up around My Game.",
+        "statModifiers": {},
+        "startingTags": []
+      }
+    ],
+    "traits": [],
+    "disciplines": [],
+    "crossTitles": [],
+    "entanglements": []
+  },
+  "progressionTrees": [
+    {
+      "id": "my-game-mastery",
+      "name": "My Game Mastery",
+      "currency": "xp",
+      "nodes": [
+        {
+          "id": "hardened",
+          "name": "Hardened",
+          "cost": 10,
+          "effects": [{ "type": "resource-boost", "params": { "resource": "hp", "amount": 5 } }]
+        }
+      ]
+    }
+  ],
+  "statuses": [],
+  "dialogues": [],
+  "quests": [],
+  "abilities": [],
+  "items": [
+    {
+      "id": "worn-blade",
+      "name": "Worn Blade",
+      "description": "A simple blade for My Game.",
+      "slot": "weapon",
+      "rarity": "common"
+    }
+  ],
+  "entityAi": {
+    "grunt": {
+      "profileId": "aggressive",
+      "goals": ["guard-zone"],
+      "fears": [],
+      "alertLevel": 0,
+      "knowledge": {}
+    }
+  },
+  "ruleset": {
+    "id": "my-game",
+    "name": "My Game",
+    "version": "0.1.0",
+    "stats": [
+      { "id": "power", "name": "Power", "min": 1, "max": 20, "default": 5 },
+      { "id": "speed", "name": "Speed", "min": 1, "max": 20, "default": 5 },
+      { "id": "grit", "name": "Grit", "min": 1, "max": 20, "default": 5 }
+    ],
+    "resources": [
+      { "id": "hp", "name": "HP", "min": 0, "max": 100, "default": 25 },
+      { "id": "stamina", "name": "Stamina", "min": 0, "max": 50, "default": 10, "regenRate": 1 },
+      { "id": "tension", "name": "Tension", "min": 0, "max": 100, "default": 0 }
+    ],
+    "verbs": [
+      { "id": "move", "name": "Move", "description": "Travel to an adjacent zone" },
+      { "id": "inspect", "name": "Inspect", "description": "Examine surroundings" },
+      { "id": "attack", "name": "Attack", "tags": ["combat"], "description": "Strike a target" },
+      { "id": "guard", "name": "Guard", "tags": ["combat", "defensive"], "description": "Reduce incoming damage" },
+      { "id": "brace", "name": "Brace", "tags": ["combat", "defensive"], "description": "Stabilize and resist status effects" },
+      { "id": "disengage", "name": "Disengage", "tags": ["combat", "movement"], "description": "Break from combat" },
+      { "id": "reposition", "name": "Reposition", "tags": ["combat", "movement"], "description": "Shift engagement state" },
+      { "id": "use", "name": "Use", "description": "Use an item" },
+      { "id": "speak", "name": "Speak", "tags": ["dialogue"], "description": "Talk to an NPC" },
+      { "id": "choose", "name": "Choose", "tags": ["dialogue"], "description": "Select a dialogue option" },
+      { "id": "use-ability", "name": "Use Ability", "tags": ["ability"], "description": "Activate a special ability" }
+    ],
+    "formulas": [
+      { "id": "hit-chance", "name": "Hit Chance", "description": "Standard: 50 + speed*5 - target.speed*3", "inputs": ["attacker.speed", "target.speed"], "output": "number (0-100)" },
+      { "id": "damage", "name": "Damage", "description": "Standard: attacker.power", "inputs": ["attacker.power"], "output": "number" }
+    ],
+    "defaultModules": [
+      "traversal-core",
+      "combat-core",
+      "cognition-core",
+      "engagement-core",
+      "combat-tactics",
+      "combat-intent",
+      "combat-recovery",
+      "combat-state-narration"
+    ],
+    "progressionModels": []
+  }
+}

package/src/content.ts

@@ -1,14 +1,27 @@
-// Starter content — entities, zones, and manifest
+// Starter content — a loadable ContentPack plus session catalogs
 //
-// Replace this with your game's content.
+// Replace this with your game's content. create-starter rewrites "my-game" /
+// "My Game" placeholders. Keep enemies' aiProfile paired with a profile in
+// setup.ts (runtime AI is overlaid after applyContentPack).
 
-import type { EntityState, ZoneState, GameManifest } from '@ai-rpg-engine/core';
+import type { GameManifest, EntityState } from '@ai-rpg-engine/core';
+import type {
+  ContentPack,
+  EntityBlueprint,
+  ZoneDefinition,
+  ProgressionTreeDefinition,
+  StatusDefinition,
+} from '@ai-rpg-engine/content-schema';
+import type { PackMetadata } from '@ai-rpg-engine/pack-registry';
+import type { BuildCatalog } from '@ai-rpg-engine/character-creation';
+import type { ItemCatalog } from '@ai-rpg-engine/equipment';
+import { myRuleset } from './ruleset.js';
 
 export const manifest: GameManifest = {
     id: 'my-game',
     title: 'My Game',
     version: '0.1.0',
-    engineVersion: '0.1.0',
+    engineVersion: '>=3.8.0 <4.0.0',
     ruleset: 'my-game',
     modules: ['traversal-core', 'status-core', 'combat-core'],
     contentPacks: ['my-game'],
@@ -16,76 +29,179 @@ export const manifest: GameManifest = {
 
 // ═══════════════════════════════════════════════════════════════════
 // PACK METADATA
-// This is a minimal subset to keep the template dependency-light. To list
-// your pack in the CLI pack selector, export the full PackMetadata shape
-// from @ai-rpg-engine/pack-registry (adds: tagline, genres, difficulty,
-// tones, tags, engineVersion, narratorTone) plus a BuildCatalog from
-// @ai-rpg-engine/character-creation — see any packages/starter-* content.ts
-// for a complete example.
+// Full PackMetadata shape so a copied pack can appear in getPackSummaries()
+// / the CLI pack selector without a second trip to the docs.
 // ═══════════════════════════════════════════════════════════════════
 
-export const packMeta = {
+export const packMeta: PackMetadata = {
     id: 'my-game',
     name: 'My Game',
-    description: 'A brief description of your game',
+    tagline: 'A one-line pitch for your game.',
+    genres: ['fantasy'],
+    difficulty: 'beginner',
+    tones: ['heroic'],
+    tags: ['starter'],
+    engineVersion: '>=3.8.0 <4.0.0',
     version: '0.1.0',
+    description: 'A brief description of your game. One to three sentences that appear as the listing subtitle.',
+    narratorTone: 'A short narrator-voice note.',
 };
 
 // ═══════════════════════════════════════════════════════════════════
-// PLAYER
+// ENTITY BLUEPRINTS (author data — not runtime EntityState)
 // ═══════════════════════════════════════════════════════════════════
 
-export const player: EntityState = {
+export const player: EntityBlueprint = {
     id: 'player',
-    blueprintId: 'player',
     type: 'player',
     name: 'Hero',
     tags: ['player'],
-    stats: { power: 5, speed: 4, grit: 3 },
-    resources: { hp: 25, stamina: 10, tension: 0 },
-    statuses: [],
-    inventory: [],
-    zoneId: 'start',
+    baseStats: { power: 5, speed: 4, grit: 3 },
+    baseResources: { hp: 25, stamina: 10, tension: 0 },
 };
 
-// ═══════════════════════════════════════════════════════════════════
-// ENEMIES
-// ═══════════════════════════════════════════════════════════════════
-
-export const enemy: EntityState = {
+export const enemy: EntityBlueprint = {
     id: 'grunt',
-    blueprintId: 'grunt',
     type: 'npc',
     name: 'Grunt',
     tags: ['enemy', 'hostile'],
-    stats: { power: 3, speed: 3, grit: 2 },
-    resources: { hp: 12 },
-    statuses: [],
-    zoneId: 'danger-zone',
-    // ai.profileId picks this enemy's combat brain. It must match a profile
+    baseStats: { power: 3, speed: 3, grit: 2 },
+    baseResources: { hp: 12 },
+    // aiProfile picks this enemy's combat brain. It must match a profile
     // provided in setup.ts (`cognition: { profiles: [...] }`) — without that
     // pairing the enemy never selects an intent and just stands there.
     // Built-ins: 'aggressive' (attack on sight) and 'cautious' (observe first).
-    ai: { profileId: 'aggressive', goals: ['guard-zone'], fears: [], alertLevel: 0, knowledge: {} },
+    // applyContentPack resolves this name against ContentPack.entityAi and
+    // ApplyContentPackOptions.profiles (setup.ts).
+    aiProfile: 'aggressive',
+};
+
+// Per-entity AI overlay. applyContentPack writes this onto EntityState.ai
+// when the entity's id is present here (F-035ac806).
+export const entityAi: Record<string, NonNullable<EntityState['ai']>> = {
+    grunt: { profileId: 'aggressive', goals: ['guard-zone'], fears: [], alertLevel: 0, knowledge: {} },
 };
 
 // ═══════════════════════════════════════════════════════════════════
-// ZONES
+// ZONES (ZoneDefinition — no roomId)
 // ═══════════════════════════════════════════════════════════════════
 
-export const zones: ZoneState[] = [
+export const zones: ZoneDefinition[] = [
     {
         id: 'start',
-        roomId: 'room-1',
         name: 'Starting Area',
         tags: ['safe'],
         neighbors: ['danger-zone'],
     },
     {
         id: 'danger-zone',
-        roomId: 'room-2',
         name: 'The Danger Zone',
         tags: ['hostile'],
         neighbors: ['start'],
     },
 ];
+
+export const placements: ContentPack['placements'] = [
+    { entityId: 'player', zoneId: 'start' },
+    { entityId: 'grunt', zoneId: 'danger-zone' },
+];
+
+// ═══════════════════════════════════════════════════════════════════
+// SESSION CATALOGS (chargen / items / progression / statuses / districts)
+// Stubs so a create-starter project can join the pack selector.
+// ═══════════════════════════════════════════════════════════════════
+
+export const buildCatalog: BuildCatalog = {
+    packId: 'my-game',
+    statBudget: 3,
+    maxTraits: 2,
+    requiredFlaws: 0,
+    archetypes: [
+        {
+            id: 'wanderer',
+            name: 'Wanderer',
+            description: 'A wanderer in My Game.',
+            statPriorities: { power: 5, speed: 4, grit: 3 },
+            startingTags: ['starter'],
+            progressionTreeId: 'my-game-mastery',
+        },
+    ],
+    backgrounds: [
+        {
+            id: 'local',
+            name: 'Local',
+            description: 'Grew up around My Game.',
+            statModifiers: {},
+            startingTags: [],
+        },
+    ],
+    traits: [],
+    disciplines: [],
+    crossTitles: [],
+    entanglements: [],
+};
+
+export const itemCatalog: ItemCatalog = {
+    items: [
+        {
+            id: 'worn-blade',
+            name: 'Worn Blade',
+            description: 'A simple blade for My Game.',
+            slot: 'weapon',
+            rarity: 'common',
+        },
+    ],
+};
+
+export const districts = [
+    {
+        id: 'my-game-grounds',
+        name: 'My Game Grounds',
+        zoneIds: ['start', 'danger-zone'],
+        tags: ['starter'],
+        controllingFaction: 'my-game',
+    },
+];
+
+export const progressionTree: ProgressionTreeDefinition = {
+    id: 'my-game-mastery',
+    name: 'My Game Mastery',
+    currency: 'xp',
+    nodes: [
+        {
+            id: 'hardened',
+            name: 'Hardened',
+            cost: 10,
+            effects: [{ type: 'resource-boost', params: { resource: 'hp', amount: 5 } }],
+        },
+    ],
+};
+
+export const statusDefinitions: StatusDefinition[] = [];
+
+// ═══════════════════════════════════════════════════════════════════
+// CONTENT PACK (the authoring pipeline consumes this)
+// ═══════════════════════════════════════════════════════════════════
+
+export const pack: ContentPack = {
+    meta: packMeta,
+    manifest,
+    entities: [player, enemy],
+    zones,
+    placements,
+    districts,
+    buildCatalog: buildCatalog as ContentPack['buildCatalog'],
+    progressionTrees: [progressionTree],
+    statuses: statusDefinitions,
+    dialogues: [],
+    quests: [],
+    abilities: [],
+    items: itemCatalog.items as ContentPack['items'],
+    entityAi,
+    ruleset: myRuleset,
+};
+
+/** Identity today — reserved for stripping any runtime-only fields later. */
+export function toContentPack(): ContentPack {
+    return pack;
+}

package/src/index.ts

@@ -1,5 +1,15 @@
-// @ai-rpg-engine/starter-YOURNAME
+// @ai-rpg-engine/starter-template
 
 export { createGame, myIntentProfiles } from './setup.js';
-export { manifest, packMeta } from './content.js';
+export {
+  manifest,
+  packMeta,
+  pack,
+  toContentPack,
+  buildCatalog,
+  itemCatalog,
+  districts,
+  progressionTree,
+  statusDefinitions,
+} from './content.js';
 export { myRuleset } from './ruleset.js';

package/src/setup.ts

@@ -17,7 +17,8 @@ import {
     aggressiveProfile,
 } from '@ai-rpg-engine/modules';
 import type { IntentProfile } from '@ai-rpg-engine/modules';
-import { manifest, player, enemy, zones } from './content.js';
+import { applyContentPack } from '@ai-rpg-engine/content-schema';
+import { manifest, pack } from './content.js';
 import { myRuleset } from './ruleset.js';
 
 // ═══════════════════════════════════════════════════════════════════
@@ -48,7 +49,7 @@ function createTensionPressure(): EngineModule {
 
 // ═══════════════════════════════════════════════════════════════════
 // INTENT PROFILES — required for enemies to act
-// Every entity in content.ts that declares an `ai.profileId` must find a
+// Every entity in content.ts that declares an `aiProfile` must find a
 // matching profile in this list: cognition builds its profile map from
 // `cognition.profiles`, and with an empty map no enemy ever selects an
 // intent — they stand still forever. Built-ins from @ai-rpg-engine/modules:
@@ -94,7 +95,7 @@ export function createGame(seed?: number): Engine {
         // recovery — safe zone recovery:
         recovery: { safeZoneTags: ['safe'] },
         // cognition — wires the intent profiles above into the enemy AI.
-        // Every ai.profileId declared in content.ts must resolve here.
+        // Every entityAi profileId (content.ts aiProfile) must resolve here.
         cognition: { profiles: myIntentProfiles },
     });
 
@@ -148,19 +149,35 @@ export function createGame(seed?: number): Engine {
         ],
     });
 
-    // Register zones
-    for (const zone of zones) {
-        engine.store.addZone(zone);
+    // Author data → runtime. JSON hosts: extractSessionContent(pack) →
+    // construct modules (traversalCore/statusCore/combatCore/inventoryCore/
+    // cognitionCore/environmentCore/districtCore/encounterSpawn +
+    // presence/length-gated quests/dialogues/abilities/equipment — NOT
+    // buildWorldStack; see content-schema's extractSessionContent JSDoc for
+    // the full recipe, F-c9309691) →
+    // applyContentPack({ profiles, channels: createStandardChannels() }).
+    // Import createStandardChannels from @ai-rpg-engine/modules — do not
+    // auto-inject. This factory still wires named catalogs at construction;
+    // apply copies EntityBlueprint relations/custom/resistances/faction/
+    // ruleProfileId and resolves aiProfile against cognition profiles +
+    // pack.entityAi.
+    const applied = applyContentPack(engine, pack, { profiles: myIntentProfiles });
+    if (!applied.ok) {
+        const detail = applied.errors.map((e) => `${e.path}: ${e.message}`).join('\n');
+        throw new Error(`applyContentPack failed:\n${detail}`);
     }
 
-    // Register entities — the store detaches (structuredClone) at ingestion,
-    // so module-level constants are safe to pass directly.
-    engine.store.addEntity(player);
-    engine.store.addEntity(enemy);
-
-    // Set player context
-    engine.store.state.playerId = 'player';
-    engine.store.state.locationId = 'start';
+    // F-bc7b8ab1: no manual playerId/locationId stamp needed here —
+    // content.ts's placements[] places pack's single type:'player' entity at
+    // 'start', so applyContentPack's own identity stamp (F-67786a6c) already
+    // derived both onto the store above. Don't add one back for your own
+    // starting zone either: if your pack authors exactly one type:'player'
+    // entity with a placement, the stamp tracks it for free — a hand-written
+    // override here is the exact pattern that can silently diverge from
+    // content.ts once you move the starting zone. Only fall back manually
+    // for a pack that declares zero or several type:'player' entities (the
+    // stamp is deliberately ambiguous-safe: it never guesses):
+    // if (!engine.store.state.playerId) engine.store.state.playerId = 'player';
 
     return engine;
 }

package/src/starter.test.ts

@@ -1,12 +1,21 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { describe, it, expect } from 'vitest';
-import { validateRulesetDefinition, validateGameContent, validateAbilityPack } from '@ai-rpg-engine/content-schema';
-import type { ContentPack, AbilityDefinition, DialogueDefinition } from '@ai-rpg-engine/content-schema';
+import { validateRulesetDefinition, validateGameContent, validateAbilityPack, loadContent, loadContentFromFile } from '@ai-rpg-engine/content-schema';
+import type { AbilityDefinition, DialogueDefinition } from '@ai-rpg-engine/content-schema';
 import { selectIntent } from '@ai-rpg-engine/modules';
 import type { CognitionState } from '@ai-rpg-engine/modules';
 import { myRuleset } from './ruleset.js';
 import { createGame, myIntentProfiles } from './setup.js';
+import {
+    pack,
+    toContentPack,
+    buildCatalog,
+    itemCatalog,
+    districts,
+    progressionTree,
+    statusDefinitions,
+} from './content.js';
 
 describe('starter template', () => {
     it('ruleset validates against schema', () => {
@@ -73,18 +82,37 @@ describe('starter template — cross-reference integrity', () => {
     // Register your AbilityDefinitions here as you write them.
     const myAbilities: AbilityDefinition[] = [];
 
-    function builtContentPack(): ContentPack {
-        const engine = createGame(1);
+    function authoredPack() {
         return {
-            zones: Object.values(engine.store.state.zones) as unknown as ContentPack['zones'],
-            entities: Object.values(engine.store.state.entities) as unknown as ContentPack['entities'],
-            dialogues: myDialogues,
-            abilities: myAbilities,
+            ...toContentPack(),
+            dialogues: [...(toContentPack().dialogues ?? []), ...myDialogues],
+            abilities: [...(toContentPack().abilities ?? []), ...myAbilities],
         };
     }
 
+    it('F-407729dc: authored pack is loadContent-valid (not a cast of live store state)', () => {
+        const r = loadContent(pack);
+        expect(r.ok).toBe(true);
+        expect(r.errors).toEqual([]);
+        expect(loadContent(toContentPack()).ok).toBe(true);
+    });
+
+    it('F-407729dc: src/content.json is a loadable fixture', () => {
+        const file = fileURLToPath(new URL('./content.json', import.meta.url));
+        const r = loadContentFromFile(file);
+        expect(r.ok).toBe(true);
+        expect(r.errors).toEqual([]);
+    });
+
+    it('F-82b17cb3: src/content.json equals toContentPack() (full pack, not a subset)', () => {
+        const file = fileURLToPath(new URL('./content.json', import.meta.url));
+        const fromFile = loadContentFromFile(file);
+        expect(fromFile.ok).toBe(true);
+        expect(JSON.parse(JSON.stringify(fromFile.pack))).toEqual(JSON.parse(JSON.stringify(toContentPack())));
+    });
+
     it('zones, entities, dialogues, and abilities have no dangling references or duplicate ids', () => {
-        const result = validateGameContent(builtContentPack());
+        const result = validateGameContent(authoredPack());
         expect(result.errors).toEqual([]);
         expect(result.ok).toBe(true);
     });
@@ -92,7 +120,7 @@ describe('starter template — cross-reference integrity', () => {
     it('has no one-way zone passages (neighbor symmetry advisory)', () => {
         // A zone listing a neighbor that doesn't list it back is legal but
         // almost always a mistake — the player can walk in and never back out.
-        const result = validateGameContent(builtContentPack());
+        const result = validateGameContent(authoredPack());
         expect(result.advisories).toEqual([]);
     });
 
@@ -215,6 +243,43 @@ describe('starter template — standalone scaffold', () => {
         expect(readme.toLowerCase()).not.toContain('copy this directory to `packages/');
         expect(readme).not.toMatch(/cp -r templates\/starter/);
     });
+
+    it('F-3dcac63f: first-run README is the game title, not a scaffold-yourself instruction', () => {
+        const readme = read('../README.md');
+        expect(readme).toMatch(/^# My Game$/m);
+        expect(readme).not.toMatch(/scaffold your own copy/i);
+        expect(readme).not.toContain('templates/starter');
+        expect(readme).toContain('standalone');
+        expect(readme).toContain('Getting started');
+    });
+
+    it('F-3dcac63f: packMeta carries the catalog fields getPackSummaries() lists on', () => {
+        const src = read('./content.ts');
+        for (const field of ['tagline', 'genres', 'difficulty', 'tones', 'tags', 'description', 'version', 'narratorTone']) {
+            expect(src, `packMeta must declare ${field}`).toMatch(new RegExp(`\\b${field}\\s*:`));
+        }
+        const index = read('./index.ts');
+        expect(index).toContain('@ai-rpg-engine/starter-template');
+        expect(index).not.toContain('starter-YOURNAME');
+    });
+
+    it('F-2abeea73: barrel exports session catalogs under stable names', () => {
+        expect(buildCatalog.archetypes.length).toBeGreaterThanOrEqual(1);
+        expect(buildCatalog.backgrounds.length).toBeGreaterThanOrEqual(1);
+        expect(itemCatalog.items.length).toBeGreaterThanOrEqual(1);
+        expect(districts.length).toBeGreaterThanOrEqual(1);
+        expect(progressionTree.nodes.length).toBeGreaterThanOrEqual(1);
+        expect(Array.isArray(statusDefinitions)).toBe(true);
+        const index = read('./index.ts');
+        for (const name of ['buildCatalog', 'itemCatalog', 'districts', 'progressionTree', 'statusDefinitions', 'pack', 'toContentPack']) {
+            expect(index, `index.ts must re-export ${name}`).toContain(name);
+        }
+        const pkg = JSON.parse(read('../package.json')) as { dependencies?: Record<string, string> };
+        const deps = pkg.dependencies ?? {};
+        expect(deps['@ai-rpg-engine/pack-registry']).toBeTruthy();
+        expect(deps['@ai-rpg-engine/character-creation']).toBeTruthy();
+        expect(deps['@ai-rpg-engine/equipment']).toBeTruthy();
+    });
 });
 
 // ═══════════════════════════════════════════════════════════════════
@@ -240,3 +305,23 @@ describe('starter template — cross-instance state isolation', () => {
             .not.toBe(a.world.entities['grunt'].resources);
     });
 });
+
+// ═══════════════════════════════════════════════════════════════════
+// IDENTITY STAMP (F-bc7b8ab1)
+// Pin, not a bug fix: this must read identically before and after removing
+// setup.ts's post-applyContentPack `engine.store.state.playerId = 'player';
+// engine.store.state.locationId = 'start';` lines — content.ts's
+// placements[] places { entityId: 'player', zoneId: 'start' }, and pack
+// carries exactly one type:'player' entity, so applyContentPack's own
+// identity stamp (F-67786a6c) already derives the same values. The manual
+// lines were the pre-fix-style override the stamp was written to obsolete —
+// this is the scaffold every new game is copied from, so the leftover
+// pattern would otherwise keep propagating into new starters.
+// ═══════════════════════════════════════════════════════════════════
+describe('starter template — identity stamp owns playerId/locationId (F-bc7b8ab1)', () => {
+    it('boots with playerId "player" and locationId "start" from applyContentPack\'s own identity stamp, with no manual override line', () => {
+        const engine = createGame(1);
+        expect(engine.world.playerId).toBe('player');
+        expect(engine.world.locationId).toBe('start');
+    });
+});