@adam0white/human-framework 3.0.0 → 3.1.0

package/README.md

@@ -4,13 +4,15 @@ HF is a TypeScript library for simulated people in games and headless simulation
 possible actions. Each person weighs needs, habits, duties, goals and suggestions, then chooses.
 A player can suggest an action; the person can defer or refuse it.
 
-HF 3.0.0 uses utility scoring and seeded randomness, with no LLM in the actor loop and no runtime
+HF 3.1.0 uses utility scoring and seeded randomness, with no LLM in the actor loop and no runtime
 dependencies. Decision records expose scored terms and template narration. Person state is plain JSON.
 This is an authored simulation model, not a validated predictor of real people.
 
 ## Migrating to v3
 
-The API migration keeps engine `2.23.0`. Relative to HF 2.23.0, it does not change seeded draws, numeric rules or saved Person state. The package version is `3.0.0`; publication is recorded separately in the release history.
+The HF 3.0 API migration kept engine `2.23.0`. Relative to HF 2.23.0, that release changed no seeded draws, numeric rules or saved Person state.
+
+HF 3.1 uses engine `3.1.0` and migrates earlier supported snapshots by preserving admitted state. Community death handling, warmth-through-25 upbringing and conditioned bodily forecasts require explicit host options, pinned again after restore. Omitted options preserve HF 3.0 continuation apart from the engine stamp. These are authored simulation rules, not validated predictions of real people.
 
 | Before                                                                         | v3                                                                                                |
 | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------- |
@@ -57,10 +59,10 @@ This is a bounded host convention, not transport, consensus or fairness. It read
 
 ## Quick start
 
-Use Node 24 or newer. In an empty directory, install the version this README describes:
+Use Node 24 or newer and TypeScript 7 or newer. In an empty directory, install the version this README describes:
 
 ```sh
-npm install @adam0white/human-framework@3.0.0
+npm install @adam0white/human-framework@3.1.0
 ```
 
 Save these 20 lines as `quickstart.mjs`, then run `node quickstart.mjs`:
@@ -265,7 +267,7 @@ reference host: `createVillage`.
 
 There are two version numbers, and they move independently.
 
-- **The release version** is the package version (`package.json`, currently `3.0.0`) and `FRAMEWORK_VERSION`, the same
+- **The release version** is the package version (`package.json`, currently `3.1.0`) and `FRAMEWORK_VERSION`, the same
   string compiled into the build; a test keeps them equal. It versions the public API under
   [semver](https://semver.org/): a breaking change to an exported name or signature bumps the major, a new
   faculty or export the minor, a fix the patch. Each release is a tag `vX.Y.Z` and a GitHub release whose notes
@@ -637,3 +639,32 @@ Use `gestureVoiceTrust(p, voiceId, amount, { reason, at?, action? })` for an exp
 `confirmObservedReputation(p, prop, truth, now, table?)` replaces the manual `credence → confirm → applyReputationBelief` sequence. Supply only a fact the person could observe. It does not run attention or invent a moral judgement.
 
 `qalbReading(p)` is a read-only, sourced narration lens over existing records. Its detached categorical rows are this person's recorded understanding and evidence. They are never a spiritual health score, a ruling, a rank, or a decision input. Do not present mood, low social trust or missing memories as evidence of poor faith.
+
+## fdlibm notices
+
+`dist/core/libm.js` ports `e_exp.c`, `e_log.c`, `k_cos.c`, `k_sin.c` and `e_rem_pio2.c`
+from Sun/FreeBSD fdlibm. The original notices are preserved below and in that module.
+Sources: [Netlib fdlibm](https://netlib.org/fdlibm/) and
+[FreeBSD e_exp.c](https://cgit.freebsd.org/src/tree/lib/msun/src/e_exp.c).
+
+```text
+ * fdlibm notices: e_exp.c (Sun 2004); e_log.c, k_cos.c, k_sin.c and e_rem_pio2.c (Sun 1993).
+ * Sources: https://netlib.org/fdlibm/ and FreeBSD lib/msun/src/e_exp.c.
+ * ====================================================
+ * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ *
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+
+```

package/dist/cognition/cognition.d.ts

@@ -35,7 +35,7 @@
  * 1971), so idle choice stops cycling short consumption at full hydration (The Rope, owner Kestrel export
  * 2026-10-19). It models no bladder, sensory-specific satiety by food, or overeating for comfort.
  */
-import type { BodyPerceptionContext } from '../body/index.ts';
+import type { BodyParams, BodyPerceptionContext } from '../body/index.ts';
 import { type HabitContext } from '../habits/index.ts';
 import { type PromptingSeen } from '../promptings/index.ts';
 import type { Affordance, BodyReadout, Command, Considered, DecisionRecord, LifeModifiers, Minute, NeedReading, Person, Suggestion, Term, Unit } from '../types.ts';
@@ -150,6 +150,11 @@ export interface ConsiderContext {
     scarcity?: Unit;
     /** The body's perception context now (an open fast), for the bodily forecast (2.6.0). */
     perception?: BodyPerceptionContext;
+    /** Q26: held current conditions, used only by the bodily forecast, never other decision terms. */
+    forecastContext?: {
+        mods: LifeModifiers;
+        params: BodyParams;
+    };
 }
 /**
  * Standing advice terms for one option: per source, the strongest matching entry's weight × trust in the source

package/dist/cognition/cognition.js

@@ -409,7 +409,7 @@ export function consider(p, aff, ctx) {
         push('effort', effort);
     // Bodily forecast (2.5.0): only offers that declare known follow-on exertion.
     if (aff.followedBy?.length) {
-        const t = bodyForecastTerm(p, aff, ctx.mods, ctx.perception);
+        const t = bodyForecastTerm(p, aff, ctx.forecastContext?.mods ?? ctx.mods, ctx.perception, ctx.forecastContext?.params);
         if (t)
             push(t.source, t.value);
     }

package/dist/core/libm.js

@@ -1,4 +1,24 @@
 // biome-ignore-all lint/correctness/noPrecisionLoss: fdlibm constants are kept digit for digit as published; each parses to the intended double.
+/*
+ * fdlibm notices: e_exp.c (Sun 2004); e_log.c, k_cos.c, k_sin.c and e_rem_pio2.c (Sun 1993).
+ * Sources: https://netlib.org/fdlibm/ and FreeBSD lib/msun/src/e_exp.c.
+ * ====================================================
+ * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ *
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
 /**
  * Platform-independent transcendental functions for the engine.
  *

package/dist/family/family.d.ts

@@ -74,6 +74,8 @@ export interface Household {
     caregivers: readonly Person[];
 }
 export interface RaiseOptions {
+    /** Explicit household influence through young adulthood. Omit for exact legacy behavior. Pin in host saves. */
+    model?: 'warmth-through-25';
     /** Also move the child's trust in voices the caregivers trust (default true). */
     voices?: boolean;
 }
@@ -81,6 +83,8 @@ export interface RaiseOptions {
  * Apply `minutes` of upbringing in `household` to `child`, at `child.now`. Warmth-weighted: a caregiver with no
  * warmth toward the child teaches nothing. Values, norm understanding, attachment and (optionally) trust in the
  * household's voices move by the age plasticities in the SCOPE paragraph. Returns the warmth-weighted
- * responsiveness the child experienced (0..1).
+ * responsiveness the child experienced (0..1) in legacy mode. With `warmth-through-25`, returns effective
+ * responsiveness weighted by mean warmth and age plasticity, approaching zero with either. The host supplies
+ * this model again after restoring a save. Raised minutes count even when warmth or plasticity is zero.
  */
 export declare function raise(child: Person, household: Household, minutes: number, opts?: RaiseOptions): Unit;

package/dist/family/family.js

@@ -29,12 +29,20 @@
  * security starts at 0.6 (58% of nonclinical mothers are secure-autonomous, F12) and moves toward the caregivers'
  * responsiveness (warmth and mood) at 50% per year, most in the first three years, with a floor of 0.1 of that
  * plasticity by age 12 (responsiveness and intergenerational correspondence, F10, F11; rates assumed). Optionally a
- * child comes to trust the voices the household trusts (`adoptVoiceTrust`). This file writes `values` for minors: one of the
+ * child comes to trust the voices the household trusts (`adoptVoiceTrust`). This file writes `values` through young adulthood: one of the
  * documented exceptions to values being fixed at creation (docs/framework.md); the opt-in `character/` drift is
  * the other. It does not model siblings'
  * influence, peers, schooling, abuse, divorce or temperament-by-parenting interactions, and it never assigns a
  * religious obligation by age: a child holds only the understanding the household lived.
  *
+ * Opt-in `RaiseOptions.model: 'warmth-through-25'` scales norm and attachment relaxation rates by mean warmth,
+ * as values and voice trust already do. All influence tapers continuously to zero at 25 using `valuePlasticity`;
+ * attachment also keeps its early-life plasticity. The return is responsiveness × mean warmth × value plasticity.
+ * These coefficients and the age horizon are engineering assumptions, not empirical calibration or rulings.
+ * F7–F11 in research/family-environment-sources.md support the shapes, not these rates. No abuse, schooling or
+ * adult culture diffusion is modelled. Without this option, arithmetic and the normalized return stay unchanged.
+ * Hosts must pin this option in saved-run configuration and supply it again after restore; no state infers it.
+ *
  * Aptitudes are read by the composite as a multiplier on learning (`aptitudeOf`); they are drawn at birth by
  * `createChild` (`ChildSpec.aptitudes`).
  */
@@ -246,13 +254,17 @@ const relax = (rate, years) => clamp01(1 - dpow(1 - clamp01(rate), years));
  * Apply `minutes` of upbringing in `household` to `child`, at `child.now`. Warmth-weighted: a caregiver with no
  * warmth toward the child teaches nothing. Values, norm understanding, attachment and (optionally) trust in the
  * household's voices move by the age plasticities in the SCOPE paragraph. Returns the warmth-weighted
- * responsiveness the child experienced (0..1).
+ * responsiveness the child experienced (0..1) in legacy mode. With `warmth-through-25`, returns effective
+ * responsiveness weighted by mean warmth and age plasticity, approaching zero with either. The host supplies
+ * this model again after restoring a save. Raised minutes count even when warmth or plasticity is zero.
  */
 export function raise(child, household, minutes, opts = {}) {
     if (!(minutes > 0) || !child.body.alive)
         return 0;
     const F = FAMILY_DEFAULTS;
-    const carers = household.caregivers.filter((c) => c.id !== child.id && c.body.alive);
+    const continuous = opts.model === 'warmth-through-25';
+    const eligible = household.caregivers.filter((c) => c.id !== child.id && c.body.alive);
+    const carers = continuous ? [...new Map(eligible.map((c) => [c.id, c])).values()] : eligible;
     const warmth = carers.map((c) => Math.max(0, relationshipWith(c, child.id).affection));
     const total = warmth.reduce((s, w) => s + w, 0);
     const fam = familyOf(child);
@@ -263,6 +275,8 @@ export function raise(child, household, minutes, opts = {}) {
     const age = ageYears(child);
     const meanWarmth = total / carers.length;
     const vp = valuePlasticity(age);
+    if (continuous && vp <= 0)
+        return 0;
     // Values.
     if (vp > 0) {
         const k = relax(F.valueRatePerYear * meanWarmth, years * vp);
@@ -279,7 +293,7 @@ export function raise(child, household, minutes, opts = {}) {
     if (vp > 0) {
         const since = child.now - MINUTES_PER_YEAR;
         const ids = [...new Set(carers.flatMap((c) => c.conscience.norms.map((n) => n.normId)))].sort();
-        const k = relax(F.normRatePerYear, years * vp);
+        const k = relax(continuous ? F.normRatePerYear * meanWarmth : F.normRatePerYear, years * vp);
         for (const id of ids) {
             let target = 0;
             let standing;
@@ -314,7 +328,9 @@ export function raise(child, household, minutes, opts = {}) {
         responsiveness += w * clamp01(0.7 * w + 0.3 * ((c.affect.mood.valence + 1) / 2));
     });
     responsiveness /= total;
-    const ka = relax(F.attachmentRatePerYear, years * attachmentPlasticity(age));
+    const ka = continuous
+        ? relax(F.attachmentRatePerYear * meanWarmth, years * attachmentPlasticity(age) * vp)
+        : relax(F.attachmentRatePerYear, years * attachmentPlasticity(age));
     const att = fam.attachment ?? F.attachmentStart;
     fam.attachment = clamp01(att + ka * (responsiveness - att));
     // Trust in the household's voices (an elder, a teacher, a host's voice): not the caregivers themselves.
@@ -337,5 +353,5 @@ export function raise(child, household, minutes, opts = {}) {
                 adoptVoiceTrust(child, id, target / wsum, kv);
         }
     }
-    return clamp01(responsiveness);
+    return clamp01(continuous ? responsiveness * meanWarmth * vp : responsiveness);
 }

package/dist/habits/habits.js

@@ -28,11 +28,11 @@
  * assumption. Does not claim: pharmacology, dependence severity or relapse probabilities.
  *
  * SCOPE (habit ease, N4): `habitEase` is a multiplier < 1 on the initiation and attentional parts of an
- * option's effort cost for a cued habitual action. Chosen by the discriminating experiment in
- * `test/habits.test.ts`: depletion increases habit performance relative to deliberate alternatives (Neal,
- * Wood & Drolet 2013, JPSP 104:959); an additive habit term cannot produce that (fatigue costs habitual and
- * deliberate options alike), an ease multiplier can. Physical exertion is not eased (habit does not make a
- * walk lighter). Does not claim: a measured size of the effect, or that automaticity removes intention.
+ * option's effort cost for a cued habitual action. `test/habits-lane.test.ts` compares candidate effort
+ * formulas under authored fatigue and sleepiness. That engineering comparison is not a restraint-depletion
+ * manipulation, participant-data replication, or full choice experiment; it does not validate a fungible
+ * willpower fuel. Physical exertion is not eased (habit does not make a walk lighter). Does not claim:
+ * a measured effect size, an empirically established explanation, or that automaticity removes intention.
  */
 import { clamp01, decay, dexp, hourOf, minuteOfDay } from '../core/index.js';
 import { MINUTES_PER_DAY, } from '../types.js';

package/dist/impression.d.ts

@@ -26,9 +26,12 @@ export declare function predictAs(observer: Person, target: Person, affordances:
     others?: readonly Suggestion[];
     scarcity?: Unit;
     now?: Minute;
+    forecastContext?: 'conditioned';
 }): ImpressionPrediction;
 /** Whether `observer` expects a command on `target` to hold and at what price (pure; see `imagine`). */
-export declare function previewCommandAs(observer: Person, target: Person, affordances: readonly Affordance[], cmd: Command, now?: Minute): {
+export declare function previewCommandAs(observer: Person, target: Person, affordances: readonly Affordance[], cmd: Command, now?: Minute, opts?: {
+    forecastContext?: 'conditioned';
+}): {
     outcome: CommandOutcome;
     confidence: Unit;
 };

package/dist/impression.js

@@ -158,10 +158,10 @@ export function predictAs(observer, target, affordances, suggestion, opts = {})
     };
 }
 /** Whether `observer` expects a command on `target` to hold and at what price (pure; see `imagine`). */
-export function previewCommandAs(observer, target, affordances, cmd, now = target.now) {
+export function previewCommandAs(observer, target, affordances, cmd, now = target.now, opts = {}) {
     const model = imagine(observer, target, now);
     return {
-        outcome: previewCommand(model, affordances, cmd),
+        outcome: previewCommand(model, affordances, cmd, opts),
         confidence: impressionConfidence(observer, target.id, now),
     };
 }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /** Human Framework public surface. */
-export declare const FRAMEWORK_VERSION = "3.0.0";
+export declare const FRAMEWORK_VERSION = "3.1.0";
 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, MakeUpReceipt, PrayerCalendar, PrayerSchedule, PrayerTimes, Retimer, } from './agenda/index.ts';

package/dist/index.js

@@ -1,5 +1,5 @@
 /** Human Framework public surface. */
-export const FRAMEWORK_VERSION = '3.0.0';
+export const FRAMEWORK_VERSION = '3.1.0';
 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, isContinuingCommitment, isUnderWay, MAKRUH_DEFAULTS, makruhWindows, missedExcuse, onFinished, owedMakeUps, PRAYER_IMPORTANCE, PURPOSE_DEFAULTS, prayerWindows, pressureReachedAt, promise, proposeGoals, RAMADAN_DEFAULTS, ramadanFast, ramadanMeals, release as releaseCommitment, retimeCommitments, retirePaidMakeUps, revisePurposes, scheduleMakeUp, spanMeetsWindow, suhoorWindow, timesFor, violatesAbstention, } from './agenda/index.js';

package/dist/migrate.js

@@ -41,6 +41,11 @@ function renameAmbient(json) {
 }
 /** The chain, keyed by the version each step upgrades from. */
 export const MIGRATIONS = {
+    '2.23.0': {
+        to: '3.1.0',
+        note: 'version stamp only; existing state and RNG are unchanged, and new behaviour requires explicit opt-in',
+        apply: stamp,
+    },
     '2.21.0': {
         to: '2.23.0',
         note: 'shape unchanged; doze delivery and plain narration fixes apply to opted-in runs',

package/dist/person.d.ts

@@ -102,6 +102,13 @@ export interface PerceiveOptions {
  */
 export declare function perceive(p: Person, percepts: readonly Percept[], options?: PerceiveOptions): Percept[];
 export interface DecideOptions {
+    /**
+     * Q26: forecast with current pregnancy and surroundings held through the bounded horizon.
+     * Approximation, not future conditions. Absent preserves legacy. Pin in host saved-run config;
+     * restore never infers this choice from Person state. Changes only the bodily forecast term.
+     * planRoute and begin pursuit fallback have no bodily forecast term and keep their existing inputs.
+     */
+    forecastContext?: 'conditioned';
     suggestion?: Suggestion;
     /** Several voices in one decision (N1); merged with `suggestion`, one per voice id. */
     suggestions?: readonly Suggestion[];
@@ -124,7 +131,7 @@ export interface DecideOptions {
  * How this person would answer a suggestion right now, without changing them or consuming randomness
  * (hover telegraph). Does not advance time. With `temperature > 0`, read `likelihood` rather than the verdict.
  */
-export declare function predict(p: Person, affordances: readonly Affordance[], suggestion: Suggestion, opts?: {
+export declare function predict(p: Person, affordances: readonly Affordance[], suggestion: Suggestion, opts?: Pick<DecideOptions, 'forecastContext'> & {
     necessity?: boolean;
     others?: readonly Suggestion[];
     scarcity?: Unit;
@@ -138,7 +145,7 @@ export declare function predict(p: Person, affordances: readonly Affordance[], s
  * or record a trace entry; a later decision on the same standing suggestion counts again (hosts that answer
  * now should drop the suggestion once it is refused).
  */
-export declare function answerNow(p: Person, affordances: readonly Affordance[], suggestion: Suggestion, opts?: {
+export declare function answerNow(p: Person, affordances: readonly Affordance[], suggestion: Suggestion, opts?: Pick<DecideOptions, 'forecastContext'> & {
     necessity?: boolean;
     others?: readonly Suggestion[];
     scarcity?: Unit;
@@ -178,7 +185,7 @@ export declare function releaseCommand(p: Person, reason?: string): boolean;
  * (a UI showing "they will do it, but would rather eat" before the host takes control). `margin` is the gap
  * the hourly autonomy and trust costs scale with.
  */
-export declare function previewCommand(p: Person, affordances: readonly Affordance[], cmd: Command): CommandOutcome;
+export declare function previewCommand(p: Person, affordances: readonly Affordance[], cmd: Command, opts?: Pick<DecideOptions, 'forecastContext'>): CommandOutcome;
 export interface BeginOptions {
     /**
      * Make a commitment at begin (e.g. carrying the injured): a pending commitment for this action and target,
@@ -271,7 +278,7 @@ export declare function nafsReading(p: Person): NafsPattern[];
  * The person's own forecast of their body through an offer and its `followedBy` spans (2.5.0, read-only), with a
  * first-person line ("I can do it, but I'll be spent for the descent."). Empty spans without `followedBy`.
  */
-export declare function bodyForecast(p: Person, aff: Affordance): {
+export declare function bodyForecast(p: Person, aff: Affordance, opts?: Pick<DecideOptions, 'forecastContext'>): {
     spans: BodyForecastSpan[];
     line: string;
 };

package/dist/person.js

@@ -906,6 +906,15 @@ function currentOffer(p) {
         return undefined;
     return { ...act.affordance, duration: act.endsAt - p.now };
 }
+/** Q26: compose one held snapshot for all public forecast paths; does not alter Person or ordinary scoring. */
+function bodyForecastContext(p, opts) {
+    return opts.forecastContext === 'conditioned'
+        ? {
+            mods: segmentModifiers(p),
+            params: p.ambient ? ambientBodyParams(p, BODY_DEFAULTS) : BODY_DEFAULTS,
+        }
+        : { mods: lifeModifiers(p), params: BODY_DEFAULTS };
+}
 /** Offers (plus the current activity) and the scoring context for a decision at `p.now`. Reads only. */
 function decisionInputs(p, affordances, id, opts) {
     const list = [...affordances];
@@ -934,6 +943,8 @@ function decisionInputs(p, affordances, id, opts) {
     const perception = fastingCtx(p);
     if (perception)
         ctx.perception = perception;
+    if (opts.forecastContext === 'conditioned')
+        ctx.forecastContext = bodyForecastContext(p, opts);
     if (opts.suggestion)
         ctx.suggestion = opts.suggestion;
     // Only set when voices were given this way, so single-voice records keep their shape.
@@ -966,6 +977,8 @@ function commandOf(c) {
 export function predict(p, affordances, suggestion, opts = {}) {
     const others = (opts.others ?? []).filter((s) => s.voiceId !== suggestion.voiceId);
     const decideOpts = { suggestion };
+    if (opts.forecastContext !== undefined)
+        decideOpts.forecastContext = opts.forecastContext;
     if (others.length > 0)
         decideOpts.suggestions = others;
     if (opts.necessity !== undefined)
@@ -990,6 +1003,8 @@ export function predict(p, affordances, suggestion, opts = {}) {
 export function answerNow(p, affordances, suggestion, opts = {}) {
     const others = (opts.others ?? []).filter((s) => s.voiceId !== suggestion.voiceId);
     const decideOpts = { suggestion };
+    if (opts.forecastContext !== undefined)
+        decideOpts.forecastContext = opts.forecastContext;
     if (others.length > 0)
         decideOpts.suggestions = others;
     if (opts.necessity !== undefined)
@@ -1162,8 +1177,8 @@ export function releaseCommand(p, reason = 'released') {
  * (a UI showing "they will do it, but would rather eat" before the host takes control). `margin` is the gap
  * the hourly autonomy and trust costs scale with.
  */
-export function previewCommand(p, affordances, cmd) {
-    const { list, ctx } = decisionInputs(p, affordances, 'preview', { command: cmd });
+export function previewCommand(p, affordances, cmd, opts = {}) {
+    const { list, ctx } = decisionInputs(p, affordances, 'preview', { ...opts, command: cmd });
     const { considered, willCtx } = scoreAll(p, list, ctx);
     return resolveCommand(p, considered, willCtx);
 }
@@ -1695,8 +1710,9 @@ export function nafsReading(p) {
  * The person's own forecast of their body through an offer and its `followedBy` spans (2.5.0, read-only), with a
  * first-person line ("I can do it, but I'll be spent for the descent."). Empty spans without `followedBy`.
  */
-export function bodyForecast(p, aff) {
-    const spans = bodyForecastFor(p, aff, lifeModifiers(p), fastingCtx(p));
+export function bodyForecast(p, aff, opts = {}) {
+    const { mods, params } = bodyForecastContext(p, opts);
+    const spans = bodyForecastFor(p, aff, mods, fastingCtx(p), params);
     return {
         spans,
         line: forecastLine(spans, forecastThresholds(aff), { plainEnglish: p.lexicon?.plainEnglish }),

package/dist/persona.js

@@ -4,7 +4,7 @@
  * identity, age, family and health compatibility before returning a new Person. Neither input is mutated.
  * This is not a world migration, identity registry, transport, hash, authentication or general calendar mapper.
  * v1 admits zero-duration travel and healthy compatible bodies only; family/bonds remain host-authored and must
- * match source provenance. Portable v1 accepts its published 2.14.1 and 2.17.0 stamps and the current engine;
+ * match source provenance. Portable v1 accepts its published 2.14.1, 2.17.0, 2.21.0 and 2.23.0 stamps and the current engine;
  * the bodily opt-ins change no portable field semantics. Pregnancy and nonempty temporal bonds are unsupported in v1. All other world-dependent stores stay with the source and are disclosed as omitted.
  */
 import { hasUnresolvedMakeUps, sameChain } from './agenda/agenda.js';
@@ -188,6 +188,7 @@ export function validatePersonaProjection(input) {
     keys(input.source, ['schema', 'engine', 'id', 'now']);
     // The 2.14.1 and 2.17.0 portable fields retain their semantics across the bodily opt-ins.
     const compatibleEngine = input.source.engine === ENGINE_VERSION ||
+        input.source.engine === '2.23.0' ||
         input.source.engine === '2.21.0' ||
         input.source.engine === '2.17.0' ||
         input.source.engine === '2.14.1';

package/dist/prospection/forecast.d.ts

@@ -11,15 +11,20 @@
  * current effort; only a person with the opt-in fatigue store (2.6.0, `enableFatigueStore`) carries accumulated
  * exertion, so only then does a long climb by itself leave them more spent for the descent; unfelt
  * sleep debt stays unfelt in the forecast; an open fast's damping of hunger and thirst applies (2.6.0) as it is
- * now, held for the whole forecast even if the fast would end during it; host surroundings are not applied (the person's own body rates and life
- * modifiers are, but not `ambient` parameters). Existing bleeding, illness and healing run in the copy, so an
+ * now, held for the whole forecast even if the fast would end during it. By default host surroundings are not
+ * applied. Q26: explicit per-call conditioned forecasts instead hold current age, pregnancy and ambient
+ * modifiers AND ambient body parameters through the bounded horizon (four follow-on spans, 1440 minutes).
+ * This is a frozen current-conditions approximation: no future weather, pregnancy progression or world
+ * lookahead. Readouts remain perceived; integration and interpolation retain the existing body model's limits.
+ * Direct helpers retain caller-supplied modifiers and default body parameters unless given other parameters.
+ * Existing bleeding, illness and healing run in the copy, so an
  * open wound can read as being spent, and death in the forecast reads as fully spent. The term is absolute
  * (see `bodyForecastTerm`). It does not plan, search routes, schedule rests on the way or
  * predict injuries, and it is not a calibrated estimate of human anticipation. Every number is an engineering
  * default. 2.8.0: an offer may carry its own thresholds (`Affordance.forecastAt`, from The Glance's night
  * keepers); offers without it read exactly as before.
  */
-import { type BodyForecastSpan, type BodyPerceptionContext } from '../body/index.ts';
+import { type BodyForecastSpan, type BodyParams, type BodyPerceptionContext } from '../body/index.ts';
 import type { Affordance, LifeModifiers, Person, Term } from '../types.ts';
 export declare const FORECAST_DEFAULTS: {
     /** Worst perceived readout during a follow-on from which the forecast starts to weigh. */
@@ -41,7 +46,7 @@ export declare function forecastThresholds(aff: Pick<Affordance, 'forecastAt'>):
     spentAt: number;
 };
 /** The person's forecast for an offer: the act, then its follow-on spans. Empty without `followedBy`. Pure. */
-export declare function bodyForecastFor(p: Person, aff: Affordance, mods: LifeModifiers, perception?: BodyPerceptionContext): BodyForecastSpan[];
+export declare function bodyForecastFor(p: Person, aff: Affordance, mods: LifeModifiers, perception?: BodyPerceptionContext, params?: BodyParams): BodyForecastSpan[];
 /**
  * The `forecast:body` term for an offer, or undefined (no follow-on, or not expected to weigh). Absolute by
  * design: it weighs being in that state *while doing* the follow-on, so a person already sleepy or thirsty is
@@ -49,7 +54,7 @@ export declare function bodyForecastFor(p: Person, aff: Affordance, mods: LifeMo
  * costs more than staying home). A resting baseline was tried and rejected: thirst and sleepiness rise at rest
  * too, which cancelled the very case the forecast exists for. Pure.
  */
-export declare function bodyForecastTerm(p: Person, aff: Affordance, mods: LifeModifiers, perception?: BodyPerceptionContext): Term | undefined;
+export declare function bodyForecastTerm(p: Person, aff: Affordance, mods: LifeModifiers, perception?: BodyPerceptionContext, params?: BodyParams): Term | undefined;
 /** A first-person line for the forecast (narration only); `at` is the offer's thresholds (2.8.0, default as before). */
 export declare function forecastLine(spans: readonly BodyForecastSpan[], at?: {
     comfortAt: number;

package/dist/prospection/forecast.js

@@ -11,8 +11,13 @@
  * current effort; only a person with the opt-in fatigue store (2.6.0, `enableFatigueStore`) carries accumulated
  * exertion, so only then does a long climb by itself leave them more spent for the descent; unfelt
  * sleep debt stays unfelt in the forecast; an open fast's damping of hunger and thirst applies (2.6.0) as it is
- * now, held for the whole forecast even if the fast would end during it; host surroundings are not applied (the person's own body rates and life
- * modifiers are, but not `ambient` parameters). Existing bleeding, illness and healing run in the copy, so an
+ * now, held for the whole forecast even if the fast would end during it. By default host surroundings are not
+ * applied. Q26: explicit per-call conditioned forecasts instead hold current age, pregnancy and ambient
+ * modifiers AND ambient body parameters through the bounded horizon (four follow-on spans, 1440 minutes).
+ * This is a frozen current-conditions approximation: no future weather, pregnancy progression or world
+ * lookahead. Readouts remain perceived; integration and interpolation retain the existing body model's limits.
+ * Direct helpers retain caller-supplied modifiers and default body parameters unless given other parameters.
+ * Existing bleeding, illness and healing run in the copy, so an
  * open wound can read as being spent, and death in the forecast reads as fully spent. The term is absolute
  * (see `bodyForecastTerm`). It does not plan, search routes, schedule rests on the way or
  * predict injuries, and it is not a calibrated estimate of human anticipation. Every number is an engineering
@@ -52,7 +57,7 @@ const smooth = (a, b, x) => {
     return t * t * (3 - 2 * t);
 };
 /** The person's forecast for an offer: the act, then its follow-on spans. Empty without `followedBy`. Pure. */
-export function bodyForecastFor(p, aff, mods, perception) {
+export function bodyForecastFor(p, aff, mods, perception, params = BODY_DEFAULTS) {
     const follow = aff.followedBy;
     if (!Array.isArray(follow) || follow.length === 0 || !p.body.alive)
         return [];
@@ -83,7 +88,7 @@ export function bodyForecastFor(p, aff, mods, perception) {
             load: { effort: clamp01(f.effort), focus: clamp01(f.focus ?? 0), mode: 'awake' },
         });
     }
-    return forecastBody(p, spans, mods, BODY_DEFAULTS, 30, perception);
+    return forecastBody(p, spans, mods, params, 30, perception);
 }
 /**
  * The `forecast:body` term for an offer, or undefined (no follow-on, or not expected to weigh). Absolute by
@@ -92,8 +97,8 @@ export function bodyForecastFor(p, aff, mods, perception) {
  * costs more than staying home). A resting baseline was tried and rejected: thirst and sleepiness rise at rest
  * too, which cancelled the very case the forecast exists for. Pure.
  */
-export function bodyForecastTerm(p, aff, mods, perception) {
-    const spans = bodyForecastFor(p, aff, mods, perception).slice(1);
+export function bodyForecastTerm(p, aff, mods, perception, params = BODY_DEFAULTS) {
+    const spans = bodyForecastFor(p, aff, mods, perception, params).slice(1);
     if (spans.length === 0)
         return undefined;
     const D = FORECAST_DEFAULTS;

package/dist/sim/index.d.ts

@@ -1,2 +1,2 @@
 export * from './longrun.ts';
-export * from './sim.ts';
+export { acceptJoint, addPerson, birth, type Community, type CommunityState, communityState, createCommunity, declineJoint, interruptPerson, interrupts, type JointProposal, jointSuccessChance, type LifecourseOptions, mirrorAffordance, nextEventAt, preview, proposeJoint, runSilent, SIM_DEFAULTS, type SilentRun, type SimEvent, type SimEventKind, type StepOptions, sharesPlace, standingHeard, stepCommunity, tellDeath, type World, } from './sim.ts';

package/dist/sim/index.js

@@ -1,2 +1,2 @@
 export * from './longrun.js';
-export * from './sim.js';
+export { acceptJoint, addPerson, birth, communityState, createCommunity, declineJoint, interruptPerson, interrupts, jointSuccessChance, mirrorAffordance, nextEventAt, preview, proposeJoint, runSilent, SIM_DEFAULTS, sharesPlace, standingHeard, stepCommunity, tellDeath, } from './sim.js';

package/dist/sim/longrun.d.ts

@@ -10,15 +10,28 @@
  * back to `stepCommunity` at the stretch's end: a common pattern is routine for the years nobody watches, lived
  * minutes for the days someone is watching. Switching fidelity is the host's decision and happens on a day boundary.
  *
+ * With `deathHandling: 'community'`, entry and dawn catch-up deaths are discovered at the sync minute and
+ * skip routine work. Routine deaths retain their whole-day batch ordering; attended news and proposal cleanup
+ * run only after every person's routine. Suppressing news does not suppress cleanup. This adds no mortality,
+ * funeral or religious model. The host pins the option after restore; omission retains the old path.
+ *
  * It does not run decisions, conversation, joint activities, contagion or the world's percepts and affordances: those
  * belong to lived time. Companions are listed by the host on both sides (each person's routine names the other),
  * since a routine day writes only its own person. Births and arrivals are the host's (`birth`, `addPerson` in
  * `onDay`); a person added during the stretch starts on the next day.
+ *
+ * Opt-in `upbringing.model: 'warmth-through-25'` selects living parents or guardians from the young person's
+ * ties, counting each different person once, through young adulthood (under 25). Guardianship does not supply
+ * warmth: `raise` reads caregiver-to-child affection. Its continuous age taper and warmth-scaled rates are
+ * engineering assumptions; no abuse, schooling or adult culture diffusion. Hosts pin `upbringing` in saved-run
+ * configuration and supply it after restore. Marriage, parenthood and co-residence do not gate this model;
+ * a living carer in the community suffices. Omitted, the under-18, parents-only path stays exact.
  */
+import { type RaiseOptions } from '../family/index.ts';
 import { type RoutineDay, type RoutineSource } from '../longrun.ts';
 import type { SkillTransfer } from '../skills/index.ts';
 import type { Minute, PersonId } from '../types.ts';
-import { type Community, type LifecourseOptions, type SimEvent } from './sim.ts';
+import { type Community, type LifecourseOptions, type SimEvent, type StepOptions } from './sim.ts';
 export declare const LIVE_COMMUNITY_DEFAULTS: {
     /** Upbringing time a day with the parents (engineering assumption: a few waking hours together). */
     upbringingMinutes: number;
@@ -30,11 +43,16 @@ export interface LiveCommunityOptions {
     onDay?(c: Community, day: number, at: Minute): void;
     /** Tell each death to everyone with a tie (default true; see `tellDeath`). */
     tellDeaths?: boolean;
+    /** Opt into attended death receipts and scheduler cleanup; pin on every resumed call. */
+    deathHandling?: StepOptions['deathHandling'];
     /**
-     * Minutes of upbringing a day for each living minor with a living parent in the community (`family.raise`; default
-     * `LIVE_COMMUNITY_DEFAULTS.upbringingMinutes`, 0 turns it off).
+     * Minutes of upbringing a day for eligible young people with a living carer in the community (`family.raise`).
+     * Default eligibility is under 18 with a parent; warmth-through-25 includes guardians and ages under 25.
+     * Defaults to `LIVE_COMMUNITY_DEFAULTS.upbringingMinutes`; 0 turns it off.
      */
     upbringingMinutes?: number;
+    /** Opt-in household model and voice selection, passed to `raise`. Pin in host saved-run configuration. */
+    upbringing?: RaiseOptions;
     lifecourse?: LifecourseOptions;
     transfer?: SkillTransfer;
 }

package/dist/sim/longrun.js

@@ -10,19 +10,30 @@
  * back to `stepCommunity` at the stretch's end: a common pattern is routine for the years nobody watches, lived
  * minutes for the days someone is watching. Switching fidelity is the host's decision and happens on a day boundary.
  *
+ * With `deathHandling: 'community'`, entry and dawn catch-up deaths are discovered at the sync minute and
+ * skip routine work. Routine deaths retain their whole-day batch ordering; attended news and proposal cleanup
+ * run only after every person's routine. Suppressing news does not suppress cleanup. This adds no mortality,
+ * funeral or religious model. The host pins the option after restore; omission retains the old path.
+ *
  * It does not run decisions, conversation, joint activities, contagion or the world's percepts and affordances: those
  * belong to lived time. Companions are listed by the host on both sides (each person's routine names the other),
  * since a routine day writes only its own person. Births and arrivals are the host's (`birth`, `addPerson` in
  * `onDay`); a person added during the stretch starts on the next day.
+ *
+ * Opt-in `upbringing.model: 'warmth-through-25'` selects living parents or guardians from the young person's
+ * ties, counting each different person once, through young adulthood (under 25). Guardianship does not supply
+ * warmth: `raise` reads caregiver-to-child affection. Its continuous age taper and warmth-scaled rates are
+ * engineering assumptions; no abuse, schooling or adult culture diffusion. Hosts pin `upbringing` in saved-run
+ * configuration and supply it after restore. Marriage, parenthood and co-residence do not gate this model;
+ * a living carer in the community suffices. Omitted, the under-18, parents-only path stays exact.
  */
 import { endDay } from '../chronicle/index.js';
 import { dayOf } from '../core/index.js';
 import { raise } from '../family/index.js';
 import { ageYears } from '../lifecourse/index.js';
 import { routineDay } from '../longrun.js';
-import { tick } from '../person.js';
 import { MINUTES_PER_DAY } from '../types.js';
-import { tellDeath } from './sim.js';
+import { advanceCommunityPerson, cleanupCommunityDeath, tellDeath, } from './sim.js';
 export const LIVE_COMMUNITY_DEFAULTS = {
     /** Upbringing time a day with the parents (engineering assumption: a few waking hours together). */
     upbringingMinutes: 240,
@@ -36,6 +47,15 @@ const UPBRINGING_UNTIL = 18;
 export function liveCommunity(c, until, opts) {
     const events = [];
     const days = {};
+    const log = (e) => {
+        const p = c.people.find((q) => q.id === e.personId);
+        events.push(p?.lexicon?.plainEnglish && e.kind === 'died' ? { ...e, detail: `${p.name} died.` } : e);
+    };
+    if (opts.deathHandling === 'community') {
+        // Older raw community JSON lacks these maps. Only the opt-in needs them here.
+        c.interrupts ??= {};
+        c.joint ??= { nextId: 0, proposals: [], excluded: {} };
+    }
     // Start at the first midnight at or after the community's clock: whoever is behind lives up to it minute by
     // minute, and open chronicle days are closed so none is carried through the stretch.
     let now = 0;
@@ -47,7 +67,7 @@ export function liveCommunity(c, until, opts) {
         return { events, days };
     for (const p of c.people) {
         if (p.body.alive && p.now < now)
-            tick(p, now);
+            advanceCommunityPerson(c, p, now, opts, log);
         endDay(p);
         if (!p.body.alive && p.now < now)
             p.now = now;
@@ -67,7 +87,9 @@ export function liveCommunity(c, until, opts) {
             if (!p.body.alive)
                 continue;
             if (p.now < now)
-                tick(p, now);
+                advanceCommunityPerson(c, p, now, opts, log);
+            if (opts.deathHandling === 'community' && !p.body.alive)
+                continue;
             if (p.now !== now)
                 continue; // added mid-stretch with a later clock: joins when the day catches up
             const r = routineDay(p, opts.routineFor(p, day), routineOpts);
@@ -106,23 +128,31 @@ export function liveCommunity(c, until, opts) {
         for (const p of c.people)
             if (!p.body.alive && p.now < now)
                 p.now = now;
-        if (tell)
-            for (const d of died)
-                tellDeath(c, d, now);
-        // Upbringing (1.8.0): each living minor spends the day's upbringing time with their living parents.
+        // Keep routine deaths batched: recipients must run their own routine before end-of-day news/cleanup.
+        for (const d of died) {
+            if (tell)
+                tellDeath(c, d, now, opts.deathHandling === 'community' ? { receipt: 'attended' } : {});
+            if (opts.deathHandling === 'community')
+                cleanupCommunityDeath(c, d, now, opts, log);
+        }
+        // Legacy: minors with parents. Opt-in: household influence through young adulthood with parents/guardians.
         if (upbringing > 0) {
             const byId = new Map(c.people.map((q) => [q.id, q]));
             for (const child of c.people) {
-                if (!child.body.alive || ageYears(child) >= UPBRINGING_UNTIL)
+                const continuous = opts.upbringing?.model === 'warmth-through-25';
+                if (!child.body.alive || ageYears(child) >= (continuous ? 25 : UPBRINGING_UNTIL))
                     continue;
                 const caregivers = child.social.relationships
-                    .filter((r) => r.roles.includes('parent'))
+                    .filter((r) => r.roles.includes('parent') || (continuous && r.roles.includes('guardian')))
                     .flatMap((r) => {
                     const q = byId.get(r.otherId);
                     return q?.body.alive ? [q] : [];
                 });
-                if (caregivers.length > 0)
-                    raise(child, { caregivers }, upbringing);
+                const selected = continuous
+                    ? [...new Map(caregivers.filter((q) => q.id !== child.id).map((q) => [q.id, q])).values()]
+                    : caregivers;
+                if (selected.length > 0)
+                    raise(child, { caregivers: selected }, upbringing, opts.upbringing);
             }
         }
     }

package/dist/sim/sim.d.ts

@@ -183,6 +183,8 @@ export interface LifecourseOptions {
     exposures?(p: Person): HealthExposures | undefined;
 }
 export interface StepOptions {
+    /** Hold current pregnancy and ambient conditions through body forecasts; pin in host run config. */
+    forecastContext?: 'conditioned';
     /** Standing suggestions, applied at every decision of that person (resolved quietly at reviews); one or several voices. */
     suggestions?: Record<PersonId, Suggestion | readonly Suggestion[]>;
     /** Contagion rolls between people who just shared an activity (default true). */
@@ -194,6 +196,15 @@ export interface StepOptions {
      * noticed (1.8.0, default true): they grieve, keep the tie as a memory, and a spouse is widowed (`partnering/`).
      */
     tellDeaths?: boolean;
+    /**
+     * Opt in to transition-based dispatch around driver-owned tick and finish advancement. Discovery is the advanced clock
+     * minute, not an inferred biological death time. Notices use attended receipts. Pin this option in
+     * the host run config on every call and restore; no community/save mark enables it implicitly.
+     * A future-dated host outcome advances discovery and tied recipients to that future clock, even past
+     * the step bound and their intervening events. Hosts needing bounded event order must resolve at
+     * the current event minute. Returned finish/death entries record scheduling and discovery clocks.
+     */
+    deathHandling?: 'community';
     /** Hosts may disable the necessity exception. */
     necessity?: boolean;
     /** Minutes an idle person waits when no option is chosen. */
@@ -240,11 +251,25 @@ export declare function birth(c: Community, a: Person, b: Person, spec: ChildSpe
  * percept through `perceive`, so they grieve, the tie is kept and marked, and a spouse is widowed. Each listener's
  * 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.
+ * delivering any news if one is ahead. This changes no listener's clock. `receipt: 'attended'`
+ * opts into knowledge-consistent bereavement: only an attended percept marks the tie and widows;
+ * dropped news changes neither. Omitted receipt keeps the original unconditional widow call.
  */
 export declare function tellDeath(c: Community, dead: Person, at: Minute, opts?: {
     late?: 'throw' | 'now';
+    receipt?: 'attended';
 }): void;
+/**
+ * SCOPE: opt-in community death discovery and scheduler cleanup, not a mortality model. Wrap one
+ * driver-owned advancement (tick by default); dispatch its alive-to-dead transition at the resulting clock.
+ * The optional advancement callback supports life-course rolls without another tick. It must be
+ * synchronous and advance only `p`; hosts own discovery of external deaths. No RNG or state mark
+ * is added. Pin `deathHandling` in the host run config, including after JSON restore. Event caps
+ * may omit returned log entries but never suppress cleanup or notices. No funeral is modeled.
+ */
+export declare function advanceCommunityPerson(c: Community, p: Person, at: Minute, opts?: Pick<StepOptions, 'deathHandling' | 'tellDeaths'>, log?: (e: SimEvent) => void, advance?: (p: Person, at: Minute) => void): void;
+/** Internal scheduler settlement. Routine callers wait until every person's day has run. */
+export declare function cleanupCommunityDeath(c: Community, p: Person, at: Minute, opts: Pick<StepOptions, 'deathHandling' | 'tellDeaths'>, log: (e: SimEvent) => void): void;
 /** Pure scheduling query, including passive bodily checkpoints during joint waiting. */
 export declare function nextEventAt(c: Community, p: Person): Minute;
 /**
@@ -255,6 +280,7 @@ export declare function preview(p: Person, affordances: readonly Affordance[], s
     necessity?: boolean;
     others?: readonly Suggestion[];
     scarcity?: number;
+    forecastContext?: 'conditioned';
 }): SuggestionResolution;
 /**
  * Force `p` to re-decide at `at` (not earlier than their own clock): a running activity's review is brought
@@ -280,7 +306,7 @@ export declare function declineJoint(c: Community, proposal: JointProposal, prop
  * activities are resolved as interrupted first, then the proposer begins the offer and each partner their
  * mirror. Returns the activities begun (empty while other partners have yet to answer).
  */
-export declare function acceptJoint(c: Community, world: World, proposal: JointProposal, partner: Person, partnerRecord: DecisionRecord, writeLog?: (e: SimEvent) => void): Activity[];
+export declare function acceptJoint(c: Community, world: World, proposal: JointProposal, partner: Person, partnerRecord: DecisionRecord, writeLog?: (e: SimEvent) => void, opts?: Pick<StepOptions, 'deathHandling' | 'tellDeaths'>): Activity[];
 /**
  * Chance that `lead` succeeds at a skilled task with `partners` helping: `successChance` with
  * support = Σ partner skill × partner capacity / max(difficulty, 0.1), clamped to 0..1.

package/dist/sim/sim.js

@@ -232,7 +232,9 @@ export function birth(c, a, b, spec) {
  * percept through `perceive`, so they grieve, the tie is kept and marked, and a spouse is widowed. Each listener's
  * 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.
+ * delivering any news if one is ahead. This changes no listener's clock. `receipt: 'attended'`
+ * opts into knowledge-consistent bereavement: only an attended percept marks the tie and widows;
+ * dropped news changes neither. Omitted receipt keeps the original unconditional widow call.
  */
 export function tellDeath(c, dead, at, opts = {}) {
     if (opts.late === 'throw') {
@@ -259,11 +261,74 @@ export function tellDeath(c, dead, at, opts = {}) {
                 summary: q.lexicon?.plainEnglish ? `${dead.name} died.` : `${dead.name} died`,
             },
         ]);
-        // A spouse is widowed even if the news went unattended.
-        if (q.bonds)
+        // Legacy calls widow even when unattended; attended mode leaves all receipt effects to perceive.
+        if (opts.receipt !== 'attended' && q.bonds)
             widow(q, dead.id, Math.max(at, q.now));
     }
 }
+/**
+ * SCOPE: opt-in community death discovery and scheduler cleanup, not a mortality model. Wrap one
+ * driver-owned advancement (tick by default); dispatch its alive-to-dead transition at the resulting clock.
+ * The optional advancement callback supports life-course rolls without another tick. It must be
+ * synchronous and advance only `p`; hosts own discovery of external deaths. No RNG or state mark
+ * is added. Pin `deathHandling` in the host run config, including after JSON restore. Event caps
+ * may omit returned log entries but never suppress cleanup or notices. No funeral is modeled.
+ */
+export function advanceCommunityPerson(c, p, at, opts = {}, log = () => { }, advance = tick) {
+    const alive = p.body.alive;
+    advance(p, at);
+    // Composite finish may advance beyond the scheduled event. Discovery uses that actual clock.
+    at = p.now;
+    if (opts.deathHandling !== 'community' || !alive || p.body.alive)
+        return;
+    log({ at, personId: p.id, kind: 'died', detail: `${p.name} died` });
+    if (opts.tellDeaths ?? true) {
+        // Perception clamps faculty time to the listener's clock. Synchronize eligible recipients first,
+        // discovering any deaths there too, so a notice is never encoded before its discovery minute.
+        for (const q of c.people) {
+            if (q === p || !q.body.alive || q.now >= at)
+                continue;
+            if (q.social.relationships.some((r) => r.otherId === p.id))
+                advanceCommunityPerson(c, q, at, opts, log);
+        }
+        tellDeath(c, p, at, { receipt: 'attended' });
+    }
+    cleanupCommunityDeath(c, p, at, opts, log);
+}
+/** Preserve finish's host-declared timing and return value; discover any internal advancement death. */
+function finishCommunityPerson(c, world, p, outcome, opts, log) {
+    let report = null;
+    advanceCommunityPerson(c, p, p.now, opts, log, () => {
+        report = finish(p, outcome, finishOpts(world));
+    });
+    return report;
+}
+/** Internal scheduler settlement. Routine callers wait until every person's day has run. */
+export function cleanupCommunityDeath(c, p, at, opts, log) {
+    for (const proposal of pendingProposals(c)) {
+        if (proposal.proposerId !== p.id && !proposal.partnerIds.includes(p.id))
+            continue;
+        // Settle before synchronization: a second discovered death cannot cancel this proposal twice.
+        settle(c, proposal, 'declined');
+        const proposer = personById(c, proposal.proposerId);
+        if (proposer?.body.alive) {
+            const when = Math.max(at, proposer.now);
+            const ex = c.joint.excluded[proposer.id];
+            if (ex?.at === when)
+                ex.ids.push(proposal.offer.id);
+            else
+                c.joint.excluded[proposer.id] = { at: when, ids: [proposal.offer.id] };
+        }
+        for (const id of [proposal.proposerId, ...proposal.partnerIds]) {
+            const q = personById(c, id);
+            if (!q?.body.alive)
+                continue;
+            if (q.now < at)
+                advanceCommunityPerson(c, q, at, opts, log);
+            interruptPerson(c, q, Math.max(at, q.now), `declined:${proposal.id}`);
+        }
+    }
+}
 /** Settled proposals kept for inspection. */
 const MAX_SETTLED_PROPOSALS = 16;
 const pendingProposals = (c) => c.joint.proposals.filter((x) => x.status === 'pending');
@@ -409,7 +474,7 @@ export function declineJoint(c, proposal, proposer) {
  * activities are resolved as interrupted first, then the proposer begins the offer and each partner their
  * mirror. Returns the activities begun (empty while other partners have yet to answer).
  */
-export function acceptJoint(c, world, proposal, partner, partnerRecord, writeLog = () => { }) {
+export function acceptJoint(c, world, proposal, partner, partnerRecord, writeLog = () => { }, opts = {}) {
     const log = (e) => {
         const person = personById(c, e.personId);
         writeLog(person?.lexicon?.plainEnglish ? { ...e, detail: plainEventDetail(person, e) } : e);
@@ -431,12 +496,41 @@ export function acceptJoint(c, world, proposal, partner, partnerRecord, writeLog
         if (q && rec)
             participants.push({ person: q, offer: mirrorFor(world, q, proposal), record: rec });
     }
-    const at = Math.max(...participants.map((x) => x.person.now));
+    let at = Math.max(...participants.map((x) => x.person.now));
+    const finishExisting = (person) => {
+        const act = person.activity;
+        if (act) {
+            const finishAt = opts.deathHandling === 'community' ? Math.max(at, person.now) : at;
+            const outcome = world.resolve(person, act, finishAt >= act.endsAt ? 'ended' : 'interrupted');
+            finishCommunityPerson(c, world, person, outcome, opts, log);
+            log({
+                at: finishAt,
+                personId: person.id,
+                kind: 'finish',
+                detail: person.lexicon?.plainEnglish
+                    ? taskEndLine(person, act.affordance.label, outcome.status)
+                    : `${act.action} ${outcome.status}`,
+                decisionId: act.decisionId,
+                affordanceId: act.affordanceId,
+                action: act.action,
+                status: outcome.status,
+            });
+        }
+    };
+    if (opts.deathHandling === 'community') {
+        for (const { person } of participants)
+            if (person.now < at)
+                advanceCommunityPerson(c, person, at, opts, log);
+        if (proposal.status !== 'pending' || participants.some(({ person }) => !person.body.alive)) {
+            declineJoint(c, proposal);
+            return [];
+        }
+    }
     // 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);
+                advanceCommunityPerson(c, person, at, opts, log);
         if (participants.some(({ person }) => person.body.doze?.since !== undefined)) {
             declineJoint(c, proposal);
             for (const { person } of participants)
@@ -444,28 +538,30 @@ export function acceptJoint(c, world, proposal, partner, partnerRecord, writeLog
             return [];
         }
     }
+    if (opts.deathHandling === 'community') {
+        // Host outcomes may advance beyond `at`. Resolve all old work before anyone starts shared work.
+        for (const { person } of participants)
+            finishExisting(person);
+        at = Math.max(...participants.map(({ person }) => person.now));
+        for (const { person } of participants)
+            if (person.now < at)
+                advanceCommunityPerson(c, person, at, opts, log);
+        if (proposal.status !== 'pending' ||
+            participants.some(({ person }) => !person.body.alive || person.body.doze?.since !== undefined)) {
+            declineJoint(c, proposal);
+            for (const { person } of participants)
+                if (person.body.alive)
+                    interruptPerson(c, person, at, `declined:${proposal.id}`);
+            return [];
+        }
+    }
     settle(c, proposal, 'accepted');
     const begun = [];
     for (const { person, offer, record } of participants) {
         if (person.now < at)
-            tick(person, at);
-        const act = person.activity;
-        if (act) {
-            const outcome = world.resolve(person, act, at >= act.endsAt ? 'ended' : 'interrupted');
-            finish(person, outcome, finishOpts(world));
-            log({
-                at,
-                personId: person.id,
-                kind: 'finish',
-                detail: person.lexicon?.plainEnglish
-                    ? taskEndLine(person, act.affordance.label, outcome.status)
-                    : `${act.action} ${outcome.status}`,
-                decisionId: act.decisionId,
-                affordanceId: act.affordanceId,
-                action: act.action,
-                status: outcome.status,
-            });
-        }
+            advanceCommunityPerson(c, person, at, opts, log);
+        if (opts.deathHandling !== 'community')
+            finishExisting(person);
         const started = begin(person, offer, record, {
             ...world.beginOptions?.(person, offer, record),
             jointId: proposal.id,
@@ -614,9 +710,9 @@ function converseOneWay(c, speaker, listener, ctx, log) {
         });
     }
 }
-function converseBoth(c, world, p, q, act, t, log) {
+function converseBoth(c, world, p, q, act, t, log, opts) {
     if (q.now < t)
-        tick(q, t);
+        advanceCommunityPerson(c, q, t, opts, log);
     // Non-joint conversation offers assume the partner is available; nobody talks with someone asleep.
     if (!q.body.alive || q.body.asleep)
         return;
@@ -717,6 +813,8 @@ function bookkeepDay(p, world, t, dayDone, opts) {
 /** Merge heard advice and the host's decision options in their existing precedence order. */
 function decisionOptions(c, world, p, opts, reason, affordances) {
     const o = {};
+    if (opts.forecastContext !== undefined)
+        o.forecastContext = opts.forecastContext;
     // 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.
@@ -798,7 +896,9 @@ export function stepCommunity(c, world, until, opts = {}) {
                 .filter((q) => q !== undefined);
             for (const q of waiters)
                 if (q.now < t)
-                    tick(q, t);
+                    advanceCommunityPerson(c, q, t, opts, log);
+            if (opts.deathHandling === 'community' && x.status !== 'pending')
+                continue;
             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');
@@ -826,7 +926,9 @@ export function stepCommunity(c, world, until, opts = {}) {
             break;
         const p = next;
         const ordinaryDue = ordinaryEventAt(c, p) <= t;
-        tick(p, t);
+        advanceCommunityPerson(c, p, t, opts, log);
+        if (opts.deathHandling === 'community' && !p.body.alive)
+            continue;
         const dozed = p.activity?.dozedAt !== undefined || p.body.doze?.since !== undefined;
         if (dozed) {
             cancelDozeWaiting(p, t);
@@ -835,7 +937,7 @@ export function stepCommunity(c, world, until, opts = {}) {
                 if (act.interrupt)
                     c.interrupts[p.id] ??= { ...act.interrupt };
                 const outcome = world.resolve(p, act, 'interrupted');
-                finish(p, outcome, finishOpts(world));
+                finishCommunityPerson(c, world, p, outcome, opts, log);
                 log({
                     at: t,
                     personId: p.id,
@@ -850,13 +952,17 @@ export function stepCommunity(c, world, until, opts = {}) {
                     status: outcome.status,
                 }, outcome.summary !== undefined);
             }
+            if (opts.deathHandling === 'community' && !p.body.alive)
+                continue;
             c.idleUntil[p.id] = t + quantum;
             if (!ordinaryDue)
                 continue;
         }
         if (!ordinaryDue && p.body.alive)
             continue;
-        bookkeepDay(p, world, t, c.dayDone, opts);
+        advanceCommunityPerson(c, p, t, opts, log, () => bookkeepDay(p, world, t, c.dayDone ?? {}, opts));
+        if (opts.deathHandling === 'community' && !p.body.alive)
+            continue;
         if (!p.body.alive) {
             log({ at: t, personId: p.id, kind: 'died', detail: `${p.name} died` });
             if (opts.tellDeaths ?? true)
@@ -899,7 +1005,7 @@ export function stepCommunity(c, world, until, opts = {}) {
         perceptReason ??= act?.interrupt?.reason;
         if (act && t >= act.endsAt) {
             const outcome = world.resolve(p, act, 'ended');
-            const report = finish(p, outcome, finishOpts(world));
+            const report = finishCommunityPerson(c, world, p, outcome, opts, log);
             const ev = {
                 at: t,
                 personId: p.id,
@@ -915,6 +1021,8 @@ export function stepCommunity(c, world, until, opts = {}) {
             if (report)
                 ev.status = report.status;
             log(ev, outcome.summary !== undefined);
+            if (opts.deathHandling === 'community' && !p.body.alive)
+                continue;
             if (outcome.status === 'completed') {
                 noteStandingDone(c, p, act, t);
                 if (pairMinute !== t) {
@@ -927,8 +1035,8 @@ export function stepCommunity(c, world, until, opts = {}) {
                         continue;
                     pairsDone.add(key);
                     if (isConversation(act))
-                        converseBoth(c, world, p, q, act, t, log);
-                    if (contagion && sharesPlace(q, act))
+                        converseBoth(c, world, p, q, act, t, log, opts);
+                    if (contagion && (opts.deathHandling !== 'community' || q.body.alive) && sharesPlace(q, act))
                         contagionBetween(p, q, act, t, log);
                 }
             }
@@ -972,7 +1080,7 @@ export function stepCommunity(c, world, until, opts = {}) {
                 detail: `joins ${acceptedProposal.offer.label}`,
                 jointId: acceptedProposal.id,
             });
-            acceptJoint(c, world, acceptedProposal, p, record, (event) => log(event, true));
+            acceptJoint(c, world, acceptedProposal, p, record, (event) => log(event, true), opts);
             continue;
         }
         const chosen = affordances.find((a) => a.id === record.chosenAffordanceId);
@@ -1010,7 +1118,7 @@ export function stepCommunity(c, world, until, opts = {}) {
         }
         if (act) {
             const outcome = world.resolve(p, act, 'interrupted');
-            finish(p, outcome, finishOpts(world));
+            finishCommunityPerson(c, world, p, outcome, opts, log);
             log({
                 at: t,
                 personId: p.id,
@@ -1024,6 +1132,8 @@ export function stepCommunity(c, world, until, opts = {}) {
                 status: outcome.status,
             });
         }
+        if (opts.deathHandling === 'community' && !p.body.alive)
+            continue;
         if (!chosen) {
             c.idleUntil[p.id] = t + quantum;
             log({ at: t, personId: p.id, kind: 'idle', detail: 'nothing chosen' });
@@ -1048,7 +1158,7 @@ export function stepCommunity(c, world, until, opts = {}) {
     }
     for (const p of c.people)
         if (p.now < until)
-            tick(p, until);
+            advanceCommunityPerson(c, p, until, opts, log);
     return events;
 }
 /**

package/dist/types.d.ts

@@ -879,7 +879,10 @@ export interface Activity {
 }
 export declare const PERSON_SCHEMA = "human/person@1";
 /**
- * Current: 2.3.0 (2026-10-17): optional temporal goals and received consequences.
+ * Engine compatibility stamp. Package versions and engine versions may differ.
+ * See CHANGELOG.md for current changes and migrate.ts for supported saved versions.
+ *
+ * 2.3.0 (2026-10-17): optional temporal goals and received consequences.
  * 2.2.0 (2026-10-14): method evidence grades each action independently.
  * Successful alternatives no longer count as failures of another action. Person state shape is unchanged.
  * 2.1.0 saves migrate by stamping the version.
@@ -915,7 +918,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.23.0";
+export declare const ENGINE_VERSION = "3.1.0";
 /** A pregnancy carried by this person (host-driven; see `family/`). */
 export interface Pregnancy {
     fatherId: PersonId;

package/dist/types.js

@@ -84,7 +84,10 @@ export const EMOTIONS = [
 // ---------------------------------------------------------------------------------------------
 export const PERSON_SCHEMA = 'human/person@1';
 /**
- * Current: 2.3.0 (2026-10-17): optional temporal goals and received consequences.
+ * Engine compatibility stamp. Package versions and engine versions may differ.
+ * See CHANGELOG.md for current changes and migrate.ts for supported saved versions.
+ *
+ * 2.3.0 (2026-10-17): optional temporal goals and received consequences.
  * 2.2.0 (2026-10-14): method evidence grades each action independently.
  * Successful alternatives no longer count as failures of another action. Person state shape is unchanged.
  * 2.1.0 saves migrate by stamping the version.
@@ -120,4 +123,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.23.0';
+export const ENGINE_VERSION = '3.1.0';

package/package.json

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