@adam0white/human-framework 2.17.0 → 2.19.0

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/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.js

@@ -38,6 +38,7 @@ import { intentionFor, narrateDecision, voiceLine } from './narrate/index.js';
 import { advanceNeeds, createNeeds, levelOf, meanSatisfaction, readNeeds, satisfy, urgencyOf, } from './needs/index.js';
 import { widow } from './partnering/index.js';
 import { beginPursuit, enablePersistence, releasePursuit } from './persistence/index.js';
+import { commitmentLabel } from './presentation.js';
 import { considerProjects, enableProjects, noteProjectAct, noteProjectStatus, perceiveProspect, } from './projects/index.js';
 import { enablePromptings, nafsPatterns, notePromptings } from './promptings/index.js';
 import { bodyForecastFor, consumeConsequences, enablePlanning, forecastLine, forecastThresholds, pruneConsequences, receiveConsequences, } from './prospection/index.js';
@@ -304,7 +305,11 @@ function recordMissed(p, broken, now, brokenBy) {
             action,
             actorId: p.id,
             valence: -0.5 * c.importance,
-            summary: `missed ${c.kind}: ${action}`,
+            summary: p.lexicon?.plainEnglish
+                ? c.kind === 'abstain'
+                    ? `I broke this abstention (${commitmentLabel(c, p.lexicon)}) by doing this: ${action.replace(/[-_]/g, ' ')}.`
+                    : `I did not complete this commitment (${commitmentLabel(c, p.lexicon)}). It required this action: ${action.replace(/[-_]/g, ' ')}.`
+                : `missed ${c.kind}: ${action}`,
             tags: ['missed', c.kind, ...(isNight(now) ? ['night'] : [])],
             ...(c.toId !== undefined && c.toId !== 'self' ? { targetId: c.toId } : {}),
         });
@@ -488,7 +493,13 @@ function crisisStep(p, at) {
         action: ev.behaviourId,
         actorId: p.id,
         valence: ev.kind === 'onset' ? -0.6 : 0.2,
-        summary: ev.kind === 'onset' ? `I broke down (${label})` : 'I came back to myself',
+        summary: p.lexicon?.plainEnglish
+            ? ev.kind === 'onset'
+                ? `I had a breakdown (${label}).`
+                : 'My breakdown ended.'
+            : ev.kind === 'onset'
+                ? `I broke down (${label})`
+                : 'I came back to myself',
         tags: ['break', ev.kind],
     });
     if (ev.kind === 'onset')
@@ -510,7 +521,13 @@ function rememberDowned(p, at, kind, reason) {
         action: reason,
         actorId: p.id,
         valence: kind === 'down' ? -0.5 : 0.3,
-        summary: kind === 'down' ? 'I went down and could not get up' : 'I got back on my feet',
+        summary: p.lexicon?.plainEnglish
+            ? kind === 'down'
+                ? 'I could not stand up.'
+                : 'I could stand up again.'
+            : kind === 'down'
+                ? 'I went down and could not get up'
+                : 'I got back on my feet',
         tags: ['downed', kind, reason],
     });
 }
@@ -940,7 +957,9 @@ export function decide(p, affordances, opts = {}) {
                 actorId: res.voiceId,
                 targetId: p.id,
                 valence: -0.3,
-                summary: `${res.voiceId} insisted that I ${chosen?.label ?? 'do as told'}`,
+                summary: p.lexicon?.plainEnglish
+                    ? `${p.lexicon.names?.[res.voiceId] ?? res.voiceId} insisted: ${chosen?.label ?? 'follow the request'}.`
+                    : `${res.voiceId} insisted that I ${chosen?.label ?? 'do as told'}`,
                 tags: ['suggestion', 'insist'],
                 voiceId: res.voiceId,
             });
@@ -992,7 +1011,9 @@ function applyCommandOutcome(p, co, list) {
         actorId: c.voiceId,
         targetId: p.id,
         valence: -0.2 - 0.3 * Math.min(1, co.margin),
-        summary: `${c.voiceId} took charge and had me ${target?.label ?? 'do as ordered'}`,
+        summary: p.lexicon?.plainEnglish
+            ? `${p.lexicon.names?.[c.voiceId] ?? c.voiceId} ordered: ${target?.label ?? 'follow the order'}.`
+            : `${c.voiceId} took charge and had me ${target?.label ?? 'do as ordered'}`,
         tags: ['suggestion', 'command'],
         voiceId: c.voiceId,
     });
@@ -1429,7 +1450,10 @@ export function finish(p, outcome, opts = {}) {
         action: aff.action,
         actorId: p.id,
         valence: felt,
-        summary: outcome.summary ?? `${aff.label}: ${outcome.status}`,
+        summary: outcome.summary ??
+            (p.lexicon?.plainEnglish
+                ? `${outcome.status === 'completed' ? 'I completed' : outcome.status === 'interrupted' ? 'I was interrupted during' : 'I could not complete'} this action: ${aff.label}.`
+                : `${aff.label}: ${outcome.status}`),
         tags: [...(aff.tags ?? []), outcome.status, ...(isNight(act.startedAt) ? ['night'] : [])],
     };
     if (aff.targetId !== undefined)
@@ -1552,5 +1576,8 @@ export function nafsReading(p) {
  */
 export function bodyForecast(p, aff) {
     const spans = bodyForecastFor(p, aff, lifeModifiers(p), fastingCtx(p));
-    return { spans, line: forecastLine(spans, forecastThresholds(aff)) };
+    return {
+        spans,
+        line: forecastLine(spans, forecastThresholds(aff), { plainEnglish: p.lexicon?.plainEnglish }),
+    };
 }

package/dist/presentation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SCOPE: opt-in English display labels for framework-owned tokens. These readers do not rewrite stored
+ * identifiers, labels or host prose. They do not change decisions, religious understandings or RNG state.
+ * Unknown reason codes have no plain display text; the host supplies their meaning.
+ */
+import type { Commitment, Lexicon, NormDefinition } from './types.ts';
+export declare function labelLine(label: string, lexicon?: Lexicon): string;
+export declare function commitmentLabel(c: Pick<Commitment, 'label' | 'kind'>, lexicon?: Lexicon): string;
+export declare function normLabel(norm: Pick<NormDefinition, 'id' | 'label'>, lexicon?: Lexicon): string;
+export declare function reasonLine(reason: string, lexicon?: Lexicon): string;

package/dist/presentation.js

@@ -0,0 +1,88 @@
+const LABELS = {
+    Fajr: 'the dawn prayer',
+    Dhuhr: 'the midday prayer',
+    Asr: 'the afternoon prayer',
+    Maghrib: 'the sunset prayer',
+    Isha: 'the night prayer',
+    suhoor: 'the meal before dawn',
+    iftar: 'the meal to end the fast',
+    'Eid prayer': 'the Eid holiday prayer',
+    'make-friend': 'making a friend',
+    'master-skill': 'learning a skill',
+    'earn-respect': 'earning respect',
+    serve: 'helping others',
+    'make-up': 'a missed commitment to complete later',
+};
+export function labelLine(label, lexicon) {
+    if (!lexicon?.plainEnglish)
+        return label;
+    const known = Object.hasOwn(LABELS, label) ? LABELS[label] : undefined;
+    if (known !== undefined)
+        return known;
+    const missedName = label.startsWith('make-up ') ? label.slice(8) : '';
+    const missed = Object.hasOwn(LABELS, missedName) ? LABELS[missedName] : undefined;
+    return missed === undefined ? label : `${missed}, performed later because it was missed`;
+}
+export function commitmentLabel(c, lexicon) {
+    if (lexicon?.plainEnglish && c.label === undefined) {
+        const kinds = {
+            worship: 'my prayer',
+            promise: 'my promise',
+            duty: 'my duty',
+            appointment: 'my appointment',
+            job: 'my work shift',
+            abstain: 'my abstention',
+        };
+        return Object.hasOwn(kinds, c.kind) ? (kinds[c.kind] ?? c.kind) : c.kind;
+    }
+    return labelLine(c.label ?? c.kind, lexicon);
+}
+export function normLabel(norm, lexicon) {
+    if (!lexicon?.plainEnglish)
+        return norm.label;
+    const labels = {
+        zakat: 'Give the required share of wealth to those entitled to it',
+        charity: 'Give voluntary charity',
+        backbiting: 'Speaking about someone in a way they would dislike',
+        'kin-marriage': 'Do not marry someone forbidden by the held rules about family relationships',
+    };
+    return Object.hasOwn(labels, norm.id) ? (labels[norm.id] ?? norm.label) : norm.label;
+}
+export function reasonLine(reason, lexicon) {
+    if (!lexicon?.plainEnglish)
+        return reason;
+    const lines = {
+        dead: 'The person has died.',
+        invalid: 'That action does not make sense.',
+        break: 'I cannot do that during this breakdown.',
+        downed: 'I cannot get up.',
+        asleep: 'I am asleep.',
+        'not-sleepy': 'I am not sleepy enough.',
+        capacity: 'I cannot manage that physically.',
+        unavailable: 'That option is not available.',
+        distrust: 'I do not trust this advice.',
+        commanded: 'I am following an order.',
+        command: 'I am following an order.',
+        busy: 'I am doing something else right now.',
+        'need:food': 'I need to eat first.',
+        'need:water': 'I need to drink first.',
+        'need:sleep': 'I need to sleep first.',
+        'need:rest': 'I need to rest first.',
+        'need:survival': 'I need to meet an urgent bodily need first.',
+    };
+    if (Object.hasOwn(lines, reason))
+        return lines[reason] ?? '';
+    if (reason.startsWith('duty:'))
+        return 'I need to keep this duty.';
+    if (reason.startsWith('norm:'))
+        return 'This conflicts with a rule I hold.';
+    if (reason.startsWith('rule:'))
+        return 'This conflicts with a personal rule I set.';
+    if (reason.startsWith('capacity:'))
+        return 'I cannot manage that physically.';
+    if (reason.startsWith('skill:'))
+        return 'I do not have enough skill for that.';
+    if (reason.startsWith('voice:'))
+        return 'I am following another person’s request.';
+    return '';
+}

package/dist/promptings/promptings.d.ts

@@ -72,6 +72,7 @@ export declare function notePromptings(p: Person, seen: readonly PromptingSeen[]
 /** Vocabulary for one prompt under a held reading (narration only; it changes nothing). */
 export declare function promptingLine(reading: PromptingReading, outcome: PromptingRecord['outcome'], kind?: PromptingResponseKind, options?: {
     voice?: 'first' | 'third';
+    plainEnglish?: boolean;
 }): string;
 /** Read-only summary of recent prompts (a lens; computes nothing new about the person). */
 export interface PromptingsReadingView {

package/dist/promptings/promptings.js

@@ -257,6 +257,34 @@ export function notePromptings(p, seen, chosenId, now) {
 }
 /** Vocabulary for one prompt under a held reading (narration only; it changes nothing). */
 export function promptingLine(reading, outcome, kind, options = {}) {
+    if (options.plainEnglish) {
+        const third = options.voice === 'third';
+        const who = third ? 'The person' : 'I';
+        const felt = third
+            ? 'The person felt an urge.'
+            : {
+                whisper: 'I felt a whisper urging me to act.',
+                inclination: 'I felt an urge from my own desires.',
+                intrusion: 'I had a thought. It does not define who I am.',
+                fault: 'I had a thought that felt like wrongdoing.',
+                none: 'I felt an urge.',
+            }[reading];
+        if (outcome === 'assented') {
+            const urge = third
+                ? 'The person felt an urge.'
+                : reading === 'whisper' || reading === 'inclination'
+                    ? felt
+                    : 'I felt an urge.';
+            return `${urge} ${who} acted on it.`;
+        }
+        if (outcome === 'passed')
+            return `${felt} It passed without action.`;
+        if (kind === 'redirect')
+            return `${felt} ${who} chose something else and let it pass.`;
+        if (kind === 'refuge')
+            return `${felt} ${who} sought refuge and let it pass.`;
+        return `${felt} ${who} did not act on it.`;
+    }
     // Plain third-person observations describe the response, without inferring the prompt's origin.
     if (options.voice === 'third') {
         if (outcome === 'assented')
@@ -313,7 +341,9 @@ export function promptingsReading(p, now = p.now) {
             practice: round(practiceAt(r, now, halfLifeOf(s))),
             ...(r.cue !== undefined ? { cue: r.cue } : {}),
         })),
-        lines: s.recent.slice(-5).map((r) => promptingLine(s.reading, r.outcome, kindOf(r.responseId))),
+        lines: s.recent
+            .slice(-5)
+            .map((r) => promptingLine(s.reading, r.outcome, kindOf(r.responseId), { plainEnglish: p.lexicon?.plainEnglish })),
     };
     if (s.readingSource !== undefined)
         view.readingSource = s.readingSource;
@@ -329,19 +359,25 @@ export function nafsPatterns(p, inputs) {
             name: 'urging',
             ref: 'Qur’an 12:53',
             evident: assentedAgainstNorm.length > 0,
-            evidence: `${assentedAgainstNorm.length} recent prompts followed against a held norm`,
+            evidence: p.lexicon?.plainEnglish
+                ? `The person acted on ${assentedAgainstNorm.length} recent urges despite a rule they hold.`
+                : `${assentedAgainstNorm.length} recent prompts followed against a held norm`,
         },
         {
             name: 'reproaching',
             ref: 'Qur’an 75:2',
             evident: reproach,
-            evidence: `open-breach weight ${round(inputs.guiltLoad, 2)}, felt guilt ${round(inputs.guilt, 2)}`,
+            evidence: p.lexicon?.plainEnglish
+                ? `The weight of unresolved breaches is ${round(inputs.guiltLoad, 2)}. The strength of felt guilt is ${round(inputs.guilt, 2)}.`
+                : `open-breach weight ${round(inputs.guiltLoad, 2)}, felt guilt ${round(inputs.guilt, 2)}`,
         },
         {
             name: 'at rest',
             ref: 'Qur’an 89:27',
             evident: letPass > 0 && assentedAgainstNorm.length === 0 && !reproach,
-            evidence: `${letPass} recent prompts let pass, none followed against a norm, no felt reproach`,
+            evidence: p.lexicon?.plainEnglish
+                ? `${letPass} recent urges passed without action. ${assentedAgainstNorm.length} were acted on against a held rule. Current guilt or unresolved breach: ${reproach ? 'yes' : 'no'}.`
+                : `${letPass} recent prompts let pass, none followed against a norm, no felt reproach`,
         },
     ];
 }

package/dist/prospection/forecast.d.ts

@@ -54,4 +54,6 @@ export declare function bodyForecastTerm(p: Person, aff: Affordance, mods: LifeM
 export declare function forecastLine(spans: readonly BodyForecastSpan[], at?: {
     comfortAt: number;
     spentAt: number;
+}, options?: {
+    plainEnglish?: boolean;
 }): string;

package/dist/prospection/forecast.js

@@ -103,7 +103,7 @@ export function bodyForecastTerm(p, aff, mods, perception) {
     return v < 0 ? { source: 'forecast:body', value: v } : undefined;
 }
 /** A first-person line for the forecast (narration only); `at` is the offer's thresholds (2.8.0, default as before). */
-export function forecastLine(spans, at = FORECAST_DEFAULTS) {
+export function forecastLine(spans, at = FORECAST_DEFAULTS, options = {}) {
     const after = spans.slice(1);
     if (after.length === 0)
         return '';
@@ -111,6 +111,20 @@ export function forecastLine(spans, at = FORECAST_DEFAULTS) {
     for (const s of after)
         if (s.worst > w.worst)
             w = s;
+    if (options.plainEnglish) {
+        const label = w.label === 'after' ? 'what comes next' : w.label;
+        const state = {
+            fatigue: 'too tired',
+            sleepiness: 'too sleepy',
+            hunger: 'too hungry',
+            thirst: 'too thirsty',
+        }[w.worstOf];
+        if (w.worst >= at.spentAt)
+            return `I can do this. I will be ${state} for ${label}.`;
+        if (w.worst >= at.comfortAt)
+            return `I can do this, but ${label} will be hard.`;
+        return `I can manage ${label} afterward.`;
+    }
     const what = { fatigue: 'spent', sleepiness: 'too sleepy', hunger: 'too hungry', thirst: 'too thirsty' }[w.worstOf];
     if (w.worst >= at.spentAt)
         return `I can do it, but I'll be ${what} for ${w.label}.`;