@adam0white/human-framework 2.19.0 → 2.21.0

package/dist/sim/sim.js

@@ -50,7 +50,7 @@
  */
 import { appraise } from '../affect/index.js';
 import { matchesCommitment, spanMeetsWindow } from '../agenda/index.js';
-import { BODY_DEFAULTS, contagionRoll, die, readBody, sicken } from '../body/index.js';
+import { BODY_DEFAULTS, contagionRoll, die, nextDozeCheck, readBody, sicken } from '../body/index.js';
 import { chronicleBetween } from '../chronicle/index.js';
 import { recordDeed } from '../conscience/index.js';
 import { converse } from '../conversation/index.js';
@@ -274,7 +274,7 @@ function awaitingJoint(c, id) {
     return pendingProposals(c).some((x) => x.proposerId === id || x.accepted.includes(id));
 }
 /** Next minute at which this person needs attention. */
-export function nextEventAt(c, p) {
+function ordinaryEventAt(c, p) {
     if (!p.body.alive)
         return Number.POSITIVE_INFINITY;
     if (awaitingJoint(c, p.id))
@@ -284,6 +284,12 @@ export function nextEventAt(c, p) {
         return Math.max(p.now, Math.min(act.endsAt, act.reviewAt));
     return Math.max(p.now, c.idleUntil[p.id] ?? p.now);
 }
+/** Pure scheduling query, including passive bodily checkpoints during joint waiting. */
+export function nextEventAt(c, p) {
+    if (p.body.doze?.since !== undefined && awaitingJoint(c, p.id))
+        return p.now;
+    return Math.min(ordinaryEventAt(c, p), nextDozeCheck(p));
+}
 /**
  * How this person would answer `suggestion` now, without changing state (UI telegraph; wraps `predict`). Pass the
  * world's `scarcityFor(p)` as `scarcity`, as the step does, or the telegraph can promise what the step refuses.
@@ -415,7 +421,6 @@ export function acceptJoint(c, world, proposal, partner, partnerRecord, writeLog
     proposal.partnerRecords[partner.id] = partnerRecord;
     if (proposal.accepted.length < proposal.partnerIds.length)
         return [];
-    settle(c, proposal, 'accepted');
     const proposer = personById(c, proposal.proposerId);
     const participants = [];
     if (proposer)
@@ -427,6 +432,19 @@ export function acceptJoint(c, world, proposal, partner, partnerRecord, writeLog
             participants.push({ person: q, offer: mirrorFor(world, q, proposal), record: rec });
     }
     const at = Math.max(...participants.map((x) => x.person.now));
+    // Opted-in catch-up can physically stop a participant. Validate everyone before any begin.
+    if (participants.some(({ person }) => person.body.doze !== undefined)) {
+        for (const { person } of participants)
+            if (person.now < at)
+                tick(person, at);
+        if (participants.some(({ person }) => person.body.doze?.since !== undefined)) {
+            declineJoint(c, proposal);
+            for (const { person } of participants)
+                interruptPerson(c, person, at, person.activity?.interrupt?.reason ?? `declined:${proposal.id}`);
+            return [];
+        }
+    }
+    settle(c, proposal, 'accepted');
     const begun = [];
     for (const { person, offer, record } of participants) {
         if (person.now < at)
@@ -770,6 +788,26 @@ export function stepCommunity(c, world, until, opts = {}) {
     c.queued ??= {};
     c.dayDone ??= {};
     synchronizeCommands(c, opts, log);
+    // Cancellation releases clocks AND review deadlines. Keep pending causes, including simultaneous doze.
+    const cancelDozeWaiting = (p, t) => {
+        for (const x of pendingProposals(c)) {
+            if (x.proposerId !== p.id && !x.partnerIds.includes(p.id))
+                continue;
+            const waiters = [x.proposerId, ...x.accepted]
+                .map((id) => personById(c, id))
+                .filter((q) => q !== undefined);
+            for (const q of waiters)
+                if (q.now < t)
+                    tick(q, t);
+            const reasons = new Map(waiters.map((q) => [q.id, q.activity?.interrupt?.reason ?? c.interrupts[q.id]?.reason]));
+            if (x.proposerId === p.id)
+                settle(c, x, 'declined');
+            else
+                declineJoint(c, x);
+            for (const q of waiters)
+                interruptPerson(c, q, t, reasons.get(q.id) ?? `declined:${x.id}`);
+        }
+    };
     // 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;
@@ -787,7 +825,32 @@ export function stepCommunity(c, world, until, opts = {}) {
         if (!next || t > until)
             break;
         const p = next;
+        const ordinaryDue = ordinaryEventAt(c, p) <= t;
         tick(p, t);
+        const dozed = p.activity?.dozedAt !== undefined || p.body.doze?.since !== undefined;
+        if (dozed) {
+            cancelDozeWaiting(p, t);
+            const act = p.activity;
+            if (act?.dozedAt !== undefined) {
+                if (act.interrupt)
+                    c.interrupts[p.id] ??= { ...act.interrupt };
+                const outcome = world.resolve(p, act, 'interrupted');
+                finish(p, outcome, finishOpts(world));
+                log({
+                    at: t,
+                    personId: p.id,
+                    kind: 'finish',
+                    detail: `${act.action} interrupted by doze`,
+                    action: act.action,
+                    status: outcome.status,
+                });
+            }
+            c.idleUntil[p.id] = t + quantum;
+            if (!ordinaryDue)
+                continue;
+        }
+        if (!ordinaryDue && p.body.alive)
+            continue;
         bookkeepDay(p, world, t, c.dayDone, opts);
         if (!p.body.alive) {
             log({ at: t, personId: p.id, kind: 'died', detail: `${p.name} died` });
@@ -821,6 +884,11 @@ export function stepCommunity(c, world, until, opts = {}) {
                 }
             }
         }
+        if (p.body.doze?.since !== undefined) {
+            cancelDozeWaiting(p, t);
+            c.idleUntil[p.id] = t + quantum;
+            continue;
+        }
         let act = p.activity;
         // An interrupt on an activity that ends at this event still reaches the next decision.
         perceptReason ??= act?.interrupt?.reason;

package/dist/social/social.js

@@ -471,6 +471,16 @@ export const REPUTATION_DEFAULTS = {
     /** First-hand familiarity damps hearsay: scale = 1 - familiarityDamping × familiarity. */
     familiarityDamping: 0.5,
 };
+/** Only authored, finite effects count; prototype properties are not character traits. */
+function reputationEffect(trait, table) {
+    const effect = Object.hasOwn(table, trait) ? table[trait] : undefined;
+    return effect &&
+        Number.isFinite(effect.affection) &&
+        Number.isFinite(effect.trust) &&
+        Number.isFinite(effect.respect)
+        ? effect
+        : undefined;
+}
 /** Splits a character proposition '<personId>:<trait>[:...]' into its subject and trait, if it is one. */
 export function parseTraitProp(prop, table = REPUTATION_TRAITS) {
     const parts = prop.split(':');
@@ -478,7 +488,7 @@ export function parseTraitProp(prop, table = REPUTATION_TRAITS) {
         return undefined;
     const personId = parts[0];
     const trait = parts[1];
-    if (personId === '' || table[trait] === undefined)
+    if (personId === '' || reputationEffect(trait, table) === undefined)
         return undefined;
     return { personId, trait };
 }
@@ -509,7 +519,7 @@ export function applyReputationBelief(p, prop, before, after, now, table = REPUT
 }
 /** Whether a character claim about a person is unfavourable to them (for backbiting tags). */
 export function isUnfavourableTrait(trait, value, table = REPUTATION_TRAITS) {
-    const e = table[trait];
+    const e = reputationEffect(trait, table);
     if (!e)
         return false;
     const sum = e.affection + e.trust + e.respect;

package/dist/types.d.ts

@@ -65,7 +65,22 @@ export interface Illness {
     /** Exposure kinds (keys of `BodyState.exposures`) whose recent load raises this chronic condition. */
     aggravatedBy?: string[];
 }
+export interface DozeContext {
+    posture: 'upright' | 'seated' | 'reclined';
+    /** Host-declared alerting demand, not volume. */
+    stimulation: Unit;
+}
+export interface DozeState {
+    context: DozeContext;
+    since?: Minute;
+}
+export interface BladderState {
+    fill: Unit;
+    pending: number;
+}
 export interface BodyState {
+    doze?: DozeState;
+    bladder?: BladderState;
     /** 1 = fully fed, 0 = starving. */
     satiety: Unit;
     /** 1 = fully hydrated. */
@@ -848,6 +863,8 @@ export interface Activity {
         at: Minute;
         reason: string;
     };
+    /** Involuntary doze stopped this activity here. Work and practice stay stopped until host resolution. */
+    dozedAt?: Minute;
     /**
      * Set by `begin` when the chosen act was possible only because necessity / the capacity bound lifted a
      * conscience veto (eating forbidden food, or drinking during the fast, in extremity). `finish` then records no
@@ -898,7 +915,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.17.0";
+export declare const ENGINE_VERSION = "2.21.0";
 /** A pregnancy carried by this person (host-driven; see `family/`). */
 export interface Pregnancy {
     fatherId: PersonId;
@@ -1181,6 +1198,8 @@ export interface Affordance {
     };
     /** Advertised need deltas over the whole activity (positive = satisfies). */
     advertises: Partial<Record<NeedId, number>>;
+    /** Intended urination: actual voiding, not completion alone, defines expectation success. */
+    voidsBladder?: boolean;
     /** Free tags: 'work', 'leisure', 'social', 'worship', 'risky', 'outdoors', ... */
     tags?: string[];
     norms?: NormTag[];
@@ -1335,6 +1354,8 @@ export interface Outcome {
     at: Minute;
     /** Realized need deltas from world effects (e.g. food eaten). Body exertion is computed by the framework. */
     needs?: Partial<Record<NeedId, number>>;
+    /** Host-confirmed urination; only a completed activity clears stored bladder fill. */
+    voidedBladder?: boolean;
     material?: number;
     /** Harm suffered. */
     injury?: Omit<Injury, 'id' | 'since'>;
@@ -1509,6 +1530,10 @@ export interface PersonSpec {
     values?: Partial<Values>;
     norms?: HeldNorm[];
     skills?: Record<string, Unit>;
+    /** Authored habits, copied in order. Invalid or over-bound setup throws RangeError. */
+    habits?: Habit[];
+    /** Authored expectations, copied in order. Invalid or over-bound setup throws RangeError. */
+    expectations?: ActionExpectation[];
     body?: Partial<Omit<BodyState, 'injuries' | 'illnesses' | 'nextId'>>;
     needs?: Partial<NeedReservoirs>;
     relationships?: (Partial<Relationship> & {
@@ -1534,6 +1559,8 @@ export interface PersonSpec {
      * `enableCharacterChange` and `enableSkillRetention` right after `createPerson`. Each is off when absent.
      */
     enable?: {
+        doze?: DozeContext;
+        bladder?: boolean;
         /** Read-only suggestion score explanations, as with `enableSuggestionReasons(p)`. */
         suggestionReasons?: boolean;
         gists?: boolean;

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.17.0';
+export const ENGINE_VERSION = '2.21.0';

package/dist/will/will.d.ts

@@ -233,6 +233,18 @@ export declare function noteVoicePromise(p: Person, voiceId: EntityId, event: {
     at?: Minute;
     action?: string;
 }): VoiceRelation;
+/**
+ * SCOPE (host trust gesture): add a host-supplied signed amount to an existing advising voice's trust,
+ * clamped to 0..1, and record the realized change in the usual bounded history. Magnitudes and reason
+ * are host premises, not calibrated claims. Missing voices return undefined without creating a voice.
+ * Non-finite amounts are ignored. No pressure, credit, counters, memory, time or RNG changes occur.
+ * Empty/non-string reasons and non-string actions reject before mutation with RangeError.
+ */
+export declare function gestureVoiceTrust(p: Person, voiceId: EntityId, amount: number, event: {
+    reason: string;
+    at?: Minute;
+    action?: string;
+}): VoiceRelation | undefined;
 /**
  * The next minute after `now` at which a pending commitment reaches `wakeCommitmentPressure`, the level at which a
  * sleeper may wake to serve it (the asleep veto lifts). The composite caps a sleeper's review there so a duty whose

package/dist/will/will.js

@@ -293,6 +293,27 @@ export function noteVoicePromise(p, voiceId, event) {
     noteTrust(v, v.trust - before, event.kept ? 'promise-kept' : 'promise-broken', at, event.action);
     return v;
 }
+/**
+ * SCOPE (host trust gesture): add a host-supplied signed amount to an existing advising voice's trust,
+ * clamped to 0..1, and record the realized change in the usual bounded history. Magnitudes and reason
+ * are host premises, not calibrated claims. Missing voices return undefined without creating a voice.
+ * Non-finite amounts are ignored. No pressure, credit, counters, memory, time or RNG changes occur.
+ * Empty/non-string reasons and non-string actions reject before mutation with RangeError.
+ */
+export function gestureVoiceTrust(p, voiceId, amount, event) {
+    if (!event || typeof event.reason !== 'string' || event.reason.length === 0)
+        throw new RangeError('A trust gesture needs a reason');
+    if (event.action !== undefined && typeof event.action !== 'string')
+        throw new RangeError('Invalid trust gesture action');
+    const v = voiceOf(p, voiceId);
+    if (!v || !Number.isFinite(amount))
+        return v;
+    const before = v.trust;
+    v.trust = clamp01(before + amount);
+    const at = event.at !== undefined && Number.isFinite(event.at) ? event.at : p.now;
+    noteTrust(v, v.trust - before, event.reason, at, event.action);
+    return v;
+}
 const finite = (x) => x === undefined || Number.isFinite(x);
 /** Host numbers the framework computes with must be finite; a NaN offer is vetoed, never chosen. */
 function wellFormed(aff) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adam0white/human-framework",
-  "version": "2.19.0",
+  "version": "2.21.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",