@adam0white/human-framework 2.18.0 → 2.20.0

package/dist/narrate/narrate.js

@@ -5,23 +5,23 @@
  * consuming the person's RNG. When memory shaped an option (the record's `recalled` episodes), the narration
  * cites the episode summary. People are named through `nameOf` (lexicon name, role phrase, or id). This is
  * presentation only: nothing here reads back into the simulation, and no claim is made that the templates
- * reflect how people actually explain themselves.
+ * reflect how people actually explain themselves. `Lexicon.plainEnglish` opts into sentence intentions
+ * and summaries; arbitrary host prose is not translated or grammatically inferred.
  */
 import { NORM_SCOPE } from '../conscience/index.js';
+import { labelLine } from '../presentation.js';
 import { capitalize, linesFor, lowerFirst, nameOf, phraseLine, pickLine } from './lexicon.js';
 /**
  * Devotional intention: 'for Allah' for norms the built-in catalog scopes as religious, else 'for God'. The phrase
  * follows the norm, not the person (review 2026-10-03): a host whose people differ in faith overrides
  * `devotion.allah` / `devotion.god` per person through `Person.lexicon` (from `PersonSpec.lexicon`).
  */
-function devotion(p, normId, lex) {
+function devotion(p, normId, lex, say = phraseLine) {
     if (p.values.tradition < 0.6)
-        return normId === undefined
-            ? phraseLine('devotion.keep', {}, lex)
-            : phraseLine('intention.right', {}, lex);
+        return normId === undefined ? say('devotion.keep', {}, lex) : say('intention.right', {}, lex);
     if (normId !== undefined && NORM_SCOPE[normId] === 'religious')
-        return phraseLine('devotion.allah', {}, lex);
-    return phraseLine('devotion.god', {}, lex);
+        return say('devotion.allah', {}, lex);
+    return say('devotion.god', {}, lex);
 }
 const topTerm = (c) => {
     let best;
@@ -33,77 +33,108 @@ const topTerm = (c) => {
 /** Voices the narration addresses as "you" (the host's own voice); other voices are named when a lexicon names them. */
 const PLAYER_VOICES = new Set(['player', 'you']);
 /** Intention string for a decision: 'for Allah', 'to feed myself', 'to keep my promise to X', ... */
-export function intentionFor(p, record, lexicon) {
+function intentionPhrase(p, record, lexicon, selected) {
     const lex = lexicon ?? p.lexicon;
+    const say = (key, vars = {}, lex) => {
+        if (selected)
+            selected.key = key;
+        return phraseLine(key, vars, lex);
+    };
     const chosen = record.considered.find((c) => c.affordanceId === record.chosenAffordanceId);
     if (!chosen)
-        return phraseLine('intention.none', {}, lex);
+        return say('intention.none', {}, lex);
     if (record.suggestion?.verdict === 'complied')
-        return phraseLine('intention.complied', {}, lex);
+        return say('intention.complied', {}, lex);
     if (record.suggestion?.verdict === 'commanded')
-        return phraseLine('intention.commanded', {}, lex);
+        return say('intention.commanded', {}, lex);
     const top = topTerm(chosen);
     if (!top)
-        return phraseLine('intention.default', {}, lex);
+        return say('intention.default', {}, lex);
     const [kind, rest] = [top.source.split(':')[0] ?? '', top.source.slice(top.source.indexOf(':') + 1)];
     switch (kind) {
         case 'need':
             return linesFor(`intention:${rest}`, lex).length > 0
-                ? phraseLine(`intention:${rest}`, {}, lex)
-                : phraseLine('intention.need', { need: rest }, lex);
+                ? say(`intention:${rest}`, {}, lex)
+                : say('intention.need', { need: rest }, lex);
         case 'norm': {
             const tracked = p.agenda.commitments.some((c) => c.normId === rest && c.kind === 'worship');
             if (NORM_SCOPE[rest] === 'religious' || tracked)
-                return devotion(p, rest, lex);
-            return phraseLine('intention.right', {}, lex);
+                return devotion(p, rest, lex, say);
+            return say('intention.right', {}, lex);
         }
         case 'conscience':
-            return phraseLine(rest === 'repair' ? 'intention.repair' : 'intention.repent', {}, lex);
+            return say(rest === 'repair' ? 'intention.repair' : 'intention.repent', {}, lex);
         case 'commitment': {
             const c = p.agenda.commitments.find((x) => x.id === rest);
             if (c?.kind === 'worship')
                 return c.normId === undefined || p.values.tradition < 0.6
-                    ? devotion(p, undefined, lex)
-                    : devotion(p, c.normId, lex);
+                    ? devotion(p, undefined, lex, say)
+                    : devotion(p, c.normId, lex, say);
             if (c?.toId && c.toId !== 'self')
-                return phraseLine('intention.promiseTo', { who: nameOf(p, c.toId, lex) }, lex);
+                return say('intention.promiseTo', { who: nameOf(p, c.toId, lex) }, lex);
             // A host may phrase a labelled commitment its own way ('intention.label:suhoor' → "for suhoor").
             if (c?.label !== undefined && linesFor(`intention.label:${c.label}`, lex).length > 0)
-                return phraseLine(`intention.label:${c.label}`, {}, lex);
-            return phraseLine('intention.word', {}, lex);
+                return say(`intention.label:${c.label}`, {}, lex);
+            return say('intention.word', {}, lex);
         }
         case 'goal': {
             const g = p.agenda.goals.find((x) => x.id === rest);
             return g
-                ? phraseLine('intention.goal', { goal: g.label.replace(/-/g, ' ') }, lex)
-                : phraseLine('intention.goalFallback', {}, lex);
+                ? say('intention.goal', { goal: lex?.plainEnglish ? labelLine(g.label, lex) : g.label.replace(/-/g, ' ') }, lex)
+                : say('intention.goalFallback', {}, lex);
         }
         case 'social':
             return rest === 'group'
-                ? phraseLine('intention.group', {}, lex)
-                : phraseLine('intention.for', { who: nameOf(p, rest, lex) }, lex);
+                ? say('intention.group', {}, lex)
+                : say('intention.for', { who: nameOf(p, rest, lex) }, lex);
         case 'suggestion': {
             const voice = rest.startsWith('remembered:') ? rest.slice('remembered:'.length) : rest;
             if (lex?.names?.[voice] !== undefined && !PLAYER_VOICES.has(voice))
-                return phraseLine('intention.suggestionBy', { who: nameOf(p, voice, lex) }, lex);
-            return phraseLine('intention.suggestion', {}, lex);
+                return say('intention.suggestionBy', { who: nameOf(p, voice, lex) }, lex);
+            return say('intention.suggestion', {}, lex);
         }
         case 'habit':
-            return phraseLine('intention.habit', {}, lex);
+            return say('intention.habit', {}, lex);
         case 'emotion':
-            return phraseLine('intention.emotion', {}, lex);
+            return say('intention.emotion', {}, lex);
         case 'material':
             return lex?.materialMeaning !== undefined
-                ? phraseLine('intention.material.named', { material: lex.materialMeaning }, lex)
-                : phraseLine('intention.material', {}, lex);
+                ? say('intention.material.named', { material: lex.materialMeaning }, lex)
+                : say('intention.material', {}, lex);
         case 'precommit':
-            return phraseLine('intention.precommit', {}, lex);
+            return say('intention.precommit', {}, lex);
         case 'expectation':
-            return phraseLine('intention.expectation', {}, lex);
+            return say('intention.expectation', {}, lex);
         default:
-            return phraseLine('intention.default', {}, lex);
+            return say('intention.default', {}, lex);
     }
 }
+/**
+ * A plain intention is a sentence; legacy intentions remain phrases for existing hosts.
+ * Host-authored sentences pass through. This renderer never changes the record or RNG.
+ */
+export function intentionFor(p, record, lexicon) {
+    const lex = lexicon ?? p.lexicon;
+    const selected = {};
+    const phrase = intentionPhrase(p, record, lex, selected);
+    if (selected.key !== undefined && lex?.lines?.[selected.key] !== undefined)
+        return phrase;
+    if (!lex?.plainEnglish || /[.!?]$/.test(phrase))
+        return phrase;
+    if (phrase === 'nothing to do')
+        return 'There is nothing for me to do.';
+    if (phrase === 'to earn')
+        return 'I want to earn money.';
+    if (phrase.startsWith('to '))
+        return `I want ${phrase}.`;
+    if (phrase.startsWith('because '))
+        return `I am doing this ${phrase}.`;
+    if (phrase.startsWith('for '))
+        return `I am doing this ${phrase}.`;
+    if (phrase === 'out of habit')
+        return 'I am doing this out of habit.';
+    return `My reason is ${phrase}.`;
+}
 function citeEpisode(p, ids, key, lex) {
     if (!ids || ids.length === 0)
         return undefined;
@@ -111,7 +142,7 @@ function citeEpisode(p, ids, key, lex) {
     if (!ep)
         return undefined;
     const summary = ep.summary.endsWith('.') ? ep.summary : `${ep.summary}.`;
-    return pickLine(ep.valence < 0 ? 'cite.bad' : 'cite.good', key, { summary: lowerFirst(summary) }, lex);
+    return pickLine(ep.valence < 0 ? 'cite.bad' : 'cite.good', key, { summary: lex?.plainEnglish ? summary : lowerFirst(summary) }, lex);
 }
 /** A rival within this fraction of the chosen utility makes the choice "a close call". */
 const CLOSE_CALL_FRACTION = 0.2;
@@ -212,13 +243,17 @@ export function voiceLine(p, res, key = res.reason, lexicon) {
         }
         case 'modified': {
             const alt = res.counterOffer?.label ?? phraseLine('voice.modified.default', {}, lex);
-            return pickLine('voice.modified', key, { alt: lowerFirst(alt) }, lex);
+            return pickLine('voice.modified', key, { alt: lex?.plainEnglish ? alt : lowerFirst(alt) }, lex);
         }
         case 'refused': {
             if (res.reason === 'distrust') {
                 const ep = res.episodeId ? p.memory.episodes.find((e) => e.id === res.episodeId) : undefined;
                 if (ep)
-                    return pickLine('voice.distrust.episode', key, { what: lowerFirst(ep.summary.replace(/\.$/, '')) }, lex);
+                    return pickLine('voice.distrust.episode', key, {
+                        what: lex?.plainEnglish
+                            ? ep.summary.replace(/[.!?]$/, '')
+                            : lowerFirst(ep.summary.replace(/\.$/, '')),
+                    }, lex);
                 return pickLine('voice.distrust', key, {}, lex);
             }
             if (res.kind === 'willNot' && res.commitmentId !== undefined) {
@@ -228,7 +263,7 @@ export function voiceLine(p, res, key = res.reason, lexicon) {
                     : duty?.label
                         ? duty.label
                         : phraseLine('voice.omission.default', {}, lex);
-                return pickLine('voice.omission', key, { what }, lex);
+                return pickLine('voice.omission', key, { what: labelLine(what, lex) }, lex);
             }
             if (res.kind === 'willNot' && res.reason.startsWith('duty:')) {
                 // An abstention held as a duty (the fast): the veto names what is being kept, not a forbidden act.
@@ -296,6 +331,13 @@ export function describePerson(p, lexicon) {
     const act = p.activity
         ? `${p.activity.action}${p.activity.targetId ? ` (${p.activity.targetId})` : ''}`
         : phraseLine('describe.idle', {}, lex);
+    if (lex?.plainEnglish) {
+        const state = bits.length > 0 ? bits.join(', ') : phraseLine('describe.well', {}, lex);
+        const activity = p.activity
+            ? `${p.name} is doing this: ${p.activity.affordance.label}${p.activity.targetId ? ` (${nameOf(p, p.activity.targetId, lex)})` : ''}.`
+            : `${p.name} is ${phraseLine('describe.idle', {}, lex)}.`;
+        return phraseLine('describe.line', { name: p.name, act: lex.lines?.['describe.line'] ? act : activity, state }, lex);
+    }
     const state = bits.length > 0 ? bits.join(', ') : phraseLine('describe.well', {}, lex);
     return phraseLine('describe.line', { name: p.name, act, state }, lex);
 }

package/dist/narrate/plain.d.ts

@@ -0,0 +1,7 @@
+/**
+ * SCOPE: literal English narration for hosts that opt in to plain English. Keys, slot names,
+ * template counts and ordering match the legacy English pack, preserving deterministic selection.
+ * Internal word and intention slots remain phrases for composition. This pack changes presentation
+ * only; it does not change simulation state, choose templates, or rewrite host-authored text.
+ */
+export declare const PLAIN_EN_LINES: Readonly<Record<string, readonly string[]>>;

package/dist/narrate/plain.js

@@ -0,0 +1,293 @@
+/**
+ * SCOPE: literal English narration for hosts that opt in to plain English. Keys, slot names,
+ * template counts and ordering match the legacy English pack, preserving deterministic selection.
+ * Internal word and intention slots remain phrases for composition. This pack changes presentation
+ * only; it does not change simulation state, choose templates, or rewrite host-authored text.
+ */
+export const PLAIN_EN_LINES = {
+    // Decision lines by dominant need (no slots).
+    'need:food': [
+        'I am very hungry, so I will eat first.',
+        'My stomach is growling. I will eat first.',
+        'I need to eat.',
+    ],
+    'need:water': [
+        'I am very thirsty. I will get water first.',
+        'I need a drink of water.',
+        'I am thirsty, so I will go to the well.',
+    ],
+    'need:sleep': [
+        'I cannot keep my eyes open. I need to go to bed.',
+        'I am exhausted. I need to sleep.',
+        'I need to sleep before I do anything else.',
+    ],
+    'need:rest': ['I need to sit down for a while.', 'I will rest before I do anything else.'],
+    'need:relief': [
+        'I need to do something about this pain.',
+        'The pain makes it hard to think about anything else.',
+    ],
+    'need:belonging': ["I've been alone too long. I want company.", 'Let me find someone to talk to.'],
+    'need:leisure': ['I need a break from all this.', 'I want to do something easier.'],
+    'need:meaning': ['I want to do something that matters.', 'I want to do something worthwhile for once.'],
+    'need:competence': ['I want to get better at this.', 'Practice will help me work more steadily.'],
+    'need:esteem': ['I want people to see me doing well.', 'I want to show what I can do.'],
+    'need:autonomy': ['I want to make my own choice this time.', 'I will do what I decide to do.'],
+    'need:safety': ['I want to feel safe first.', 'I will be careful for now.'],
+    /** {need} */
+    'need:fallback': ['I need {need}.'],
+    // Decision lines by other dominant sources.
+    'source:habit': [
+        'I am doing what I always do.',
+        'I am doing this out of habit.',
+        'It is what I do at this hour.',
+    ],
+    'source:effort': ['I will choose something easy for now.', 'I will avoid anything strenuous.'],
+    'review.cause': [
+        'After {cause}, I left {missed} undone. {next}',
+        'I left {missed} unfinished after {cause}. {next}',
+        'I left {missed} unfinished because of {cause}. {next}',
+    ],
+    'review.accounting': [
+        'I did not keep {missed}. Next time I will be ready.',
+        'I left {missed} undone. I will prepare for the next occasion.',
+        'Today I left {missed} unfinished. Next time I will make time for it.',
+    ],
+    'review.ruminating': [
+        'I keep thinking about {missed}.',
+        'My thoughts keep returning to {missed}.',
+        'I cannot stop thinking about {missed}.',
+    ],
+    'source:material.named': ['It brings {material}.', 'We can use the {material}.'],
+    'intention.material.named': ['for {material}'],
+    'source:material': ['I can earn money from it.', 'It pays.'],
+    'source:expectation': ['It went well last time.', 'I know what happens when I do this.'],
+    'source:conscience:repair': ['I owe them that much.', 'I have to correct what I did wrong.'],
+    'source:conscience:repent': ['I need to repent to God.', 'I need to stop doing wrong.'],
+    'source:preference': [
+        'I see no reason not to do this.',
+        'This is good enough for me.',
+        'I see no reason to choose something else.',
+    ],
+    // Verbs for refusing a forbidden act ("I won't {verb}").
+    'normVerb:theft': ['steal'],
+    'normVerb:lying': ['lie'],
+    'normVerb:harm-others': ['hurt anyone'],
+    'normVerb:intoxicants': ['drink that'],
+    'normVerb:backbiting': ['say bad things about them when they are absent'],
+    'normVerb:forbidden-food': ['eat that'],
+    'normVerb:default': ['do that'],
+    'normLabel:sawm-ramadan': ['my fast'],
+    'normLabel:default': ['what I have undertaken'],
+    // Lines for fulfilling a held norm.
+    'normFulfil:salah': [
+        'It is time to pray.',
+        'I will pray first. The rest can wait.',
+        'I will pray, then decide what to do.',
+    ],
+    'normFulfil:charity': ['I can spare some for others.', 'I will give to charity while I can.'],
+    'normFulfil:help-neighbor': ['They need help.', 'A neighbour should help.'],
+    'normFulfil:keep-promise': ['I made a promise.', 'I said I would do it.'],
+    'normFulfil:kindness-to-parents': ['I am doing this for my parents.'],
+    'normFulfil:gratitude': ['I should say thank you.'],
+    'normFulfil:default': ['It is the right thing to do.', 'I am doing this because I should.'],
+    // Emotion lines keyed by the tag the tendency acts through.
+    'emotion:social': ['I want company.', "I'd like someone to talk to."],
+    'emotion:worship': ['I want to pray.', 'I want to be near God.'],
+    'emotion:novel': ['I want something different.', "I'm restless."],
+    'emotion:rest': ['I need a break.', "I've had enough for now."],
+    'emotion:comfort': ['I need some comfort.', 'I want to feel safe.'],
+    'emotion:repair': ['I have to correct what I did wrong.', 'I feel troubled by it.'],
+    'emotion:risky': ['I feel like doing it.', 'I see no reason not to do it.'],
+    'emotion:default': ['I feel like doing it.', 'I want to do it because of how I feel.'],
+    // Other decision lines. decision.social: {who}.
+    'decision.nothing': ['There is nothing I can do right now.', 'I can only wait.'],
+    'decision.complied': ['You insisted, so I will do it.', 'I would rather not do it, but you insist.'],
+    'decision.commanded': ['I was told to do it, so I am doing it.', 'I am following an order.'],
+    'decision.commitment': ['I said I would do it, so I will.', 'I have to keep my commitment.'],
+    'decision.goal': ['This helps me get closer to what I want.', 'I am continuing to work toward my goal.'],
+    'decision.social': ['I would like to see {who}.', 'I want to spend time with {who}.'],
+    'decision.suggestion': ['You asked, so I will do it.', 'I will do it since you suggest it.'],
+    'decision.closeCall': ['I almost chose something else.', 'I nearly chose something else.'],
+    /** {summary}: the episode summary, lower-cased, ending with a full stop. */
+    'cite.bad': ['Last time, {summary}'],
+    'cite.good': ['I remember: {summary}'],
+    // Intentions (single phrases). intention.need: {need}; promiseTo/for/suggestionBy: {who}; goal: {goal}.
+    'intention:food': ['to feed myself'],
+    'intention:water': ['to drink'],
+    'intention:sleep': ['to sleep'],
+    'intention:rest': ['to rest'],
+    'intention:relief': ['to ease the pain'],
+    'intention:belonging': ['to be with people'],
+    'intention:leisure': ['to enjoy myself'],
+    'intention:meaning': ['to do something that matters'],
+    'intention:competence': ['to get better'],
+    'intention:esteem': ['to be respected'],
+    'intention:autonomy': ['to choose for myself'],
+    'intention:safety': ['to be safe'],
+    'intention.need': ['to meet my need for {need}'],
+    'intention.none': ['nothing to do'],
+    'intention.complied': ['because you insisted'],
+    'intention.commanded': ['because I was ordered to'],
+    'intention.default': ['because it suits me'],
+    'intention.right': ['because it is right'],
+    'intention.repair': ['to repair the harm I caused'],
+    'intention.repent': ['to repent for my wrongs'],
+    'intention.promiseTo': ['to keep my promise to {who}'],
+    'intention.word': ['to keep my promise'],
+    'intention.goal': ['I want to achieve this goal: {goal}.'],
+    'intention.goalFallback': ['for my goal'],
+    'intention.group': ['to be among people'],
+    'intention.for': ['for {who}'],
+    'intention.suggestion': ['because you asked'],
+    'intention.suggestionBy': ['because {who} asked'],
+    'intention.habit': ['out of habit'],
+    'intention.emotion': ['because I feel like it'],
+    'intention.material': ['to earn'],
+    'intention.precommit': ['because I decided to do this'],
+    'intention.expectation': ['because it worked before'],
+    'devotion.allah': ['for Allah'],
+    'devotion.god': ['for God'],
+    'devotion.keep': ['to keep my devotion'],
+    // Spoken replies to a suggestion. deferred: {After}; modified: {alt}; distrust.episode: {what};
+    // omission: {what}; willNot: {verb}.
+    'voice.assented.trusted': ['I trust you, so I will go.', 'That is a good idea. I will do it.'],
+    'voice.assented': ['I will do it.', 'I agree to do it.'],
+    'voice.complied': ['I will do it since you insist.', 'I will do it if you insist, but I would rather not.'],
+    'voice.commanded': ['I will do it.', 'I will do what you say.'],
+    'voice.commanded.reluctant': [
+        'I will do what you say. I would choose something else.',
+        'I will do it. I do not like it.',
+    ],
+    'voice.underOrders': ['I have my orders.', 'I cannot do that because I am following an order.'],
+    'voice.break': ['I cannot do it now.', 'Leave me alone.'],
+    'voice.downed': ['I cannot get up.', 'I cannot do it because I cannot get up.'],
+    'voice.deferred': ['I cannot do it now. {After}, I will do it.', '{After}, I will do it.'],
+    'voice.deferred.default': ['later'],
+    'voice.modified': ['I will do this instead: {alt}.', 'I will not do that. I will do this: {alt}.'],
+    'voice.modified.default': ['do something similar'],
+    'voice.distrust.episode': [
+        'I will not follow your suggestion again. I remember what happened last time: {what}.',
+        'I will not do it. I remember what happened last time: {what}.',
+    ],
+    'voice.distrust': ['Why would I listen to you?', 'You have pressured me enough.'],
+    'voice.omission': [
+        'I will not miss {what}, whatever you say.',
+        'I will not do it if it means missing {what}.',
+    ],
+    'voice.omission.prayer': ['my prayer'],
+    'voice.omission.default': ['my duty'],
+    'voice.willNot': ['I will not {verb}, whatever you say.', 'I will not do it. I do not {verb}.'],
+    'voice.duty': [
+        'I will not do it while I am keeping {what}.',
+        'I will not do it because it goes against {what}.',
+    ],
+    'voice.asleep': ["I'm asleep."],
+    'voice.survival': ['I cannot do it in my current condition.'],
+    'voice.notSleepy': ["I'm not tired."],
+    'voice.unavailable': ['That is not available here now.', 'I cannot do that here now.'],
+    'voice.invalid': ["That doesn't make sense."],
+    'voice.capacity': ['I cannot do it. I am exhausted.', 'I do not have the strength.'],
+    'voice.skill': ['I do not know how to do that.'],
+    'voice.cannot': ['I cannot do it right now.', 'That is not possible.'],
+    'needFirst:need:food': ['I have to eat first.'],
+    'needFirst:need:water': ['I have to drink first.'],
+    'needFirst:need:sleep': ['I have to sleep first.'],
+    'needFirst:need:rest': ['I have to rest first.'],
+    // Person summary. describe.line: {name} {act} {state}; describe.dead: {name}; describe.feeling: {emotion}.
+    'describe.dead': ['{name} has died.'],
+    'describe.line': ['{name} is {state}. {act}'],
+    'describe.idle': ['idle'],
+    'describe.well': ['well'],
+    'describe.asleep': ['asleep'],
+    'describe.hungry': ['hungry'],
+    'describe.thirsty': ['thirsty'],
+    'describe.tired': ['tired'],
+    'describe.pain': ['in pain'],
+    'describe.feeling': ['feeling {emotion}'],
+    // Names and roles. role.phrase: {poss} {role}.
+    'word.them': ['them'],
+    'role.phrase': ['{poss} {role}'],
+    'role:spouse': ['spouse'],
+    'role:parent': ['parent'],
+    'role:child': ['child'],
+    // Chronicle (third/first person via {Subj}/{subj}/{obj}/{poss}/{Poss}). See `chronicle/story.ts`.
+    /** {label} {n} {days} */
+    'chronicle.prayer.all': ['{Subj} prayed {label} every day.'],
+    'chronicle.prayer.one': ['{Subj} prayed {label}.'],
+    'chronicle.prayer': ['{Subj} prayed {label} on {n} of {days} days.'],
+    'chronicle.prayer.never': ['{Subj} did not pray {label}.'],
+    /** {past} {n} {days} */
+    'chronicle.action.all': ['{Subj} {past} every day.'],
+    'chronicle.action': ['{Subj} {past} on {n} of {days} days.'],
+    /** {kept} {total} {kinds} */
+    'chronicle.kept': ['{Subj} kept {kept} of {total} {kinds}.'],
+    /** {kind}: the one commitment of its kind that day, kept or not */
+    'chronicle.kept.one': ['{Subj} kept {kind}.'],
+    'chronicle.broke.one': ['{Subj} did not keep {kind}.'],
+    /** {who} */
+    'chronicle.trust.up': ['{Subj} came to trust {who} more.'],
+    'chronicle.trust.down': ['{Subj} trusted {who} less by the end.'],
+    /** {gerund} {Gerund} {when} (' around 05:00' or '') */
+    'chronicle.habit.formed': ['{Gerund}{when} had become a habit.'],
+    'chronicle.habit.faded': ['The habit of {gerund}{when} faded.'],
+    /** {hour} */
+    'chronicle.when': [' around {hour}'],
+    /** Verb forms for a prayer by label. {label} */
+    'prayer.base': ['pray {label}'],
+    'prayer.past': ['prayed {label}'],
+    'prayer.gerund': ['praying {label}'],
+    /** {times} ('once' / '3 times') {n} {m} */
+    /** {m} repairs to a wronged person, {k} breaches without a victim the person turned back from */
+    'chronicle.breaches': [
+        '{Subj} acted against {poss} own standards {times} and took action to repair the harm from {m} of those actions.',
+    ],
+    'chronicle.breaches.turned': [
+        '{Subj} acted against {poss} own standards {times} and repented for {k} of those actions.',
+    ],
+    'chronicle.breaches.both': [
+        '{Subj} acted against {poss} own standards {times}, took action to repair the harm from {m} of those actions and repented for {k}.',
+    ],
+    'chronicle.breaches.none': ['{Subj} acted against {poss} own standards {times}.'],
+    /** {n} */
+    'word.once': ['once'],
+    'word.times': ['{n} times'],
+    /** {amount} */
+    'chronicle.material.gain': ['{Subj} gained {amount}.'],
+    'chronicle.material.loss': ['{Subj} lost {amount}.'],
+    /** {kinds} */
+    'chronicle.illness': ['{Subj} became ill with {kinds}.'],
+    'chronicle.mood.up': ['{Poss} mood improved over those days.'],
+    'chronicle.mood.down': ['{Poss} mood worsened over those days.'],
+    /** {summary} */
+    'chronicle.episode': ['This event was memorable for {obj}: {summary}'],
+    /** {day} */
+    'chronicle.died': ['{Subj} died on day {day}.'],
+    'chronicle.empty': ['Nothing was recorded.'],
+    /** {past} {label} */
+    'diff.unprompted': ['By the end {subj} {past} without being told.'],
+    'diff.stillPrompted': ['{Subj} still needed reminders to {base}.'],
+    'diff.started': ['By the end {subj} {past} most days, which {subj} had rarely done before.'],
+    'diff.stopped': ['By the end {subj} had mostly stopped {gerund}.'],
+    /** {who} */
+    'diff.trust.up': ['{Subj} trusted {who} more than before.'],
+    'diff.trust.down': ['{Subj} trusted {who} less than before.'],
+    'diff.mood.up': ['{Poss} mood had improved.'],
+    'diff.mood.down': ['{Poss} mood had worsened.'],
+    'diff.none': ['Little had changed.'],
+    // Plural nouns for commitment kinds in chronicle counts.
+    'kinds:promise': ['promises'],
+    'kinds:duty': ['duties'],
+    'kinds:appointment': ['appointments'],
+    'kinds:worship': ['prayers'],
+    'kinds:job': ['work shifts'],
+    'kinds:abstain': ['abstentions'],
+    'kinds:default': ['commitments'],
+    // Singular, with an article, for a count of one.
+    'kind:promise': ['a promise'],
+    'kind:duty': ['a duty'],
+    'kind:appointment': ['an appointment'],
+    'kind:worship': ['a prayer'],
+    'kind:job': ['a work shift'],
+    'kind:abstain': ['an abstention'],
+    'kind:default': ['a commitment'],
+};

package/dist/observed-reputation.d.ts

@@ -0,0 +1,4 @@
+import { type TraitEffect } from './social/social.ts';
+import type { EntityId, Minute, Person } from './types.ts';
+/** Returns the same detached, sorted misled-source ids as confirm; no relationship alias escapes. */
+export declare function confirmObservedReputation(p: Person, prop: string, truth: boolean, now: Minute, table?: Record<string, TraitEffect>): EntityId[];

package/dist/observed-reputation.js

@@ -0,0 +1,16 @@
+/**
+ * SCOPE: opt-in composition of beliefs.confirm and social.applyReputationBelief, in that order.
+ * Owns no state or formula. This is the Hearsay 2 wrapper: direct observation corrects the belief,
+ * recalibrates its sources and applies the credence change to the subject's relationship. It does
+ * not infer opposite traits, accuse a source of lying, run attention or record a percept. Hosts
+ * supply only observations their person has access to. Existing callers remain unchanged.
+ */
+import { confirm, credence } from './beliefs/beliefs.js';
+import { applyReputationBelief } from './social/social.js';
+/** Returns the same detached, sorted misled-source ids as confirm; no relationship alias escapes. */
+export function confirmObservedReputation(p, prop, truth, now, table) {
+    const before = credence(p, prop);
+    const misled = confirm(p, prop, truth, now);
+    applyReputationBelief(p, prop, before, credence(p, prop), now, table);
+    return misled;
+}

package/dist/partnering/partnering.js

@@ -419,7 +419,7 @@ export function marry(a, b, at, custom = GENERIC_CUSTOM, opts = {}) {
             targetId: y.id,
             valence: 0.9,
             salience: 0.95,
-            summary: 'married',
+            summary: x.lexicon?.plainEnglish ? `I married ${y.name}.` : 'married',
             tags: ['marriage', 'family'],
         });
         feel(x, 'joy', 0.7, `event:marriage:${y.id}`, at, y.id);

package/dist/person.d.ts

@@ -50,6 +50,11 @@ export declare const PERSON_DEFAULTS: {
     nightFrom: number;
     nightTo: number;
 };
+/**
+ * SCOPE (host setup): optional habits and expectations copy authored records, including nested cues and
+ * need deltas, in source order. Invalid numbers, domains or collection bounds reject with RangeError;
+ * setup never clamps, evicts, learns, advances time or consumes RNG. Omitted options keep legacy state.
+ */
 export declare function createPerson(spec: PersonSpec): Person;
 export interface PersonReadout {
     body: BodyReadout;