@sharpee/story-loader 3.0.0 → 3.3.0

package/runtime.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChordRuntime = exports.ChordBehaviorTrait = exports.STRATEGY_SELECTOR = void 0;
+const chord_1 = require("@sharpee/chord");
+const engine_1 = require("@sharpee/engine");
+const phrasebook_data_js_1 = require("./phrasebook-data.js");
 const world_model_1 = require("@sharpee/world-model");
-const errors_1 = require("./errors");
-const state_keys_1 = require("./state-keys");
-const text_1 = require("./text");
-const hatch_context_1 = require("./hatch-context");
-const event_contract_1 = require("./event-contract");
+const stdlib_1 = require("@sharpee/stdlib");
+const errors_js_1 = require("./errors.js");
+const state_keys_js_1 = require("./state-keys.js");
+const text_js_1 = require("./text.js");
+const hatch_context_js_1 = require("./hatch-context.js");
+const event_contract_js_1 = require("./event-contract.js");
+const event_id_map_js_1 = require("./event-id-map.js");
+const message_alias_map_js_1 = require("./message-alias-map.js");
 /**
  * Chord strategy adverb → phrase-algebra Choice selector (ADR-196).
  * The Z5 table (ADR-211 Decision 4): adverbs mirror the selectors 1:1;
@@ -27,6 +33,11 @@ class ChordBehaviorTrait {
     type = ChordBehaviorTrait.type;
 }
 exports.ChordBehaviorTrait = ChordBehaviorTrait;
+/**
+ * The two gerunds a topic table serves (ADR-239 D1 — one table, ask and
+ * tell alike). The table rides these actions' interceptor dispatch.
+ */
+const TOPIC_GERUNDS = ['asking', 'telling'];
 class ChordRuntime {
     ir;
     host;
@@ -57,80 +68,334 @@ class ChordRuntime {
                     return;
                 // Event clauses (`after entering it`) bind to the event stream per
                 // the selector contract — the ownership package's replacement for
-                // floating `when` rules.
-                if (event_contract_1.EVENT_TRIGGERS[clause.action]) {
-                    this.bindEventClause(world, entity, clause, clauseIndex);
+                // floating `when` rules. A REGION owner re-homes the verb onto the
+                // crossing events (ADR-236 D6): entering → region_entered, leaving
+                // → region_exited.
+                const trigger = this.eventTriggerFor(entity, clause);
+                if (trigger) {
+                    this.bindEventClause(world, entity, clause, clauseIndex, trigger);
                     return;
                 }
+                if (event_contract_js_1.REGION_EVENT_TRIGGERS[clause.action]) {
+                    // `leaving` exists only as a region crossing reaction (D6) — on
+                    // any other owner it would silently never fire. Refuse at load.
+                    throw new errors_js_1.LoadError(`\`${clause.clauseKind} ${clause.action} it\` — \`${clause.action}\` is a region crossing reaction (ADR-236), and \`${entity.name}\` is not a region. Put the clause on the region block whose boundary it reacts to.`, clause.span);
+                }
+                // D5 fail-fast (ADR-228): only bind clauses something will consult.
+                if (!this.isConsultedGerund(clause.action)) {
+                    if (this.isDispatchAction(clause.action)) {
+                        // Dispatch reactions fire via fireAfterClauses (the runtime owns
+                        // those actions — interceptors never fire on the dispatch path),
+                        // so `after` is live without any registration here…
+                        if (clause.clauseKind === 'after')
+                            return;
+                        // …but an entity `on` clause has no dispatch surface at all.
+                        throw new errors_js_1.LoadError(`\`on ${clause.action} it\` — \`${clause.action}\` is a Chord dispatch action, and entity \`on\` clauses never fire on the dispatch path. Move the clause into a trait (\`define trait … on ${clause.action} it\`) and compose the trait, or react with \`after ${clause.action} it\`.`, clause.span);
+                    }
+                    throw this.deadGerundError(clause);
+                }
                 this.prepareOnClauseTarget(world, entity, clause);
                 const list = byAction.get(clause.action) ?? [];
                 list.push({ entity, clause });
                 byAction.set(clause.action, list);
             });
         }
+        // ADR-239: topic tables ride the asking/telling dispatch. Every table
+        // owner gets an arm — with or without a catch-all clause (D5: with no
+        // catch-all declared, a miss simply returns {} and the action's
+        // unconditional unknown_topic/not_interested default stands).
+        for (const gerund of TOPIC_GERUNDS) {
+            for (const entity of this.ir.entities) {
+                if (!(entity.topics ?? []).length)
+                    continue;
+                const list = byAction.get(gerund) ?? [];
+                if (!list.some((c) => c.entity.id === entity.id)) {
+                    this.prepareTopicTarget(world, entity);
+                    list.push({ entity, clause: null });
+                    byAction.set(gerund, list);
+                }
+            }
+        }
         for (const [action, clauses] of byAction) {
-            world.registerActionInterceptor(ChordBehaviorTrait.type, `if.action.${action}`, this.buildDispatchingInterceptor(clauses));
+            world.registerActionInterceptor(ChordBehaviorTrait.type, `if.action.${action}`, this.buildDispatchingInterceptor(action, clauses));
         }
         // Phase B: `define trait` clauses register per TRAIT TYPE — capability
         // behaviors for dispatch verbs, interceptors for standard-semantics
         // actions (§5.4 routing recorded on the IR by the analyzer).
         for (const trait of this.ir.traits) {
-            const traitType = state_keys_1.CHORD_TRAIT_PREFIX + trait.name;
+            const traitType = state_keys_js_1.CHORD_TRAIT_PREFIX + trait.name;
+            const interceptorClauses = new Map();
+            const capabilityActions = new Set();
             for (const clause of trait.onClauses) {
                 if (clause.binding === 'every-turn')
                     continue; // scheduler phase (plan phase 5)
                 if (clause.binding === 'role') {
-                    throw new errors_1.LoadError(`Role-bound trait clauses (\`on ${clause.action} anything as the ${clause.role}\`) are not wired yet — the standard-action role path is post-Zoo scope.`, clause.span);
+                    throw new errors_js_1.LoadError(`Role-bound trait clauses (\`on ${clause.action} anything as the ${clause.role}\`) are not wired yet — the standard-action role path is post-Zoo scope.`, clause.span);
                 }
                 if (clause.routing === 'capability') {
+                    // The capability registry is (traitType, action)-keyed and
+                    // last-wins: a second clause for the same dispatch action would
+                    // silently OVERWRITE the first. Refuse legibly (never-guess)
+                    // until the capability pair is wired.
+                    if (capabilityActions.has(clause.action)) {
+                        throw new errors_js_1.LoadError(`Trait \`${trait.name}\` declares more than one clause for the dispatch action \`${clause.action}\` — the capability registry holds one behavior per (trait, action), so the second clause could never fire. Merge the bodies into one clause.`, clause.span);
+                    }
+                    capabilityActions.add(clause.action);
                     world.registerCapabilityBehavior(traitType, `chord.action.${clause.action}`, this.buildCapabilityBehavior(trait.name, clause));
                 }
                 else {
-                    world.registerActionInterceptor(traitType, `if.action.${clause.action}`, this.buildTraitInterceptor(clause));
+                    // D5 fail-fast (ADR-228): the analyzer routed this clause to the
+                    // interceptor path, so its gerund must name a consulted action.
+                    if (!this.isConsultedGerund(clause.action))
+                        throw this.deadGerundError(clause);
+                    const list = interceptorClauses.get(clause.action) ?? [];
+                    list.push(clause);
+                    interceptorClauses.set(clause.action, list);
                 }
             }
+            // One MERGED interceptor per (trait, action) — the D3 `on`/`after`
+            // pair both fire (the idempotent registry would otherwise keep only
+            // the last-registered clause, silently).
+            for (const [action, actionClauses] of interceptorClauses) {
+                world.registerActionInterceptor(traitType, `if.action.${action}`, this.mergeArms(actionClauses.map((clause, index) => this.buildTraitInterceptor(clause, `${trait.name}.${action}.${clause.clauseKind}.${index}`))));
+            }
         }
-        // Derived properties (`dark while`, `is blocked while`) — recompute
-        // when possession, location, or openable/switchable state changes.
-        if (this.derivedDarkRooms().length > 0 || this.hasConditionalBlockedExits()) {
-            for (const trigger of [
-                'if.event.taken',
-                'if.event.dropped',
-                'if.event.worn',
-                'if.event.removed',
-                'if.event.put_on',
-                'if.event.put_in',
-                'if.event.actor_moved',
-                'if.event.opened',
-                'if.event.closed',
-                'if.event.switched_on',
-                'if.event.switched_off',
-            ]) {
-                world.chainEvent(trigger, (_event, w) => {
-                    this.recomputeDerived(w);
-                    return null;
-                }, { key: `chord.derived.${trigger}`, priority: 100 });
+        // Derived properties (`dark while`, blocked exits) — ADR-240: registered
+        // as live evaluators consulted at point of use. Nothing is stamped and
+        // nothing recomputes: mutations are instant, every reader sees current
+        // truth (the former eleven-event recompute trigger list is gone).
+        this.registerDerivedEvaluators(world);
+        // Phrasebooks (ADR-250 D4): one evaluator per book-covered key the
+        // story does not define — same ADR-240 seam, resolved at render time.
+        this.registerPhrasebookEvaluators(world);
+        // Message overrides (ADR-255 D6): standard-action message baselines,
+        // registered on the same seam so they beat the platform default but lose
+        // to per-entity/on-clause message ids.
+        this.registerMessageOverrideEvaluators(world);
+    }
+    /** Resolved books cache (built once per runtime — see resolvedBooks). */
+    books = null;
+    /**
+     * The story's phrasebooks in arbitration order, entries resolved:
+     * `define`d books carry their entries in the IR; `use`d books resolve
+     * from the packaged-data registry with manifest-key conformance (ADR-250
+     * D3 — LoadError on a missing book or a key mismatch), plus the D1 key
+     * rules the story compiler never saw the packaged data pass through.
+     */
+    resolvedBooks() {
+        if (this.books)
+            return this.books;
+        this.books = this.ir.phrasebooks.map((book) => {
+            if (book.source === 'define') {
+                return { name: book.name, condition: book.condition ?? null, entries: book.entries ?? {} };
+            }
+            const data = phrasebook_data_js_1.PHRASEBOOK_DATA.get(book.name);
+            if (!data) {
+                throw new errors_js_1.LoadError(`Phrasebook \`${book.name}\` is not in the load-time data registry — the compile-time manifest knows the name, the runtime has no entries for it.`);
+            }
+            const manifestKeys = [...(chord_1.PHRASEBOOK_REGISTRY.get(book.name)?.keys ?? [])].sort();
+            const dataKeys = Object.keys(data.entries).sort();
+            if (manifestKeys.join('') !== dataKeys.join('')) {
+                throw new errors_js_1.LoadError(`Phrasebook \`${book.name}\`: manifest keys [${manifestKeys.join(', ')}] and data keys [${dataKeys.join(', ')}] disagree.`);
+            }
+            for (const key of dataKeys) {
+                if (key.includes('.')) {
+                    throw new errors_js_1.LoadError(`Phrasebook \`${book.name}\`: \`${key}\` is a dotted platform ID — books voice story keys only (ADR-250 D1).`);
+                }
+            }
+            return { name: book.name, condition: book.condition ?? null, entries: data.entries };
+        });
+        return this.books;
+    }
+    /** Book entries covering a key, in arbitration order (emit-time staging). */
+    bookEntriesFor(key) {
+        return this.resolvedBooks().flatMap((b) => (b.entries[key] ? [b.entries[key]] : []));
+    }
+    /**
+     * ADR-250 D4.2: register ONE evaluator per key that some book covers and
+     * the story does NOT define — story-beats-book is decided here,
+     * statically, so a story-defined key never pays predicate evaluation.
+     * The key convention (`phrasebook.template.<key>`) is built by the
+     * engine's read point (`phrasebookTemplateKey`) and here — nowhere else.
+     */
+    registerPhrasebookEvaluators(world) {
+        const books = this.resolvedBooks();
+        if (books.length === 0)
+            return;
+        const storyTable = this.ir.phrases.locales[this.ir.phrases.defaultLocale] ?? {};
+        const covered = new Set();
+        for (const book of books) {
+            for (const key of Object.keys(book.entries)) {
+                if (!storyTable[key])
+                    covered.add(key);
+            }
+        }
+        for (const key of covered) {
+            world.registerEvaluator((0, engine_1.phrasebookTemplateKey)(key), (w) => this.resolvePhrasebook(key, w));
+        }
+    }
+    /**
+     * The evaluator body: first book in declaration order whose predicate
+     * holds AND that covers the key supplies it (ADR-245 D3 arbitration).
+     * Derivation mirrors registered phrases — verbatim/single/multi-variant
+     * templates and a Choice atom keyed `phrasebook.<book>` / key so
+     * cycling/first-time/sticky counters stay per (book, key) (ADR-250 D5)
+     * — keeping every Chord IR shape loader-side (ADR-210 direction rule).
+     */
+    resolvePhrasebook(key, world) {
+        for (const book of this.resolvedBooks()) {
+            const entry = book.entries[key];
+            if (!entry)
+                continue;
+            if (book.condition && !this.evaluator.evalCondition(book.condition, { world }))
+                continue;
+            const { template, params } = this.derivePhraseTemplate(entry, `phrasebook.${book.name}`, key);
+            return { book: book.name, key, template, ...(Object.keys(params).length > 0 ? { params } : {}) };
+        }
+        return undefined;
+    }
+    /**
+     * Derive the render-time template + bound params for an IR phrase body,
+     * shared by phrasebook resolution and ADR-255 message overrides: a verbatim
+     * or single-variant phrase becomes its literal template; a strategy/multi
+     * phrase becomes `{variants}` plus a Choice atom keyed by (counterEntityId,
+     * messageKey) so cycling/first-time/sticky counters stay per source+key.
+     */
+    derivePhraseTemplate(entry, counterEntityId, messageKey) {
+        const params = {};
+        let template;
+        if (entry.verbatim) {
+            template = '{verbatim:text}';
+            params.text = entry.variants[0]?.text ?? '';
+        }
+        else if (entry.strategy === null && entry.variants.length === 1) {
+            template = (0, text_js_1.withLineBreaks)(entry.variants[0].text);
+        }
+        else {
+            template = '{variants}';
+            if (entry.strategy) {
+                const choice = {
+                    kind: 'choice',
+                    alternatives: entry.variants.map((v) => ({ kind: 'literal', text: (0, text_js_1.withLineBreaks)(v.text) })),
+                    selector: exports.STRATEGY_SELECTOR[entry.strategy],
+                    entityId: counterEntityId,
+                    messageKey,
+                };
+                params.variants = choice;
+            }
+        }
+        return { template, params };
+    }
+    /**
+     * ADR-255 D6: register one evaluator per overridden standard-action message,
+     * on the SAME phrasebook resolution seam (`phrasebook.template.<id>`) the
+     * engine consults before the platform default — so an `override message`
+     * sets the story-wide baseline (with full strategy/cycling parity) while a
+     * per-entity phrase or on-clause refusal, which emit their own message ids,
+     * still win. The alias is resolved to its dotted `if.action.*` id here, on
+     * the loader side (Interface Contract 3); the alias never reaches the engine.
+     */
+    registerMessageOverrideEvaluators(world) {
+        const table = this.ir.messageOverrides.locales[this.ir.messageOverrides.defaultLocale] ?? {};
+        for (const [alias, entry] of Object.entries(table)) {
+            const messageId = (0, message_alias_map_js_1.aliasToActionMessageId)(alias);
+            if (!messageId)
+                continue; // analyzer already rejected unknown aliases
+            world.registerEvaluator((0, engine_1.phrasebookTemplateKey)(messageId), () => {
+                if (entry.condition && !this.evaluator.evalCondition(entry.condition, { world }))
+                    return undefined;
+                const { template, params } = this.derivePhraseTemplate(entry, 'message-override', messageId);
+                return { book: 'message-override', key: messageId, template, ...(Object.keys(params).length > 0 ? { params } : {}) };
+            });
+        }
+    }
+    /**
+     * ADR-240 D2/D3: register every derived property as a named world-evaluator.
+     * `dark while` rooms register on `dark.<roomId>`; EVERY blocked exit —
+     * conditional or not (a constant-true predicate) — registers on
+     * `exit.blocked.<roomId>.<direction>`, with its refusal message on
+     * `exit.message.*` resolved AT REFUSAL TIME (phrase strategies vary per
+     * attempt). Registration is idempotent per world; re-binding re-registers.
+     */
+    registerDerivedEvaluators(world) {
+        for (const { entity, condition } of this.derivedDarkRooms()) {
+            const worldId = this.host.entityId(entity.id);
+            if (!worldId)
+                continue;
+            world.registerEvaluator((0, world_model_1.darkKey)(worldId), (w) => this.evaluator.evalCondition(condition, { world: w }));
+        }
+        for (const irEntity of this.ir.entities) {
+            if (irEntity.blockedExits.length === 0)
+                continue;
+            const worldId = this.host.entityId(irEntity.id);
+            if (!worldId)
+                continue;
+            for (const blocked of irEntity.blockedExits) {
+                const direction = world_model_1.Direction[blocked.direction.toUpperCase()];
+                if (!direction)
+                    continue;
+                const condition = blocked.condition;
+                world.registerEvaluator((0, stdlib_1.exitBlockedKey)(worldId, direction), condition
+                    ? (w) => this.evaluator.evalCondition(condition, { world: w, it: irEntity.id })
+                    : () => true);
+                world.registerEvaluator((0, stdlib_1.exitMessageKey)(worldId, direction), (w) => this.blockedPhraseText(blocked.phraseKey, w));
             }
         }
     }
+    // ------------------------------------------------------- D5 fail-fast
+    /**
+     * True when an interceptor registered under `if.action.<gerund>` can ever
+     * fire: a wired stdlib action consults the id (the ADR-228 D5 registry,
+     * derived from the descriptor table), or the gerund names a `define
+     * action X from` hatch — an author-owned TS Action the loader can't see
+     * inside, which may consult its own id.
+     * @param gerund the clause's action word (e.g. `taking`)
+     */
+    isConsultedGerund(gerund) {
+        if (stdlib_1.interceptorConsultingActionIds.has(`if.action.${gerund}`))
+            return true;
+        return this.ir.hatches.some((h) => h.hatchKind === 'action' && h.name === gerund);
+    }
+    /** True when the gerund names a `define action` dispatch action. */
+    isDispatchAction(gerund) {
+        return this.ir.actions.some((a) => a.name === gerund);
+    }
+    /**
+     * Load-time diagnostic for a clause whose gerund nothing will ever
+     * consult (ADR-228 D5): a typo or an unimplemented action word would
+     * otherwise register and silently die. lowering/raising get the pointed
+     * capability-dispatch message (they are full-delegation by design).
+     * @param clause the dead clause (its span anchors the diagnostic)
+     */
+    deadGerundError(clause) {
+        const phrase = `${clause.clauseKind} ${clause.action} it`;
+        if (clause.action === 'lowering' || clause.action === 'raising') {
+            return new errors_js_1.LoadError(`\`${phrase}\` — \`${clause.action}\` is a full-delegation capability action by design (ADR-118): the standard action never consults interceptors. Use a capability behavior or a Chord dispatch action (\`define action ${clause.action}\`) instead.`, clause.span);
+        }
+        return new errors_js_1.LoadError(`\`${phrase}\` — no standard action consults \`if.action.${clause.action}\`, so this clause would never fire. Check the action word's spelling, or create the verb with \`define action ${clause.action}\`.`, clause.span);
+    }
     // ---------------------------------------------------------- event clauses
     /**
-     * Bind an event clause (`after entering it` on a room) to its trigger
-     * event per the selector contract — the ownership package's replacement
-     * for floating `when` rules: the same firing semantics, owned by the
-     * entity the event is about.
+     * Bind an event clause (`after entering it` on a room or region) to its
+     * trigger event per the selector contract — the ownership package's
+     * replacement for floating `when` rules: the same firing semantics,
+     * owned by the entity the event is about.
      */
-    bindEventClause(world, entity, clause, clauseIndex) {
-        const trigger = event_contract_1.EVENT_TRIGGERS[clause.action];
+    bindEventClause(world, entity, clause, clauseIndex, trigger) {
         const key = `chord.clause.${entity.id}.${clause.action}.${clauseIndex}`;
         world.chainEvent(trigger, (event, w) => this.fireEventClause(entity, clause, key, event, w), { key });
     }
+    /** The clause's trigger event type by owner kind, or undefined for non-event clauses. */
+    eventTriggerFor(entity, clause) {
+        const isRegionOwner = entity.kinds.some((k) => k.name === 'region');
+        return isRegionOwner ? event_contract_js_1.REGION_EVENT_TRIGGERS[clause.action] : event_contract_js_1.EVENT_TRIGGERS[clause.action];
+    }
     /** Test/debug entry: run every event clause bound to this event type. */
     fireEventClauses(world, event) {
         const out = [];
         for (const entity of this.ir.entities) {
             entity.onClauses.forEach((clause, clauseIndex) => {
-                if (clause.binding === 'every-turn' || event_contract_1.EVENT_TRIGGERS[clause.action] !== event.type)
+                if (clause.binding === 'every-turn' || this.eventTriggerFor(entity, clause) !== event.type)
                     return;
                 const key = `chord.clause.${entity.id}.${clause.action}.${clauseIndex}`;
                 const produced = this.fireEventClause(entity, clause, key, event, world);
@@ -141,15 +406,24 @@ class ChordRuntime {
         return out;
     }
     fireEventClause(entity, clause, key, event, world) {
-        // The clause is about its owner: `after entering it` fires when the
-        // movement's destination IS the owner — read through the AC-9 payload
-        // guard, never a blind cast (the stdlib event is a foreign surface).
-        if (clause.action === 'entering' && (0, event_contract_1.enteringDestination)(event.data) !== this.host.entityId(entity.id))
+        // The clause is about its owner. Region owners (ADR-236 D6): the
+        // crossing event names which boundary was crossed — fire only for this
+        // region's own boundary (the emitter's getRegionCrossings already made
+        // parent reactions crossing-accurate; no transitive widening here).
+        if (entity.kinds.some((k) => k.name === 'region')) {
+            if ((0, event_contract_js_1.crossingRegionId)(event.data) !== this.host.entityId(entity.id))
+                return null;
+        }
+        else if (clause.action === 'entering' && (0, event_contract_js_1.enteringDestination)(event.data) !== this.host.entityId(entity.id)) {
+            // Room/enterable owners: `after entering it` fires when the
+            // movement's destination IS the owner — read through the AC-9 payload
+            // guard, never a blind cast (the stdlib event is a foreign surface).
             return null;
+        }
         const ctx = { world, it: entity.id };
         if (clause.condition && !this.evaluator.evalCondition(clause.condition, ctx))
             return null;
-        const occKey = state_keys_1.CHORD_OCCURRENCE_PREFIX + key;
+        const occKey = state_keys_js_1.CHORD_OCCURRENCE_PREFIX + key;
         const occurrence = (world.getStateValue(occKey) ?? 0) + 1;
         if (clause.once && occurrence > 1)
             return null; // `, once` — one lifetime firing (D5)
@@ -163,10 +437,10 @@ class ChordRuntime {
     prepareOnClauseTarget(world, entity, clause) {
         const worldId = this.host.entityId(entity.id);
         if (!worldId)
-            throw new errors_1.LoadError(`Entity \`${entity.id}\` has no world instance.`, clause.span);
+            throw new errors_js_1.LoadError(`Entity \`${entity.id}\` has no world instance.`, clause.span);
         const target = world.getEntity(worldId);
         if (!target)
-            throw new errors_1.LoadError(`Entity \`${entity.id}\` vanished before binding.`, clause.span);
+            throw new errors_js_1.LoadError(`Entity \`${entity.id}\` vanished before binding.`, clause.span);
         if (!target.has(ChordBehaviorTrait.type)) {
             target.add(new ChordBehaviorTrait());
         }
@@ -175,17 +449,106 @@ class ChordRuntime {
             target.add(new world_model_1.ReadableTrait({ text: '' }));
         }
     }
+    /** Mark a topic-table owner so interceptor resolution finds it (no clause needed). */
+    prepareTopicTarget(world, entity) {
+        const worldId = this.host.entityId(entity.id);
+        if (!worldId)
+            throw new errors_js_1.LoadError(`Entity \`${entity.id}\` has no world instance.`, entity.span);
+        const target = world.getEntity(worldId);
+        if (!target)
+            throw new errors_js_1.LoadError(`Entity \`${entity.id}\` vanished before binding.`, entity.span);
+        if (!target.has(ChordBehaviorTrait.type)) {
+            target.add(new ChordBehaviorTrait());
+        }
+    }
+    /**
+     * Per-clause consultation state. Two live arms on one owner (ratchet D3's
+     * `on` + `after` pair) share ONE InterceptorSharedData bag per firing —
+     * each clause keeps its skip/occurrence/decision state in its own
+     * namespaced sub-bag so the arms never clobber each other.
+     */
+    clauseBag(data, ns) {
+        const key = `chord.arm.${ns}`;
+        let bag = data[key];
+        if (!bag) {
+            bag = {};
+            data[key] = bag;
+        }
+        return bag;
+    }
+    /**
+     * Merge one owner's clause interceptors into a single arm, in declaration
+     * order (the ratchet D3 contract, previously broken by first-match arm
+     * routing — an `on`/`after` pair on the same owner+gerund silently
+     * shadowed the second clause): the first refusal wins preValidate; every
+     * arm's postValidate/postExecute runs (own namespaced state); postReport
+     * merges — the first `on` override wins (only `on` clauses override),
+     * every arm's emits APPEND (the `after` half of D3).
+     */
+    mergeArms(arms) {
+        if (arms.length === 1)
+            return arms[0];
+        return {
+            preValidate(target, world, actorId, data) {
+                for (const arm of arms) {
+                    const veto = arm.preValidate?.(target, world, actorId, data);
+                    if (veto)
+                        return veto;
+                }
+                return null;
+            },
+            postValidate(target, world, actorId, data) {
+                for (const arm of arms)
+                    arm.postValidate?.(target, world, actorId, data);
+                return null;
+            },
+            postExecute(target, world, actorId, data) {
+                for (const arm of arms)
+                    arm.postExecute?.(target, world, actorId, data);
+            },
+            postReport(target, world, actorId, data) {
+                const merged = {};
+                const emit = [];
+                for (const arm of arms) {
+                    const result = arm.postReport?.(target, world, actorId, data) ?? {};
+                    if (result.override && !merged.override)
+                        merged.override = result.override;
+                    if (result.emit)
+                        emit.push(...result.emit);
+                }
+                if (emit.length)
+                    merged.emit = emit;
+                return merged;
+            },
+        };
+    }
     /**
-     * One interceptor per action: each hook forwards to the clause whose
-     * entity is the action's target (per-clause interceptors keep their own
-     * occurrence keys and decision snapshots).
+     * One interceptor per action: each hook forwards to the arm whose entity
+     * is the action's target. An owner's arm is the D3-merged composite of
+     * ALL its clauses for this action (each clause keeps its own namespaced
+     * occurrence keys and decision snapshots). On the topic gerunds
+     * (asking/telling, ADR-239) a table owner's arm consults its declared
+     * topic table first; the merged clause composite serves as the
+     * catch-all, firing only on a table miss (D5).
      */
-    buildDispatchingInterceptor(clauses) {
+    buildDispatchingInterceptor(action, clauses) {
         const runtime = this;
-        const arms = clauses.map(({ entity, clause }) => ({
-            entity,
-            interceptor: this.buildInterceptor(entity, clause),
-        }));
+        const isTopicAction = TOPIC_GERUNDS.includes(action);
+        const byEntity = new Map();
+        for (const { entity, clause } of clauses) {
+            const group = byEntity.get(entity.id) ?? { entity, entityClauses: [] };
+            if (clause)
+                group.entityClauses.push(clause);
+            byEntity.set(entity.id, group);
+        }
+        const arms = [...byEntity.values()].map(({ entity, entityClauses }) => {
+            const built = entityClauses.map((clause, index) => this.buildInterceptor(entity, clause, `${entity.id}.${action}.${clause.clauseKind}.${index}`));
+            const catchAll = built.length ? this.mergeArms(built) : undefined;
+            const interceptor = isTopicAction && (entity.topics ?? []).length
+                ? this.buildTopicArm(entity, catchAll)
+                : catchAll ?? {};
+            return { entity, interceptor };
+        });
         const armFor = (target) => arms.find((a) => runtime.host.entityId(a.entity.id) === target.id)?.interceptor;
         return {
             preValidate(target, world, actorId, data) {
@@ -209,48 +572,67 @@ class ChordRuntime {
      * win/lose → postReport. An `on` clause's first phrase OVERRIDES the
      * primary message; an `after` clause's phrases APPEND (D3).
      */
-    buildInterceptor(entity, clause) {
+    buildInterceptor(entity, clause, ns) {
         const runtime = this;
         const ownWorldId = () => runtime.host.entityId(entity.id);
-        const skipped = (data) => data.chordSkip === true;
+        const occurrenceKey = state_keys_js_1.CHORD_OCCURRENCE_PREFIX + `on.${ns}`;
         return {
-            preValidate(target, world) {
+            preValidate(target, world, _actorId, data) {
                 if (target.id !== ownWorldId() || clause.clauseKind === 'after')
                     return null;
+                const bag = runtime.clauseBag(data, ns);
                 const ctx = { world, it: entity.id };
+                // D8 (ADR-228): the `while` gate is evaluated once per firing, at
+                // validate time, BEFORE findRefusal — a gated-out clause sits out
+                // entirely, refusals included. preValidate and postValidate may both
+                // evaluate the gate: no mutation occurs between them within one
+                // action, so the answers cannot differ. Do not move this evaluation.
+                if (clause.condition && !runtime.evaluator.evalCondition(clause.condition, ctx)) {
+                    bag.skip = true;
+                    return null;
+                }
+                // `, once`: a clause that has already fired keeps its refusal out
+                // too (peek only — the occurrence bump stays in postValidate).
+                if (clause.once && (world.getStateValue(occurrenceKey) ?? 0) >= 1) {
+                    bag.skip = true;
+                    return null;
+                }
                 const refusal = runtime.findRefusal(clause.body, ctx);
                 return refusal ? { valid: false, error: refusal } : null;
             },
             postValidate(target, world, _actorId, data) {
                 if (target.id !== ownWorldId())
                     return null;
+                const bag = runtime.clauseBag(data, ns);
                 const ctx = { world, it: entity.id };
+                // D8: same gate, same evaluation point (see preValidate).
                 if (clause.condition && !runtime.evaluator.evalCondition(clause.condition, ctx)) {
-                    data.chordSkip = true; // `while <cond>` gate — clause sits out this firing
+                    bag.skip = true; // `while <cond>` gate — clause sits out this firing
                     return null;
                 }
-                const key = state_keys_1.CHORD_OCCURRENCE_PREFIX + `on.${entity.id}.${clause.action}`;
-                const occurrence = (world.getStateValue(key) ?? 0) + 1;
+                const occurrence = (world.getStateValue(occurrenceKey) ?? 0) + 1;
                 if (clause.once && occurrence > 1) {
-                    data.chordSkip = true; // `, once` — one lifetime firing (D5)
+                    bag.skip = true; // `, once` — one lifetime firing (D5)
                     return null;
                 }
-                world.setStateValue(key, occurrence);
+                world.setStateValue(occurrenceKey, occurrence);
                 ctx.occurrence = occurrence;
-                data.chordOccurrence = occurrence;
-                data.chordDecisions = runtime.snapshotDecisions(clause.body, ctx);
+                bag.occurrence = occurrence;
+                bag.decisions = runtime.snapshotDecisions(clause.body, ctx);
                 return null;
             },
             postExecute(target, world, _actorId, data) {
-                if (target.id !== ownWorldId() || skipped(data))
+                const bag = runtime.clauseBag(data, ns);
+                if (target.id !== ownWorldId() || bag.skip === true)
                     return;
-                const ctx = runtime.restoreCtx(world, entity.id, data);
+                const ctx = runtime.restoreCtx(world, entity.id, bag);
                 runtime.execStatements(clause.body, ctx, 'mutations');
             },
             postReport(target, world, _actorId, data) {
-                if (target.id !== ownWorldId() || skipped(data))
+                const bag = runtime.clauseBag(data, ns);
+                if (target.id !== ownWorldId() || bag.skip === true)
                     return {};
-                const ctx = runtime.restoreCtx(world, entity.id, data);
+                const ctx = runtime.restoreCtx(world, entity.id, bag);
                 const reports = runtime.execStatements(clause.body, ctx, 'reports');
                 const result = {};
                 const emit = [];
@@ -272,12 +654,110 @@ class ChordRuntime {
             },
         };
     }
-    restoreCtx(world, itIrId, data) {
+    restoreCtx(world, itIrId, bag) {
         return {
             world,
             it: itIrId,
-            occurrence: data.chordOccurrence,
-            decisions: data.chordDecisions,
+            occurrence: bag.occurrence,
+            decisions: bag.decisions,
+        };
+    }
+    // ------------------------------------------------- topic tables (ADR-239)
+    /**
+     * Runtime dispatch for one topic-table owner (ADR-239 D4/D5): normalized
+     * whole-topic lookup against the declared rows — entity tier first (the
+     * platform's quiet `topicEntityId` resolution), then free-text tier
+     * (primary or declared alias; the SAME normalizeTopic the analyzer's
+     * overlap gates used — one implementation, imported from chord). A hit
+     * runs the matched ROW's body exactly like a one-clause `on` firing
+     * (its first phrase OVERRIDES the primary message; the catch-all never
+     * runs — suppression, not append). A miss falls to the owner's
+     * catch-all clause when one is declared; with none, `{}` leaves the
+     * action's unconditional unknown_topic/not_interested default standing.
+     * The asked topic reaches `data` via the lifecycle seedData hook.
+     */
+    buildTopicArm(entity, catchAll) {
+        const runtime = this;
+        const rows = entity.topics ?? [];
+        /** Match once per firing; memoized on the consultation's sharedData. */
+        const rowIndexFor = (data) => {
+            if (typeof data.chordTopicRow === 'number')
+                return data.chordTopicRow;
+            const askedEntity = typeof data.topicEntityId === 'string' ? data.topicEntityId : null;
+            const askedText = typeof data.topic === 'string' ? (0, chord_1.normalizeTopic)(data.topic) : null;
+            let index = -1;
+            if (askedEntity !== null) {
+                index = rows.findIndex((r) => r.filter.kind === 'entity' && runtime.host.entityId(r.filter.id) === askedEntity);
+            }
+            if (index === -1 && askedText !== null && askedText !== '') {
+                index = rows.findIndex((r) => r.filter.kind === 'text' &&
+                    ((0, chord_1.normalizeTopic)(r.filter.primary) === askedText || r.filter.aliases.some((a) => (0, chord_1.normalizeTopic)(a) === askedText)));
+            }
+            data.chordTopicRow = index;
+            return index;
+        };
+        // One occurrence namespace per ROW, shared across ask and tell (D1 —
+        // one table serves both): a row-body `first time` ordinal counts
+        // deliveries of that response, however it was reached.
+        const occurrenceKeyOf = (rowIndex) => `${state_keys_js_1.CHORD_OCCURRENCE_PREFIX}topic.${entity.id}.${rowIndex}`;
+        return {
+            preValidate(target, world, actorId, data) {
+                const row = rows[rowIndexFor(data)];
+                if (!row)
+                    return catchAll?.preValidate?.(target, world, actorId, data) ?? null;
+                const ctx = { world, it: entity.id };
+                const refusal = runtime.findRefusal(row.body, ctx);
+                return refusal ? { valid: false, error: refusal } : null;
+            },
+            postValidate(target, world, actorId, data) {
+                const index = rowIndexFor(data);
+                const row = rows[index];
+                if (!row)
+                    return catchAll?.postValidate?.(target, world, actorId, data) ?? null;
+                const bag = runtime.clauseBag(data, `topic.${entity.id}`);
+                const ctx = { world, it: entity.id };
+                const key = occurrenceKeyOf(index);
+                const occurrence = (world.getStateValue(key) ?? 0) + 1;
+                world.setStateValue(key, occurrence);
+                ctx.occurrence = occurrence;
+                bag.occurrence = occurrence;
+                bag.decisions = runtime.snapshotDecisions(row.body, ctx);
+                return null;
+            },
+            postExecute(target, world, actorId, data) {
+                const row = rows[rowIndexFor(data)];
+                if (!row) {
+                    catchAll?.postExecute?.(target, world, actorId, data);
+                    return;
+                }
+                const ctx = runtime.restoreCtx(world, entity.id, runtime.clauseBag(data, `topic.${entity.id}`));
+                runtime.execStatements(row.body, ctx, 'mutations');
+            },
+            postReport(target, world, actorId, data) {
+                const row = rows[rowIndexFor(data)];
+                if (!row)
+                    return catchAll?.postReport?.(target, world, actorId, data) ?? {};
+                const ctx = runtime.restoreCtx(world, entity.id, runtime.clauseBag(data, `topic.${entity.id}`));
+                const reports = runtime.execStatements(row.body, ctx, 'reports');
+                const result = {};
+                const emit = [];
+                for (const event of reports) {
+                    const payload = (event.data ?? {});
+                    if (event.type === 'chord.phrase' && !result.override) {
+                        // A hit fully owns the response (D5) — override, never append.
+                        result.override = {
+                            messageId: String(payload.messageId),
+                            params: payload.params ?? {},
+                        };
+                    }
+                    else {
+                        emit.push({ type: event.type, payload });
+                    }
+                }
+                if (emit.length)
+                    result.emit = emit;
+                return result;
+            },
         };
     }
     // ------------------------------------------- dispatch verbs (Phase B, §5.4)
@@ -285,7 +765,7 @@ class ChordRuntime {
     writeChordTraitField(world, worldId, field, value, span) {
         const entity = world.getEntity(worldId);
         for (const trait of entity?.traits.values() ?? []) {
-            if (!trait.type.startsWith(state_keys_1.CHORD_TRAIT_PREFIX))
+            if (!trait.type.startsWith(state_keys_js_1.CHORD_TRAIT_PREFIX))
                 continue;
             const record = trait;
             if (field in record) {
@@ -293,7 +773,7 @@ class ChordRuntime {
                 return;
             }
         }
-        throw new errors_1.LoadError(`No trait on this entity carries the field \`${field}\`.`, span);
+        throw new errors_js_1.LoadError(`No trait on this entity carries the field \`${field}\`.`, span);
     }
     /**
      * A `define trait` clause on a dispatch verb → CapabilityBehavior
@@ -313,11 +793,25 @@ class ChordRuntime {
         return {
             validate(entity, world, actorId, data) {
                 const ctx = ctxOf(entity, world, actorId, data);
+                // D8 (ADR-228): the `while` gate is evaluated once per firing, at
+                // validate time, BEFORE findRefusal — a gated-out clause sits out
+                // entirely, refusals included. ADR-229 R5: the dispatch action
+                // reads `chordSkip` as "not claiming" and falls through to the
+                // next candidate / body / miss; the execute/report guards below
+                // stay as defense in depth. Do not move this evaluation.
+                if (clause.condition && !runtime.evaluator.evalCondition(clause.condition, ctx)) {
+                    data.chordSkip = true;
+                    return { valid: true };
+                }
+                const key = `${state_keys_js_1.CHORD_OCCURRENCE_PREFIX}trait.${traitName}.${clause.action}.${runtime.host.irIdOf(entity.id)}`;
+                const occurrence = (world.getStateValue(key) ?? 0) + 1;
+                if (clause.once && occurrence > 1) {
+                    data.chordSkip = true; // `, once` — one lifetime firing (D5)
+                    return { valid: true };
+                }
                 const refusal = runtime.findRefusal(clause.body, ctx);
                 if (refusal)
                     return { valid: false, error: refusal };
-                const key = `${state_keys_1.CHORD_OCCURRENCE_PREFIX}trait.${traitName}.${clause.action}.${runtime.host.irIdOf(entity.id)}`;
-                const occurrence = (world.getStateValue(key) ?? 0) + 1;
                 world.setStateValue(key, occurrence);
                 ctx.occurrence = occurrence;
                 data.chordOccurrence = occurrence;
@@ -325,9 +819,13 @@ class ChordRuntime {
                 return { valid: true };
             },
             execute(entity, world, actorId, data) {
+                if (data.chordSkip === true)
+                    return;
                 runtime.execStatements(clause.body, ctxOf(entity, world, actorId, data), 'mutations');
             },
             report(entity, world, actorId, data) {
+                if (data.chordSkip === true)
+                    return [];
                 const events = runtime.execStatements(clause.body, ctxOf(entity, world, actorId, data), 'reports');
                 return events.map((e) => ({ type: e.type, payload: (e.data ?? {}) }));
             },
@@ -342,33 +840,72 @@ class ChordRuntime {
      * ActionInterceptor registered under the trait type (ADR-118 resolves it
      * for every entity carrying the trait).
      */
-    buildTraitInterceptor(clause) {
+    buildTraitInterceptor(clause, ns) {
         const runtime = this;
         const itOf = (target) => runtime.host.irIdOf(target.id) ?? target.id;
+        const occurrenceKeyOf = (target) => `${state_keys_js_1.CHORD_OCCURRENCE_PREFIX}trait.${ns}.${itOf(target)}`;
         return {
-            preValidate(target, world) {
-                const refusal = runtime.findRefusal(clause.body, { world, it: itOf(target) });
+            preValidate(target, world, _actorId, data) {
+                if (clause.clauseKind === 'after')
+                    return null;
+                const ctx = { world, it: itOf(target) };
+                // D8 (ADR-228): the `while` gate is evaluated once per firing, at
+                // validate time, BEFORE findRefusal — a gated-out clause sits out
+                // entirely, refusals included. preValidate and postValidate may both
+                // evaluate the gate: no mutation occurs between them within one
+                // action, so the answers cannot differ. Do not move this evaluation.
+                const bag = runtime.clauseBag(data, ns);
+                if (clause.condition && !runtime.evaluator.evalCondition(clause.condition, ctx)) {
+                    bag.skip = true;
+                    return null;
+                }
+                // `, once`: a clause that has already fired keeps its refusal out
+                // too (peek only — the occurrence bump stays in postValidate).
+                if (clause.once && (world.getStateValue(occurrenceKeyOf(target)) ?? 0) >= 1) {
+                    bag.skip = true;
+                    return null;
+                }
+                const refusal = runtime.findRefusal(clause.body, ctx);
                 return refusal ? { valid: false, error: refusal } : null;
             },
             postValidate(target, world, _actorId, data) {
-                const key = `${state_keys_1.CHORD_OCCURRENCE_PREFIX}trait.${clause.action}.${itOf(target)}`;
+                const bag = runtime.clauseBag(data, ns);
+                const ctx = { world, it: itOf(target) };
+                // D8: same gate, same evaluation point (see preValidate).
+                if (clause.condition && !runtime.evaluator.evalCondition(clause.condition, ctx)) {
+                    bag.skip = true; // `while <cond>` gate — clause sits out this firing
+                    return null;
+                }
+                const key = occurrenceKeyOf(target);
                 const occurrence = (world.getStateValue(key) ?? 0) + 1;
+                if (clause.once && occurrence > 1) {
+                    bag.skip = true; // `, once` — one lifetime firing (D5)
+                    return null;
+                }
                 world.setStateValue(key, occurrence);
-                const ctx = { world, it: itOf(target), occurrence };
-                data.chordOccurrence = occurrence;
-                data.chordDecisions = runtime.snapshotDecisions(clause.body, ctx);
+                ctx.occurrence = occurrence;
+                bag.occurrence = occurrence;
+                bag.decisions = runtime.snapshotDecisions(clause.body, ctx);
                 return null;
             },
             postExecute(target, world, _actorId, data) {
-                runtime.execStatements(clause.body, runtime.restoreCtx(world, itOf(target), data), 'mutations');
+                const bag = runtime.clauseBag(data, ns);
+                if (bag.skip === true)
+                    return;
+                runtime.execStatements(clause.body, runtime.restoreCtx(world, itOf(target), bag), 'mutations');
             },
             postReport(target, world, _actorId, data) {
-                const reports = runtime.execStatements(clause.body, runtime.restoreCtx(world, itOf(target), data), 'reports');
+                const bag = runtime.clauseBag(data, ns);
+                if (bag.skip === true)
+                    return {};
+                const reports = runtime.execStatements(clause.body, runtime.restoreCtx(world, itOf(target), bag), 'reports');
                 const result = {};
                 const emit = [];
                 for (const event of reports) {
                     const payload = (event.data ?? {});
-                    if (event.type === 'chord.phrase' && !result.override) {
+                    // Only `on` clauses override the primary message; `after` phrases
+                    // APPEND (ratchet D3 — mirrors the entity interceptor's guard).
+                    if (clause.clauseKind === 'on' && event.type === 'chord.phrase' && !result.override) {
                         result.override = { messageId: String(payload.messageId), params: payload.params ?? {} };
                     }
                     else {
@@ -431,24 +968,36 @@ class ChordRuntime {
                 // Instance-type lookup: ChordDataTrait types are per-instance, so
                 // the constructor-static path (getBehaviorForCapability) can't see
                 // them.
+                //
+                // ADR-229 R5: a gated-out behavior does NOT claim the dispatch.
+                // A candidate whose validate returns valid with `chordSkip` set
+                // (false `while` gate, or consumed `, once` — both side-effect-free
+                // probes) is treated as if its clause were never declared: selection
+                // falls through to the next trait's behavior, the action body, or
+                // the `otherwise refuse` miss. A real refusal (valid: false) still
+                // claims immediately, exactly as before.
                 let behavior;
+                let capShared = { chordSlots: slots };
                 for (const trait of entity.traits.values()) {
-                    behavior = context.world.getBehaviorBinding(trait.type, actionId)?.behavior;
-                    if (behavior)
-                        break;
+                    const candidate = context.world.getBehaviorBinding(trait.type, actionId)?.behavior;
+                    if (!candidate)
+                        continue;
+                    const candidateShared = { chordSlots: slots };
+                    const result = candidate.validate(entity, context.world, context.player.id, candidateShared);
+                    if (!result.valid)
+                        return { valid: false, error: result.error };
+                    if (candidateShared.chordSkip === true)
+                        continue; // gated out — not claiming
+                    behavior = candidate;
+                    capShared = candidateShared;
+                    break;
                 }
                 // A behavior host is optional when the action carries its own body
                 // (§5.4: the body IS the action's semantics — photographing has no
-                // per-trait behavior by design). No behavior AND no body = the
-                // dispatch miss, exactly as before.
+                // per-trait behavior by design). No claiming behavior AND no body =
+                // the dispatch miss.
                 if (!behavior && def.body.length === 0)
                     return { valid: false, error: def.otherwise ?? 'cant' };
-                const capShared = { chordSlots: slots };
-                if (behavior) {
-                    const result = behavior.validate(entity, context.world, context.player.id, capShared);
-                    if (!result.valid)
-                        return { valid: false, error: result.error };
-                }
                 if (def.body.length) {
                     // The body's own validate partition (leading refusals/musts) and
                     // the pre-mutation decision snapshot (§5.4).
@@ -491,6 +1040,14 @@ class ChordRuntime {
             },
             blocked(context, result) {
                 const key = result.error ?? def.otherwise ?? 'cant';
+                // Platform default (Phase 8 #13): `'cant'` is the built-in fallback
+                // key for an action with no authored `otherwise`/refusal — no story
+                // phrase exists for it, and phraseEvent would throw a LoadError at
+                // emit time. Render the platform's generic refusal instead
+                // (lang-en-us `scope.out_of_scope`: "You can't do that.").
+                if (key === 'cant') {
+                    return [context.event('action.blocked', { messageId: 'scope.out_of_scope', reason: 'cant' })];
+                }
                 const event = runtime.phraseEvent(key, { world: context.world });
                 return [context.event(event.type, (event.data ?? {}))];
             },
@@ -530,7 +1087,7 @@ class ChordRuntime {
             // <state>` on a state anchor (ratchet D10). Pointer and last-fired
             // turn live in world state — save/restore covers progression.
             const slug = sequence.name.replace(/\s+/g, '-');
-            const key = `${state_keys_1.CHORD_OCCURRENCE_PREFIX}sequence.${slug}`;
+            const key = `${state_keys_js_1.CHORD_OCCURRENCE_PREFIX}sequence.${slug}`;
             const firedKey = `${key}.turn`;
             const stepReady = (step, world, turn) => {
                 switch (step.timing) {
@@ -544,9 +1101,9 @@ class ChordRuntime {
                         if (!step.anchor)
                             return false;
                         if (step.anchor.owner === 'story') {
-                            return world.getStateValue(state_keys_1.CHORD_STORY_STATE_KEY) === step.anchor.state;
+                            return world.getStateValue(state_keys_js_1.CHORD_STORY_STATE_KEY) === step.anchor.state;
                         }
-                        return world.getStateValue(state_keys_1.CHORD_STATE_PREFIX + step.anchor.owner) === step.anchor.state;
+                        return world.getStateValue(state_keys_js_1.CHORD_STATE_PREFIX + step.anchor.owner) === step.anchor.state;
                     }
                 }
             };
@@ -574,7 +1131,7 @@ class ChordRuntime {
             irEntity.onClauses.forEach((clause, clauseIndex) => {
                 if (clause.binding !== 'every-turn')
                     return;
-                const key = `${state_keys_1.CHORD_OCCURRENCE_PREFIX}entity-turn.${irEntity.id}.${clauseIndex}`;
+                const key = `${state_keys_js_1.CHORD_OCCURRENCE_PREFIX}entity-turn.${irEntity.id}.${clauseIndex}`;
                 daemons.push({
                     id: `chord.entity-turn.${irEntity.id}.${clauseIndex}`,
                     name: `on every turn (${irEntity.id})`,
@@ -599,6 +1156,31 @@ class ChordRuntime {
                 });
             });
         });
+        // Story-owned every-turn clauses (`on every turn` in the story header
+        // body — ADR-236 D7, ratchet R4): one daemon per clause with NO
+        // presence gate — the story is everywhere ("a background clock for the
+        // whole game"); narration broadcasts. `it` never appears in the body
+        // (the analyzer's story-clause-it gate refused it at compile).
+        (this.ir.story.onClauses ?? []).forEach((clause, clauseIndex) => {
+            if (clause.binding !== 'every-turn')
+                return;
+            const key = `${state_keys_js_1.CHORD_OCCURRENCE_PREFIX}story-turn.${clauseIndex}`;
+            daemons.push({
+                id: `chord.story-turn.${clauseIndex}`,
+                name: 'on every turn (story)',
+                run: (ctx) => {
+                    const evalCtx = { world: ctx.world };
+                    if (clause.condition && !this.evaluator.evalCondition(clause.condition, evalCtx))
+                        return [];
+                    const fired = (ctx.world.getStateValue(key) ?? 0) + 1;
+                    if (clause.once && fired > 1)
+                        return []; // `, once` (D5)
+                    ctx.world.setStateValue(key, fired);
+                    evalCtx.occurrence = fired;
+                    return this.narrated(this.execStatements(clause.body, evalCtx));
+                },
+            });
+        });
         // Every-turn trait clauses (`on every turn while …[, once]`): one
         // daemon per clause, evaluated per entity carrying the trait. The
         // composition condition (`chatty while not after-hours`) gates per
@@ -607,7 +1189,7 @@ class ChordRuntime {
             trait.onClauses.forEach((clause, clauseIndex) => {
                 if (clause.binding !== 'every-turn')
                     return;
-                const traitType = state_keys_1.CHORD_TRAIT_PREFIX + trait.name;
+                const traitType = state_keys_js_1.CHORD_TRAIT_PREFIX + trait.name;
                 daemons.push({
                     id: `chord.trait-turn.${trait.name}.${clauseIndex}`,
                     name: `on every turn (${trait.name})`,
@@ -630,7 +1212,7 @@ class ChordRuntime {
                                 continue;
                             if (clause.condition && !this.evaluator.evalCondition(clause.condition, evalCtx))
                                 continue;
-                            const key = `${state_keys_1.CHORD_OCCURRENCE_PREFIX}trait-turn.${trait.name}.${clauseIndex}.${irEntity.id}`;
+                            const key = `${state_keys_js_1.CHORD_OCCURRENCE_PREFIX}trait-turn.${trait.name}.${clauseIndex}.${irEntity.id}`;
                             const fired = (ctx.world.getStateValue(key) ?? 0) + 1;
                             if (clause.once && fired > 1)
                                 continue; // `, once` (D5)
@@ -663,11 +1245,23 @@ class ChordRuntime {
     narrated(events) {
         return events.map((e) => ({ ...e, narrate: true }));
     }
+    /**
+     * Execute a machine body (`on enter`/`on exit`/transition effects,
+     * ADR-215 state-machines depth) — story-owned: no `it` (compile-gated),
+     * narration broadcasts like any story-owned surface.
+     * @param statements the resolved IR statement tree
+     * @param world the live world the effect runs against
+     */
+    execMachineBody(statements, world) {
+        return this.narrated(this.execStatements(statements, { world }));
+    }
     /**
      * Decision 10 presence semantics: the player shares the owner's location.
-     * A room owner means the player is IN that room; for anything else the
-     * two share a containing room (same co-location rule as can-see/can-reach
-     * — presence, not sight, so the snake speaks in darkness).
+     * A room owner means the player is IN that room; a region owner "is" at
+     * every member room — presence is `isInRegion(player, region)`, transitive
+     * through nesting (ADR-236 D4); for anything else the two share a
+     * containing room (same co-location rule as can-see/can-reach — presence,
+     * not sight, so the snake speaks in darkness).
      */
     playerPresentAt(world, irEntityId) {
         const ownerId = this.host.entityId(irEntityId);
@@ -676,8 +1270,10 @@ class ChordRuntime {
             return false;
         if (ownerId === playerId)
             return true;
-        const playerRoom = world.getContainingRoom(playerId)?.id ?? world.getLocation(playerId);
         const owner = world.getEntity(ownerId);
+        if (owner?.has(world_model_1.TraitType.REGION))
+            return world.isInRegion(playerId, ownerId);
+        const playerRoom = world.getContainingRoom(playerId)?.id ?? world.getLocation(playerId);
         if (owner?.has(world_model_1.TraitType.ROOM))
             return playerRoom === ownerId;
         const ownerRoom = world.getContainingRoom(ownerId)?.id ?? world.getLocation(ownerId);
@@ -703,7 +1299,7 @@ class ChordRuntime {
             const ctx = { world, it: targetIrId };
             if (clause.condition && !this.evaluator.evalCondition(clause.condition, ctx))
                 return;
-            const key = `${state_keys_1.CHORD_OCCURRENCE_PREFIX}after.${irEntity.id}.${actionName}.${clauseIndex}`;
+            const key = `${state_keys_js_1.CHORD_OCCURRENCE_PREFIX}after.${irEntity.id}.${actionName}.${clauseIndex}`;
             const occurrence = (world.getStateValue(key) ?? 0) + 1;
             if (clause.once && occurrence > 1)
                 return; // `, once` (D5)
@@ -725,49 +1321,53 @@ class ChordRuntime {
         }
         return out;
     }
+    // ADR-240 D4: `recomputeDerived` and its trigger wiring are DELETED — the
+    // registered evaluators above are consulted live at every read; there is
+    // no cached derivation left to refresh.
     /**
-     * Re-evaluate derived properties: `dark while` into `RoomTrait.isDark`,
-     * and `is blocked while <cond>` into blockedExits (block/unblock per the
-     * condition's current truth — grammar log 2026-07-10).
+     * Blocked-exit refusal text, resolved AT REFUSAL TIME (ADR-240 D6): a
+     * multi-variant phrase honors its strategy per attempt — `randomly`
+     * through the seeded story RNG, `cycling`/`stopping`/`first-time`
+     * through a world-state counter, `sticky` through a stored pick — so
+     * refusal text varies exactly as ADR-211 phrase semantics intend.
      */
-    recomputeDerived(world) {
-        for (const { entity, condition } of this.derivedDarkRooms()) {
-            const worldId = this.host.entityId(entity.id);
-            const room = worldId ? world.getEntity(worldId)?.get(world_model_1.TraitType.ROOM) : undefined;
-            if (!room)
-                continue;
-            room.isDark = this.evaluator.evalCondition(condition, { world });
-        }
-        for (const irEntity of this.ir.entities) {
-            for (const blocked of irEntity.blockedExits) {
-                if (!blocked.condition)
-                    continue;
-                const worldId = this.host.entityId(irEntity.id);
-                const room = worldId ? world.getEntity(worldId) : undefined;
-                if (!room)
-                    continue;
-                const direction = world_model_1.Direction[blocked.direction.toUpperCase()];
-                if (!direction)
-                    continue;
-                const holds = this.evaluator.evalCondition(blocked.condition, { world, it: irEntity.id });
-                if (holds) {
-                    world_model_1.RoomBehavior.blockExit(room, direction, this.blockedPhraseText(blocked.phraseKey));
-                }
-                else {
-                    world_model_1.RoomBehavior.unblockExit(room, direction);
-                }
+    blockedPhraseText(key, world) {
+        const phrase = this.ir.phrases.locales[this.ir.phrases.defaultLocale]?.[key];
+        if (!phrase)
+            return '';
+        const variants = phrase.variants;
+        if (variants.length <= 1)
+            return variants[0]?.text ?? '';
+        const stateKey = `${state_keys_js_1.CHORD_OCCURRENCE_PREFIX}blocked.${key}`;
+        switch (phrase.strategy) {
+            case 'randomly':
+                return variants[this.evaluator.pickIndex(variants.length, world)].text;
+            case 'sticky': {
+                const stored = world.getStateValue(stateKey);
+                if (typeof stored === 'number')
+                    return variants[stored].text;
+                const pick = this.evaluator.pickIndex(variants.length, world);
+                world.setStateValue(stateKey, pick);
+                return variants[pick].text;
+            }
+            case 'stopping': {
+                const n = world.getStateValue(stateKey) ?? 0;
+                world.setStateValue(stateKey, Math.min(n + 1, variants.length - 1));
+                return variants[Math.min(n, variants.length - 1)].text;
+            }
+            case 'first-time': {
+                const n = world.getStateValue(stateKey) ?? 0;
+                world.setStateValue(stateKey, n + 1);
+                return variants[n === 0 ? 0 : Math.min(1, variants.length - 1)].text;
+            }
+            case 'cycling':
+            default: {
+                const n = world.getStateValue(stateKey) ?? 0;
+                world.setStateValue(stateKey, n + 1);
+                return variants[n % variants.length].text;
             }
         }
     }
-    /** Single-variant text of a blocked-exit phrase (mirrors the loader's read). */
-    blockedPhraseText(key) {
-        const phrase = this.ir.phrases.locales[this.ir.phrases.defaultLocale]?.[key];
-        return phrase?.variants[0]?.text ?? '';
-    }
-    /** True when any entity declares a conditional blocked exit. */
-    hasConditionalBlockedExits() {
-        return this.ir.entities.some((e) => e.blockedExits.some((b) => b.condition !== null));
-    }
     // ------------------------------------------------------------ statements
     /**
      * Execute a statement tree. `phase` narrows which leaves act:
@@ -788,8 +1388,15 @@ class ChordRuntime {
                         events.push(this.phraseEvent(stmt.phraseKey, ctx, stmt.params));
                     break;
                 case 'emit':
+                    // ADR-216: the payload evaluates live against the turn context —
+                    // literals as numbers/strings, value expressions through the
+                    // shared evaluator, arrays/objects recursively.
+                    // ADR-256: the Chord IR event id is dotless; translate it to the
+                    // platform runtime type here (media.* → dotted; author events pass
+                    // through). Not inside rawEvent — that also mints the internal
+                    // `chord.phrase` event, which must not be translated.
                     if (phase !== 'mutations' && whenHolds(stmt))
-                        events.push(this.rawEvent(stmt.event, {}));
+                        events.push(this.rawEvent((0, event_id_map_js_1.translateEventId)(stmt.event), this.emitPayload(stmt.payload, ctx)));
                     break;
                 case 'win':
                 case 'lose':
@@ -799,20 +1406,40 @@ class ChordRuntime {
                         events.push(this.host.triggerEnding(ctx.world, stmt.kind === 'win' ? 'victory' : 'defeat', stmt.phraseKey ?? undefined));
                     }
                     break;
+                case 'kill':
+                    // `kill the player` (ADR-227 Decision 4): terminal death via the
+                    // platform's killPlayer sink — the engine routes game-over off the
+                    // canonical if.event.player.died it returns; triggerEnding is NOT
+                    // called (a distinct lowering target from win/lose). The phrase
+                    // carries the death text; the cause derives from the phrase key.
+                    if (phase !== 'mutations' && whenHolds(stmt)) {
+                        if (stmt.phraseKey)
+                            events.push(this.phraseEvent(stmt.phraseKey, ctx));
+                        const player = ctx.world.getPlayer();
+                        if (player) {
+                            const died = (0, stdlib_1.killPlayer)(ctx.world, player, {
+                                cause: stmt.phraseKey ?? 'killed',
+                                terminal: true,
+                            });
+                            if (died)
+                                events.push(died);
+                        }
+                    }
+                    break;
                 case 'change': {
                     if (phase !== 'reports' && whenHolds(stmt)) {
                         if (stmt.entity.kind === 'story') {
                             // `change the story to <state>` — the story object's phase (D2).
-                            this.checkForwardMarch(this.ir.story.states, this.ir.story.reversible, ctx.world.getStateValue(state_keys_1.CHORD_STORY_STATE_KEY), stmt.state, 'the story', stmt.span);
-                            ctx.world.setStateValue(state_keys_1.CHORD_STORY_STATE_KEY, stmt.state);
+                            this.checkForwardMarch(this.ir.story.states, this.ir.story.reversible, ctx.world.getStateValue(state_keys_js_1.CHORD_STORY_STATE_KEY), stmt.state, 'the story', stmt.span);
+                            ctx.world.setStateValue(state_keys_js_1.CHORD_STORY_STATE_KEY, stmt.state);
                         }
                         else {
                             const irId = this.irIdOfValue(stmt.entity, ctx);
                             const set = this.stateSetOf(irId, stmt.state);
                             if (set) {
-                                this.checkForwardMarch(set.states, set.reversible, ctx.world.getStateValue(state_keys_1.CHORD_STATE_PREFIX + irId), stmt.state, irId, stmt.span);
+                                this.checkForwardMarch(set.states, set.reversible, ctx.world.getStateValue(state_keys_js_1.CHORD_STATE_PREFIX + irId), stmt.state, irId, stmt.span);
                             }
-                            ctx.world.setStateValue(state_keys_1.CHORD_STATE_PREFIX + irId, stmt.state);
+                            ctx.world.setStateValue(state_keys_js_1.CHORD_STATE_PREFIX + irId, stmt.state);
                         }
                     }
                     break;
@@ -846,7 +1473,7 @@ class ChordRuntime {
                             this.writeChordTraitField(ctx.world, baseId, stmt.target.field, value, stmt.span);
                         }
                         else {
-                            throw new errors_1.LoadError('`set` targets a trait data field.', stmt.span);
+                            throw new errors_js_1.LoadError('`set` targets a trait data field.', stmt.span);
                         }
                     }
                     break;
@@ -857,12 +1484,12 @@ class ChordRuntime {
                         // awards are no-ops and `, once` is automatic. Names arrive
                         // owner-qualified from the analyzer (ratchet D12).
                         if (stmt.expression.length !== 1) {
-                            throw new errors_1.LoadError('Only `award <score-name>` is supported (expression awards are later scope).', stmt.span);
+                            throw new errors_js_1.LoadError('Only `award <score-name>` is supported (expression awards are later scope).', stmt.span);
                         }
                         const name = stmt.expression[0];
                         const worth = this.scoreWorth.get(name);
                         if (worth === undefined) {
-                            throw new errors_1.LoadError(`\`${name}\` is not a declared score.`, stmt.span);
+                            throw new errors_js_1.LoadError(`\`${name}\` is not a declared score.`, stmt.span);
                         }
                         ctx.world.awardScore(name, worth, name);
                     }
@@ -988,7 +1615,7 @@ class ChordRuntime {
         const from = states.indexOf(current);
         const to = states.indexOf(target);
         if (from >= 0 && to >= 0 && to < from) {
-            throw new errors_1.LoadError(`\`change\` to \`${target}\` moves ${ownerDesc} backward in a forward-only set (currently \`${current}\`) — add \`, reversible\` to the \`states:\` line to permit back-transitions (D4).`, span);
+            throw new errors_js_1.LoadError(`\`change\` to \`${target}\` moves ${ownerDesc} backward in a forward-only set (currently \`${current}\`) — add \`, reversible\` to the \`states:\` line to permit back-transitions (D4).`, span);
         }
     }
     /**
@@ -1000,21 +1627,33 @@ class ChordRuntime {
     findRefusal(body, ctx) {
         for (const stmt of body) {
             if (stmt.kind === 'refuse')
-                return stmt.phraseKey;
+                return this.resolvePhraseKey(stmt.phraseKey, ctx);
             if (stmt.kind === 'must') {
                 if (!this.evaluator.evalCondition(stmt.condition, ctx))
-                    return stmt.phraseKey;
+                    return this.resolvePhraseKey(stmt.phraseKey, ctx);
                 continue;
             }
             if (stmt.kind === 'refuse-when') {
                 if (this.evaluator.evalCondition(stmt.condition, ctx))
-                    return stmt.phraseKey;
+                    return this.resolvePhraseKey(stmt.phraseKey, ctx);
                 continue;
             }
             break; // first non-refusal statement ends the validate partition
         }
         return null;
     }
+    /**
+     * Resolve a refusal phrase key to its registered message id. A
+     * per-entity `phrase <key>:` declaration registers entity-scoped as
+     * `<irId>.<key>` — the same override rule `phraseEvent` applies at emit
+     * time — so a bare refusal key written inside that entity's clause must
+     * travel as the scoped id: the key crosses into stdlib's blocked() as a
+     * fully-qualified message id (ADR-231 D1) and is rendered verbatim.
+     */
+    resolvePhraseKey(key, ctx) {
+        const table = this.ir.phrases.locales[this.ir.phrases.defaultLocale] ?? {};
+        return ctx.it && table[`${ctx.it}.${key}`] ? `${ctx.it}.${key}` : key;
+    }
     /**
      * Snapshot every branching decision (`if` and `select-on`) before
      * mutations run, walking only the branches actually taken (§5.4: the
@@ -1081,7 +1720,7 @@ class ChordRuntime {
         // the persisted chance stream (via one draw per firing). Sticky (Z5)
         // reuses the same slot with the Choice encoding instead of an
         // occurrence count: stored = chosen index + 1, 0/undefined = unchosen.
-        const key = state_keys_1.CHORD_OCCURRENCE_PREFIX + `select.${stmt.span.line}`;
+        const key = state_keys_js_1.CHORD_OCCURRENCE_PREFIX + `select.${stmt.span.line}`;
         if (stmt.strategy === 'sticky') {
             const stored = ctx.world.getStateValue(key);
             if (stored && stored > 0)
@@ -1102,7 +1741,7 @@ class ChordRuntime {
             case 'randomly':
                 return this.randomIndex(count, ctx);
             default:
-                throw new errors_1.LoadError(`Unknown select strategy \`${stmt.strategy}\`.`, stmt.span);
+                throw new errors_js_1.LoadError(`Unknown select strategy \`${stmt.strategy}\`.`, stmt.span);
         }
     }
     randomIndex(count, ctx) {
@@ -1159,8 +1798,14 @@ class ChordRuntime {
         const table = this.ir.phrases.locales[this.ir.phrases.defaultLocale] ?? {};
         const overrideKey = ctx.it && table[`${ctx.it}.${key}`] ? `${ctx.it}.${key}` : key;
         const phrase = table[overrideKey];
-        if (!phrase)
-            throw new errors_1.LoadError(`Phrase \`${key}\` is missing from the IR at emit time.`);
+        // ADR-250: a key covered only by phrasebooks has no table entry — emit
+        // the bare key (the render-path book layer supplies the winning
+        // template and its Choice) but still stage stmt params and any hatch
+        // producers the book entries reference, since staging is emit-time work.
+        const bookVariants = phrase ? null : this.bookEntriesFor(key).flatMap((e) => e.variants);
+        if (!phrase && bookVariants.length === 0) {
+            throw new errors_js_1.LoadError(`Phrase \`${key}\` is missing from the IR at emit time.`);
+        }
         const params = {};
         // Authored `with <param> = <value>` bindings (zoo-chain follow-up,
         // 2026-07-12): entity values pass as their display name (the template's
@@ -1170,7 +1815,7 @@ class ChordRuntime {
             const asEntity = typeof value === 'string' ? ctx.world.getEntity(value) : undefined;
             params[p.param] = asEntity ? asEntity.name : value;
         }
-        for (const variant of phrase.variants) {
+        for (const variant of phrase ? phrase.variants : bookVariants) {
             for (const marker of variant.markers) {
                 const producer = this.host.producers.get(marker);
                 if (producer) {
@@ -1181,10 +1826,10 @@ class ChordRuntime {
                     // producer reaching outside it fails HERE, named, not as an
                     // anonymous TypeError downstream.
                     try {
-                        params[marker] = producer((0, hatch_context_1.stagingRenderContext)(ctx.world));
+                        params[marker] = producer((0, hatch_context_js_1.stagingRenderContext)(ctx.world));
                     }
                     catch (error) {
-                        throw new errors_1.LoadError(`Hatch \`${marker}\` threw while staging phrase \`${overrideKey}\`: ${error instanceof Error ? error.message : String(error)}. Hatches see the narrow staging context only (design.md §5.6).`);
+                        throw new errors_js_1.LoadError(`Hatch \`${marker}\` threw while staging phrase \`${overrideKey}\`: ${error instanceof Error ? error.message : String(error)}. Hatches see the narrow staging context only (design.md §5.6).`);
                     }
                 }
             }
@@ -1202,16 +1847,16 @@ class ChordRuntime {
                     params[name] = slotEntity.name;
             }
         }
-        if (phrase.verbatim) {
+        if (phrase?.verbatim) {
             // `{verbatim:text}` template (loader registration) — the atom is
             // exempt from whitespace collapse, so line structure and interior
             // spacing survive as authored (grammar log 2026-07-10).
             params.text = phrase.variants[0]?.text ?? '';
         }
-        else if (phrase.strategy) {
+        else if (phrase?.strategy) {
             const choice = {
                 kind: 'choice',
-                alternatives: phrase.variants.map((v) => ({ kind: 'literal', text: (0, text_1.withLineBreaks)(v.text) })),
+                alternatives: phrase.variants.map((v) => ({ kind: 'literal', text: (0, text_js_1.withLineBreaks)(v.text) })),
                 selector: exports.STRATEGY_SELECTOR[phrase.strategy],
                 entityId: counter?.entityId ?? 'chord',
                 messageKey: counter?.messageKey ?? overrideKey,
@@ -1220,6 +1865,38 @@ class ChordRuntime {
         }
         return this.rawEvent('chord.phrase', { messageId: overrideKey, params });
     }
+    /**
+     * Evaluate an emit payload (ADR-216) against the live turn context.
+     * Keys pass VERBATIM; number literals become numbers; `true`/`false`
+     * symbols become booleans; other value expressions evaluate through the
+     * shared evaluator (entity refs → world ids, field reads → live values).
+     */
+    emitPayload(fields, ctx) {
+        const data = {};
+        for (const field of fields ?? []) {
+            data[field.key] = this.emitValue(field.value, ctx);
+        }
+        return data;
+    }
+    emitValue(value, ctx) {
+        switch (value.kind) {
+            case 'literal':
+                return value.valueType === 'number' ? Number(value.value) : value.value;
+            case 'value':
+                if (value.value.kind === 'symbol' && (value.value.name === 'true' || value.value.name === 'false')) {
+                    return value.value.name === 'true';
+                }
+                return this.evaluator.evalValue(value.value, ctx);
+            case 'array':
+                return value.items.map((item) => this.emitValue(item, ctx));
+            case 'object': {
+                const nested = {};
+                for (const field of value.fields)
+                    nested[field.key] = this.emitValue(field.value, ctx);
+                return nested;
+            }
+        }
+    }
     rawEvent(type, data) {
         return {
             id: `chord-${type}-${this.eventSeq++}`,
@@ -1235,13 +1912,13 @@ class ChordRuntime {
             return value.id;
         if (value.kind === 'it') {
             if (!ctx.it)
-                throw new errors_1.LoadError('`it` used outside an entity-scoped clause.');
+                throw new errors_js_1.LoadError('`it` used outside an entity-scoped clause.');
             return ctx.it;
         }
         const worldId = this.evaluator.entityValue(value, ctx);
         const irId = this.host.irIdOf(worldId);
         if (!irId)
-            throw new errors_1.LoadError('Cannot change the state of a non-story entity.');
+            throw new errors_js_1.LoadError('Cannot change the state of a non-story entity.');
         return irId;
     }
 }