@adam0white/human-framework 2.8.0 → 2.9.1

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

@@ -511,7 +511,10 @@ export interface Commitment {
     status: 'pending' | 'kept' | 'broken' | 'released';
     /** Optional recurrence: re-create after it closes (e.g. daily prayer windows). */
     recurEvery?: number;
-    /** Optional display name, e.g. 'Maghrib'; used in counter-offers ("after I pray Maghrib"). */
+    /**
+     * Optional display name, e.g. 'Maghrib'; used in counter-offers ("after I pray Maghrib") and in `reviewLine`
+     * ("I didn't keep my call to Mum"), so write it as a noun phrase.
+     */
     label?: string;
     /** For kind 'abstain': action ids whose completion inside the window breaks it. */
     violatedBy?: string[];
@@ -837,7 +840,7 @@ export declare const PERSON_SCHEMA = "human/person@1";
  * and an activity that would cover a closing stretch is reviewed when the stretch begins (`isUnderWay`,
  * `dutyReviewAt`). Person shape unchanged.
  */
-export declare const ENGINE_VERSION = "2.8.0";
+export declare const ENGINE_VERSION = "2.9.0";
 /** A pregnancy carried by this person (host-driven; see `family/`). */
 export interface Pregnancy {
     fatherId: PersonId;
@@ -1100,7 +1103,11 @@ export interface Affordance {
     /** Free tags: 'work', 'leisure', 'social', 'worship', 'risky', 'outdoors', ... */
     tags?: string[];
     norms?: NormTag[];
-    /** Commitment ids this would fulfil if completed. */
+    /**
+     * Commitment ids this would fulfil if completed. Listing two or more keeps every listed one that is pending and
+     * in window, and no other (2.9.0), not even an earlier-ending match by action; listing one keeps the
+     * earliest-ending match, explicit or by action, as before.
+     */
     fulfills?: string[];
     /** Goal ids this advances. */
     advances?: string[];
@@ -1249,7 +1256,11 @@ export interface Outcome {
      * under protest and 1 otherwise. Lower quality lowers felt valence and therefore learned expectations.
      */
     quality?: Unit;
-    /** Commitment ids this outcome keeps (defaults to the activity's `Affordance.fulfills`). */
+    /**
+     * Commitment ids this outcome keeps (defaults to the activity's `Affordance.fulfills`). With two or more listed,
+     * every listed one pending and in window is kept, and no other (2.9.0); with one, one completion keeps the
+     * earliest-ending match.
+     */
     fulfills?: string[];
     /** Goal ids this outcome advances (defaults to the activity's `Affordance.advances`). */
     advances?: string[];
@@ -1333,9 +1344,16 @@ export interface Term {
      *  'goal:g1', 'habit', 'emotion:fear:risky' (emotion id, then the tag it acts through), 'effort', 'risk',
      *  'suggestion:player', 'social:p2', 'expectation', 'autonomy' (reactance to a pushing voice),
      *  'promptings:turn' (a practised turning-away), 'forecast:body' (expected
-     *  bodily state during `followedBy` spans), 'promptings:echo' (recurrence under the `fault` reading) */
+     *  bodily state during `followedBy` spans), 'promptings:echo' (recurrence under the `fault` reading),
+     *  'review:resolve' (a resolve from the evening review) */
     source: string;
     value: number;
+    /**
+     * What a generic source refers to (2.9.0), so `source` stays stable for hosts that match it exactly. Set on
+     * `review:resolve` to the resolve's key (`Resolve.key`) when exactly one resolve weighed in; absent when several
+     * did. Absent on every other term.
+     */
+    ref?: string;
 }
 export interface Considered {
     affordanceId: string;
@@ -1455,6 +1473,13 @@ export interface PromptingResponse {
     /** Skill-like practice 0..1 as of `lastUsedAt`; it decays slowly with disuse. */
     practice: Unit;
     lastUsedAt: Minute;
+    /**
+     * What this response was learned for (2.9.0): an action, an offer tag, or the opposing norm or goal (`n1`,
+     * `norm:n1` or `goal:g1`). A cued response serves only prompts it matches; a response without a cue serves every
+     * prompt that no cued response matches. A norm or goal cue matches only the prompt's strongest opposing term.
+     * Cues longer than 200 characters are ignored.
+     */
+    cue?: string;
 }
 export interface PromptingRecord {
     at: Minute;
@@ -1482,6 +1507,8 @@ export interface PromptingsState {
     }>;
     /** Echo gained per prompt under `fault`. Default 0: the recurrence term is a host-set assumption (P3 contested). */
     echoRate: number;
+    /** Days over which disused practice halves (2.9.0, host-set); absent = `PROMPTINGS_DEFAULTS.practiceHalfLifeDays`. */
+    practiceHalfLifeDays?: number;
 }
 /**
  * How a person reviews a day (2.7.0, a held reading): `accounting` (muhasaba: name the lapse and resolve for its
@@ -1528,12 +1555,21 @@ export interface ReviewSpec {
 export interface PromptingsSpec {
     reading?: PromptingReading;
     readingSource?: string;
+    /** `cue` (2.9.0): what the response was learned for; see `PromptingResponse.cue`. */
     responses?: {
         id: string;
         kind: PromptingResponseKind;
         practice?: Unit;
+        cue?: string;
     }[];
     echoRate?: number;
+    /**
+     * Days over which disused practice halves (2.9.0), for hosts whose time runs short (a one-week game). Applies to
+     * every response of the person, including disuse since a response's last use. Absent = 60 days, as before.
+     * Read on every `enablePromptings` call: re-enabling without it returns the person to the default. Values outside
+     * (0, 36500] are ignored.
+     */
+    practiceHalfLifeDays?: number;
 }
 /** What the body is doing over an interval. */
 export interface BodyLoad {

package/dist/types.js

@@ -120,4 +120,4 @@ export const PERSON_SCHEMA = 'human/person@1';
  * and an activity that would cover a closing stretch is reviewed when the stretch begins (`isUnderWay`,
  * `dutyReviewAt`). Person shape unchanged.
  */
-export const ENGINE_VERSION = '2.8.0';
+export const ENGINE_VERSION = '2.9.0';

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.8.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",