@adam0white/human-framework 2.8.0 → 2.9.1

package/dist/person.js

@@ -1,12 +1,12 @@
 /**
  * SCOPE: the composite. `createPerson` wires every faculty's constructor; `tick` advances all faculties in
  * closed form from `p.now` to a later minute under the current activity's body load (idle awake otherwise),
- * splitting at the activity's end; `perceive` runs attention, then beliefs, relationships, judgement of
- * others' acts, memory and appraisal; `decide` scores offers and resolves the will (`answerNow` answers a
- * suggestion immediately); `begin` and `finish` bracket an activity and route the outcome into body, needs,
- * skills, habits, memory, conscience, agenda, relationships and trust in advising voices. Direct control is
- * `command`, `releaseCommand` and `previewCommand`; `knockDown` and `standUp` move a person in and out of the
- * downed state; `observeSkill` is observational learning; `setRetention` sets the per-person retention
+ * splitting at the activity's end and the absolute hourly grid; `perceive` runs attention, then beliefs,
+ * relationships, judgement of others' acts, memory and appraisal; `decide` scores offers and resolves the
+ * will (`answerNow` answers a suggestion immediately); `begin` and `finish` bracket an activity and route the
+ * outcome into body, needs, skills, habits, memory, conscience, agenda, relationships and trust in advising
+ * voices. Direct control is `command`, `releaseCommand` and `previewCommand`; `knockDown` and `standUp`
+ * move a person in and out of the downed state; `observeSkill` is observational learning; `setRetention` sets the per-person retention
  * bounds; `readPerson` is the read-only summary. Snapshot and restore live in `restore.ts`. This file owns
  * `now`, `activity`, `trace`, `nextDecision` and `retention`; every other slice is written only through its
  * owning module. It sequences the modules and makes no behavioural claims of its own beyond the engineering
@@ -1136,6 +1136,115 @@ export function learningFor(p, domain) {
 export function observeSkill(p, skill, minutes, modelLevel, domain) {
     return learnByWatching(p, skill, minutes, modelLevel, learningFor(p, domain), p.now);
 }
+/** Realized need changes, using readings captured before and after the outcome's deltas. */
+function realizedNeedDeltas(act, given, before, after) {
+    const aff = act.affordance;
+    const realized = {};
+    for (const id of [...PHYSIOLOGICAL_NEEDS, ...PSYCHOLOGICAL_NEEDS]) {
+        if (given[id] === undefined)
+            continue;
+        realized[id] =
+            id === 'food' || id === 'water' || id === 'relief'
+                ? levelOf(after, id) - levelOf(before, id)
+                : given[id];
+    }
+    for (const id of ['sleep', 'rest']) {
+        if (aff.advertises[id] !== undefined && given[id] === undefined) {
+            realized[id] = levelOf(after, id) - (act.needsAtStart[id] ?? levelOf(before, id));
+        }
+    }
+    return realized;
+}
+/** Record the deed and apply its appraisal, repentance, repair and regulation. */
+function respondToConscience(p, act, now, completed, minutes) {
+    const aff = act.affordance;
+    const deed = recordDeed(p, aff, act.intention, now, completed, act.necessity ? { necessity: true } : {});
+    for (const ev of deed.appraisal)
+        appraise(p, ev);
+    const tags = aff.tags ?? [];
+    if (completed && (tags.includes('worship') || tags.includes('repent'))) {
+        // Worship closes breaches against God alone; guilt toward a wronged person waits for repair.
+        const repented = new Set();
+        for (const b of p.conscience.breaches) {
+            if (!b.repaired && b.victimId === undefined && repent(p, b.id, now))
+                repented.add(b.normId);
+        }
+        for (const b of p.conscience.breaches)
+            if (!b.repaired && b.victimId !== undefined)
+                repented.delete(b.normId);
+        for (const normId of [...repented].sort())
+            release(p, { id: 'guilt', causePrefix: `breach:${normId}` }, 0.6);
+        regulate(p, minutes, 'worship');
+    }
+    if (completed && (tags.includes('repair') || tags.includes('apologize')) && aff.targetId !== undefined) {
+        recordRepair(p, aff.targetId, now);
+        release(p, { id: 'guilt', targetId: aff.targetId });
+        socialEvent(p, { at: now, kind: 'apology', otherId: aff.targetId, byMe: true, magnitude: 0.7 });
+    }
+    if (act.mode === 'sleep' || tags.includes('rest') || tags.includes('reflection')) {
+        regulate(p, minutes, tags.includes('reflection') ? 'reflection' : 'rest');
+    }
+    return { deed, tags };
+}
+/** Record relationships and character experience from a completed activity. */
+function recordParticipation(p, aff, tags, now, minutes) {
+    const D = PERSON_DEFAULTS;
+    if (p.character && (aff.with ?? []).some((o) => o !== p.id))
+        noteCharacterSocial(p, minutes);
+    const kind = tags.includes('work') ? 'shared-work' : 'chat';
+    for (const other of aff.with ?? []) {
+        if (other === p.id)
+            continue;
+        socialEvent(p, { at: now, kind, otherId: other, byMe: true, magnitude: D.participationMagnitude });
+    }
+    if (aff.targetId !== undefined && aff.targetId !== p.id) {
+        const care = tags.includes('help') ? 'help' : tags.includes('gift') ? 'gift' : undefined;
+        if (care)
+            socialEvent(p, { at: now, kind: care, otherId: aff.targetId, byMe: true, magnitude: 0.7 });
+    }
+}
+/** Learn from each advising voice after the activity's conscience and agenda results are known. */
+function learnActivityVoices(p, act, after, now, felt, broken, breached) {
+    const aff = act.affordance;
+    const D = PERSON_DEFAULTS;
+    // Trust in every voice that pushed this activity: how it felt, minus bodily harm the host's deltas do not
+    // show (needs that fell during the activity and are now urgent).
+    const voices = act.suggestions ?? (act.suggestion ? [act.suggestion] : []);
+    if (voices.length > 0) {
+        let harm = 0;
+        for (const id of ['food', 'water', 'sleep', 'rest']) {
+            if (urgencyOf(after, id) < D.voiceHarmUrgency)
+                continue;
+            harm += Math.max(0, (act.needsAtStart[id] ?? levelOf(after, id)) - levelOf(after, id));
+        }
+        // Doing what a voice pushed broke a commitment or the person's own standards: that costs the voice as harm
+        // does (review 2026-10-03: thirty broken fasts under insistence had moved trust only 0.50 -> 0.41). Omissions
+        // the push caused later (a missed prayer during a pushed activity) are not attributed here.
+        let breach = 0;
+        for (const c of broken)
+            breach += D.missedDistress * c.importance;
+        breach += D.missedDistress * 0.5 * breached;
+        for (const res of voices) {
+            const protest = res.verdict === 'complied' || res.verdict === 'commanded';
+            const reason = breach > 0
+                ? protest
+                    ? 'breach-under-protest'
+                    : 'breach'
+                : harm > 0
+                    ? protest
+                        ? 'harm-under-protest'
+                        : 'harm'
+                    : felt >= 0
+                        ? 'went-well'
+                        : 'went-badly';
+            learnFromVoice(p, res, clampSigned(felt - D.voiceHarmGain * harm - breach), {
+                at: now,
+                action: aff.action,
+                reason,
+            });
+        }
+    }
+}
 /**
  * Apply what happened. Physiological deltas go to the body, psychological ones to the needs, then skills,
  * habits, memory (expectation learning and an episode), conscience (deed, breaches, repair), agenda,
@@ -1179,20 +1288,7 @@ export function finish(p, outcome, opts = {}) {
     // Realized deltas: what the body actually took in for food/water/relief (a drink at full hydration
     // realizes nothing), host values for psychological needs, and measured since the start for sleep/rest.
     const after = readNeeds(p, readBodyOf(p));
-    const realized = {};
-    for (const id of [...PHYSIOLOGICAL_NEEDS, ...PSYCHOLOGICAL_NEEDS]) {
-        if (given[id] === undefined)
-            continue;
-        realized[id] =
-            id === 'food' || id === 'water' || id === 'relief'
-                ? levelOf(after, id) - levelOf(before, id)
-                : given[id];
-    }
-    for (const id of ['sleep', 'rest']) {
-        if (aff.advertises[id] !== undefined && given[id] === undefined) {
-            realized[id] = levelOf(after, id) - (act.needsAtStart[id] ?? levelOf(before, id));
-        }
-    }
+    const realized = realizedNeedDeltas(act, given, before, after);
     // Felt valence.
     let felt = 0;
     for (const id of Object.keys(realized)) {
@@ -1255,32 +1351,7 @@ export function finish(p, outcome, opts = {}) {
         episode.voiceId = act.suggestion.voiceId;
     remember(p, episode);
     // Conscience.
-    const deed = recordDeed(p, aff, act.intention, now, completed, act.necessity ? { necessity: true } : {});
-    for (const ev of deed.appraisal)
-        appraise(p, ev);
-    const tags = aff.tags ?? [];
-    if (completed && (tags.includes('worship') || tags.includes('repent'))) {
-        // Worship closes breaches against God alone; guilt toward a wronged person waits for repair.
-        const repented = new Set();
-        for (const b of p.conscience.breaches) {
-            if (!b.repaired && b.victimId === undefined && repent(p, b.id, now))
-                repented.add(b.normId);
-        }
-        for (const b of p.conscience.breaches)
-            if (!b.repaired && b.victimId !== undefined)
-                repented.delete(b.normId);
-        for (const normId of [...repented].sort())
-            release(p, { id: 'guilt', causePrefix: `breach:${normId}` }, 0.6);
-        regulate(p, minutes, 'worship');
-    }
-    if (completed && (tags.includes('repair') || tags.includes('apologize')) && aff.targetId !== undefined) {
-        recordRepair(p, aff.targetId, now);
-        release(p, { id: 'guilt', targetId: aff.targetId });
-        socialEvent(p, { at: now, kind: 'apology', otherId: aff.targetId, byMe: true, magnitude: 0.7 });
-    }
-    if (act.mode === 'sleep' || tags.includes('rest') || tags.includes('reflection')) {
-        regulate(p, minutes, tags.includes('reflection') ? 'reflection' : 'rest');
-    }
+    const { deed, tags } = respondToConscience(p, act, now, completed, minutes);
     // Agenda.
     const routed = { ...outcome };
     if (routed.fulfills === undefined && aff.fulfills !== undefined)
@@ -1303,58 +1374,10 @@ export function finish(p, outcome, opts = {}) {
         }
     }
     // Relationships from taking part together.
-    if (completed) {
-        if (p.character && (aff.with ?? []).some((o) => o !== p.id))
-            noteCharacterSocial(p, minutes);
-        const kind = tags.includes('work') ? 'shared-work' : 'chat';
-        for (const other of aff.with ?? []) {
-            if (other === p.id)
-                continue;
-            socialEvent(p, { at: now, kind, otherId: other, byMe: true, magnitude: D.participationMagnitude });
-        }
-        if (aff.targetId !== undefined && aff.targetId !== p.id) {
-            const care = tags.includes('help') ? 'help' : tags.includes('gift') ? 'gift' : undefined;
-            if (care)
-                socialEvent(p, { at: now, kind: care, otherId: aff.targetId, byMe: true, magnitude: 0.7 });
-        }
-    }
-    // Trust in every voice that pushed this activity: how it felt, minus bodily harm the host's deltas do not
-    // show (needs that fell during the activity and are now urgent).
-    const voices = act.suggestions ?? (act.suggestion ? [act.suggestion] : []);
-    if (voices.length > 0) {
-        let harm = 0;
-        for (const id of ['food', 'water', 'sleep', 'rest']) {
-            if (urgencyOf(after, id) < D.voiceHarmUrgency)
-                continue;
-            harm += Math.max(0, (act.needsAtStart[id] ?? levelOf(after, id)) - levelOf(after, id));
-        }
-        // Doing what a voice pushed broke a commitment or the person's own standards: that costs the voice as harm
-        // does (review 2026-10-03: thirty broken fasts under insistence had moved trust only 0.50 -> 0.41). Omissions
-        // the push caused later (a missed prayer during a pushed activity) are not attributed here.
-        let breach = 0;
-        for (const c of broken)
-            breach += D.missedDistress * c.importance;
-        breach += D.missedDistress * 0.5 * deed.breached.length;
-        for (const res of voices) {
-            const protest = res.verdict === 'complied' || res.verdict === 'commanded';
-            const reason = breach > 0
-                ? protest
-                    ? 'breach-under-protest'
-                    : 'breach'
-                : harm > 0
-                    ? protest
-                        ? 'harm-under-protest'
-                        : 'harm'
-                    : felt >= 0
-                        ? 'went-well'
-                        : 'went-badly';
-            learnFromVoice(p, res, clampSigned(felt - D.voiceHarmGain * harm - breach), {
-                at: now,
-                action: aff.action,
-                reason,
-            });
-        }
-    }
+    if (completed)
+        recordParticipation(p, aff, tags, now, minutes);
+    // Voice learning follows both conscience and agenda, so it includes their breaches.
+    learnActivityVoices(p, act, after, now, felt, broken, deed.breached.length);
     // Chronicle, while the activity is still current.
     const noted = { kept: kept.map((c) => c.id) };
     if (act.suggestion)

package/dist/promptings/promptings.d.ts

@@ -26,8 +26,17 @@ export declare const PROMPTINGS_DEFAULTS: {
  * keeps its practice and last use (the spec's `practice` only seeds new responses). Returns the state.
  */
 export declare function enablePromptings(p: Person, spec?: PromptingsSpec): PromptingsState;
-/** Practice of a response at `now`, after disuse decay. Pure. */
-export declare function practiceAt(r: PromptingResponse, now: Minute): Unit;
+/** Practice of a response at `now`, after disuse decay (`halfLifeDays` defaults to 60, as before 2.9.0). Pure. */
+export declare function practiceAt(r: PromptingResponse, now: Minute, halfLifeDays?: number): Unit;
+/** What a prompt offers a cue to match (2.9.0). */
+export interface PromptContext {
+    action: string;
+    tags?: readonly string[] | undefined;
+    /** The opposing term's source: 'norm:x' or 'goal:g'. */
+    opposedBy: string;
+}
+/** Whether a response's cue matches a prompt: its action, one of its tags, or the opposing norm or goal. Pure. */
+export declare function responseCueMatches(cue: string, at: PromptContext): boolean;
 /** Whether an option's terms carry a noticed prompt: its strongest pull and the opposing term. Pure. */
 export declare function promptIn(terms: readonly Term[], tags: readonly string[] | undefined): {
     source: string;
@@ -46,6 +55,8 @@ export interface PromptingSeen {
     opposedBy: string;
     /** Whether a turning-away term was applied. */
     turnApplied: boolean;
+    /** The offer's tags (2.9.0), for matching a response's cue. */
+    tags?: readonly string[] | undefined;
 }
 /** What `notePromptings` did, for the composite (the `fault` guilt goes through affect). */
 export interface PromptingsNoted {
@@ -68,10 +79,12 @@ export interface PromptingsReadingView {
     turned: number;
     passed: number;
     assented: number;
+    /** `cue` only when the response has one (2.9.0). */
     responses: {
         id: string;
         kind: PromptingResponseKind;
         practice: Unit;
+        cue?: string;
     }[];
     /** Vocabulary for the last few prompts, newest last. */
     lines: string[];

package/dist/promptings/promptings.js

@@ -8,7 +8,8 @@
  *
  * Detection reads an option's traced terms and changes none of them: the pull is the sum of positive `habit`,
  * `emotion:*`, `need:*` and `promptings:echo` terms (every positive term on an offer tagged `temptation`); it is a
- * prompt when the pull reaches `noticeAt` while a `norm:*` or `goal:*` term on the same option is negative.
+ * prompt when the pull reaches `noticeAt` while a `norm:*` or `goal:*` term on the same option is negative (goal
+ * terms are never negative, see `agendaTerms`, so in practice the opposition is a held norm).
  * Abstention windows are not detected (they veto, and carry no term). A person with a response gets one extra
  * term, `promptings:turn` = -turnMax × practice, on that option; it is bounded and absent at survival desperation,
  * so a desperate bodily need still wins (2:286). Each prompt is recorded once per decision point (a review that
@@ -16,6 +17,16 @@
  * or `passed` (not chosen, no response). Practice grows with diminishing gains once per decision point where the
  * response was used (more when it held; a vetoed option earns none, since the will blocked it), and halves over `practiceHalfLifeDays` of disuse.
  *
+ * Cued responses and host time (2.9.0, both opt-in): a response may carry a `cue` (an action, an offer tag, or the
+ * opposing norm or goal), for a phrase learned at one pull. At a prompt the person uses the most practised response
+ * whose cue matches it; when none matches, the most practised response without a cue. A cued response never serves
+ * a prompt it does not match, so a phrase learned at the alarm does not also turn the person from gossip (the
+ * literal "global best" fallback would bring that back). Each response used at a decision point gains once. Without
+ * cues every response is uncued and this is the 2.4.0 rule exactly. `practiceHalfLifeDays` in `enablePromptings`
+ * replaces the 60-day half-life for the whole person (a one-week game can let a phrase fade); it is one setting per
+ * person, not per response, because the need is the host's time scale and no source gives phrases different decay.
+ * Practice is decayed lazily from `lastUsedAt`, so a new half-life also applies to disuse already elapsed.
+ *
  * Held readings (reconciliation.md §5): `whisper`, `inclination`, `intrusion` and `none` give identical decisions
  * and differ only in the vocabulary of `promptingLine`. `fault` (the scrupulous reading, which both the tradition
  * and clinicians reject) adds a small guilt emotion at the prompt itself, from the person's own understanding;
@@ -71,7 +82,14 @@ export function enablePromptings(p, spec = {}) {
             continue;
         const held = prev?.responses.find((x) => x.id === r.id);
         const seed = Number.isFinite(r.practice) ? clamp01(r.practice) : 0.1;
-        responses.push(held ? { ...held, kind: r.kind } : { id: r.id, kind: r.kind, practice: seed, lastUsedAt: p.now });
+        const next = held
+            ? { ...held, kind: r.kind }
+            : { id: r.id, kind: r.kind, practice: seed, lastUsedAt: p.now };
+        // The spec's cue wins; a response re-enabled without one loses its old cue.
+        delete next.cue;
+        if (cueOk(r.cue))
+            next.cue = r.cue;
+        responses.push(next);
     }
     const state = {
         reading: spec.reading && READINGS.includes(spec.reading) ? spec.reading : 'none',
@@ -82,22 +100,44 @@ export function enablePromptings(p, spec = {}) {
     };
     if (spec.readingSource !== undefined)
         state.readingSource = spec.readingSource;
+    if (halfLifeOk(spec.practiceHalfLifeDays))
+        state.practiceHalfLifeDays = spec.practiceHalfLifeDays;
     p.promptings = state;
     return state;
 }
-/** Practice of a response at `now`, after disuse decay. Pure. */
-export function practiceAt(r, now) {
-    return clamp01(halve(r.practice, now - r.lastUsedAt, PROMPTINGS_DEFAULTS.practiceHalfLifeDays));
+const cueOk = (x) => typeof x === 'string' && x !== '' && x.length <= 200;
+const halfLifeOk = (x) => typeof x === 'number' && Number.isFinite(x) && x > 0 && x <= 36500;
+const halfLifeOf = (s) => s.practiceHalfLifeDays ?? PROMPTINGS_DEFAULTS.practiceHalfLifeDays;
+/** Practice of a response at `now`, after disuse decay (`halfLifeDays` defaults to 60, as before 2.9.0). Pure. */
+export function practiceAt(r, now, halfLifeDays = PROMPTINGS_DEFAULTS.practiceHalfLifeDays) {
+    return clamp01(halve(r.practice, now - r.lastUsedAt, halfLifeDays));
+}
+/** Whether a response's cue matches a prompt: its action, one of its tags, or the opposing norm or goal. Pure. */
+export function responseCueMatches(cue, at) {
+    if (cue === at.action || cue === at.opposedBy || (at.tags?.includes(cue) ?? false))
+        return true;
+    const colon = at.opposedBy.indexOf(':');
+    return colon >= 0 && cue === at.opposedBy.slice(colon + 1);
 }
-/** The response a person would use now: highest practice, ties by id. */
-function bestResponse(s, now) {
-    let best;
+/**
+ * The response a person would use now at prompt `at`: the most practised whose cue matches, else the most
+ * practised without a cue; ties by id. Without cues this is the most practised response (2.4.0).
+ */
+function bestResponse(s, now, at) {
+    let cued;
+    let plain;
+    const better = (b, r, x) => !b || x > b.practice || (x === b.practice && r.id < b.r.id);
+    const half = halfLifeOf(s);
     for (const r of s.responses) {
-        const practice = practiceAt(r, now);
-        if (!best || practice > best.practice || (practice === best.practice && r.id < best.r.id))
-            best = { r, practice };
+        const practice = practiceAt(r, now, half);
+        if (r.cue === undefined) {
+            if (better(plain, r, practice))
+                plain = { r, practice };
+        }
+        else if (responseCueMatches(r.cue, at) && better(cued, r, practice))
+            cued = { r, practice };
     }
-    return best;
+    return cued ?? plain;
 }
 const isPull = (source, tagged) => tagged ||
     source === 'habit' ||
@@ -145,10 +185,13 @@ export function promptingTerms(p, action, terms, tags, now, desperation) {
     }
     if (desperation >= PROMPTINGS_DEFAULTS.survivalDesperation)
         return out;
-    const best = bestResponse(s, now);
-    if (!best || best.practice <= 0)
+    if (s.responses.length === 0)
         return out;
-    if (!promptIn([...terms, ...out], tags))
+    const seen = promptIn([...terms, ...out], tags);
+    if (!seen)
+        return out;
+    const best = bestResponse(s, now, { action, tags, opposedBy: seen.opposedBy });
+    if (!best || best.practice <= 0)
         return out;
     const v = round(-PROMPTINGS_DEFAULTS.turnMax * best.practice);
     if (v < 0)
@@ -165,11 +208,12 @@ export function notePromptings(p, seen, chosenId, now) {
     if (!s || seen.length === 0)
         return noted;
     const D = PROMPTINGS_DEFAULTS;
-    const best = bestResponse(s, now);
-    // One practice gain per decision point, however many options carried a prompt: the larger one if any held.
-    let gain = 0;
+    // One practice gain per response per decision point, however many options it served: the larger one if any held.
+    // Responses are chosen before any practice moves, as `promptingTerms` chose them.
+    const gains = new Map();
     for (const x of seen) {
         const assented = x.affordanceId === chosenId;
+        const best = bestResponse(s, now, x);
         const used = x.turnApplied && best !== undefined;
         const rec = {
             at: now,
@@ -181,7 +225,7 @@ export function notePromptings(p, seen, chosenId, now) {
         };
         if (used && best) {
             rec.responseId = best.r.id;
-            gain = Math.max(gain, assented ? D.gainAttempt : D.gainTurned);
+            gains.set(best.r, Math.max(gains.get(best.r) ?? 0, assented ? D.gainAttempt : D.gainTurned));
         }
         s.recent.push(rec);
         noted.records.push(rec);
@@ -194,10 +238,12 @@ export function notePromptings(p, seen, chosenId, now) {
             }
         }
     }
-    if (best && gain > 0) {
-        const practice = practiceAt(best.r, now);
-        best.r.practice = round(clamp01(practice + gain * (1 - practice)));
-        best.r.lastUsedAt = now;
+    for (const [r, gain] of gains) {
+        if (gain <= 0)
+            continue;
+        const practice = practiceAt(r, now, halfLifeOf(s));
+        r.practice = round(clamp01(practice + gain * (1 - practice)));
+        r.lastUsedAt = now;
     }
     if (s.recent.length > D.maxRecent)
         s.recent.splice(0, s.recent.length - D.maxRecent);
@@ -249,7 +295,12 @@ export function promptingsReading(p, now = p.now) {
         turned: count('turned'),
         passed: count('passed'),
         assented: count('assented'),
-        responses: s.responses.map((r) => ({ id: r.id, kind: r.kind, practice: round(practiceAt(r, now)) })),
+        responses: s.responses.map((r) => ({
+            id: r.id,
+            kind: r.kind,
+            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))),
     };
     if (s.readingSource !== undefined)
@@ -298,12 +349,15 @@ export function sanitizePromptings(input, now) {
             continue;
         if (!minute(r.lastUsedAt) || r.lastUsedAt > now || responses.some((x) => x.id === r.id))
             continue;
-        responses.push({
+        const kept = {
             id: r.id,
             kind: r.kind,
             practice: r.practice,
             lastUsedAt: r.lastUsedAt,
-        });
+        };
+        if (cueOk(r.cue))
+            kept.cue = r.cue;
+        responses.push(kept);
     }
     const recent = [];
     for (const r of input.recent.slice(-D.maxRecent)) {
@@ -344,5 +398,7 @@ export function sanitizePromptings(input, now) {
     };
     if (str(input.readingSource))
         out.readingSource = input.readingSource;
+    if (halfLifeOk(input.practiceHalfLifeDays))
+        out.practiceHalfLifeDays = input.practiceHalfLifeDays;
     return out;
 }

package/dist/prospection/prospection.js

@@ -260,9 +260,15 @@ export function sanitizeProspection(input, now, personId) {
             !minute(r.receivedAt) ||
             r.receivedAt > now)
             continue;
-        if (revisions.some((old) => identity(old, r)))
+        const validated = {
+            sourceId: r.sourceId,
+            id: r.id,
+            revision: r.revision,
+            receivedAt: r.receivedAt,
+        };
+        if (revisions.some((old) => identity(old, validated)))
             return undefined;
-        revisions.push({ sourceId: r.sourceId, id: r.id, revision: r.revision, receivedAt: r.receivedAt });
+        revisions.push(validated);
     }
     const valid = [];
     for (const e of entries) {

package/dist/restore.d.ts

@@ -1,6 +1,15 @@
 import type { Person } from './types.ts';
 /** A deep copy of the person as plain JSON (what a host saves). */
 export declare function snapshot(p: Person): Person;
+/**
+ * A deterministic 16-hex-digit digest of the canonical saved person. Canonicalization runs the saved form
+ * through `restore` (including migrations, defaults, bounds and optional-slice sanitizers), then sorts every
+ * object's keys recursively; array order stays significant. Thus key insertion order and empty optional slices
+ * that `restore` drops do not change the digest. Includes the engine stamp. Reads only; never mutates `p`.
+ * Uses 64-bit FNV-1a over JSON's UTF-16 code units, with no platform or crypto dependency. This is a change
+ * detector, not a cryptographic integrity check; collisions are possible. Invalid saves throw as in `restore`.
+ */
+export declare function fingerprint(p: Person): string;
 /**
  * Validate a saved person and fill defaults for missing or mistyped fields, slice by slice and field by
  * field. A save from an earlier supported engine is upgraded by `migrate` first. Throws on a wrong schema, a

package/dist/restore.js

@@ -31,6 +31,26 @@ import { sanitizeWill } from './will/index.js';
 export function snapshot(p) {
     return structuredClone(p);
 }
+/**
+ * A deterministic 16-hex-digit digest of the canonical saved person. Canonicalization runs the saved form
+ * through `restore` (including migrations, defaults, bounds and optional-slice sanitizers), then sorts every
+ * object's keys recursively; array order stays significant. Thus key insertion order and empty optional slices
+ * that `restore` drops do not change the digest. Includes the engine stamp. Reads only; never mutates `p`.
+ * Uses 64-bit FNV-1a over JSON's UTF-16 code units, with no platform or crypto dependency. This is a change
+ * detector, not a cryptographic integrity check; collisions are possible. Invalid saves throw as in `restore`.
+ */
+export function fingerprint(p) {
+    const json = JSON.stringify(restore(snapshot(p)), (_key, value) => {
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            return value;
+        return Object.fromEntries(Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+    });
+    let hash = 0xcbf29ce484222325n;
+    for (let i = 0; i < json.length; i++) {
+        hash = BigInt.asUintN(64, (hash ^ BigInt(json.charCodeAt(i))) * 0x100000001b3n);
+    }
+    return hash.toString(16).padStart(16, '0');
+}
 // Unlike core `isObj`, arrays pass: a required slice saved as an array is filled from defaults, not refused.
 const isObject = (x) => typeof x === 'object' && x !== null;
 const isMinute = (x) => isNum(x) && Math.abs(x) <= MAX_MINUTE;

package/dist/review/review.js

@@ -3,7 +3,8 @@
  * 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`), with the sign of the commitment's own term (toward a duty, away from an abstention's breaking
+ * `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
@@ -23,6 +24,11 @@
  * 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 { clamp01, dexp, isObj, minuteOfDay, round } from '../core/index.js';
 export const REVIEW_DEFAULTS = {
@@ -72,6 +78,7 @@ export function reviewTerms(p, terms) {
         return [];
     let value = 0;
     const used = new Set();
+    let only;
     for (const t of terms) {
         const m = /^(commitment|abstain):(.+)$/.exec(t.source);
         if (!m || t.value === 0)
@@ -83,11 +90,18 @@ export function reviewTerms(p, terms) {
         if (!r || used.has(r.key))
             continue;
         used.add(r.key);
+        only = r.key;
         value += Math.sign(t.value) * REVIEW_DEFAULTS.resolveScale * r.strength;
     }
     const max = REVIEW_DEFAULTS.resolveScale;
     value = Math.max(-max, Math.min(max, value));
-    return value === 0 ? [] : [{ source: 'review:resolve', value: round(value) }];
+    if (value === 0)
+        return [];
+    const term = { source: 'review:resolve', value: round(value) };
+    // Name the resolve when exactly one weighed in (2.9.0, The Pass): "he turned from the jar, as he said he would".
+    if (used.size === 1 && only !== undefined)
+        term.ref = only;
+    return [term];
 }
 const fade = (s, days) => days <= 0 ? s : s * dexp((-Math.LN2 * days) / REVIEW_DEFAULTS.halfLifeDays);
 /**

package/dist/sim/sim.d.ts

@@ -225,6 +225,7 @@ export declare function communityState(c: Community): CommunityState;
 /**
  * A community over `people`. With `prior` (from `communityState`, possibly through JSON), the host-side state is
  * resumed from it, so a run restored from people + community + world state continues exactly as it would have.
+ * `prior` is copied: after stepping, write back `communityState(c)`; the old `prior` stays stale.
  */
 export declare function createCommunity(people: Person[], prior?: CommunityState): Community;
 /** Add a person to a community (a newborn, an arrival); keeps the id order the driver relies on. */
@@ -237,9 +238,13 @@ export declare function birth(c: Community, a: Person, b: Person, spec: ChildSpe
 /**
  * Tell `dead`'s death at `at` to everyone alive in the community who has a tie to them (1.8.0): a told `death`
  * percept through `perceive`, so they grieve, the tie is kept and marked, and a spouse is widowed. Each listener's
- * clock must be at or before `at`; the drivers call it when they notice the death.
+ * receipt time is at least their own `now`. `late: 'now'` explicitly permits listeners past `at`, as does the
+ * existing default. `late: 'throw'` requires all eligible listeners to be at or before `at` and throws before
+ * delivering any news if one is ahead. This changes no listener's clock.
  */
-export declare function tellDeath(c: Community, dead: Person, at: Minute): void;
+export declare function tellDeath(c: Community, dead: Person, at: Minute, opts?: {
+    late?: 'throw' | 'now';
+}): void;
 /** Next minute at which this person needs attention. */
 export declare function nextEventAt(c: Community, p: Person): Minute;
 /**