@adam0white/human-framework 2.9.0 → 2.9.1

package/dist/agenda/agenda.js

@@ -489,7 +489,7 @@ function deadlinePressure(g, now) {
     return 1 + AGENDA_DEFAULTS.goalDeadlineBoost * clamp01((now - g.adoptedAt) / span);
 }
 /** Shared existing amount and urgency reader; no future knowledge is consulted here. @internal */
-export function goalValue(g, aff, now) {
+function goalValue(g, aff, now) {
     const amount = goalAmount(g, aff);
     return amount > 0
         ? g.importance * clamp01(amount * AGENDA_DEFAULTS.goalAmountGain) * deadlinePressure(g, now)

package/dist/beliefs/beliefs.d.ts

@@ -39,7 +39,29 @@ export interface AttendContext {
 }
 /** Attention as limited capacity: keep the K most relevant percepts plus any that cannot be ignored. */
 export declare function attend(p: Person, percepts: Percept[], ctx: AttendContext): Percept[];
+/** Information-source trust, independent of relationship trust and advising-voice trust. */
 export declare function trustOf(p: Person, sourceId: EntityId): Unit;
+/**
+ * Set authored trust in an information source, clamped to 0..1. Writes only `memory.sourceTrust`;
+ * it does not change relationship trust or advising-voice trust. Nonfinite trust and self ids throw.
+ * Later `believe` (including testimony through `perceive`) reads this trust; `confirm` recalibrates it.
+ */
+export declare function seedSourceTrust(p: Person, sourceId: EntityId, trust: Unit): Unit;
+/**
+ * Set or replace an authored belief without applying source trust or recording an observation.
+ * `credence` is the probability that `value` holds, clamped to 0..1 and stored as bounded signed
+ * log-odds. `at` defaults to the person's current minute. Nonfinite credence or time throws.
+ * Only `memory.beliefs` changes, with ordinary belief eviction. An omitted source leaves no sources;
+ * a named source records its claim for later `confirm`, without changing any trust store now. The person's own id
+ * and 'self' are refused (they mark observation): use `confirm` for something the person saw.
+ * It does not apply reputation to relationships; use `seedTie` to author a relationship.
+ */
+export declare function seedBelief(p: Person, prop: string, spec: {
+    value: boolean;
+    credence: Unit;
+    at?: Minute;
+    source?: EntityId;
+}): Belief;
 /** Testimony or inference: add reliability-weighted log-odds evidence for (or against) `prop`. */
 export declare function believe(p: Person, prop: string, value: boolean, confidence: Unit, sourceId: EntityId, now: Minute): Belief;
 export declare function credence(p: Person, prop: string): Unit;

package/dist/beliefs/beliefs.js

@@ -8,6 +8,12 @@
  * gained, the trust-asymmetry finding). It does NOT model motivated reasoning, belief networks or
  * inference between propositions, source memory errors, or social consensus effects; parameters are
  * engineering defaults for game time scales.
+ *
+ * Three independent stores: `social.relationships[].trust` moves through authored ties, social events
+ * (including forgiveness), judged acts and reputation; `will.voices[].trust` moves through followed-advice
+ * outcomes, insisting, commands, `noteVoicePromise`, `seedVoice` and `adoptVoiceTrust` (also used by upbringing).
+ * This module owns `memory.sourceTrust`: `seedSourceTrust` authors it and `confirm` recalibrates it.
+ * `believe`, including testimony delivered by `perceive`, weights claims by source trust, read by `trustOf`.
  */
 import { clamp, clamp01, decay, dpow, expit, logit } from '../core/index.js';
 import { MINUTES_PER_DAY } from '../types.js';
@@ -97,11 +103,31 @@ export function attend(p, percepts, ctx) {
     }
     return out;
 }
+/** Information-source trust, independent of relationship trust and advising-voice trust. */
 export function trustOf(p, sourceId) {
     if (sourceId === p.id || sourceId === 'self')
         return BELIEF_DEFAULTS.selfTrust;
     return p.memory.sourceTrust[sourceId] ?? BELIEF_DEFAULTS.defaultTrust;
 }
+/**
+ * Set authored trust in an information source, clamped to 0..1. Writes only `memory.sourceTrust`;
+ * it does not change relationship trust or advising-voice trust. Nonfinite trust and self ids throw.
+ * Later `believe` (including testimony through `perceive`) reads this trust; `confirm` recalibrates it.
+ */
+export function seedSourceTrust(p, sourceId, trust) {
+    if (!Number.isFinite(trust))
+        throw new Error('human: source trust must be finite');
+    if (sourceId === p.id || sourceId === 'self')
+        throw new Error('human: self trust cannot be seeded');
+    const value = clamp01(trust);
+    Object.defineProperty(p.memory.sourceTrust, sourceId, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+    return value;
+}
 /** Testimony weight from trust: 0 at or below the floor, never negative, so low trust alone never flips a claim. @internal */
 export function testimonyWeight(trust) {
     const d = BELIEF_DEFAULTS;
@@ -141,6 +167,31 @@ function ensureBelief(p, prop, now) {
     }
     return b;
 }
+/**
+ * Set or replace an authored belief without applying source trust or recording an observation.
+ * `credence` is the probability that `value` holds, clamped to 0..1 and stored as bounded signed
+ * log-odds. `at` defaults to the person's current minute. Nonfinite credence or time throws.
+ * Only `memory.beliefs` changes, with ordinary belief eviction. An omitted source leaves no sources;
+ * a named source records its claim for later `confirm`, without changing any trust store now. The person's own id
+ * and 'self' are refused (they mark observation): use `confirm` for something the person saw.
+ * It does not apply reputation to relationships; use `seedTie` to author a relationship.
+ */
+export function seedBelief(p, prop, spec) {
+    const at = spec.at ?? p.now;
+    if (!Number.isFinite(spec.credence))
+        throw new Error('human: belief credence must be finite');
+    if (!Number.isFinite(at))
+        throw new Error('human: belief time must be finite');
+    // The person's own id and 'self' mark direct observation (`observedDiscount`, `confirm`); authoring is not seeing.
+    if (spec.source === p.id || spec.source === 'self')
+        throw new Error('human: an authored belief cannot name the person as its source; use confirm for an observation');
+    const b = ensureBelief(p, prop, at);
+    const limit = BELIEF_DEFAULTS.maxLogOdds;
+    b.logOdds = clamp((spec.value ? 1 : -1) * logit(clamp01(spec.credence)), -limit, limit);
+    b.updatedAt = at;
+    b.sources = spec.source === undefined ? [] : [{ id: spec.source, value: spec.value }];
+    return b;
+}
 /** Testimony or inference: add reliability-weighted log-odds evidence for (or against) `prop`. */
 export function believe(p, prop, value, confidence, sourceId, now) {
     const d = BELIEF_DEFAULTS;

package/dist/cognition/cognition.js

@@ -225,7 +225,7 @@ export function socialContext(ctx) {
     };
 }
 /** Same perceived-body effort estimate for actual offers and received successors. @internal */
-export function effortValue(p, aff, ctx) {
+function effortValue(p, aff, ctx) {
     const K = COGNITION_DEFAULTS;
     const per = ctx.body.perceived;
     const effort = clamp01(aff.effort);
@@ -239,7 +239,7 @@ export function effortValue(p, aff, ctx) {
     return -K.effortScale * effortCost;
 }
 /** Same material valuation for actual offers and received successor costs. @internal */
-export function materialValue(p, material, scarcity) {
+function materialValue(p, material, scarcity) {
     const K = COGNITION_DEFAULTS;
     const v = p.values;
     const weight = (v.security + v.achievement + v.power) / 3;

package/dist/conscience/conscience.d.ts

@@ -100,9 +100,13 @@ export declare function recordDeed(p: Person, aff: Affordance, intention: string
  * The person repents a breach: regret, stopping and resolve. When another person was wronged,
  * restitution is also required, so the breach closes only after `recordRepair` for that victim.
  * Returns whether the breach is now closed. This records the person's acts, not acceptance.
+ * The unused `_now` parameter is optional since 2.9.1 and is removed in 3.0.
  */
-export declare function repent(p: Person, id: string, _now: Minute): boolean;
-/** Restitution/apology delivered to a wronged person (host-attested): closes their open breaches. */
-export declare function recordRepair(p: Person, victimId: string, _now: Minute): number;
+export declare function repent(p: Person, id: string, _now?: Minute): boolean;
+/**
+ * Restitution/apology delivered to a wronged person (host-attested): closes their open breaches.
+ * The unused `_now` parameter is optional since 2.9.1 and is removed in 3.0.
+ */
+export declare function recordRepair(p: Person, victimId: string, _now?: Minute): number;
 /** Felt weight of open breaches, saturating: 1 - Π(1 - weight). Input for guilt in affect. */
 export declare function guiltLoad(p: Person): Unit;

package/dist/conscience/conscience.js

@@ -351,6 +351,7 @@ export function recordDeed(p, aff, intention, now, completed, opts = {}) {
  * The person repents a breach: regret, stopping and resolve. When another person was wronged,
  * restitution is also required, so the breach closes only after `recordRepair` for that victim.
  * Returns whether the breach is now closed. This records the person's acts, not acceptance.
+ * The unused `_now` parameter is optional since 2.9.1 and is removed in 3.0.
  */
 export function repent(p, id, _now) {
     const breach = p.conscience.breaches.find((b) => b.id === id);
@@ -361,7 +362,10 @@ export function repent(p, id, _now) {
     breach.repaired = true;
     return true;
 }
-/** Restitution/apology delivered to a wronged person (host-attested): closes their open breaches. */
+/**
+ * Restitution/apology delivered to a wronged person (host-attested): closes their open breaches.
+ * The unused `_now` parameter is optional since 2.9.1 and is removed in 3.0.
+ */
 export function recordRepair(p, victimId, _now) {
     let count = 0;
     for (const b of p.conscience.breaches) {

package/dist/core/math.d.ts

@@ -5,6 +5,7 @@ export declare const clampSigned: (value: number) => number;
 export declare const lerp: (a: number, b: number, t: number) => number;
 export declare const sigmoid: (x: number) => number;
 export declare const logit: (p: number) => number;
+/** @deprecated since 2.9.1, removed in 3.0; use sigmoid */
 export declare const expit: typeof sigmoid;
 /** Exponential decay of `value` toward `target` over `dt` minutes with the given half-life. */
 export declare function decay(value: number, dt: number, halfLife: number, target?: number): number;

package/dist/core/math.js

@@ -36,6 +36,7 @@ export const logit = (p) => {
     const q = clamp(p, 1e-6, 1 - 1e-6);
     return dlog(q / (1 - q));
 };
+/** @deprecated since 2.9.1, removed in 3.0; use sigmoid */
 export const expit = sigmoid;
 /** Exponential decay of `value` toward `target` over `dt` minutes with the given half-life. */
 export function decay(value, dt, halfLife, target = 0) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-/** Human Framework v1 public surface. */
-export declare const FRAMEWORK_VERSION = "2.9.0";
+/** Human Framework public surface. */
+export declare const FRAMEWORK_VERSION = "2.9.1";
 export type { CrisisEvent, PracticeKind } from './affect/index.ts';
 export { AFFECT_DEFAULTS, actionTendencies, advanceAffect, appraise, breakAllows, breakBehaviour, breakHazard, CRISIS_DEFAULTS, checkCrisis, createAffect, easeBreak, emotionLevel, enableBreaks, feel, inBreak, readAffect, regulate, release as releaseEmotion, skipCrisis, strain, tendencyEmotions, } from './affect/index.ts';
 export type { GoalTemplate, PrayerCalendar, PrayerSchedule, PrayerTimes, Retimer, } from './agenda/index.ts';
@@ -31,7 +31,7 @@ export * from './person.ts';
 export * from './promptings/index.ts';
 export type { ConsequenceEvidence } from './prospection/index.ts';
 export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, forecastThresholds, PROSPECTION_DEFAULTS, } from './prospection/index.ts';
-export * from './restore.ts';
+export { fingerprint, restore, snapshot } from './restore.ts';
 export * from './review/index.ts';
 export * from './scenarios/index.ts';
 export * from './sim/index.ts';

package/dist/index.js

@@ -1,5 +1,5 @@
-/** Human Framework v1 public surface. */
-export const FRAMEWORK_VERSION = '2.9.0';
+/** Human Framework public surface. */
+export const FRAMEWORK_VERSION = '2.9.1';
 export { AFFECT_DEFAULTS, actionTendencies, advanceAffect, appraise, breakAllows, breakBehaviour, breakHazard, CRISIS_DEFAULTS, checkCrisis, createAffect, easeBreak, emotionLevel, enableBreaks, feel, inBreak, readAffect, regulate, release as releaseEmotion, skipCrisis, strain, tendencyEmotions, } from './affect/index.js';
 // `agenda.release` collides with `affect.release`; the agenda one is re-exported under a clearer name.
 export { AGENDA_DEFAULTS, abandonGoal, adoptGoal, advanceAgenda, agendaTerms, applyExemptions, CARE_DEFAULTS, calendarRetimer, careDuty, commitmentPressure, createAgenda, DEFAULT_PRAYER_TIMES, EID_PRAYER_IMPORTANCE, EXEMPTION_DEFAULTS, eidPrayer, eidWindow, fastWindow, iftarWindow, inMakruhTime, isUnderWay, MAKRUH_DEFAULTS, makruhWindows, missedExcuse, onFinished, owedMakeUps, PRAYER_IMPORTANCE, PURPOSE_DEFAULTS, prayerWindows, pressureReachedAt, promise, proposeGoals, RAMADAN_DEFAULTS, ramadanFast, ramadanMeals, release as releaseCommitment, retimeCommitments, revisePurposes, scheduleMakeUp, spanMeetsWindow, suhoorWindow, timesFor, violatesAbstention, } from './agenda/index.js';
@@ -27,7 +27,7 @@ export * from './partnering/index.js';
 export * from './person.js';
 export * from './promptings/index.js';
 export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, forecastThresholds, PROSPECTION_DEFAULTS, } from './prospection/index.js';
-export * from './restore.js';
+export { fingerprint, restore, snapshot } from './restore.js';
 export * from './review/index.js';
 export * from './scenarios/index.js';
 export * from './sim/index.js';

package/dist/migrate.js

@@ -8,7 +8,17 @@
  * field of the optional surroundings slice (`ambient.now` → `ambient.percept`) and changes no behaviour (the optional `social.impressions` and `social.reserve`, like `retention`, are optional and start
  * absent in a migrated save); `restore` then fills and sanitizes
  * the slices as for any save. 2.0.0 to 2.1.0 adds optional conditional method state, absent
- * until explicitly used, so existing hosts retain their previous behavior; that step stamps the version. 2.1.0 to 2.2.0 preserves optional method records and stamps the version; successful alternatives now retain independent support. 2.2.0 to 2.3.0 stamps the version; received consequences and temporal goals remain absent unless explicitly supplied. 2.3.0 to 2.4.0 stamps the version; promptings remain absent unless enabled. 2.4.0 to 2.5.0 stamps the version; the bodily forecast reads only offers that declare `followedBy`. 2.5.0 to 2.6.0 stamps the version; the fatigue store stays absent unless enabled. 2.6.0 to 2.7.0 stamps the version; the evening review stays absent unless enabled. A migrated save continues under the current engine's rules: it restores and runs,
+ * until explicitly used, so existing hosts retain their previous behavior; that step stamps the version.
+ * 2.1.0 to 2.2.0 preserves optional method records and stamps the version; successful alternatives now
+ * retain independent support. 2.2.0 to 2.3.0 stamps the version; received consequences and temporal goals
+ * remain absent unless explicitly supplied. 2.3.0 to 2.4.0 stamps the version; promptings remain absent
+ * unless enabled. 2.4.0 to 2.5.0 stamps the version; the bodily forecast reads only offers that declare
+ * `followedBy`. 2.5.0 to 2.6.0 stamps the version; the fatigue store stays absent unless enabled. 2.6.0 to
+ * 2.7.0 stamps the version; the evening review stays absent unless enabled. 2.7.0 to 2.8.0 stamps the
+ * version; fullness stays absent unless enabled, and alongside partners and reconsideration are opt-in.
+ * 2.8.0 to 2.9.0 stamps the version; prompting cues and practice half-lives stay absent unless supplied,
+ * review terms may carry refs, and an outcome naming several commitments now keeps each rather than only
+ * the earliest-ending one. A migrated save continues under the current engine's rules: it restores and runs,
  * but it does not reproduce what the old engine would have done next where the rules changed (1.4.0 to 1.5.0
  * changed how standing advice is heard; 1.8.0 to 1.9.0 changed the omission rule). Saves older than 1.4.0 and unknown versions are refused with an error.
  *

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/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/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;
 /**

package/dist/sim/sim.js

@@ -125,6 +125,7 @@ export function communityState(c) {
 /**
  * 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 function createCommunity(people, prior) {
     const sorted = [...people].sort((a, b) => cmpStr(a.id, b.id));
@@ -181,9 +182,19 @@ export function birth(c, a, b, spec) {
 /**
  * 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 function tellDeath(c, dead, at) {
+export function tellDeath(c, dead, at, opts = {}) {
+    if (opts.late === 'throw') {
+        for (const q of c.people) {
+            if (q === dead || !q.body.alive || q.now <= at)
+                continue;
+            if (q.social.relationships.some((r) => r.otherId === dead.id))
+                throw new Error(`tellDeath: listener ${q.id} is past the death minute`);
+        }
+    }
     for (const q of c.people) {
         if (q === dead || !q.body.alive)
             continue;
@@ -572,24 +583,8 @@ function contagionBetween(p, q, act, t, log) {
         }
     }
 }
-/**
- * Advance the community to `until`, processing person events in (time, id) order. Returns the events.
- */
-export function stepCommunity(c, world, until, opts = {}) {
-    const events = [];
-    const quantum = Math.max(1, opts.idleQuantum ?? SIM_DEFAULTS.idleQuantum);
-    const maxEvents = opts.maxEvents ?? SIM_DEFAULTS.maxEvents;
-    const salience = opts.interruptSalience ?? SIM_DEFAULTS.interruptSalience;
-    // 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);
-    };
-    const contagion = opts.contagion ?? true;
-    c.queued ??= {};
-    c.dayDone ??= {};
+/** Synchronize the host's commands before selecting the next event. */
+function synchronizeCommands(c, opts, log) {
     if (opts.controlled) {
         for (const p of c.people) {
             const cmd = opts.controlled[p.id];
@@ -614,36 +609,108 @@ export function stepCommunity(c, world, until, opts = {}) {
             }
         }
     }
-    const decideOpts = (p, reason, affordances) => {
-        const o = {};
-        // Voices: queued conversation advice first (fresher), then the host's standing suggestions that are heard now
-        // (standing-advice SCOPE); one per voice. At reviews they still weigh in, but `decide` resolves them quietly
-        // (no counters, pressure or autonomy cost), so one request is not re-counted as many verdicts.
-        const standing = opts.suggestions?.[p.id];
-        const merged = [];
-        const seen = new Set();
-        const heard = (standing ? (Array.isArray(standing) ? standing : [standing]) : []).filter((s) => standingHeard(c, p, s, affordances, p.now));
-        for (const s of [...(c.queued?.[p.id] ?? []), ...heard]) {
-            if (seen.has(s.voiceId))
-                continue;
-            seen.add(s.voiceId);
-            merged.push(s);
+}
+/** Run life-course bookkeeping and the host's day hook at the first event of a new day. */
+function bookkeepDay(p, world, t, dayDone, opts) {
+    // First event of a new day: life-course rolls for the days crossed, then the host's day hook.
+    const day = dayOf(t);
+    const lastDay = dayDone[p.id];
+    if (lastDay === undefined || day > lastDay) {
+        dayDone[p.id] = day;
+        const lc = opts.lifecourse;
+        if (lc && lastDay !== undefined && p.body.alive) {
+            const dt = (day - lastDay) * MINUTES_PER_DAY;
+            if (lc.chronicOnsets) {
+                const onsetOpts = {};
+                if (lc.conditions)
+                    onsetOpts.conditions = lc.conditions;
+                const ex = lc.exposures?.(p);
+                if (ex)
+                    onsetOpts.exposures = ex;
+                for (const ill of chronicOnsets(p, dt, p.rng, onsetOpts))
+                    sicken(p, ill);
+            }
+            if (lc.mortality) {
+                const roll = mortalityEvent(p, dt, p.rng, lc.multiplier !== undefined ? { multiplier: lc.multiplier } : {});
+                if (roll.died)
+                    die(p);
+            }
         }
-        const [first, ...rest] = merged;
-        if (first)
-            o.suggestion = first;
-        if (rest.length > 0)
-            o.suggestions = rest;
-        const scarcity = world.scarcityFor?.(p);
-        if (scarcity !== undefined && scarcity > 0)
-            o.scarcity = scarcity;
-        if (opts.necessity !== undefined)
-            o.necessity = opts.necessity;
-        const forced = reason ?? c.interrupts[p.id]?.reason;
-        if (forced !== undefined && !p.activity)
-            o.interrupt = forced;
-        return o;
+        if (p.body.alive)
+            world.onDay?.(p, day);
+    }
+}
+/** Merge heard advice and the host's decision options in their existing precedence order. */
+function decisionOptions(c, world, p, opts, reason, affordances) {
+    const o = {};
+    // Voices: queued conversation advice first (fresher), then the host's standing suggestions that are heard now
+    // (standing-advice SCOPE); one per voice. At reviews they still weigh in, but `decide` resolves them quietly
+    // (no counters, pressure or autonomy cost), so one request is not re-counted as many verdicts.
+    const standing = opts.suggestions?.[p.id];
+    const merged = [];
+    const seen = new Set();
+    const heard = (standing ? (Array.isArray(standing) ? standing : [standing]) : []).filter((s) => standingHeard(c, p, s, affordances, p.now));
+    for (const s of [...(c.queued?.[p.id] ?? []), ...heard]) {
+        if (seen.has(s.voiceId))
+            continue;
+        seen.add(s.voiceId);
+        merged.push(s);
+    }
+    const [first, ...rest] = merged;
+    if (first)
+        o.suggestion = first;
+    if (rest.length > 0)
+        o.suggestions = rest;
+    const scarcity = world.scarcityFor?.(p);
+    if (scarcity !== undefined && scarcity > 0)
+        o.scarcity = scarcity;
+    if (opts.necessity !== undefined)
+        o.necessity = opts.necessity;
+    const forced = reason ?? c.interrupts[p.id]?.reason;
+    if (forced !== undefined && !p.activity)
+        o.interrupt = forced;
+    return o;
+}
+/** Add pending joint mirrors to world offers and apply this minute's declined-offer exclusions. */
+function offersForDecision(c, world, p, t) {
+    // Offers: the world's, plus mirrors of joint proposals awaiting this person's answer, minus offers a partner
+    // just declined (this minute only).
+    const asked = pendingProposals(c).filter((x) => x.partnerIds.includes(p.id) && !x.accepted.includes(p.id));
+    const mirrors = new Map();
+    let affordances = world.affordancesFor(p);
+    for (const x of asked) {
+        const m = mirrorFor(world, p, x);
+        mirrors.set(m.id, x);
+        affordances = [...affordances.filter((a) => a.id !== m.id), m];
+    }
+    const ex = c.joint.excluded[p.id];
+    if (ex) {
+        if (ex.at === t)
+            affordances = affordances.filter((a) => !ex.ids.includes(a.id));
+        else
+            delete c.joint.excluded[p.id];
+    }
+    return { asked, mirrors, affordances };
+}
+/**
+ * Advance the community to `until`, processing person events in (time, id) order. Returns the events.
+ */
+export function stepCommunity(c, world, until, opts = {}) {
+    const events = [];
+    const quantum = Math.max(1, opts.idleQuantum ?? SIM_DEFAULTS.idleQuantum);
+    const maxEvents = opts.maxEvents ?? SIM_DEFAULTS.maxEvents;
+    const salience = opts.interruptSalience ?? SIM_DEFAULTS.interruptSalience;
+    // 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);
     };
+    const contagion = opts.contagion ?? true;
+    c.queued ??= {};
+    c.dayDone ??= {};
+    synchronizeCommands(c, opts, log);
     // Pairs whose shared activity already ran its conversation and contagion at `pairMinute` (both partners
     // finishing the same joint activity at the same minute would otherwise run them twice).
     let pairMinute = Number.NEGATIVE_INFINITY;
@@ -662,33 +729,7 @@ export function stepCommunity(c, world, until, opts = {}) {
             break;
         const p = next;
         tick(p, t);
-        // First event of a new day: life-course rolls for the days crossed, then the host's day hook.
-        const day = dayOf(t);
-        const lastDay = c.dayDone[p.id];
-        if (lastDay === undefined || day > lastDay) {
-            c.dayDone[p.id] = day;
-            const lc = opts.lifecourse;
-            if (lc && lastDay !== undefined && p.body.alive) {
-                const dt = (day - lastDay) * MINUTES_PER_DAY;
-                if (lc.chronicOnsets) {
-                    const onsetOpts = {};
-                    if (lc.conditions)
-                        onsetOpts.conditions = lc.conditions;
-                    const ex = lc.exposures?.(p);
-                    if (ex)
-                        onsetOpts.exposures = ex;
-                    for (const ill of chronicOnsets(p, dt, p.rng, onsetOpts))
-                        sicken(p, ill);
-                }
-                if (lc.mortality) {
-                    const roll = mortalityEvent(p, dt, p.rng, lc.multiplier !== undefined ? { multiplier: lc.multiplier } : {});
-                    if (roll.died)
-                        die(p);
-                }
-            }
-            if (p.body.alive)
-                world.onDay?.(p, day);
-        }
+        bookkeepDay(p, world, t, c.dayDone, opts);
         if (!p.body.alive) {
             log({ at: t, personId: p.id, kind: 'died', detail: `${p.name} died` });
             if (opts.tellDeaths ?? true)
@@ -758,24 +799,8 @@ export function stepCommunity(c, world, until, opts = {}) {
             }
             act = p.activity;
         }
-        // Offers: the world's, plus mirrors of joint proposals awaiting this person's answer, minus offers a partner
-        // just declined (this minute only).
-        const asked = pendingProposals(c).filter((x) => x.partnerIds.includes(p.id) && !x.accepted.includes(p.id));
-        const mirrors = new Map();
-        let affordances = world.affordancesFor(p);
-        for (const x of asked) {
-            const m = mirrorFor(world, p, x);
-            mirrors.set(m.id, x);
-            affordances = [...affordances.filter((a) => a.id !== m.id), m];
-        }
-        const ex = c.joint.excluded[p.id];
-        if (ex) {
-            if (ex.at === t)
-                affordances = affordances.filter((a) => !ex.ids.includes(a.id));
-            else
-                delete c.joint.excluded[p.id];
-        }
-        const record = decide(p, affordances, decideOpts(p, perceptReason, affordances));
+        const { asked, mirrors, affordances } = offersForDecision(c, world, p, t);
+        const record = decide(p, affordances, decisionOptions(c, world, p, opts, perceptReason, affordances));
         delete c.interrupts[p.id];
         // Conversation advice is weighed until the next fresh decision, then it has been heard.
         if (!act)

package/dist/will/will.js

@@ -562,10 +562,49 @@ const voiceTerm = (c, voiceId) => c?.terms.find((t) => t.source === `suggestion:
  * group-advice findings only in shape (advice is weighed by trust in each adviser, not by headcount); it does not model conformity to a majority, persuasion between the voices, or the person asking for advice.
  */
 function evaluate(p, input, ctx, given, draw) {
-    const W = WILL_DEFAULTS;
     const cmd = ctx.command;
     // A commanding voice is not also weighed as a suggestion in the same decision.
     const suggestions = cmd ? given.filter((s) => s.voiceId !== cmd.voiceId) : given;
+    const prepared = prepareVetoes(p, input, ctx, suggestions);
+    const { considered, affById } = prepared;
+    const selection = selectOption(p, considered, ctx, draw);
+    const ev = {
+        chosenId: selection.winner?.affordanceId ?? null,
+        considered,
+        resolutions: [],
+        autonomyDelta: 0,
+        voices: [],
+    };
+    if (cmd && arbitrateCommand(p, ctx, cmd, suggestions, prepared, selection, ev))
+        return ev;
+    if (suggestions.length === 0)
+        return withCommandRefusal(ev, cmd);
+    if (inBreak(p)) {
+        // During a mental break no voice reaches them; nothing is counted for or against any of them.
+        ev.resolutions = suggestions.map((s) => ({
+            voiceId: s.voiceId,
+            verdict: 'refused',
+            kind: 'cannot',
+            reason: 'break',
+            says: '',
+        }));
+        ev.voices = suggestions.map((s) => ({ id: s.voiceId, pressure: 0, accepted: 0, refused: 0 }));
+        if (ev.resolutions.length === 1)
+            ev.suggestion = ev.resolutions[0];
+        return withCommandRefusal(ev, cmd);
+    }
+    const judged = judgeVoices(p, ctx, suggestions, prepared, selection);
+    arbitrateInsistence(p, judged, considered, affById, ev);
+    ev.resolutions = judged.map((j) => j.res);
+    ev.voices = judged.map((j) => j.side);
+    const chosen = considered.find((c) => c.affordanceId === ev.chosenId);
+    ev.suggestion =
+        creditedResolution(ev.resolutions, chosen) ??
+            (ev.resolutions.length === 1 ? ev.resolutions[0] : undefined);
+    return withCommandRefusal(ev, cmd);
+}
+/** Apply capacity, conscience, per-voice distrust and omission vetoes, in that order. */
+function prepareVetoes(p, input, ctx, suggestions) {
     const affById = new Map(ctx.affordances.map((a) => [a.id, a]));
     const duties = closingDuties(p, ctx);
     const servesDuty = (aff) => duties.some((c) => keepsDuty(p, c, aff, ctx.now));
@@ -609,6 +648,11 @@ function evaluate(p, input, ctx, given, draw) {
             out.vetoed = veto;
         return out;
     });
+    return { affById, duties, baseVeto, distrustOf, considered };
+}
+/** Select once using the supplied draw; prediction passes no draw and stays deterministic. */
+function selectOption(p, considered, ctx, draw) {
+    const W = WILL_DEFAULTS;
     // Selection: inertia for the current activity, then argmax or softmax.
     const live = considered.filter((c) => !c.vetoed);
     const current = p.activity;
@@ -636,67 +680,55 @@ function evaluate(p, input, ctx, given, draw) {
             }
         }
     }
-    const ev = {
-        chosenId: winner?.affordanceId ?? null,
-        considered,
-        resolutions: [],
-        autonomyDelta: 0,
-        voices: [],
-    };
-    if (cmd) {
-        const co = commandOutcome(p, considered, ctx, cmd, winner, score, baseVeto, duties);
-        ev.command = co;
-        if (co.holds && co.targetAffordanceId !== undefined) {
-            // Direct control: the commanded option is done; every other voice is set aside (no counters) and a
-            // distrust veto another voice caused does not stand in the way.
-            ev.chosenId = co.targetAffordanceId;
-            for (const c of considered)
-                if (c.vetoed?.reason === 'distrust')
-                    delete c.vetoed;
-            const res = {
-                voiceId: cmd.voiceId,
-                verdict: 'commanded',
-                reason: 'command',
-                says: '',
-                margin: co.margin,
-            };
-            if (co.ownAffordanceId !== null && co.ownAffordanceId !== co.targetAffordanceId)
-                res.insteadAffordanceId = co.ownAffordanceId;
-            const all = [
-                res,
-                ...suggestions.map((s) => ({
-                    voiceId: s.voiceId,
-                    verdict: 'refused',
-                    kind: 'cannot',
-                    reason: 'commanded',
-                    says: '',
-                })),
-            ].sort((a, b) => cmpStr(a.voiceId, b.voiceId));
-            ev.resolutions = all;
-            ev.voices = all.map((r) => ({ id: r.voiceId, pressure: 0, accepted: 0, refused: 0 }));
-            ev.suggestion = res;
-            return ev;
-        }
-    }
-    if (suggestions.length === 0)
-        return withCommandRefusal(ev, cmd);
-    if (inBreak(p)) {
-        // During a mental break no voice reaches them; nothing is counted for or against any of them.
-        ev.resolutions = suggestions.map((s) => ({
-            voiceId: s.voiceId,
-            verdict: 'refused',
-            kind: 'cannot',
-            reason: 'break',
+    return { winner, ranked, score };
+}
+/** Return true when a command holds and completes the evaluation ahead of all suggestions. */
+function arbitrateCommand(p, ctx, cmd, suggestions, prepared, selection, ev) {
+    const { considered, baseVeto, duties } = prepared;
+    const { winner, score } = selection;
+    const co = commandOutcome(p, considered, ctx, cmd, winner, score, baseVeto, duties);
+    ev.command = co;
+    if (co.holds && co.targetAffordanceId !== undefined) {
+        // Direct control: the commanded option is done; every other voice is set aside (no counters) and a
+        // distrust veto another voice caused does not stand in the way.
+        ev.chosenId = co.targetAffordanceId;
+        for (const c of considered)
+            if (c.vetoed?.reason === 'distrust')
+                delete c.vetoed;
+        const res = {
+            voiceId: cmd.voiceId,
+            verdict: 'commanded',
+            reason: 'command',
             says: '',
-        }));
-        ev.voices = suggestions.map((s) => ({ id: s.voiceId, pressure: 0, accepted: 0, refused: 0 }));
-        if (ev.resolutions.length === 1)
-            ev.suggestion = ev.resolutions[0];
-        return withCommandRefusal(ev, cmd);
+            margin: co.margin,
+        };
+        if (co.ownAffordanceId !== null && co.ownAffordanceId !== co.targetAffordanceId)
+            res.insteadAffordanceId = co.ownAffordanceId;
+        const all = [
+            res,
+            ...suggestions.map((s) => ({
+                voiceId: s.voiceId,
+                verdict: 'refused',
+                kind: 'cannot',
+                reason: 'commanded',
+                says: '',
+            })),
+        ].sort((a, b) => cmpStr(a.voiceId, b.voiceId));
+        ev.resolutions = all;
+        ev.voices = all.map((r) => ({ id: r.voiceId, pressure: 0, accepted: 0, refused: 0 }));
+        ev.suggestion = res;
+        return true;
     }
+    return false;
+}
+/** Judge each voice against the same selected option before resolving competing insistence. */
+function judgeVoices(p, ctx, suggestions, prepared, selection) {
+    const W = WILL_DEFAULTS;
+    const { considered, affById, distrustOf } = prepared;
+    const { winner, ranked, score } = selection;
     const winnerAff = winner ? affById.get(winner.affordanceId) : undefined;
     const reason = dominantTerm(winner);
-    const judged = suggestions.map((s) => {
+    return suggestions.map((s) => {
         const suggested = considered.filter((c) => {
             const aff = affById.get(c.affordanceId);
             return aff !== undefined && suggestionTargets(s, aff);
@@ -815,6 +847,10 @@ function evaluate(p, input, ctx, given, draw) {
                 : { affordanceId: bestSuggested.affordanceId, label: 'later' },
         }));
     });
+}
+/** Settle competing insistence in the existing voice order, preserving equal-trust/strength ties. */
+function arbitrateInsistence(p, judged, considered, affById, ev) {
+    const W = WILL_DEFAULTS;
     // Rule (a): at most one insisted option is complied with.
     const insisting = judged.filter((j) => j.comply !== undefined);
     let forcer;
@@ -882,13 +918,6 @@ function evaluate(p, input, ctx, given, draw) {
             }
         }
     }
-    ev.resolutions = judged.map((j) => j.res);
-    ev.voices = judged.map((j) => j.side);
-    const chosen = considered.find((c) => c.affordanceId === ev.chosenId);
-    ev.suggestion =
-        creditedResolution(ev.resolutions, chosen) ??
-            (ev.resolutions.length === 1 ? ev.resolutions[0] : undefined);
-    return withCommandRefusal(ev, cmd);
 }
 /** Add the commanding voice's refusal (a command that did not hold) to the resolutions, in voice-id order. */
 function withCommandRefusal(ev, cmd) {

package/package.json

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