@adam0white/human-framework 2.18.0 → 2.19.0

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')

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/types.d.ts

@@ -1767,6 +1767,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.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 = {
@@ -829,7 +830,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 +890,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 +949,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 +1147,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.19.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",