@adam0white/human-framework 2.9.0 → 2.10.0

package/dist/sim/sim.js

@@ -125,6 +125,7 @@ export function communityState(c) {
 /**
  * A community over `people`. With `prior` (from `communityState`, possibly through JSON), the host-side state is
  * resumed from it, so a run restored from people + community + world state continues exactly as it would have.
+ * `prior` is copied: after stepping, write back `communityState(c)`; the old `prior` stays stale.
  */
 export function createCommunity(people, prior) {
     const sorted = [...people].sort((a, b) => cmpStr(a.id, b.id));
@@ -181,9 +182,19 @@ export function birth(c, a, b, spec) {
 /**
  * Tell `dead`'s death at `at` to everyone alive in the community who has a tie to them (1.8.0): a told `death`
  * percept through `perceive`, so they grieve, the tie is kept and marked, and a spouse is widowed. Each listener's
- * clock must be at or before `at`; the drivers call it when they notice the death.
+ * 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.
  */
-export function tellDeath(c, dead, at) {
+export function tellDeath(c, dead, at, opts = {}) {
+    if (opts.late === 'throw') {
+        for (const q of c.people) {
+            if (q === dead || !q.body.alive || q.now <= at)
+                continue;
+            if (q.social.relationships.some((r) => r.otherId === dead.id))
+                throw new Error(`tellDeath: listener ${q.id} is past the death minute`);
+        }
+    }
     for (const q of c.people) {
         if (q === dead || !q.body.alive)
             continue;
@@ -572,24 +583,8 @@ function contagionBetween(p, q, act, t, log) {
         }
     }
 }
-/**
- * Advance the community to `until`, processing person events in (time, id) order. Returns the events.
- */
-export function stepCommunity(c, world, until, opts = {}) {
-    const events = [];
-    const quantum = Math.max(1, opts.idleQuantum ?? SIM_DEFAULTS.idleQuantum);
-    const maxEvents = opts.maxEvents ?? SIM_DEFAULTS.maxEvents;
-    const salience = opts.interruptSalience ?? SIM_DEFAULTS.interruptSalience;
-    // Communities created before joint support (plain JSON from an older host) get the new bookkeeping.
-    c.interrupts ??= {};
-    c.joint ??= { nextId: 0, proposals: [], excluded: {} };
-    const log = (e) => {
-        if (events.length < maxEvents)
-            events.push(e);
-    };
-    const contagion = opts.contagion ?? true;
-    c.queued ??= {};
-    c.dayDone ??= {};
+/** Synchronize the host's commands before selecting the next event. */
+function synchronizeCommands(c, opts, log) {
     if (opts.controlled) {
         for (const p of c.people) {
             const cmd = opts.controlled[p.id];
@@ -614,36 +609,108 @@ export function stepCommunity(c, world, until, opts = {}) {
             }
         }
     }
-    const decideOpts = (p, reason, affordances) => {
-        const o = {};
-        // 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.
-        const standing = opts.suggestions?.[p.id];
-        const merged = [];
-        const seen = new Set();
-        const heard = (standing ? (Array.isArray(standing) ? standing : [standing]) : []).filter((s) => standingHeard(c, p, s, affordances, p.now));
-        for (const s of [...(c.queued?.[p.id] ?? []), ...heard]) {
-            if (seen.has(s.voiceId))
-                continue;
-            seen.add(s.voiceId);
-            merged.push(s);
+}
+/** Run life-course bookkeeping and the host's day hook at the first event of a new day. */
+function bookkeepDay(p, world, t, dayDone, opts) {
+    // First event of a new day: life-course rolls for the days crossed, then the host's day hook.
+    const day = dayOf(t);
+    const lastDay = dayDone[p.id];
+    if (lastDay === undefined || day > lastDay) {
+        dayDone[p.id] = day;
+        const lc = opts.lifecourse;
+        if (lc && lastDay !== undefined && p.body.alive) {
+            const dt = (day - lastDay) * MINUTES_PER_DAY;
+            if (lc.chronicOnsets) {
+                const onsetOpts = {};
+                if (lc.conditions)
+                    onsetOpts.conditions = lc.conditions;
+                const ex = lc.exposures?.(p);
+                if (ex)
+                    onsetOpts.exposures = ex;
+                for (const ill of chronicOnsets(p, dt, p.rng, onsetOpts))
+                    sicken(p, ill);
+            }
+            if (lc.mortality) {
+                const roll = mortalityEvent(p, dt, p.rng, lc.multiplier !== undefined ? { multiplier: lc.multiplier } : {});
+                if (roll.died)
+                    die(p);
+            }
         }
-        const [first, ...rest] = merged;
-        if (first)
-            o.suggestion = first;
-        if (rest.length > 0)
-            o.suggestions = rest;
-        const scarcity = world.scarcityFor?.(p);
-        if (scarcity !== undefined && scarcity > 0)
-            o.scarcity = scarcity;
-        if (opts.necessity !== undefined)
-            o.necessity = opts.necessity;
-        const forced = reason ?? c.interrupts[p.id]?.reason;
-        if (forced !== undefined && !p.activity)
-            o.interrupt = forced;
-        return o;
+        if (p.body.alive)
+            world.onDay?.(p, day);
+    }
+}
+/** Merge heard advice and the host's decision options in their existing precedence order. */
+function decisionOptions(c, world, p, opts, reason, affordances) {
+    const o = {};
+    // 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.
+    const standing = opts.suggestions?.[p.id];
+    const merged = [];
+    const seen = new Set();
+    const heard = (standing ? (Array.isArray(standing) ? standing : [standing]) : []).filter((s) => standingHeard(c, p, s, affordances, p.now));
+    for (const s of [...(c.queued?.[p.id] ?? []), ...heard]) {
+        if (seen.has(s.voiceId))
+            continue;
+        seen.add(s.voiceId);
+        merged.push(s);
+    }
+    const [first, ...rest] = merged;
+    if (first)
+        o.suggestion = first;
+    if (rest.length > 0)
+        o.suggestions = rest;
+    const scarcity = world.scarcityFor?.(p);
+    if (scarcity !== undefined && scarcity > 0)
+        o.scarcity = scarcity;
+    if (opts.necessity !== undefined)
+        o.necessity = opts.necessity;
+    const forced = reason ?? c.interrupts[p.id]?.reason;
+    if (forced !== undefined && !p.activity)
+        o.interrupt = forced;
+    return o;
+}
+/** Add pending joint mirrors to world offers and apply this minute's declined-offer exclusions. */
+function offersForDecision(c, world, p, t) {
+    // Offers: the world's, plus mirrors of joint proposals awaiting this person's answer, minus offers a partner
+    // just declined (this minute only).
+    const asked = pendingProposals(c).filter((x) => x.partnerIds.includes(p.id) && !x.accepted.includes(p.id));
+    const mirrors = new Map();
+    let affordances = world.affordancesFor(p);
+    for (const x of asked) {
+        const m = mirrorFor(world, p, x);
+        mirrors.set(m.id, x);
+        affordances = [...affordances.filter((a) => a.id !== m.id), m];
+    }
+    const ex = c.joint.excluded[p.id];
+    if (ex) {
+        if (ex.at === t)
+            affordances = affordances.filter((a) => !ex.ids.includes(a.id));
+        else
+            delete c.joint.excluded[p.id];
+    }
+    return { asked, mirrors, affordances };
+}
+/**
+ * Advance the community to `until`, processing person events in (time, id) order. Returns the events.
+ */
+export function stepCommunity(c, world, until, opts = {}) {
+    const events = [];
+    const quantum = Math.max(1, opts.idleQuantum ?? SIM_DEFAULTS.idleQuantum);
+    const maxEvents = opts.maxEvents ?? SIM_DEFAULTS.maxEvents;
+    const salience = opts.interruptSalience ?? SIM_DEFAULTS.interruptSalience;
+    // Communities created before joint support (plain JSON from an older host) get the new bookkeeping.
+    c.interrupts ??= {};
+    c.joint ??= { nextId: 0, proposals: [], excluded: {} };
+    const log = (e) => {
+        if (events.length < maxEvents)
+            events.push(e);
     };
+    const contagion = opts.contagion ?? true;
+    c.queued ??= {};
+    c.dayDone ??= {};
+    synchronizeCommands(c, opts, log);
     // Pairs whose shared activity already ran its conversation and contagion at `pairMinute` (both partners
     // finishing the same joint activity at the same minute would otherwise run them twice).
     let pairMinute = Number.NEGATIVE_INFINITY;
@@ -662,33 +729,7 @@ export function stepCommunity(c, world, until, opts = {}) {
             break;
         const p = next;
         tick(p, t);
-        // First event of a new day: life-course rolls for the days crossed, then the host's day hook.
-        const day = dayOf(t);
-        const lastDay = c.dayDone[p.id];
-        if (lastDay === undefined || day > lastDay) {
-            c.dayDone[p.id] = day;
-            const lc = opts.lifecourse;
-            if (lc && lastDay !== undefined && p.body.alive) {
-                const dt = (day - lastDay) * MINUTES_PER_DAY;
-                if (lc.chronicOnsets) {
-                    const onsetOpts = {};
-                    if (lc.conditions)
-                        onsetOpts.conditions = lc.conditions;
-                    const ex = lc.exposures?.(p);
-                    if (ex)
-                        onsetOpts.exposures = ex;
-                    for (const ill of chronicOnsets(p, dt, p.rng, onsetOpts))
-                        sicken(p, ill);
-                }
-                if (lc.mortality) {
-                    const roll = mortalityEvent(p, dt, p.rng, lc.multiplier !== undefined ? { multiplier: lc.multiplier } : {});
-                    if (roll.died)
-                        die(p);
-                }
-            }
-            if (p.body.alive)
-                world.onDay?.(p, day);
-        }
+        bookkeepDay(p, world, t, c.dayDone, opts);
         if (!p.body.alive) {
             log({ at: t, personId: p.id, kind: 'died', detail: `${p.name} died` });
             if (opts.tellDeaths ?? true)
@@ -758,24 +799,8 @@ export function stepCommunity(c, world, until, opts = {}) {
             }
             act = p.activity;
         }
-        // Offers: the world's, plus mirrors of joint proposals awaiting this person's answer, minus offers a partner
-        // just declined (this minute only).
-        const asked = pendingProposals(c).filter((x) => x.partnerIds.includes(p.id) && !x.accepted.includes(p.id));
-        const mirrors = new Map();
-        let affordances = world.affordancesFor(p);
-        for (const x of asked) {
-            const m = mirrorFor(world, p, x);
-            mirrors.set(m.id, x);
-            affordances = [...affordances.filter((a) => a.id !== m.id), m];
-        }
-        const ex = c.joint.excluded[p.id];
-        if (ex) {
-            if (ex.at === t)
-                affordances = affordances.filter((a) => !ex.ids.includes(a.id));
-            else
-                delete c.joint.excluded[p.id];
-        }
-        const record = decide(p, affordances, decideOpts(p, perceptReason, affordances));
+        const { asked, mirrors, affordances } = offersForDecision(c, world, p, t);
+        const record = decide(p, affordances, decisionOptions(c, world, p, opts, perceptReason, affordances));
         delete c.interrupts[p.id];
         // Conversation advice is weighed until the next fresh decision, then it has been heard.
         if (!act)

package/dist/social/impressions.d.ts

@@ -1,5 +1,5 @@
-import type { EntityId, Minute, Person, PersonId, Signed, StateCue, Traits, Unit } from '../types.ts';
-export type CueKind = 'state' | 'place' | 'trait' | 'tie' | 'trust' | 'skill';
+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)[];
@@ -21,6 +21,7 @@ export declare const IMPRESSION_DEFAULTS: {
         tie: number;
         trust: number;
         skill: number;
+        regard: number;
     };
     /** Default reserve: base + emotionalityCoef × (1 − emotionality) for pain and fear; fatigue and mood a little. */
     reserve: {
@@ -129,3 +130,31 @@ export declare function impressionOf(observer: Person, targetId: PersonId, now:
  * and unhurt reads positive, frightened or hurt negative. Cognition weighs it on risky offers shared with them.
  */
 export declare function companionSteadiness(p: Person, otherId: PersonId, now: Minute): Signed;
+/**
+ * SCOPE (believed regard): the person's estimate of how another regards them, updated only by their own evidence
+ * that the other knows of an act. Seen witnesses carry full weight; a learned relay carries information-source
+ * trust. The person projects the act's valence and their own held-norm judgement, without reading the other's
+ * mind. Negative samples carry the social negativity bias. Evidence halves over 60 days. This does not model
+ * hidden witnesses, unknown relays, recursive beliefs or the other's actual feelings. Relationships and
+ * impressions remain separate stores. The projection weights and half-life are engineering defaults.
+ */
+/** An act of mine that someone else knows of (2.10.0). */
+export interface KnownAct {
+    kind: string;
+    targetId?: PersonId;
+    valence?: Signed;
+    norms?: NormTag[];
+}
+/**
+ * The person has their own evidence that `otherId` knows of their act: they saw them see it (`via: 'seen'`) or were
+ * told they heard (`via: 'told'`, weighted by trust in `sourceId`). Moves the believed regard cue. See the SCOPE.
+ */
+export declare function noteKnownBy(p: Person, ev: {
+    otherId: PersonId;
+    act: KnownAct;
+    at?: Minute;
+    via: 'seen' | 'told';
+    sourceId?: EntityId;
+}): Estimate | undefined;
+/** How `p` believes `otherId` regards them; the neutral prior has zero confidence. Pure and RNG-free. */
+export declare function regardOf(p: Person, otherId: PersonId, now: Minute): Estimate;

package/dist/social/impressions.js

@@ -25,8 +25,10 @@
  * of one's own state, deliberate deception beyond reserve, the target noticing being watched, or gossip about
  * impressions (conversation carries reputation beliefs separately, `social.ts`).
  */
+import { testimonyWeight, trustOf } from '../beliefs/beliefs.js';
 import { clamp, clamp01, cmpStr, decay, latestPerId, newestN, round } from '../core/index.js';
 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;
@@ -40,6 +42,7 @@ export const IMPRESSION_DEFAULTS = {
         trust: 30 * MINUTES_PER_DAY,
         /** `skill:<id>`: how good someone is at a craft changes over seasons, and what was seen of it lasts. */
         skill: MINUTES_PER_YEAR,
+        regard: 60 * MINUTES_PER_DAY,
     },
     /** confidence = weight / (weight + priorWeight). */
     priorWeight: 1.5,
@@ -56,6 +59,7 @@ export const IMPRESSION_DEFAULTS = {
         tie: 0,
         trust: 0.5,
         skill: 0.3,
+        regard: 0,
     },
     /** Default reserve: base + emotionalityCoef × (1 − emotionality) for pain and fear; fatigue and mood a little. */
     reserve: { base: 0.1, emotionalityCoef: 0.4, fatigue: 0.1, mood: 0.2 },
@@ -83,6 +87,8 @@ export const IMPRESSION_DEFAULTS = {
     maxCues: 48,
 };
 function cueKind(key) {
+    if (key === 'regard')
+        return 'regard';
     if (key.startsWith('trait:'))
         return 'trait';
     if (key.startsWith('tie:'))
@@ -103,7 +109,7 @@ function priorOf(key) {
     return P[kind];
 }
 function rangeOf(key) {
-    return key === 'mood' || cueKind(key) === 'tie' ? [-1, 1] : [0, 1];
+    return key === 'mood' || key === 'regard' || cueKind(key) === 'tie' ? [-1, 1] : [0, 1];
 }
 /** FNV-1a over a string, as a 0..1 fraction: deterministic observation error with no RNG drawn. */
 function hash01(s) {
@@ -379,3 +385,34 @@ export function sanitizeImpressions(social) {
     else
         social.impressions = kept;
 }
+/**
+ * The person has their own evidence that `otherId` knows of their act: they saw them see it (`via: 'seen'`) or were
+ * told they heard (`via: 'told'`, weighted by trust in `sourceId`). Moves the believed regard cue. See the SCOPE.
+ */
+export function noteKnownBy(p, ev) {
+    if (ev.otherId === p.id)
+        return undefined;
+    const weight = ev.via === 'seen' ? 1 : ev.sourceId === undefined ? 0 : testimonyWeight(trustOf(p, ev.sourceId));
+    if (!(weight > 0))
+        return undefined;
+    const at = ev.at ?? p.now;
+    const defaults = {
+        'promise-broken': -0.6,
+        'promise-kept': 0.3,
+        harm: -0.6,
+        help: 0.4,
+        apology: 0.2,
+    };
+    const valence = ev.act.valence ?? (Object.hasOwn(defaults, ev.act.kind) ? (defaults[ev.act.kind] ?? 0) : 0);
+    const judgement = judge(p, { actorId: p.id, norms: ev.act.norms ?? [] }, p.conscience.norms, at).praiseworthiness;
+    const value = clamp(valence * (ev.act.targetId === ev.otherId ? 1 : 0.5) + 0.3 * judgement, -1, 1);
+    if (!Number.isFinite(value) || !Number.isFinite(at))
+        return undefined;
+    const imp = impressionFor(p, ev.otherId, true, at);
+    sample(imp, 'regard', value, weight * (value < 0 ? SOCIAL_DEFAULTS.negativityBias : 1), at);
+    return regardOf(p, ev.otherId, at);
+}
+/** How `p` believes `otherId` regards them; the neutral prior has zero confidence. Pure and RNG-free. */
+export function regardOf(p, otherId, now) {
+    return estimate(p, otherId, 'regard', now);
+}

package/dist/social/social.d.ts

@@ -30,6 +30,8 @@ export declare const SOCIAL_DEFAULTS: {
         group: number;
         /** Group size (others) from which the extraversion term applies. */
         groupFrom: number;
+        regardRepair: number;
+        regardRepairMax: number;
     };
     judge: {
         respect: number;

package/dist/social/social.js

@@ -6,14 +6,16 @@
  * helps), reciprocity as a favour ledger (Gouldner 1960), the mere-exposure / familiarity growth with
  * diminishing returns, HEXACO agreeableness as tolerance of provocation and honesty-humility as sensitivity
  * to deceit (Ashton & Lee), Schwartz benevolence as care for close others. Observers judge only the outward
- * act and never see intentions. It does NOT model the other person's view of me (each person holds their
- * own one-sided record) or attachment styles (gossip, reputation and bereavement are in the SCOPE paragraphs
+ * act and never see intentions. An opt-in `regard` impression estimates the other's view of me and adds a bounded
+ * repair term; it never reads the other's actual view. It does NOT model attachment styles
+ * (gossip, reputation and bereavement are in the SCOPE paragraphs
  * further down; insiders, outsiders and threats in `groups.ts`); the
  * coefficients are engineering defaults, not calibrated estimates.
  */
 import { clamp, clamp01, clampSigned, cmpStr, decay, dlog, expit, round } from '../core/index.js';
 import { MINUTES_PER_DAY, MINUTES_PER_YEAR } from '../types.js';
 import { careFor } from './groups.js';
+import { regardOf } from './impressions.js';
 const WEEK = 7 * MINUTES_PER_DAY;
 export const SOCIAL_DEFAULTS = {
     maxRelationships: 80,
@@ -50,6 +52,8 @@ export const SOCIAL_DEFAULTS = {
         group: 0.3,
         /** Group size (others) from which the extraversion term applies. */
         groupFrom: 3,
+        regardRepair: 0.5,
+        regardRepairMax: 0.3,
     },
     judge: {
         respect: 0.12,
@@ -328,6 +332,18 @@ export function socialTerms(p, aff, ctx) {
         const size = clamp01((others - W.groupFrom + 1) / 6);
         terms.push({ source: 'social:group', value: round(W.group * (p.traits.extraversion - 0.5) * 2 * size) });
     }
+    if (aff.targetId !== undefined &&
+        aff.targetId !== p.id &&
+        (tags.includes('repair') || aff.action === 'apology' || aff.action === 'amends') &&
+        !isDeceased(p, aff.targetId)) {
+        const regard = regardOf(p, aff.targetId, p.now);
+        if (regard.value < 0 && regard.confidence > 0) {
+            terms.push({
+                source: `regard:${aff.targetId}`,
+                value: round(Math.min(W.regardRepairMax, W.regardRepair * -regard.value * regard.confidence * (0.5 + p.traits.agreeableness))),
+            });
+        }
+    }
     return terms;
 }
 /** Moral weight of an observed act against one held standing, -1..1 before conviction. */

package/dist/types.d.ts

@@ -393,6 +393,49 @@ export interface Belief {
         id: EntityId;
         value: boolean;
     }[];
+    /**
+     * Where this person first got the belief (2.10.0, `beliefs/`). Absent unless an incoming claim carried provenance
+     * (`PerceptClaim.origin` or `lineage`). First acquisition wins; never read by decisions.
+     */
+    provenance?: BeliefProvenance;
+}
+/** Where a belief first came from, as far as the person knows (2.10.0). Owned by `beliefs/`. */
+export interface BeliefProvenance {
+    /** Who first said it: the first teller of the chain as told, or this person when they saw it themselves. */
+    origin: EntityId;
+    /** Who this person first heard it from (equal to `origin` when told first-hand or observed). */
+    firstFrom: EntityId;
+    /** Minute the provenance was acquired. */
+    at: Minute;
+    /** Opaque host token (at most 64 characters), carried unchanged through relays; HF never parses it. */
+    lineage?: string;
+}
+/** One proposition claim carried by a percept. */
+export interface PerceptClaim {
+    prop: string;
+    value: boolean;
+    confidence: Unit;
+    /** 2.10.0: who first said it, as the teller passes it on (provenance; never read by decisions). */
+    origin?: EntityId;
+    /** 2.10.0: opaque host lineage token (at most 64 characters), carried unchanged by `converse`. */
+    lineage?: string;
+}
+/**
+ * A report that `sourceId` told the reporter (the percept's `actorId`) that `prop` is `value` (2.10.0). On an attended
+ * `told` percept it is checked against what `sourceId` told this person (`beliefs.contradicted`).
+ */
+export interface ReportedAccount {
+    sourceId: EntityId;
+    prop: string;
+    value: boolean;
+}
+/** A noted contradiction by one source on one proposition (2.10.0, `beliefs/`); kept so it counts once. */
+export interface NotedContradiction {
+    sourceId: EntityId;
+    prop: string;
+    at: Minute;
+    /** Testimony weight already applied, 0..1; absent means 1 (heard both accounts directly). */
+    weight?: Unit;
 }
 /** Learned expectation of an action's actual result for this person (prediction-error learning). */
 export interface ActionExpectation {
@@ -431,6 +474,8 @@ export interface MemoryState {
     /** Lasting gists (1.8.0, opt-in via `enableGists`; absent = episodes are simply forgotten). Bounded. */
     gists?: Gist[];
     nextGist?: number;
+    /** Contradictions already noted (2.10.0, `beliefs.contradicted`). Absent until one is noted. Bounded. */
+    contradictions?: NotedContradiction[];
 }
 export interface Relationship {
     otherId: PersonId;
@@ -840,7 +885,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.9.0";
+export declare const ENGINE_VERSION = "2.10.0";
 /** A pregnancy carried by this person (host-driven; see `family/`). */
 export interface Pregnancy {
     fatherId: PersonId;
@@ -1157,11 +1202,7 @@ export interface Percept {
     /** Base salience before attention, 0..1. */
     salience: Unit;
     /** Proposition claims carried by the percept (e.g. a rumour). */
-    claims?: {
-        prop: string;
-        value: boolean;
-        confidence: Unit;
-    }[];
+    claims?: PerceptClaim[];
     /** Norms the observed act honoured or violated (for judging others). */
     norms?: NormTag[];
     /**
@@ -1206,6 +1247,14 @@ export interface Percept {
         id: string;
         revision: number;
     }[];
+    /**
+     * 2.10.0: on a percept of my own act (`actorId` is the perceiver), the people I saw see it. Each one's believed
+     * regard of me moves (`social/impressions.ts`, `noteKnownBy`). Someone present but not listed changes nothing.
+     * The first 8 are read.
+     */
+    witnesses?: readonly PersonId[];
+    /** 2.10.0: on a `told` percept, accounts the teller says another source gave them (at most four). */
+    reports?: readonly ReportedAccount[];
 }
 /**
  * Domains with distinct age curves for learning rate (`lifecourse.learningMultiplier`). 'general' is

package/dist/types.js

@@ -120,4 +120,4 @@ export const PERSON_SCHEMA = 'human/person@1';
  * and an activity that would cover a closing stretch is reviewed when the stretch begins (`isUnderWay`,
  * `dutyReviewAt`). Person shape unchanged.
  */
-export const ENGINE_VERSION = '2.9.0';
+export const ENGINE_VERSION = '2.10.0';