@adam0white/human-framework 2.18.0 → 2.20.0

package/dist/scenarios/village.js

@@ -257,6 +257,7 @@ export function createVillage(people, opts) {
         return out;
     };
     const resolve = (p, act, reason) => {
+        const say = (legacy, plain) => (p.lexicon?.plainEnglish ? plain : legacy);
         const now = p.now;
         state.now = Math.max(state.now, now);
         const aff = act.affordance;
@@ -272,12 +273,16 @@ export function createVillage(people, opts) {
             // Partial work counts: a field shift left early yields and pays pro rata for the time put in.
             const span = Math.max(1, act.endsAt - act.startedAt);
             const progress = clamp01((now - act.startedAt) / span);
-            const out = { ...base, status: 'interrupted', summary: `${aff.label}: interrupted` };
+            const out = {
+                ...base,
+                status: 'interrupted',
+                summary: say(`${aff.label}: interrupted`, `I was interrupted during the task “${aff.label}”.`),
+            };
             if (act.action === 'work-field' && progress > 0) {
                 state.food += V.fieldYield * progress;
                 out.material = V.wage * progress;
                 out.needs = { competence: 0.1 * progress };
-                out.summary = `${aff.label}: stopped ${Math.round(progress * 100)}% of the way through`;
+                out.summary = say(`${aff.label}: stopped ${Math.round(progress * 100)}% of the way through`, `I stopped the task “${aff.label}” after completing ${Math.round(progress * 100)}% of it.`);
             }
             return out;
         }
@@ -291,17 +296,29 @@ export function createVillage(people, opts) {
             case 'eat':
                 if (state.food >= 1) {
                     state.food -= 1;
-                    return done({ ...base, needs: { food: 0.6 }, summary: 'ate at the kitchen' });
+                    return done({
+                        ...base,
+                        needs: { food: 0.6 },
+                        summary: say('ate at the kitchen', 'I ate at the kitchen.'),
+                    });
                 }
-                return { ...base, status: 'failed', summary: 'found the kitchen empty' };
+                return {
+                    ...base,
+                    status: 'failed',
+                    summary: say('found the kitchen empty', 'I found the kitchen empty.'),
+                };
             case 'drink':
-                return done({ ...base, needs: { water: 0.6 }, summary: 'drank at the well' });
+                return done({
+                    ...base,
+                    needs: { water: 0.6 },
+                    summary: say('drank at the well', 'I drank at the well.'),
+                });
             case 'sleep':
-                return done({ ...base, summary: 'slept' });
+                return done({ ...base, summary: say('slept', 'I slept.') });
             case 'rest':
-                return done({ ...base, needs: { leisure: 0.1 }, summary: 'rested' });
+                return done({ ...base, needs: { leisure: 0.1 }, summary: say('rested', 'I rested.') });
             case 'wait':
-                return done({ ...base, summary: 'waited' });
+                return done({ ...base, summary: say('waited', 'I waited.') });
             case 'work-field': {
                 const ok = chance(state.rng, successChance(p, 'farming', 0.3, capacity));
                 if (ok) {
@@ -310,7 +327,7 @@ export function createVillage(people, opts) {
                         ...base,
                         needs: { competence: 0.1 },
                         material: V.wage,
-                        summary: 'worked the field; a good shift',
+                        summary: say('worked the field; a good shift', 'I worked in the field. The shift went well.'),
                     });
                 }
                 state.food += 1;
@@ -318,7 +335,7 @@ export function createVillage(people, opts) {
                     ...base,
                     status: 'failed',
                     needs: { competence: 0.02 },
-                    summary: 'worked the field; a poor shift',
+                    summary: say('worked the field; a poor shift', 'I worked in the field. The shift went poorly.'),
                 };
             }
             case 'forage': {
@@ -329,23 +346,35 @@ export function createVillage(people, opts) {
                         status: 'failed',
                         injury: { part: 'leg', severity: risk.severity, healRatePerDay: 0.1 },
                         summary: isNightAt(act.startedAt)
-                            ? 'went to the forest at night and got hurt by an animal'
-                            : 'got hurt by an animal in the forest',
+                            ? say('went to the forest at night and got hurt by an animal', 'I went to the forest at night. An animal hurt me.')
+                            : say('got hurt by an animal in the forest', 'An animal hurt me in the forest.'),
                     };
                 }
                 state.food += V.forageYield;
-                return done({ ...base, needs: { food: 0.3 }, summary: 'foraged in the forest' });
+                return done({
+                    ...base,
+                    needs: { food: 0.3 },
+                    summary: say('foraged in the forest', 'I gathered food in the forest.'),
+                });
             }
             case 'cook': {
                 const ok = chance(state.rng, successChance(p, 'cooking', 0.3, capacity));
                 if (ok) {
                     state.food += V.cookYield;
-                    return done({ ...base, needs: { competence: 0.08 }, summary: 'cooked a good meal' });
+                    return done({
+                        ...base,
+                        needs: { competence: 0.08 },
+                        summary: say('cooked a good meal', 'I cooked a good meal.'),
+                    });
                 }
-                return { ...base, status: 'failed', summary: 'burnt the meal' };
+                return { ...base, status: 'failed', summary: say('burnt the meal', 'I burnt the meal.') };
             }
             case 'pray':
-                return done({ ...base, needs: { meaning: 0.1 }, summary: 'prayed at the mosque' });
+                return done({
+                    ...base,
+                    needs: { meaning: 0.1 },
+                    summary: say('prayed at the mosque', 'I prayed at the mosque.'),
+                });
             case 'apologize': {
                 const other = act.targetId;
                 if (other !== undefined) {
@@ -357,10 +386,13 @@ export function createVillage(people, opts) {
                         targetId: other,
                         valence: 0.3,
                         salience: 0.6,
-                        summary: `${p.name} apologised`,
+                        summary: say(`${p.name} apologised`, `${p.name} apologised.`),
                     });
                 }
-                return done({ ...base, summary: `apologised to ${other ?? 'a neighbour'}` });
+                return done({
+                    ...base,
+                    summary: say(`apologised to ${other ?? 'a neighbour'}`, `I apologised to ${other ?? 'a neighbour'}.`),
+                });
             }
             case 'chat': {
                 const other = aff.with?.[0];
@@ -373,13 +405,13 @@ export function createVillage(people, opts) {
                         targetId: other,
                         valence: 0.3,
                         salience: 0.4,
-                        summary: `${p.name} stopped to chat`,
+                        summary: say(`${p.name} stopped to chat`, `${p.name} stopped to chat.`),
                     });
                 }
                 return done({
                     ...base,
                     needs: { belonging: 0.3, leisure: 0.1 },
-                    summary: `chatted with ${other ?? 'a neighbour'}`,
+                    summary: say(`chatted with ${other ?? 'a neighbour'}`, `I chatted with ${other ?? 'a neighbour'}.`),
                 });
             }
             case 'help': {
@@ -394,13 +426,13 @@ export function createVillage(people, opts) {
                         valence: 0.5,
                         salience: 0.6,
                         norms: [{ normId: 'help-neighbor', relation: 'fulfills' }],
-                        summary: `${p.name} helped with the work`,
+                        summary: say(`${p.name} helped with the work`, `${p.name} helped with the work.`),
                     });
                 }
                 return done({
                     ...base,
                     needs: { meaning: 0.2, esteem: 0.05 },
-                    summary: `helped ${other ?? 'a neighbour'}`,
+                    summary: say(`helped ${other ?? 'a neighbour'}`, `I helped ${other ?? 'a neighbour'}.`),
                     percepts: other
                         ? [
                             {
@@ -411,7 +443,7 @@ export function createVillage(people, opts) {
                                 targetId: p.id,
                                 valence: 0.3,
                                 salience: 0.5,
-                                summary: `${other} said thank you`,
+                                summary: say(`${other} said thank you`, `${other} said thank you.`),
                             },
                         ]
                         : [],
@@ -429,13 +461,18 @@ export function createVillage(people, opts) {
                         valence: -0.5,
                         salience: 0.8,
                         norms: [{ normId: 'theft', relation: 'violates' }],
-                        summary: `${p.name} took bread from the house`,
+                        summary: say(`${p.name} took bread from the house`, `${p.name} took bread from the house.`),
                     });
                 }
-                return done({ ...base, needs: { food: 0.5 }, material: 1, summary: 'took bread that was not mine' });
+                return done({
+                    ...base,
+                    needs: { food: 0.5 },
+                    material: 1,
+                    summary: say('took bread that was not mine', 'I took bread that was not mine.'),
+                });
             }
             default:
-                return done({ ...base, summary: `${aff.label}: done` });
+                return done({ ...base, summary: say(`${aff.label}: done`, `I completed the task “${aff.label}”.`) });
         }
     };
     const perceptsFor = (p, since, until) => {

package/dist/sim/longrun.js

@@ -77,11 +77,28 @@ export function liveCommunity(c, until, opts) {
                 days[p.id] = list;
             }
             for (const kind of r.onsets)
-                events.push({ at: r.at, personId: p.id, kind: 'onset', detail: `${p.name}: ${kind}` });
+                events.push({
+                    at: r.at,
+                    personId: p.id,
+                    kind: 'onset',
+                    detail: p.lexicon?.plainEnglish ? `${p.name} developed ${kind}.` : `${p.name}: ${kind}`,
+                });
             if (r.stage)
-                events.push({ at: r.at, personId: p.id, kind: 'stage', detail: `${p.name} is now ${r.stage}` });
+                events.push({
+                    at: r.at,
+                    personId: p.id,
+                    kind: 'stage',
+                    detail: p.lexicon?.plainEnglish
+                        ? `${p.name} entered the ${r.stage} stage of life.`
+                        : `${p.name} is now ${r.stage}`,
+                });
             if (r.died) {
-                events.push({ at: r.at, personId: p.id, kind: 'died', detail: `${p.name} died` });
+                events.push({
+                    at: r.at,
+                    personId: p.id,
+                    kind: 'died',
+                    detail: p.lexicon?.plainEnglish ? `${p.name} died.` : `${p.name} died`,
+                });
                 died.push(p);
             }
         }

package/dist/sim/sim.d.ts

@@ -280,7 +280,7 @@ export declare function declineJoint(c: Community, proposal: JointProposal, prop
  * activities are resolved as interrupted first, then the proposer begins the offer and each partner their
  * mirror. Returns the activities begun (empty while other partners have yet to answer).
  */
-export declare function acceptJoint(c: Community, world: World, proposal: JointProposal, partner: Person, partnerRecord: DecisionRecord, log?: (e: SimEvent) => void): Activity[];
+export declare function acceptJoint(c: Community, world: World, proposal: JointProposal, partner: Person, partnerRecord: DecisionRecord, writeLog?: (e: SimEvent) => void): Activity[];
 /**
  * Chance that `lead` succeeds at a skilled task with `partners` helping: `successChance` with
  * support = Σ partner skill × partner capacity / max(difficulty, 0.1), clamped to 0..1.

package/dist/sim/sim.js

@@ -79,6 +79,54 @@ function finishOpts(world) {
         o.transfer = world.skillTransfer;
     return o;
 }
+/** Complete sentences for generated event details. Host outcome summaries bypass this reader. */
+function plainEventDetail(p, event) {
+    const name = p.name;
+    const detail = event.detail;
+    switch (event.kind) {
+        case 'decide':
+            return detail;
+        case 'idle':
+            return `${name} did not choose a task.`;
+        case 'died':
+            return `${name} died.`;
+        case 'begin':
+        case 'continue':
+        case 'finish':
+            return detail;
+        case 'perceive': {
+            const counts = /^(\d+)\/(\d+) percepts$/.exec(detail);
+            return counts ? `${name} noticed ${counts[1]} of ${counts[2]} events.` : `${name} noticed “${detail}”.`;
+        }
+        case 'interrupt':
+            return `${name} was interrupted by the event “${detail.replace(/^percept:/, '')}”.`;
+        case 'propose':
+            return `${name} proposed the shared task “${detail}”.`;
+        case 'accept':
+            return `${name} joined the shared task “${detail.replace(/^joins /, '')}”.`;
+        case 'decline':
+            return `${name} declined the shared task “${detail.replace(/^declined /, '')}”.`;
+        case 'converse':
+            return `${name} spoke. The exchange included: “${detail}”.`;
+        case 'contagion':
+            return `${name} ${detail}.`;
+        case 'command':
+            return `${name} received the order “${detail}”.`;
+        case 'release':
+            return `${name} was released from the order.`;
+        case 'onset':
+            return `${name} developed the condition “${detail}”.`;
+        case 'stage':
+            return `${name} entered the life stage “${detail}”.`;
+    }
+}
+function taskEndLine(p, label, status) {
+    if (status === 'completed')
+        return `${p.name} completed the task “${label}”.`;
+    if (status === 'failed')
+        return `${p.name} failed to complete the task “${label}”.`;
+    return `${p.name} was interrupted during the task “${label}”.`;
+}
 /**
  * Whether standing suggestion `s` is heard by `p` at a decision over `affordances` (standing-advice SCOPE): its target
  * must be on offer or be the running activity, and if the action keeps commitments and was completed since the suggestion was given, doing it
@@ -208,7 +256,7 @@ export function tellDeath(c, dead, at, opts = {}) {
                 targetId: dead.id,
                 valence: -0.8,
                 salience: 0.9,
-                summary: `${dead.name} died`,
+                summary: q.lexicon?.plainEnglish ? `${dead.name} died.` : `${dead.name} died`,
             },
         ]);
         // A spouse is widowed even if the news went unattended.
@@ -355,7 +403,11 @@ export function declineJoint(c, proposal, proposer) {
  * activities are resolved as interrupted first, then the proposer begins the offer and each partner their
  * mirror. Returns the activities begun (empty while other partners have yet to answer).
  */
-export function acceptJoint(c, world, proposal, partner, partnerRecord, log = () => { }) {
+export function acceptJoint(c, world, proposal, partner, partnerRecord, writeLog = () => { }) {
+    const log = (e) => {
+        const person = personById(c, e.personId);
+        writeLog(person?.lexicon?.plainEnglish ? { ...e, detail: plainEventDetail(person, e) } : e);
+    };
     if (proposal.status !== 'pending' || !proposal.partnerIds.includes(partner.id))
         return [];
     if (!proposal.accepted.includes(partner.id))
@@ -387,7 +439,9 @@ export function acceptJoint(c, world, proposal, partner, partnerRecord, log = ()
                 at,
                 personId: person.id,
                 kind: 'finish',
-                detail: `${act.action} ${outcome.status}`,
+                detail: person.lexicon?.plainEnglish
+                    ? taskEndLine(person, act.affordance.label, outcome.status)
+                    : `${act.action} ${outcome.status}`,
                 decisionId: act.decisionId,
                 affordanceId: act.affordanceId,
                 action: act.action,
@@ -404,7 +458,9 @@ export function acceptJoint(c, world, proposal, partner, partnerRecord, log = ()
                 at,
                 personId: person.id,
                 kind: 'begin',
-                detail: `${offer.label} (joint ${proposal.id})`,
+                detail: person.lexicon?.plainEnglish
+                    ? `${person.name} began the shared task “${offer.label}”. ${record.intention}`
+                    : `${offer.label} (joint ${proposal.id})`,
                 decisionId: record.id,
                 affordanceId: offer.id,
                 action: offer.action,
@@ -703,9 +759,12 @@ export function stepCommunity(c, world, until, opts = {}) {
     // Communities created before joint support (plain JSON from an older host) get the new bookkeeping.
     c.interrupts ??= {};
     c.joint ??= { nextId: 0, proposals: [], excluded: {} };
-    const log = (e) => {
-        if (events.length < maxEvents)
-            events.push(e);
+    // Presentation only: retain host-authored summaries and every event field other than generated detail.
+    const log = (e, authored = false) => {
+        const person = personById(c, e.personId);
+        if (events.length < maxEvents) {
+            events.push(person?.lexicon?.plainEnglish && !authored ? { ...e, detail: plainEventDetail(person, e) } : e);
+        }
     };
     const contagion = opts.contagion ?? true;
     c.queued ??= {};
@@ -772,14 +831,17 @@ export function stepCommunity(c, world, until, opts = {}) {
                 at: t,
                 personId: p.id,
                 kind: 'finish',
-                detail: outcome.summary ?? `${act.action} ${outcome.status}`,
+                detail: outcome.summary ??
+                    (p.lexicon?.plainEnglish
+                        ? taskEndLine(p, act.affordance.label, outcome.status)
+                        : `${act.action} ${outcome.status}`),
                 decisionId: act.decisionId,
                 affordanceId: act.affordanceId,
                 action: act.action,
             };
             if (report)
                 ev.status = report.status;
-            log(ev);
+            log(ev, outcome.summary !== undefined);
             if (outcome.status === 'completed') {
                 noteStandingDone(c, p, act, t);
                 if (pairMinute !== t) {
@@ -837,14 +899,22 @@ export function stepCommunity(c, world, until, opts = {}) {
                 detail: `joins ${acceptedProposal.offer.label}`,
                 jointId: acceptedProposal.id,
             });
-            acceptJoint(c, world, acceptedProposal, p, record, log);
+            acceptJoint(c, world, acceptedProposal, p, record, (event) => log(event, true));
             continue;
         }
         const chosen = affordances.find((a) => a.id === record.chosenAffordanceId);
         const continuing = act !== null && (record.chosenAffordanceId === null || record.chosenAffordanceId === act.affordanceId);
         if (act && continuing) {
             reviewed(p);
-            log({ at: t, personId: p.id, kind: 'continue', detail: act.action, affordanceId: act.affordanceId });
+            log({
+                at: t,
+                personId: p.id,
+                kind: 'continue',
+                detail: p.lexicon?.plainEnglish
+                    ? `${p.name} continued the task “${act.affordance.label}”.`
+                    : act.action,
+                affordanceId: act.affordanceId,
+            });
             continue;
         }
         if (chosen && isJointOffer(c, p, chosen)) {
@@ -854,11 +924,15 @@ export function stepCommunity(c, world, until, opts = {}) {
                 at: t,
                 personId: p.id,
                 kind: proposal.status === 'declined' ? 'decline' : 'propose',
-                detail: `${chosen.label} with ${proposal.partnerIds.join(', ')}`,
+                detail: p.lexicon?.plainEnglish
+                    ? proposal.status === 'declined'
+                        ? `The shared task “${chosen.label}” could not start because a partner was unavailable.`
+                        : `${chosen.label} with ${proposal.partnerIds.map((id) => personById(c, id)?.name ?? id).join(', ')}`
+                    : `${chosen.label} with ${proposal.partnerIds.join(', ')}`,
                 affordanceId: chosen.id,
                 action: chosen.action,
                 jointId: proposal.id,
-            });
+            }, Boolean(p.lexicon?.plainEnglish && proposal.status === 'declined'));
             continue;
         }
         if (act) {
@@ -868,7 +942,9 @@ export function stepCommunity(c, world, until, opts = {}) {
                 at: t,
                 personId: p.id,
                 kind: 'finish',
-                detail: `${act.action} interrupted`,
+                detail: p.lexicon?.plainEnglish
+                    ? taskEndLine(p, act.affordance.label, 'interrupted')
+                    : `${act.action} interrupted`,
                 decisionId: act.decisionId,
                 affordanceId: act.affordanceId,
                 action: act.action,
@@ -889,7 +965,9 @@ export function stepCommunity(c, world, until, opts = {}) {
             at: t,
             personId: p.id,
             kind: 'begin',
-            detail: `${chosen.label} (${record.intention})`,
+            detail: p.lexicon?.plainEnglish
+                ? `${p.name} began the task “${chosen.label}”. ${record.intention}`
+                : `${chosen.label} (${record.intention})`,
             decisionId: record.id,
             affordanceId: chosen.id,
             action: chosen.action,

package/dist/social/social.js

@@ -471,6 +471,16 @@ export const REPUTATION_DEFAULTS = {
     /** First-hand familiarity damps hearsay: scale = 1 - familiarityDamping × familiarity. */
     familiarityDamping: 0.5,
 };
+/** Only authored, finite effects count; prototype properties are not character traits. */
+function reputationEffect(trait, table) {
+    const effect = Object.hasOwn(table, trait) ? table[trait] : undefined;
+    return effect &&
+        Number.isFinite(effect.affection) &&
+        Number.isFinite(effect.trust) &&
+        Number.isFinite(effect.respect)
+        ? effect
+        : undefined;
+}
 /** Splits a character proposition '<personId>:<trait>[:...]' into its subject and trait, if it is one. */
 export function parseTraitProp(prop, table = REPUTATION_TRAITS) {
     const parts = prop.split(':');
@@ -478,7 +488,7 @@ export function parseTraitProp(prop, table = REPUTATION_TRAITS) {
         return undefined;
     const personId = parts[0];
     const trait = parts[1];
-    if (personId === '' || table[trait] === undefined)
+    if (personId === '' || reputationEffect(trait, table) === undefined)
         return undefined;
     return { personId, trait };
 }
@@ -509,7 +519,7 @@ export function applyReputationBelief(p, prop, before, after, now, table = REPUT
 }
 /** Whether a character claim about a person is unfavourable to them (for backbiting tags). */
 export function isUnfavourableTrait(trait, value, table = REPUTATION_TRAITS) {
-    const e = table[trait];
+    const e = reputationEffect(trait, table);
     if (!e)
         return false;
     const sum = e.affection + e.trust + e.respect;

package/dist/types.d.ts

@@ -1509,6 +1509,10 @@ export interface PersonSpec {
     values?: Partial<Values>;
     norms?: HeldNorm[];
     skills?: Record<string, Unit>;
+    /** Authored habits, copied in order. Invalid or over-bound setup throws RangeError. */
+    habits?: Habit[];
+    /** Authored expectations, copied in order. Invalid or over-bound setup throws RangeError. */
+    expectations?: ActionExpectation[];
     body?: Partial<Omit<BodyState, 'injuries' | 'illnesses' | 'nextId'>>;
     needs?: Partial<NeedReservoirs>;
     relationships?: (Partial<Relationship> & {
@@ -1767,6 +1771,8 @@ export interface VoiceConflict {
  * slots documented next to each key.
  */
 export interface Lexicon {
+    /** Use complete, plain English in built-in narration. Omitted keeps exact legacy wording. */
+    plainEnglish?: boolean;
     /** Include person identity and stable temperament in assent/deferral selection (no RNG draws). */
     variety?: boolean;
     /** What material gains mean here, e.g. 'food', 'household keep' or 'resources'; absent keeps legacy money lines. */

package/dist/will/will.d.ts

@@ -233,6 +233,18 @@ export declare function noteVoicePromise(p: Person, voiceId: EntityId, event: {
     at?: Minute;
     action?: string;
 }): VoiceRelation;
+/**
+ * SCOPE (host trust gesture): add a host-supplied signed amount to an existing advising voice's trust,
+ * clamped to 0..1, and record the realized change in the usual bounded history. Magnitudes and reason
+ * are host premises, not calibrated claims. Missing voices return undefined without creating a voice.
+ * Non-finite amounts are ignored. No pressure, credit, counters, memory, time or RNG changes occur.
+ * Empty/non-string reasons and non-string actions reject before mutation with RangeError.
+ */
+export declare function gestureVoiceTrust(p: Person, voiceId: EntityId, amount: number, event: {
+    reason: string;
+    at?: Minute;
+    action?: string;
+}): VoiceRelation | undefined;
 /**
  * The next minute after `now` at which a pending commitment reaches `wakeCommitmentPressure`, the level at which a
  * sleeper may wake to serve it (the asleep veto lifts). The composite caps a sleeper's review there so a duty whose

package/dist/will/will.js

@@ -37,6 +37,7 @@ import { commitmentPressure, isUnderWay, pressureReachedAt } from '../agenda/ind
 import { downedAllows, readCapacities } from '../body/index.js';
 import { CONSCIENCE_DEFAULTS, normVeto } from '../conscience/index.js';
 import { clamp01, cmpStr, decay, dexp, dpow, hasNumbers, isObj, random, round } from '../core/index.js';
+import { commitmentLabel } from '../presentation.js';
 import { skillLevel } from '../skills/index.js';
 import { MINUTES_PER_DAY, MINUTES_PER_HOUR } from '../types.js';
 export const WILL_DEFAULTS = {
@@ -292,6 +293,27 @@ export function noteVoicePromise(p, voiceId, event) {
     noteTrust(v, v.trust - before, event.kept ? 'promise-kept' : 'promise-broken', at, event.action);
     return v;
 }
+/**
+ * SCOPE (host trust gesture): add a host-supplied signed amount to an existing advising voice's trust,
+ * clamped to 0..1, and record the realized change in the usual bounded history. Magnitudes and reason
+ * are host premises, not calibrated claims. Missing voices return undefined without creating a voice.
+ * Non-finite amounts are ignored. No pressure, credit, counters, memory, time or RNG changes occur.
+ * Empty/non-string reasons and non-string actions reject before mutation with RangeError.
+ */
+export function gestureVoiceTrust(p, voiceId, amount, event) {
+    if (!event || typeof event.reason !== 'string' || event.reason.length === 0)
+        throw new RangeError('A trust gesture needs a reason');
+    if (event.action !== undefined && typeof event.action !== 'string')
+        throw new RangeError('Invalid trust gesture action');
+    const v = voiceOf(p, voiceId);
+    if (!v || !Number.isFinite(amount))
+        return v;
+    const before = v.trust;
+    v.trust = clamp01(before + amount);
+    const at = event.at !== undefined && Number.isFinite(event.at) ? event.at : p.now;
+    noteTrust(v, v.trust - before, event.reason, at, event.action);
+    return v;
+}
 const finite = (x) => x === undefined || Number.isFinite(x);
 /** Host numbers the framework computes with must be finite; a NaN offer is vetoed, never chosen. */
 function wellFormed(aff) {
@@ -829,7 +851,10 @@ function judgeVoices(p, ctx, suggestions, prepared, selection) {
                         kind: 'notNow',
                         commitmentId: v.omission,
                         ...(winnerAff ? { insteadAffordanceId: winnerAff.id } : {}),
-                        counterOffer: { affordanceId: suggested[0]?.affordanceId, label: dutyLabel(duty, winnerAff) },
+                        counterOffer: {
+                            affordanceId: suggested[0]?.affordanceId,
+                            label: dutyLabel(duty, winnerAff, p),
+                        },
                     }));
                 }
                 return out(resolution('refused', v.reason, { kind: 'willNot', commitmentId: v.omission }));
@@ -886,7 +911,12 @@ function judgeVoices(p, ctx, suggestions, prepared, selection) {
             kind: 'notNow',
             insteadAffordanceId: winnerAff?.id,
             counterOffer: winnerAff
-                ? { affordanceId: bestSuggested.affordanceId, label: `after I ${winnerAff.label}` }
+                ? {
+                    affordanceId: bestSuggested.affordanceId,
+                    label: p.lexicon?.plainEnglish
+                        ? `after I finish this task (${winnerAff.label})`
+                        : `after I ${winnerAff.label}`,
+                }
                 : { affordanceId: bestSuggested.affordanceId, label: 'later' },
         }));
     });
@@ -940,7 +970,11 @@ function arbitrateInsistence(p, judged, considered, affById, ev) {
                     insteadAffordanceId: forced,
                     counterOffer: {
                         ...(firstTarget !== undefined ? { affordanceId: firstTarget } : {}),
-                        label: forcedAff ? `after I ${forcedAff.label}` : 'later',
+                        label: forcedAff
+                            ? p.lexicon?.plainEnglish
+                                ? `after I finish this task (${forcedAff.label})`
+                                : `after I ${forcedAff.label}`
+                            : 'later',
                     },
                 };
                 if (j.res.likelihood !== undefined)
@@ -1134,7 +1168,12 @@ export function conflictBetweenVoices(considered, resolutions, chosenAffordanceI
     };
 }
 /** Counter-offer for a request deferred behind a duty: "after I pray", "after I feed the children". */
-function dutyLabel(duty, winner) {
+function dutyLabel(duty, winner, p) {
+    if (p.lexicon?.plainEnglish) {
+        if (duty)
+            return `after I finish this duty (${commitmentLabel(duty, p.lexicon)})`;
+        return winner ? `after I finish this task (${winner.label})` : 'after my duty';
+    }
     if (duty?.kind === 'worship')
         return duty.label ? `after I pray ${duty.label}` : 'after I pray';
     if (duty?.label)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adam0white/human-framework",
-  "version": "2.18.0",
+  "version": "2.20.0",
   "description": "Deterministic, explainable simulated people: body, needs, affect, memory, beliefs, skills, habits, relationships, values and a will that can refuse a suggestion",
   "keywords": [
     "simulation",