@adam0white/human-framework 2.9.0 → 2.10.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.9.0",
+  "version": "2.10.0",
   "description": "Deterministic, explainable simulated people: body, needs, affect, memory, beliefs, skills, habits, relationships, values and a will that can refuse a suggestion",
   "keywords": [
     "simulation",