@adam0white/human-framework 2.23.0 → 3.1.0

package/dist/family/family.d.ts

@@ -40,11 +40,6 @@ export declare function conceptionChance(mother: Person, father: Person, days: n
  * median (an engineering bound against extreme draws). Returns the pregnancy, or undefined if one is already open.
  */
 export declare function conceive(mother: Person, father: Person | PersonId, seed: number, at: Minute): Pregnancy | undefined;
-/** @deprecated since 2.1: pass `at` (and the optional knobs) positionally. Removed in 3.0. */
-export declare function conceive(mother: Person, father: Person | PersonId, opts: {
-    at: Minute;
-    seed: number;
-}): Pregnancy | undefined;
 /**
  * Weeks since conception (0 when not pregnant). Counted from conception, not from the last menstrual period, which
  * is where obstetric weeks and trimesters are conventionally counted from (about two weeks earlier). The second
@@ -79,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;
 }
@@ -86,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`).
  */
@@ -161,19 +169,25 @@ export function conceptionChance(mother, father, days) {
         return 0;
     return clamp01(1 - dpow(1 - c, days / FAMILY_DEFAULTS.cycleDays));
 }
-export function conceive(mother, father, seedOrOpts, when) {
-    const opts = typeof seedOrOpts === 'number' ? { seed: seedOrOpts, at: when } : seedOrOpts;
+/**
+ * Record that `mother` has conceived by `father` at `at`. The due date is drawn from a stream derived from `seed`;
+ * `seed` also becomes the child's seed at delivery. The drawn length is clamped to 4 sd below and 3 sd above the
+ * median (an engineering bound against extreme draws). Returns the pregnancy, or undefined if one is already open.
+ */
+export function conceive(mother, father, seed, at) {
+    if (!Number.isFinite(at))
+        throw new TypeError('conceive requires a finite positional time');
     const fam = familyOf(mother);
     if (fam.pregnancy)
         return undefined;
-    const rng = createRng((opts.seed ^ 0x9e3779b9) >>> 0);
+    const rng = createRng((seed ^ 0x9e3779b9) >>> 0);
     const F = FAMILY_DEFAULTS;
     const days = clamp(normal(rng, F.gestationDays, F.gestationSdDays), F.gestationDays - 4 * F.gestationSdDays, F.gestationDays + 3 * F.gestationSdDays);
     const pregnancy = {
         fatherId: typeof father === 'string' ? father : father.id,
-        conceivedAt: opts.at,
-        dueAt: opts.at + Math.round(days * MINUTES_PER_DAY),
-        seed: opts.seed,
+        conceivedAt: at,
+        dueAt: at + Math.round(days * MINUTES_PER_DAY),
+        seed,
     };
     fam.pregnancy = pregnancy;
     return { ...pregnancy };
@@ -240,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);
@@ -257,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);
@@ -273,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;
@@ -308,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.
@@ -331,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

@@ -6,14 +6,9 @@ export declare function outwardSigns(target: Person): OutwardSigns;
 /** What `target` says of themself: words hide more than faces (`wordsReserve`), and a limp is not mentioned. */
 export declare function selfReport(target: Person): OutwardSigns;
 /** `observer` looks at `target` at `at` (clarity 0..1: a clear look near by, or a distant figure; default 1). */
-export declare function glimpseOf(observer: Person, target: Person, at: Minute, clarity?: Unit): void;
-/** @deprecated since 2.1: pass `at` (and the optional knobs) positionally. Removed in 3.0. */
-export declare function glimpseOf(observer: Person, target: Person, opts: {
-    at: Minute;
-    clarity?: Unit;
-}): void;
+export declare function glimpsePerson(observer: Person, target: Person, at: Minute, clarity?: Unit): void;
 /** `observer` has known `target` for a long time (familiarity 0..1): traits and family ties, condensed. */
-export declare function acquaintWith(observer: Person, target: Person, familiarity: Unit, at: Minute): void;
+export declare function acquaintPerson(observer: Person, target: Person, familiarity: Unit, at: Minute): void;
 /** How sure the observer is of the things that drive an answer: traits and the state cues, 0..1. */
 export declare function impressionConfidence(observer: Person, targetId: PersonId, now: Minute): Unit;
 /**
@@ -31,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

@@ -4,7 +4,7 @@
  * - `outwardSigns(target)`: perceived fatigue, pain and fear and the felt mood, each reduced by the target's reserve;
  *   a limp (lost moving capacity) shows through any reserve. `selfReport(target)` is the same in words, which hide
  *   more (`IMPRESSION_DEFAULTS.wordsReserve`): "I'm fine".
- * - `glimpseOf(observer, target, at, clarity?)` = `glimpse` of the target's outward signs; `acquaintWith` hands the target's
+ * - `glimpsePerson(observer, target, at, clarity?)` = `glimpse` of the target's outward signs; `acquaintPerson` hands the target's
  *   traits and family ties (public roles) to `acquaint`.
  * - `imagine(observer, target, now)`: the target as the observer pictures them — a copy whose traits, fear, pain,
  *   fatigue, mood, ties and trust in voices are the observer's beliefs (each pulled to the prior by its uncertainty)
@@ -61,14 +61,12 @@ export function selfReport(target) {
     s.pain = round(body.perceived.pain * (1 - clamp01(reserveOf(target, 'pain') * IMPRESSION_DEFAULTS.wordsReserve)));
     return s;
 }
-export function glimpseOf(observer, target, when, clarity) {
-    if (typeof when === 'number')
-        glimpse(observer, target.id, outwardSigns(target), when, clarity);
-    else
-        glimpse(observer, target.id, outwardSigns(target), when.at, when.clarity);
+/** `observer` looks at `target` at `at` (clarity 0..1: a clear look near by, or a distant figure; default 1). */
+export function glimpsePerson(observer, target, at, clarity) {
+    glimpse(observer, target.id, outwardSigns(target), at, clarity);
 }
 /** `observer` has known `target` for a long time (familiarity 0..1): traits and family ties, condensed. */
-export function acquaintWith(observer, target, familiarity, at) {
+export function acquaintPerson(observer, target, familiarity, at) {
     const ties = {};
     for (const r of target.social.relationships)
         if (r.roles.some((x) => PUBLIC_ROLES.includes(x)))
@@ -160,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 = "2.23.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';
@@ -46,5 +46,6 @@ export * from './scenarios/index.ts';
 export * from './sim/index.ts';
 export * from './skills/index.ts';
 export * from './social/index.ts';
+export { canonicalTickInputs, type TickInput, type TickInputKey } from './tick-input.ts';
 export * from './types.ts';
 export * from './will/index.ts';

package/dist/index.js

@@ -1,5 +1,5 @@
 /** Human Framework public surface. */
-export const FRAMEWORK_VERSION = '2.23.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';
@@ -42,5 +42,6 @@ export * from './scenarios/index.js';
 export * from './sim/index.js';
 export * from './skills/index.js';
 export * from './social/index.js';
+export { canonicalTickInputs } from './tick-input.js';
 export * from './types.js';
 export * from './will/index.js';

package/dist/longrun.d.ts

@@ -87,8 +87,8 @@ export interface RoutineDay {
  * Live one routine day from `p.now` (see SCOPE). A dead person only moves the clock. Returns what happened.
  */
 export declare function routineDay(p: Person, routine: Routine, opts?: RoutineOptions): RoutineDay;
-/** A routine, or one chosen per day (by season, age, role). */
-export type RoutineSource = Routine | ((p: Person, day: number) => Routine);
+/** Choose a routine for a person at the start of an absolute day. Capture host context in a closure. */
+export type RoutineSource = (p: Person, day: number) => Routine;
 /**
  * Live from `p.now` to `to` by routine (see SCOPE): the running activity is dropped and the open chronicle day closed
  * first, whole days are lived with `routineDay`, a remainder shorter than a day is skipped (`skip`), and past

package/dist/longrun.js

@@ -181,7 +181,6 @@ export function routineDay(p, routine, opts = {}) {
         report.stage = stageAfter;
     return report;
 }
-const routineOf = (src, p) => typeof src === 'function' ? src(p, dayOf(p.now)) : src;
 /**
  * Live from `p.now` to `to` by routine (see SCOPE): the running activity is dropped and the open chronicle day closed
  * first, whole days are lived with `routineDay`, a remainder shorter than a day is skipped (`skip`), and past
@@ -199,7 +198,7 @@ export function liveRoutine(p, to, routine, opts = {}) {
     endDay(p);
     p.activity = null;
     while (p.now + MINUTES_PER_DAY <= to && p.body.alive) {
-        const r = routineDay(p, routineOf(routine, p), opts);
+        const r = routineDay(p, routine(p, dayOf(p.now)), opts);
         if (r.episodes.length > 0 || r.onsets.length > 0 || r.stage || r.died)
             out.push(r);
     }

package/dist/memory/memory.d.ts

@@ -139,10 +139,6 @@ export interface RetellOptions {
  * from the listener to others (a host may call it again with the listener as teller).
  */
 export declare function retell(teller: Person, listener: Person, at: Minute, opts?: RetellOptions): Gist[];
-/** @deprecated since 2.1: pass `at` (and the optional knobs) positionally. Removed in 3.0. */
-export declare function retell(teller: Person, listener: Person, opts: RetellOptions & {
-    at: Minute;
-}): Gist[];
 /** Encode an episode. Evicts the weakest (salience × recency) episode beyond the bound. */
 export declare function remember(p: Person, e: Omit<Episode, 'id' | 'salience'> & {
     salience?: Unit;

package/dist/memory/memory.js

@@ -287,8 +287,22 @@ export const RETELL_DEFAULTS = {
     /** Gists weaker than this (teller's salience) are not worth telling. */
     minSalience: 0.1,
 };
-export function retell(teller, listener, when, knobs = {}) {
-    const opts = typeof when === 'number' ? { ...knobs, at: when } : when;
+/**
+ * `teller` tells `listener` at `at` the gist of what mattered to them (2.0, L2: stories passed in a household or around a
+ * fire). The listener must have gists on (`enableGists`); otherwise nothing happens. The teller's strongest gists
+ * (up to `limit`, optionally only those about `placeIds`) become the listener's own gists with the tag `told`, the
+ * teller's valence and summary, and a salience of the teller's × `trust` × `RETELL_DEFAULTS.share`. A listener who
+ * already holds a gist about the same thing (kind, action, target and place, whoever was there) from their own
+ * experience keeps it unchanged; one told before keeps the
+ * stronger telling (retelling the same story does not keep raising it). So a child of parents who fear a place
+ * weighs that fear (cognition's `memory` term, by place at half weight) before ever standing there, and their own
+ * later visits outweigh it as they would any gist. No randomness; returns the gists written or strengthened.
+ * It does not model distortion in the retelling, the listener doubting the teller beyond `trust`, or retelling on
+ * from the listener to others (a host may call it again with the listener as teller).
+ */
+export function retell(teller, listener, at, opts = {}) {
+    if (!Number.isFinite(at))
+        throw new TypeError('retell requires a finite positional time');
     const told = teller.memory.gists;
     const list = listener.memory.gists;
     if (!told || !list || teller.id === listener.id)
@@ -312,7 +326,7 @@ export function retell(teller, listener, when, knobs = {}) {
             if (salience > mine.salience) {
                 mine.salience = salience;
                 mine.weight = salience;
-                mine.lastAt = opts.at;
+                mine.lastAt = at;
                 out.push(mine);
             }
             continue;
@@ -321,15 +335,15 @@ export function retell(teller, listener, when, knobs = {}) {
         listener.memory.nextGist = (listener.memory.nextGist ?? 0) + 1;
         const g = {
             id,
-            at: opts.at,
+            at,
             kind: src.kind,
             valence: src.valence,
             salience,
             summary: src.summary,
             tags: ['told', ...src.tags.filter((t) => t !== 'told')].slice(0, GIST_DEFAULTS.maxTags),
             count: 0,
-            firstAt: opts.at,
-            lastAt: opts.at,
+            firstAt: at,
+            lastAt: at,
             weight: salience,
             peak: salience,
         };

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

@@ -29,7 +29,8 @@ import { ageCharacter, enableCharacterChange, noteCharacterDay, noteCharacterSoc
 import { closeDay, enableYearbook, endDay, noteAnswer, noteCommitments, noteDecision, noteMood, noteOutcome, trimChronicle, } from './chronicle/index.js';
 import { decide as cognitionDecide, desperationOf, prospectiveRoute, scoreAll } from './cognition/index.js';
 import { createConscience, guiltLoad, heldNorms, normVeto, recordDeed, recordRepair, repent, } from './conscience/index.js';
-import { clamp01, clampSigned, createRng, dayOf, isObj, keysOf, minuteOfDay, round } from './core/index.js';
+import { clamp01, clampSigned, createRng, dayOf, isObj, minuteOfDay, round } from './core/index.js';
+import { keysOf } from './core/keys.js';
 import { enableCuriosity, noteCuriosity } from './curiosity/index.js';
 import { ambientBodyParams, ambientModifiers, ambientMood, ambientNeeds } from './environment/index.js';
 import { aptitudeOf, createFamily, pregnancyModifiers } from './family/index.js';
@@ -905,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];
@@ -933,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.
@@ -965,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)
@@ -989,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)
@@ -1161,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);
 }
@@ -1390,7 +1406,7 @@ function respondToConscience(p, act, now, completed, minutes) {
         // Worship closes breaches against God alone; guilt toward a wronged person waits for repair.
         const repented = new Set();
         for (const b of p.conscience.breaches) {
-            if (!b.repaired && b.victimId === undefined && repent(p, b.id, now))
+            if (!b.repaired && b.victimId === undefined && repent(p, b.id))
                 repented.add(b.normId);
         }
         for (const b of p.conscience.breaches)
@@ -1401,7 +1417,7 @@ function respondToConscience(p, act, now, completed, minutes) {
         regulate(p, minutes, 'worship');
     }
     if (completed && (tags.includes('repair') || tags.includes('apologize')) && aff.targetId !== undefined) {
-        recordRepair(p, aff.targetId, now);
+        recordRepair(p, aff.targetId);
         release(p, { id: 'guilt', targetId: aff.targetId });
         socialEvent(p, { at: now, kind: 'apology', otherId: aff.targetId, byMe: true, magnitude: 0.7 });
     }
@@ -1694,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';