@adam0white/human-framework 2.18.0 → 2.20.0

package/dist/person.js

@@ -27,17 +27,18 @@ import { ageCharacter, enableCharacterChange, noteCharacterDay, noteCharacterSoc
 import { closeDay, enableYearbook, endDay, noteAnswer, noteCommitments, noteDecision, noteMood, noteOutcome, trimChronicle, } from './chronicle/index.js';
 import { decide as cognitionDecide, desperationOf, prospectiveRoute, scoreAll } from './cognition/index.js';
 import { createConscience, guiltLoad, heldNorms, normVeto, recordDeed, recordRepair, repent, } from './conscience/index.js';
-import { clamp01, clampSigned, createRng, dayOf, isObj, minuteOfDay, round } from './core/index.js';
+import { clamp01, clampSigned, createRng, dayOf, isObj, keysOf, minuteOfDay, round } from './core/index.js';
 import { enableCuriosity, noteCuriosity } from './curiosity/index.js';
 import { ambientBodyParams, ambientModifiers, ambientMood, ambientNeeds } from './environment/index.js';
 import { aptitudeOf, createFamily, pregnancyModifiers } from './family/index.js';
-import { advanceHabits, reinforce, withholdCued } from './habits/index.js';
+import { advanceHabits, HABIT_DEFAULTS, reinforce, withholdCued } from './habits/index.js';
 import { ageYears, learningMultiplier, lifeModifiers } from './lifecourse/index.js';
-import { advanceMemory, createMemory, enableGists, foldGists, learnOutcome, recallByCue, remember, } from './memory/index.js';
+import { advanceMemory, createMemory, enableGists, foldGists, learnOutcome, MEMORY_DEFAULTS, recallByCue, remember, } from './memory/index.js';
 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';
@@ -113,7 +114,56 @@ function fill(keys, given, def) {
     }
     return out;
 }
+function validateHostSetup(spec) {
+    const finite = (n) => Number.isFinite(n);
+    const unit = (n) => finite(n) && n >= 0 && n <= 1;
+    const count = (n) => Number.isSafeInteger(n) && n >= 0;
+    const optional = (n, valid) => n === undefined || valid(n);
+    if (spec.habits !== undefined) {
+        if (!Array.isArray(spec.habits) || spec.habits.length > HABIT_DEFAULTS.maxHabits)
+            throw new RangeError('Invalid habits setup bound');
+        for (const h of spec.habits) {
+            if (!h ||
+                !isObj(h.cue) ||
+                typeof h.action !== 'string' ||
+                h.action.length === 0 ||
+                !unit(h.strength) ||
+                !count(h.repetitions) ||
+                !finite(h.lastAt) ||
+                !optional(h.withheld, count) ||
+                !optional(h.lastWithheldAt, finite) ||
+                !optional(h.craving, unit) ||
+                !optional(h.cue.hour, (n) => finite(n) && n >= 0 && n < 24) ||
+                (h.cue.placeId !== undefined && typeof h.cue.placeId !== 'string') ||
+                (h.cue.after !== undefined && typeof h.cue.after !== 'string'))
+                throw new RangeError('Invalid habit setup record');
+        }
+    }
+    if (spec.expectations !== undefined) {
+        if (!Array.isArray(spec.expectations) || spec.expectations.length > MEMORY_DEFAULTS.maxExpectations)
+            throw new RangeError('Invalid expectations setup bound');
+        for (const e of spec.expectations) {
+            if (!e ||
+                typeof e.key !== 'string' ||
+                e.key.length === 0 ||
+                !isObj(e.needs) ||
+                !unit(e.successRate) ||
+                !count(e.samples) ||
+                !finite(e.valence) ||
+                Math.abs(e.valence) > 1 ||
+                Object.entries(e.needs).some(([key, n]) => ![...PHYSIOLOGICAL_NEEDS, ...PSYCHOLOGICAL_NEEDS].some((need) => need === key) ||
+                    (n !== undefined && !finite(n))))
+                throw new RangeError('Invalid expectation setup record');
+        }
+    }
+}
+/**
+ * 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 function createPerson(spec) {
+    validateHostSetup(spec);
     const now = spec.now ?? 0;
     const traits = fill(TRAIT_KEYS, spec.traits, 0.5);
     const values = fill(VALUE_KEYS, spec.values, 0.5);
@@ -142,6 +192,38 @@ export function createPerson(spec) {
         trace: [],
         nextDecision: 0,
     };
+    if (spec.habits)
+        p.habits = spec.habits.map((h) => {
+            const cue = {};
+            if (h.cue.hour !== undefined)
+                cue.hour = h.cue.hour;
+            if (h.cue.placeId !== undefined)
+                cue.placeId = h.cue.placeId;
+            if (h.cue.after !== undefined)
+                cue.after = h.cue.after;
+            const out = {
+                cue,
+                action: h.action,
+                strength: h.strength,
+                repetitions: h.repetitions,
+                lastAt: h.lastAt,
+            };
+            if (h.craving !== undefined)
+                out.craving = h.craving;
+            if (h.withheld !== undefined)
+                out.withheld = h.withheld;
+            if (h.lastWithheldAt !== undefined)
+                out.lastWithheldAt = h.lastWithheldAt;
+            return out;
+        });
+    if (spec.expectations)
+        p.memory.expectations = spec.expectations.map((e) => ({
+            key: e.key,
+            needs: Object.fromEntries(Object.entries(e.needs)),
+            successRate: e.successRate,
+            samples: e.samples,
+            valence: e.valence,
+        }));
     if (spec.lexicon)
         p.lexicon = structuredClone(spec.lexicon);
     if (spec.retention)
@@ -304,7 +386,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 +574,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 +602,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 +1038,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 +1092,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,
     });
@@ -1378,7 +1480,7 @@ export function finish(p, outcome, opts = {}) {
     const realized = realizedNeedDeltas(act, given, before, after);
     // Felt valence.
     let felt = 0;
-    for (const id of Object.keys(realized)) {
+    for (const id of keysOf(realized)) {
         felt += D.feltGain * (D.feltBase + urgencyOf(before, id)) * (realized[id] ?? 0);
     }
     if (outcome.status === 'failed')
@@ -1429,7 +1531,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 +1657,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}.`;

package/dist/qalb.d.ts

@@ -0,0 +1,28 @@
+/**
+ * SCOPE: a read-only narration lens over retained attention evidence, held norms and conviction,
+ * mood and the three distinct trust stores. Owns no state and supplies no decision input. It does
+ * not infer spiritual health, rank people, judge norms, measure the ruh or compute divine acceptance.
+ * Retained memories are evidence available for narration, not a complete attention history.
+ *
+ * Provenance: research/reconciliation.md §2–4, §7 (Q7: Qur'an 22:46; H9: Bukhari 52 /
+ * Muslim 1599a); research/islamic-foundations.md §2 (qalb as an overlapping interpretive view);
+ * research/decisions.md, “Qalb, nafs, fitra, ʿaql as state”. These support the lens, not a
+ * diagnostic mapping. Sign/zero categories below are engineering descriptions of stored values,
+ * not religious categories. Mood and interpersonal trust imply nothing about faith.
+ */
+import type { Person } from './types.ts';
+export interface QalbDescription {
+    facet: 'attention' | 'held-norm' | 'mood' | 'trust';
+    category: string;
+    /** Every description is attributed to this simulated person's records. */
+    personId: string;
+    text: string;
+    /** Detached identifiers and state paths, never mutable state objects or spiritual scores. */
+    evidence: string[];
+    sources: string[];
+}
+/**
+ * Plain English descriptions; no scalar summary, comparison or hidden update.
+ * Hosts must not present these records as spiritual health or a religious assessment.
+ */
+export declare function qalbReading(p: Person): QalbDescription[];

package/dist/qalb.js

@@ -0,0 +1,67 @@
+/**
+ * Plain English descriptions; no scalar summary, comparison or hidden update.
+ * Hosts must not present these records as spiritual health or a religious assessment.
+ */
+export function qalbReading(p) {
+    const sources = [
+        'research/reconciliation.md §2–4, §7; Q7 (22:46); H9 (Bukhari 52; Muslim 1599a)',
+        'research/islamic-foundations.md §2: Qalb',
+        'research/decisions.md: Qalb, nafs, fitra, ʿaql as state (2026-10-18)',
+    ];
+    const rows = [];
+    const add = (facet, category, text, evidence) => {
+        rows.push({ facet, category, personId: p.id, text, evidence, sources: [...sources] });
+    };
+    const memories = [...p.memory.episodes, ...(p.memory.gists ?? [])];
+    add('attention', memories.length ? 'retained-evidence' : 'no-retained-evidence', memories.length
+        ? 'Their memories retain some experiences. These do not show everything they noticed.'
+        : 'Their records contain no retained experiences. This does not show what they noticed.', memories.map((e) => `memory:${e.id}:${e.kind}`));
+    if (!p.conscience.norms.length)
+        add('held-norm', 'unrecorded', 'Their records contain no held rules.', ['conscience.norms']);
+    for (const n of p.conscience.norms) {
+        add('held-norm', n.conviction === 0 ? 'no-conviction' : 'held-understanding', n.conviction === 0
+            ? 'They have a recorded rule with no stated conviction.'
+            : 'They hold an understanding of this rule. This is their view.', [`norm:${n.normId}`, `standing:${n.standing}`, 'conscience.norms.conviction']);
+    }
+    add('mood', p.affect.mood.valence < 0 ? 'unpleasant' : p.affect.mood.valence > 0 ? 'pleasant' : 'neutral', p.affect.mood.valence < 0
+        ? 'Their recorded mood feels unpleasant.'
+        : p.affect.mood.valence > 0
+            ? 'Their recorded mood feels pleasant.'
+            : 'Their recorded mood feels neutral.', ['affect.mood.valence']);
+    add('mood', p.affect.mood.arousal === 0 ? 'no-arousal' : 'some-arousal', p.affect.mood.arousal === 0
+        ? 'Their recorded mood has no arousal.'
+        : 'Their recorded mood has some arousal.', ['affect.mood.arousal']);
+    // Keep stores distinct. Do not substitute relationship trust for source or advising-voice trust.
+    const ties = p.social.relationships.map((r) => ({
+        store: 'social.relationships',
+        id: r.otherId,
+        trust: r.trust,
+    }));
+    const voices = p.will.voices.map((v) => ({ store: 'will.voices', id: v.voiceId, trust: v.trust }));
+    const sourcesTrust = Object.entries(p.memory.sourceTrust).map(([id, trust]) => ({
+        store: 'memory.sourceTrust',
+        id,
+        trust,
+    }));
+    const trusts = [...ties, ...voices, ...sourcesTrust];
+    if (!trusts.length)
+        add('trust', 'unrecorded', 'Their records contain no learned trust.', [
+            'social.relationships',
+            'will.voices',
+            'memory.sourceTrust',
+        ]);
+    for (const t of trusts) {
+        // 0.5 is the numeric range midpoint, not a faith threshold or personal baseline.
+        const subject = t.store === 'social.relationships'
+            ? 'this person'
+            : t.store === 'will.voices'
+                ? 'this advising voice'
+                : 'this information source';
+        add('trust', t.trust < 0.5 ? 'below-midpoint' : t.trust > 0.5 ? 'above-midpoint' : 'at-midpoint', t.trust < 0.5
+            ? `Their trust in ${subject} is below the middle of its range.`
+            : t.trust > 0.5
+                ? `Their trust in ${subject} is above the middle of its range.`
+                : `Their trust in ${subject} is at the middle of its range.`, [`${t.store}:${t.id}`]);
+    }
+    return rows;
+}

package/dist/review/review.d.ts

@@ -1,3 +1,35 @@
+/**
+ * SCOPE (evening self-review, muhasaba, 2.7.0): once a day, from `at` (default 21:00), a person looks back over
+ * the commitments the chronicle recorded as kept or broken since their last review, and for each one they broke
+ * forms or renews a *resolve*: an if–then intention for that commitment's next occasion (Gollwitzer & Sheeran
+ * 2006, research/reconciliation.md E1). While a matching commitment is pending, the resolve adds one bounded term,
+ * `review:resolve` (each resolve counted once per option, the sum clamped to ±`resolveScale`; 2.9.0: the term's
+ * `ref` is the resolve's key when exactly one resolve weighed in), with the sign of the commitment's own term (toward a duty, away from an abstention's breaking
+ * act), scaled by its strength. Strength grows with diminishing gains at each further lapse, relaxes once the
+ * commitment is kept, and fades over `halfLifeDays` of disuse. Released and excused commitments (exemptions,
+ * sleep, necessity) form no resolve: what was beyond capacity is not held against the person (2:286). The review
+ * also runs when the day closes, if the evening passed without it or a lapse came after it.
+ *
+ * Held readings (`ReviewStyle`): `accounting` is self-accounting as the tradition describes it, naming the lapse
+ * with a view to tomorrow (Q 59:18, whose "tomorrow" most exegetes read as the hereafter, so a daily review is an
+ * inference; ʿUmar's saying reported by Tirmidhi after 2459, an athar, not a prophetic
+ * hadith) and turning back without despair (3:135, 39:53); it forms full resolves and adds no emotion. Reading accounting as
+ * non-punishing, like self-compassion after failure raising the motivation to repair (Breines & Chen 2012, E3),
+ * is an engineering mapping, not a finding about muhasaba. `ruminating` goes over
+ * the lapse abstractly: weaker resolves and a small distress emotion (Watkins 2008, E4: abstract, unconstructive
+ * repetitive thought). `none` never reviews. The review reads only chronicle notes and changes no other module's
+ * state except that one emotion.
+ *
+ * Every number is an engineering default, not fitted. Does not claim: divine reckoning or acceptance, a measure of
+ * piety, repentance as a ruling (tawba conditions are not modelled), effects on sleep onset (Harvey's model, E6, is
+ * not evidence enough), or that review improves outcomes beyond the borrowed if–then shape. It draws no randomness;
+ * without `enableReview` nothing here runs and existing runs replay byte for byte.
+ *
+ * Host notes (2.9.0, docs only). `reviewLine` sets commitment labels into "I didn't keep …" and "Today I kept …",
+ * so a label should be a noun phrase ("my call to Mum", "the evening prayer"), not a verb phrase ("calling Mum").
+ * A recurring commitment lapses on any day its window passes unlived: a host that skips a day (no service, a
+ * fast-forward) should still live, or release, that day's occasions, or the review counts each one as missed.
+ */
 import type { DayRecord, Minute, Person, ReviewRecord, ReviewSpec, ReviewState, ReviewStyle, Term } from '../types.ts';
 export declare const REVIEW_DEFAULTS: {
     /** Default evening review time, minute of day. */

package/dist/review/review.js

@@ -32,6 +32,7 @@
  */
 import { clamp01, dexp, isObj, minuteOfDay, round } from '../core/index.js';
 import { pickLine } from '../narrate/lexicon.js';
+import { labelLine } from '../presentation.js';
 export const REVIEW_DEFAULTS = {
     /** Default evening review time, minute of day. */
     at: 21 * 60,
@@ -198,7 +199,10 @@ export function reviewLine(p, options = {}) {
     const r = st?.last;
     if (!st || st.style === 'none' || !r)
         return undefined;
-    const list = (xs) => xs.length <= 1 ? (xs[0] ?? '') : `${xs.slice(0, -1).join(', ')} and ${xs.at(-1)}`;
+    const list = (items) => {
+        const xs = items.map((item) => labelLine(item, p.lexicon));
+        return xs.length <= 1 ? (xs[0] ?? '') : `${xs.slice(0, -1).join(', ')} and ${xs.at(-1)}`;
+    };
     if (r.missed.length === 0)
         return r.kept.length > 0 ? `Today I kept ${list(r.kept)}.` : undefined;
     if (options.cause) {
@@ -208,7 +212,7 @@ export function reviewLine(p, options = {}) {
             : 'Next time I will make room to return to it.';
         return pickLine('review.cause', `${p.id}:${r.day}`, { cause, missed: list(r.missed), next }, p.lexicon);
     }
-    if (options.variety ?? p.lexicon?.variety) {
+    if (p.lexicon?.plainEnglish || (options.variety ?? p.lexicon?.variety)) {
         return pickLine(`review.${st.style}`, `${p.id}:${r.day}`, { missed: list(r.missed) }, p.lexicon);
     }
     if (st.style === 'ruminating')