@adam0white/human-framework 2.23.0 → 3.1.0

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,31 +10,49 @@
  * 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 Routine, type RoutineDay } from '../longrun.ts';
+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, Person, PersonId } from '../types.ts';
-import { type Community, type LifecourseOptions, type SimEvent } from './sim.ts';
+import type { Minute, PersonId } from '../types.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;
 };
 export interface LiveCommunityOptions {
     /** Each living person's routine for a day (`day` is the day number being lived). */
-    routineFor(p: Person, day: number, c: Community): Routine;
+    routineFor: RoutineSource;
     /** At each dawn, before anyone's day: births, arrivals, routine changes. */
     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,10 +87,12 @@ 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, c), routineOpts);
+            const r = routineDay(p, opts.routineFor(p, day), routineOpts);
             if (r.episodes.length > 0 || r.onsets.length > 0 || r.stage || r.died) {
                 const list = days[p.id] ?? [];
                 list.push(r);
@@ -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/social/impressions.d.ts

@@ -1,8 +1,6 @@
 import type { EntityId, Minute, NormTag, Person, PersonId, Signed, StateCue, Traits, Unit } from '../types.ts';
 export type CueKind = 'state' | 'place' | 'trait' | 'tie' | 'trust' | 'skill' | 'regard';
 export declare const STATE_CUES: readonly StateCue[];
-/** @deprecated since 2.1: use `TRAIT_KEYS` (types.ts), the same list. Removed in 3.0. */
-export declare const TRAIT_NAMES: readonly (keyof Traits)[];
 export declare const IMPRESSION_DEFAULTS: {
     /** Weight half-life by kind, minutes (0 = no decay). */
     halfLife: Record<CueKind, number>;
@@ -88,20 +86,10 @@ export declare function setReserve(p: Person, reserve: Partial<Record<StateCue,
  * the evidence and how true it is (a figure in the dark tells little and tells it wrong).
  */
 export declare function glimpse(observer: Person, targetId: PersonId, signs: OutwardSigns, at: Minute, clarity?: Unit): void;
-/** @deprecated since 2.1: pass `at` (and the optional knobs) positionally. Removed in 3.0. */
-export declare function glimpse(observer: Person, targetId: PersonId, signs: OutwardSigns, opts: {
-    at: Minute;
-    clarity?: Unit;
-}): void;
 /** What someone was seen to do: place fear, ties, trust in a voice and trait evidence (see `ObservedAct`). */
 export declare function observeAct(observer: Person, targetId: PersonId, act: ObservedAct, table?: Record<string, Partial<Record<keyof Traits, Unit>>>): void;
 /** Testimony about someone (their own words, or another's): `value` on `key`, weighted (e.g. by trust in the teller). */
 export declare function hear(observer: Person, targetId: PersonId, key: string, value: number, at: Minute, weight?: Unit): void;
-/** @deprecated since 2.1: pass `at` (and the optional knobs) positionally. Removed in 3.0. */
-export declare function hear(observer: Person, targetId: PersonId, key: string, value: number, opts: {
-    at: Minute;
-    weight?: Unit;
-}): void;
 /**
  * Years of history condensed (host call, e.g. at the start of a run for people who already know each other): one
  * sample per trait from `traits` with an error that shrinks with familiarity, at weight

package/dist/social/impressions.js

@@ -30,8 +30,6 @@ import { clamp, clamp01, cmpStr, decay, latestPerId, newestN, round } from '../c
 import { MINUTES_PER_DAY, MINUTES_PER_YEAR, TRAIT_KEYS } from '../types.js';
 import { judge, SOCIAL_DEFAULTS } from './social.js';
 export const STATE_CUES = ['fatigue', 'pain', 'fear', 'mood'];
-/** @deprecated since 2.1: use `TRAIT_KEYS` (types.ts), the same list. Removed in 3.0. */
-export const TRAIT_NAMES = TRAIT_KEYS;
 export const IMPRESSION_DEFAULTS = {
     /** Weight half-life by kind, minutes (0 = no decay). */
     halfLife: {
@@ -208,11 +206,16 @@ function erred(observer, targetId, key, at, value, clarity) {
     const e = (hash01(`${observer.id}|${targetId}|${key}|${at}`) - 0.5) * IMPRESSION_DEFAULTS.noise;
     return value + e * (1 - clamp01(clarity));
 }
-export function glimpse(observer, targetId, signs, when, clarity) {
+/**
+ * A look at someone's outward signs (from the composite's `outwardSigns`). `clarity` 0..1 scales both the weight of
+ * the evidence and how true it is (a figure in the dark tells little and tells it wrong).
+ */
+export function glimpse(observer, targetId, signs, at, clarity) {
+    if (!Number.isFinite(at))
+        throw new TypeError('glimpse requires a finite positional time');
     if (targetId === observer.id)
         return;
-    const at = typeof when === 'number' ? when : when.at;
-    const clear = clamp01((typeof when === 'number' ? clarity : when.clarity) ?? 1);
+    const clear = clamp01(clarity ?? 1);
     if (clear <= 0)
         return;
     const imp = impressionFor(observer, targetId, true, at);
@@ -252,11 +255,13 @@ export function observeAct(observer, targetId, act, table = IMPRESSION_DEFAULTS.
         }
     }
 }
-export function hear(observer, targetId, key, value, when, weight) {
+/** Testimony about someone (their own words, or another's): `value` on `key`, weighted (e.g. by trust in the teller). */
+export function hear(observer, targetId, key, value, at, weight) {
+    if (!Number.isFinite(at))
+        throw new TypeError('hear requires a finite positional time');
     if (targetId === observer.id)
         return;
-    const at = typeof when === 'number' ? when : when.at;
-    const w = clamp01((typeof when === 'number' ? weight : when.weight) ?? 0.5);
+    const w = clamp01(weight ?? 0.5);
     if (w <= 0)
         return;
     const imp = impressionFor(observer, targetId, true, at);