@adam0white/human-framework 2.9.0 → 2.10.0

package/dist/agenda/agenda.js

@@ -489,7 +489,7 @@ function deadlinePressure(g, now) {
     return 1 + AGENDA_DEFAULTS.goalDeadlineBoost * clamp01((now - g.adoptedAt) / span);
 }
 /** Shared existing amount and urgency reader; no future knowledge is consulted here. @internal */
-export function goalValue(g, aff, now) {
+function goalValue(g, aff, now) {
     const amount = goalAmount(g, aff);
     return amount > 0
         ? g.importance * clamp01(amount * AGENDA_DEFAULTS.goalAmountGain) * deadlinePressure(g, now)

package/dist/beliefs/beliefs.d.ts

@@ -1,4 +1,4 @@
-import type { Belief, EntityId, Minute, Percept, Person, Unit } from '../types.ts';
+import type { Belief, BeliefProvenance, EntityId, Minute, Percept, Person, Unit } from '../types.ts';
 export declare const BELIEF_DEFAULTS: {
     maxBeliefs: number;
     maxSources: number;
@@ -17,6 +17,9 @@ export declare const BELIEF_DEFAULTS: {
     /** Trust change on confirmation: gain toward 1, loss toward 0 (loss > gain). */
     trustGain: number;
     trustLoss: number;
+    /** Loss of source trust after attending incompatible accounts from that same source. */
+    contradictionLoss: number;
+    maxContradictions: number;
     /** Half-life of log-odds drift toward 0. */
     driftHalfLife: number;
     attentionBase: number;
@@ -39,7 +42,29 @@ export interface AttendContext {
 }
 /** Attention as limited capacity: keep the K most relevant percepts plus any that cannot be ignored. */
 export declare function attend(p: Person, percepts: Percept[], ctx: AttendContext): Percept[];
+/** Information-source trust, independent of relationship trust and advising-voice trust. */
 export declare function trustOf(p: Person, sourceId: EntityId): Unit;
+/**
+ * Set authored trust in an information source, clamped to 0..1. Writes only `memory.sourceTrust`;
+ * it does not change relationship trust or advising-voice trust. Nonfinite trust and self ids throw.
+ * Later `believe` (including testimony through `perceive`) reads this trust; `confirm` recalibrates it.
+ */
+export declare function seedSourceTrust(p: Person, sourceId: EntityId, trust: Unit): Unit;
+/**
+ * Set or replace an authored belief without applying source trust or recording an observation.
+ * `credence` is the probability that `value` holds, clamped to 0..1 and stored as bounded signed
+ * log-odds. `at` defaults to the person's current minute. Nonfinite credence or time throws.
+ * Only `memory.beliefs` changes, with ordinary belief eviction. An omitted source leaves no sources;
+ * a named source records its claim for later `confirm`, without changing any trust store now. The person's own id
+ * and 'self' are refused (they mark observation): use `confirm` for something the person saw.
+ * It does not apply reputation to relationships; use `seedTie` to author a relationship.
+ */
+export declare function seedBelief(p: Person, prop: string, spec: {
+    value: boolean;
+    credence: Unit;
+    at?: Minute;
+    source?: EntityId;
+}): Belief;
 /** Testimony or inference: add reliability-weighted log-odds evidence for (or against) `prop`. */
 export declare function believe(p: Person, prop: string, value: boolean, confidence: Unit, sourceId: EntityId, now: Minute): Belief;
 export declare function credence(p: Person, prop: string): Unit;
@@ -67,3 +92,22 @@ export declare function contested(p: Person, prop: string): {
     against: EntityId[];
     contested: boolean;
 };
+/** Where this person first got the belief on `prop`, or undefined. */
+export declare function provenanceOf(p: Person, prop: string): BeliefProvenance | undefined;
+export interface ContradictionResult {
+    applied: boolean;
+    reason?: 'no-account' | 'same-account' | 'already-noted' | 'self' | 'untrusted-reporter';
+    before: Unit;
+    after: Unit;
+}
+/**
+ * The person learns that `sourceId` also gave the account `prop = value` elsewhere, against what that source told
+ * them. See the contradiction SCOPE.
+ */
+export declare function contradicted(p: Person, ev: {
+    sourceId: EntityId;
+    prop: string;
+    value: boolean;
+    reporterId?: EntityId;
+    at?: Minute;
+}): ContradictionResult;

package/dist/beliefs/beliefs.js

@@ -8,9 +8,24 @@
  * gained, the trust-asymmetry finding). It does NOT model motivated reasoning, belief networks or
  * inference between propositions, source memory errors, or social consensus effects; parameters are
  * engineering defaults for game time scales.
+ *
+ * Three independent stores: `social.relationships[].trust` moves through authored ties, social events
+ * (including forgiveness), judged acts and reputation; `will.voices[].trust` moves through followed-advice
+ * outcomes, insisting, commands, `noteVoicePromise`, `seedVoice` and `adoptVoiceTrust` (also used by upbringing).
+ * This module owns `memory.sourceTrust`: `seedSourceTrust` authors it, `confirm` recalibrates it and
+ * `contradicted` reduces it when one source gives incompatible accounts.
+ * `believe`, including testimony delivered by `perceive`, weights claims by source trust, read by `trustOf`.
+ *
+ * SCOPE (Word and witness): optional provenance records the first known origin, direct teller and opaque
+ * host lineage of a belief. It does not change credence or decisions, reconstruct a relay graph, verify an
+ * origin, or survive belief eviction. Contradiction reduces information-source trust only when a retained
+ * first-hand account from that source opposes the newly learned account. Independent sources disagreeing
+ * are not a contradiction here. A third-party report is weighted by the reporter's source trust; this does
+ * not prove deceit, change the belief, or change relationship or voice trust. Loss and retention limits are
+ * engineering defaults, not calibrated effect sizes. Deduplication lasts only while its bounded record stays.
  */
-import { clamp, clamp01, decay, dpow, expit, logit } from '../core/index.js';
-import { MINUTES_PER_DAY } from '../types.js';
+import { clamp, clamp01, decay, dpow, expit, isNum, isObj, logit } from '../core/index.js';
+import { MAX_MINUTE, MINUTES_PER_DAY } from '../types.js';
 export const BELIEF_DEFAULTS = {
     maxBeliefs: 300,
     maxSources: 6,
@@ -29,6 +44,9 @@ export const BELIEF_DEFAULTS = {
     /** Trust change on confirmation: gain toward 1, loss toward 0 (loss > gain). */
     trustGain: 0.1,
     trustLoss: 0.25,
+    /** Loss of source trust after attending incompatible accounts from that same source. */
+    contradictionLoss: 0.25,
+    maxContradictions: 32,
     /** Half-life of log-odds drift toward 0. */
     driftHalfLife: 45 * MINUTES_PER_DAY,
     // Attention
@@ -97,10 +115,32 @@ export function attend(p, percepts, ctx) {
     }
     return out;
 }
+/** Information-source trust, independent of relationship trust and advising-voice trust. */
 export function trustOf(p, sourceId) {
     if (sourceId === p.id || sourceId === 'self')
         return BELIEF_DEFAULTS.selfTrust;
-    return p.memory.sourceTrust[sourceId] ?? BELIEF_DEFAULTS.defaultTrust;
+    // Own entries only: an id such as `constructor` or `__proto__` must not read an inherited property.
+    const own = Object.hasOwn(p.memory.sourceTrust, sourceId) ? p.memory.sourceTrust[sourceId] : undefined;
+    return typeof own === 'number' ? own : BELIEF_DEFAULTS.defaultTrust;
+}
+/**
+ * Set authored trust in an information source, clamped to 0..1. Writes only `memory.sourceTrust`;
+ * it does not change relationship trust or advising-voice trust. Nonfinite trust and self ids throw.
+ * Later `believe` (including testimony through `perceive`) reads this trust; `confirm` recalibrates it.
+ */
+export function seedSourceTrust(p, sourceId, trust) {
+    if (!Number.isFinite(trust))
+        throw new Error('human: source trust must be finite');
+    if (sourceId === p.id || sourceId === 'self')
+        throw new Error('human: self trust cannot be seeded');
+    const value = clamp01(trust);
+    Object.defineProperty(p.memory.sourceTrust, sourceId, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+    return value;
 }
 /** Testimony weight from trust: 0 at or below the floor, never negative, so low trust alone never flips a claim. @internal */
 export function testimonyWeight(trust) {
@@ -141,6 +181,31 @@ function ensureBelief(p, prop, now) {
     }
     return b;
 }
+/**
+ * Set or replace an authored belief without applying source trust or recording an observation.
+ * `credence` is the probability that `value` holds, clamped to 0..1 and stored as bounded signed
+ * log-odds. `at` defaults to the person's current minute. Nonfinite credence or time throws.
+ * Only `memory.beliefs` changes, with ordinary belief eviction. An omitted source leaves no sources;
+ * a named source records its claim for later `confirm`, without changing any trust store now. The person's own id
+ * and 'self' are refused (they mark observation): use `confirm` for something the person saw.
+ * It does not apply reputation to relationships; use `seedTie` to author a relationship.
+ */
+export function seedBelief(p, prop, spec) {
+    const at = spec.at ?? p.now;
+    if (!Number.isFinite(spec.credence))
+        throw new Error('human: belief credence must be finite');
+    if (!Number.isFinite(at))
+        throw new Error('human: belief time must be finite');
+    // The person's own id and 'self' mark direct observation (`observedDiscount`, `confirm`); authoring is not seeing.
+    if (spec.source === p.id || spec.source === 'self')
+        throw new Error('human: an authored belief cannot name the person as its source; use confirm for an observation');
+    const b = ensureBelief(p, prop, at);
+    const limit = BELIEF_DEFAULTS.maxLogOdds;
+    b.logOdds = clamp((spec.value ? 1 : -1) * logit(clamp01(spec.credence)), -limit, limit);
+    b.updatedAt = at;
+    b.sources = spec.source === undefined ? [] : [{ id: spec.source, value: spec.value }];
+    return b;
+}
 /** Testimony or inference: add reliability-weighted log-odds evidence for (or against) `prop`. */
 export function believe(p, prop, value, confidence, sourceId, now) {
     const d = BELIEF_DEFAULTS;
@@ -182,7 +247,13 @@ export function confirm(p, prop, truth, now) {
         if (s.id === p.id || s.id === 'self')
             continue;
         const t = trustOf(p, s.id);
-        p.memory.sourceTrust[s.id] = clamp01(s.value === truth ? t + d.trustGain * (1 - t) : t - d.trustLoss * t);
+        // An own data property even for ids such as `__proto__` (plain assignment would set the prototype).
+        Object.defineProperty(p.memory.sourceTrust, s.id, {
+            value: clamp01(s.value === truth ? t + d.trustGain * (1 - t) : t - d.trustLoss * t),
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
         if (s.value !== truth)
             misled.push(s.id);
     }
@@ -221,3 +292,136 @@ export function contested(p, prop) {
 }
 // Remembered advice (N9) is owned by `will/` (`standingAdvice`, fed from `Percept.advice`); review 2026-10-03
 // removed a second, unused belief-based implementation here so the two could not drift apart.
+// ---------------------------------------------------------------------------------------------
+// Word and witness (2.10.0): provenance and contradiction.
+// ---------------------------------------------------------------------------------------------
+const validId = (x) => typeof x === 'string' && x.length > 0;
+const validMinute = (x) => isNum(x) && Math.abs(x) <= MAX_MINUTE;
+function cleanProvenance(x) {
+    if (!isObj(x) || !validId(x.origin) || !validId(x.firstFrom) || !validMinute(x.at))
+        return undefined;
+    if (x.lineage !== undefined && typeof x.lineage !== 'string')
+        return undefined;
+    const out = { origin: x.origin, firstFrom: x.firstFrom, at: x.at };
+    if (typeof x.lineage === 'string' && x.lineage.length <= 64)
+        out.lineage = x.lineage;
+    return out;
+}
+/** Record where a belief came from, if it has no provenance yet (first acquisition wins). @internal */
+export function noteProvenance(p, claim, teller, at) {
+    if (claim.origin === undefined && claim.lineage === undefined)
+        return;
+    const b = findBelief(p, claim.prop);
+    if (!b || b.provenance !== undefined)
+        return;
+    const input = { origin: claim.origin ?? teller, firstFrom: teller, at };
+    if (claim.lineage !== undefined)
+        input.lineage = claim.lineage;
+    const meta = cleanProvenance(input);
+    if (meta !== undefined)
+        b.provenance = meta;
+}
+/** Where this person first got the belief on `prop`, or undefined. */
+export function provenanceOf(p, prop) {
+    return findBelief(p, prop)?.provenance;
+}
+/**
+ * The person learns that `sourceId` also gave the account `prop = value` elsewhere, against what that source told
+ * them. See the contradiction SCOPE.
+ */
+export function contradicted(p, ev) {
+    return applyContradiction(p, ev, ev.reporterId === undefined ? undefined : trustOf(p, ev.reporterId));
+}
+/**
+ * `contradicted` with the reporter's trust given, so that several reports delivered together share one trust basis
+ * (`perceive` reads it once per percept, before any report applies). @internal
+ */
+export function applyContradiction(p, ev, reporterTrust) {
+    const t = trustOf(p, ev.sourceId);
+    const refused = (reason) => ({
+        applied: false,
+        reason,
+        before: t,
+        after: t,
+    });
+    if (ev.sourceId === p.id || ev.sourceId === 'self')
+        return refused('self');
+    const weight = reporterTrust === undefined ? 1 : testimonyWeight(reporterTrust);
+    // One loss per (source, proposition), at the strongest evidence: a weaker earlier report leaves room for the rest.
+    const prior = p.memory.contradictions?.find((x) => x.sourceId === ev.sourceId && x.prop === ev.prop);
+    const priorWeight = prior === undefined ? 0 : (prior.weight ?? 1);
+    if (prior !== undefined && priorWeight >= weight)
+        return refused('already-noted');
+    const account = findBelief(p, ev.prop)?.sources.find((s) => s.id === ev.sourceId);
+    if (!account)
+        return refused('no-account');
+    if (account.value === ev.value)
+        return refused('same-account');
+    // A reporter at or below the trust floor carries no weight and must not use up the pair.
+    if (weight <= 0)
+        return refused('untrusted-reporter');
+    const at = ev.at ?? p.now;
+    if (!validMinute(at))
+        throw new Error('human: contradiction time must be a finite supported minute');
+    const loss = BELIEF_DEFAULTS.contradictionLoss;
+    // Multiplicative, so the total over a pair is `1 - loss * strongest weight` whatever the arrival order.
+    const after = seedSourceTrust(p, ev.sourceId, (t * (1 - loss * weight)) / (1 - loss * priorWeight));
+    if (prior !== undefined) {
+        if (weight >= 1)
+            delete prior.weight;
+        else
+            prior.weight = weight;
+    }
+    else {
+        const noted = p.memory.contradictions ?? [];
+        const row = { sourceId: ev.sourceId, prop: ev.prop, at };
+        if (weight < 1)
+            row.weight = weight;
+        noted.push(row);
+        noted.sort((a, b) => a.at - b.at);
+        p.memory.contradictions = noted.slice(-BELIEF_DEFAULTS.maxContradictions);
+    }
+    return { applied: true, before: t, after };
+}
+/**
+ * Restore (2.10.0): drop malformed provenance (lineage over 64 characters is dropped, not truncated) and bound and
+ * validate `contradictions`. A save the engine wrote is unchanged. @internal
+ */
+export function sanitizeBeliefMeta(memory) {
+    for (const b of memory.beliefs) {
+        if (!isObj(b) || b.provenance === undefined)
+            continue;
+        const meta = cleanProvenance(b.provenance);
+        if (meta === undefined)
+            delete b.provenance;
+        else
+            b.provenance = meta;
+    }
+    if (memory.contradictions === undefined)
+        return;
+    if (!Array.isArray(memory.contradictions)) {
+        delete memory.contradictions;
+        return;
+    }
+    const clean = [];
+    const seen = new Map();
+    for (const x of memory.contradictions) {
+        if (!isObj(x) || typeof x.sourceId !== 'string' || typeof x.prop !== 'string' || !validMinute(x.at))
+            continue;
+        const props = seen.get(x.sourceId) ?? new Set();
+        if (props.has(x.prop))
+            continue;
+        props.add(x.prop);
+        seen.set(x.sourceId, props);
+        const row = { sourceId: x.sourceId, prop: x.prop, at: x.at };
+        // A malformed weight reads as 1 (fully applied): restore never reopens a pair to a further loss.
+        if (typeof x.weight === 'number' && Number.isFinite(x.weight) && x.weight > 0 && x.weight < 1)
+            row.weight = x.weight;
+        clean.push(row);
+    }
+    clean.sort((a, b) => a.at - b.at);
+    if (clean.length === 0)
+        delete memory.contradictions;
+    else
+        memory.contradictions = clean.slice(-BELIEF_DEFAULTS.maxContradictions);
+}

package/dist/cognition/cognition.js

@@ -225,7 +225,7 @@ export function socialContext(ctx) {
     };
 }
 /** Same perceived-body effort estimate for actual offers and received successors. @internal */
-export function effortValue(p, aff, ctx) {
+function effortValue(p, aff, ctx) {
     const K = COGNITION_DEFAULTS;
     const per = ctx.body.perceived;
     const effort = clamp01(aff.effort);
@@ -239,7 +239,7 @@ export function effortValue(p, aff, ctx) {
     return -K.effortScale * effortCost;
 }
 /** Same material valuation for actual offers and received successor costs. @internal */
-export function materialValue(p, material, scarcity) {
+function materialValue(p, material, scarcity) {
     const K = COGNITION_DEFAULTS;
     const v = p.values;
     const weight = (v.security + v.achievement + v.power) / 3;

package/dist/conscience/conscience.d.ts

@@ -100,9 +100,13 @@ export declare function recordDeed(p: Person, aff: Affordance, intention: string
  * The person repents a breach: regret, stopping and resolve. When another person was wronged,
  * restitution is also required, so the breach closes only after `recordRepair` for that victim.
  * Returns whether the breach is now closed. This records the person's acts, not acceptance.
+ * The unused `_now` parameter is optional since 2.9.1 and is removed in 3.0.
  */
-export declare function repent(p: Person, id: string, _now: Minute): boolean;
-/** Restitution/apology delivered to a wronged person (host-attested): closes their open breaches. */
-export declare function recordRepair(p: Person, victimId: string, _now: Minute): number;
+export declare function repent(p: Person, id: string, _now?: Minute): boolean;
+/**
+ * Restitution/apology delivered to a wronged person (host-attested): closes their open breaches.
+ * The unused `_now` parameter is optional since 2.9.1 and is removed in 3.0.
+ */
+export declare function recordRepair(p: Person, victimId: string, _now?: Minute): number;
 /** Felt weight of open breaches, saturating: 1 - Π(1 - weight). Input for guilt in affect. */
 export declare function guiltLoad(p: Person): Unit;

package/dist/conscience/conscience.js

@@ -351,6 +351,7 @@ export function recordDeed(p, aff, intention, now, completed, opts = {}) {
  * The person repents a breach: regret, stopping and resolve. When another person was wronged,
  * restitution is also required, so the breach closes only after `recordRepair` for that victim.
  * Returns whether the breach is now closed. This records the person's acts, not acceptance.
+ * The unused `_now` parameter is optional since 2.9.1 and is removed in 3.0.
  */
 export function repent(p, id, _now) {
     const breach = p.conscience.breaches.find((b) => b.id === id);
@@ -361,7 +362,10 @@ export function repent(p, id, _now) {
     breach.repaired = true;
     return true;
 }
-/** Restitution/apology delivered to a wronged person (host-attested): closes their open breaches. */
+/**
+ * Restitution/apology delivered to a wronged person (host-attested): closes their open breaches.
+ * The unused `_now` parameter is optional since 2.9.1 and is removed in 3.0.
+ */
 export function recordRepair(p, victimId, _now) {
     let count = 0;
     for (const b of p.conscience.breaches) {

package/dist/conversation/conversation.d.ts

@@ -53,6 +53,8 @@ export interface ConverseContext {
     magnitude?: Unit;
     /** Character-trait vocabulary (defaults to `REPUTATION_TRAITS`). */
     traits?: Record<string, TraitEffect>;
+    /** Carry belief origin and opaque lineage into told claims (off by default). */
+    provenance?: boolean;
 }
 /** Host-visible record of one claim. */
 export interface ToldClaim {
@@ -69,6 +71,8 @@ export interface ToldClaim {
     /** The person the claim is about, when it is a character claim. */
     about?: PersonId;
     score: number;
+    origin?: EntityId;
+    lineage?: string;
 }
 export interface AdviceGiven {
     action: string;

package/dist/conversation/conversation.js

@@ -29,6 +29,11 @@
  * percept (it is in `claims`, not `told`). A claim this listener already heard from this speaker, in the same
  * direction, is dropped before the speaker chooses, so it is not even a deed. The speaker keeps no memory of what was said to whom; the listener's
  * belief stands in for it.
+ *
+ * SCOPE (Word and witness, 2.10.0): `provenance: true` carries each claim's first known origin and opaque
+ * lineage into testimony. Missing provenance names the speaker as origin. Metadata changes neither claim
+ * selection nor repetition rules; the host still owns the relay graph and disclosure. It does not establish
+ * that an origin is truthful, expose deceit to the listener, or infer who else heard a claim.
  */
 import { clamp01, expit, round } from '../core/index.js';
 import { isDeceased, isUnfavourableTrait, parseTraitProp, REPUTATION_TRAITS, relationshipWith, } from '../social/index.js';
@@ -191,6 +196,12 @@ export function converse(speaker, listener, ctx) {
         .slice(0, Math.max(0, maxClaims));
     const norms = new Map();
     for (const c of chosen) {
+        if (ctx.provenance) {
+            const meta = speaker.memory.beliefs.find((b) => b.prop === c.prop)?.provenance;
+            c.origin = meta?.origin ?? speaker.id;
+            if (meta?.lineage !== undefined)
+                c.lineage = meta.lineage;
+        }
         out.claims.push(c);
         const pcNorms = [];
         if (c.backbiting) {
@@ -220,6 +231,11 @@ export function converse(speaker, listener, ctx) {
                 ? `${nameOf(speaker)} says ${c.about} is ${c.value ? '' : 'not '}${c.prop.split(':')[1] ?? ''}`
                 : `${nameOf(speaker)} says ${c.prop} is ${c.value ? 'so' : 'not so'}`,
         };
+        const claim = pc.claims?.[0];
+        if (claim && c.origin !== undefined)
+            claim.origin = c.origin;
+        if (claim && c.lineage !== undefined)
+            claim.lineage = c.lineage;
         if (c.about !== undefined) {
             pc.targetId = c.about;
             const parsed = parseTraitProp(c.prop, table);
@@ -260,6 +276,15 @@ export function converse(speaker, listener, ctx) {
             claims: [{ prop: `advice:${a.action}`, value: true, confidence: round(a.cred) }],
             summary: `${nameOf(speaker)} says I should ${a.action}`,
         };
+        if (ctx.provenance) {
+            const meta = beliefs.find((b) => b.prop === `${prefix}${a.action}`)?.provenance;
+            const claim = percept.claims?.[0];
+            if (claim) {
+                claim.origin = meta?.origin ?? speaker.id;
+                if (meta?.lineage !== undefined)
+                    claim.lineage = meta.lineage;
+            }
+        }
         if (ctx.placeId !== undefined)
             percept.placeId = ctx.placeId;
         const suggestion = { voiceId: speaker.id, action: a.action, strength: round(a.strength) };

package/dist/core/math.d.ts

@@ -5,6 +5,7 @@ export declare const clampSigned: (value: number) => number;
 export declare const lerp: (a: number, b: number, t: number) => number;
 export declare const sigmoid: (x: number) => number;
 export declare const logit: (p: number) => number;
+/** @deprecated since 2.9.1, removed in 3.0; use sigmoid */
 export declare const expit: typeof sigmoid;
 /** Exponential decay of `value` toward `target` over `dt` minutes with the given half-life. */
 export declare function decay(value: number, dt: number, halfLife: number, target?: number): number;

package/dist/core/math.js

@@ -36,6 +36,7 @@ export const logit = (p) => {
     const q = clamp(p, 1e-6, 1 - 1e-6);
     return dlog(q / (1 - q));
 };
+/** @deprecated since 2.9.1, removed in 3.0; use sigmoid */
 export const expit = sigmoid;
 /** Exponential decay of `value` toward `target` over `dt` minutes with the given half-life. */
 export function decay(value, dt, halfLife, target = 0) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-/** Human Framework v1 public surface. */
-export declare const FRAMEWORK_VERSION = "2.9.0";
+/** Human Framework public surface. */
+export declare const FRAMEWORK_VERSION = "2.10.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, PrayerCalendar, PrayerSchedule, PrayerTimes, Retimer, } from './agenda/index.ts';
@@ -31,7 +31,7 @@ export * from './person.ts';
 export * from './promptings/index.ts';
 export type { ConsequenceEvidence } from './prospection/index.ts';
 export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, forecastThresholds, PROSPECTION_DEFAULTS, } from './prospection/index.ts';
-export * from './restore.ts';
+export { fingerprint, restore, snapshot } from './restore.ts';
 export * from './review/index.ts';
 export * from './scenarios/index.ts';
 export * from './sim/index.ts';

package/dist/index.js

@@ -1,5 +1,5 @@
-/** Human Framework v1 public surface. */
-export const FRAMEWORK_VERSION = '2.9.0';
+/** Human Framework public surface. */
+export const FRAMEWORK_VERSION = '2.10.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, isUnderWay, MAKRUH_DEFAULTS, makruhWindows, missedExcuse, onFinished, owedMakeUps, PRAYER_IMPORTANCE, PURPOSE_DEFAULTS, prayerWindows, pressureReachedAt, promise, proposeGoals, RAMADAN_DEFAULTS, ramadanFast, ramadanMeals, release as releaseCommitment, retimeCommitments, revisePurposes, scheduleMakeUp, spanMeetsWindow, suhoorWindow, timesFor, violatesAbstention, } from './agenda/index.js';
@@ -27,7 +27,7 @@ export * from './partnering/index.js';
 export * from './person.js';
 export * from './promptings/index.js';
 export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, forecastThresholds, PROSPECTION_DEFAULTS, } from './prospection/index.js';
-export * from './restore.js';
+export { fingerprint, restore, snapshot } from './restore.js';
 export * from './review/index.js';
 export * from './scenarios/index.js';
 export * from './sim/index.js';

package/dist/memory/memory.js

@@ -349,7 +349,10 @@ export function retell(teller, listener, when, knobs = {}) {
 }
 /** The same thing happening, whoever it happened to (kind, action, target, place). */
 const sameStory = (g, e) => g.kind === e.kind && g.action === e.action && g.targetId === e.targetId && g.placeId === e.placeId;
-const trustOfSource = (p, id) => p.memory.sourceTrust[id] ?? 0.5;
+const trustOfSource = (p, id) => {
+    const own = Object.hasOwn(p.memory.sourceTrust, id) ? p.memory.sourceTrust[id] : undefined;
+    return typeof own === 'number' ? own : 0.5;
+};
 const idNum = (id) => Number(id.slice(1)) || 0;
 const byId = (a, b) => idNum(a.id) - idNum(b.id);
 function recency(now, at) {

package/dist/migrate.js

@@ -8,7 +8,19 @@
  * field of the optional surroundings slice (`ambient.now` → `ambient.percept`) and changes no behaviour (the optional `social.impressions` and `social.reserve`, like `retention`, are optional and start
  * absent in a migrated save); `restore` then fills and sanitizes
  * the slices as for any save. 2.0.0 to 2.1.0 adds optional conditional method state, absent
- * until explicitly used, so existing hosts retain their previous behavior; that step stamps the version. 2.1.0 to 2.2.0 preserves optional method records and stamps the version; successful alternatives now retain independent support. 2.2.0 to 2.3.0 stamps the version; received consequences and temporal goals remain absent unless explicitly supplied. 2.3.0 to 2.4.0 stamps the version; promptings remain absent unless enabled. 2.4.0 to 2.5.0 stamps the version; the bodily forecast reads only offers that declare `followedBy`. 2.5.0 to 2.6.0 stamps the version; the fatigue store stays absent unless enabled. 2.6.0 to 2.7.0 stamps the version; the evening review stays absent unless enabled. A migrated save continues under the current engine's rules: it restores and runs,
+ * until explicitly used, so existing hosts retain their previous behavior; that step stamps the version.
+ * 2.1.0 to 2.2.0 preserves optional method records and stamps the version; successful alternatives now
+ * retain independent support. 2.2.0 to 2.3.0 stamps the version; received consequences and temporal goals
+ * remain absent unless explicitly supplied. 2.3.0 to 2.4.0 stamps the version; promptings remain absent
+ * unless enabled. 2.4.0 to 2.5.0 stamps the version; the bodily forecast reads only offers that declare
+ * `followedBy`. 2.5.0 to 2.6.0 stamps the version; the fatigue store stays absent unless enabled. 2.6.0 to
+ * 2.7.0 stamps the version; the evening review stays absent unless enabled. 2.7.0 to 2.8.0 stamps the
+ * version; fullness stays absent unless enabled, and alongside partners and reconsideration are opt-in.
+ * 2.8.0 to 2.9.0 stamps the version; prompting cues and practice half-lives stay absent unless supplied,
+ * review terms may carry refs, and an outcome naming several commitments now keeps each rather than only
+ * the earliest-ending one. 2.9.0 to 2.10.0 stamps the version; belief provenance, noted contradictions and
+ * believed regard stay absent unless a host supplies them;
+ * `regard` becomes a reserved impression cue key. A migrated save continues under the current engine's rules: it restores and runs,
  * but it does not reproduce what the old engine would have done next where the rules changed (1.4.0 to 1.5.0
  * changed how standing advice is heard; 1.8.0 to 1.9.0 changed the omission rule). Saves older than 1.4.0 and unknown versions are refused with an error.
  *
@@ -58,6 +70,11 @@ export const MIGRATIONS = {
         note: 'the surroundings field `ambient.now` is renamed `ambient.percept`; per-person retention is optional and starts absent; behaviour unchanged',
         apply: renameAmbient,
     },
+    '2.9.0': {
+        to: '2.10.0',
+        note: 'belief provenance (Belief.provenance), noted contradictions (memory.contradictions) and the believed-regard impression cue are optional and start absent; existing hosts retain exact behavior',
+        apply: stamp,
+    },
     '2.8.0': {
         to: '2.9.0',
         note: 'prompting responses may carry a cue and the slice a practice half-life (both optional, absent as before); review terms may carry a ref; an outcome naming two or more commitments in fulfills now keeps each of them, where 2.8.0 kept the earliest-ending one',