@adam0white/human-framework 2.9.1 → 2.11.0

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;
@@ -89,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

@@ -12,11 +12,20 @@
  * 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 and `confirm` recalibrates it.
+ * 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,
@@ -35,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
@@ -107,7 +119,9 @@ export function attend(p, percepts, ctx) {
 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`;
@@ -233,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);
     }
@@ -272,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

@@ -40,6 +40,7 @@ import { agendaTermsWithGoalEstimates } from '../agenda/index.js';
 import { trustOf } from '../beliefs/index.js';
 import { normTerms } from '../conscience/index.js';
 import { clamp01, cmpStr, dexp, minuteOfDay, round } from '../core/index.js';
+import { curiosityTerms } from '../curiosity/index.js';
 import { habitEase, habitPull } from '../habits/index.js';
 import { expectedEffect } from '../memory/index.js';
 import { methodEvidence } from '../methods/index.js';
@@ -452,6 +453,9 @@ export function consider(p, aff, ctx) {
     if (!inBreak(p))
         for (const t of rememberedTerms(p, aff, ctx.now, voices))
             push(t.source, t.value);
+    if (p.curiosity)
+        for (const t of curiosityTerms(p, aff, ctx))
+            push(t.source, t.value);
     // Promptings (2.4.0, opt-in): a recurrence pull under `fault` and a practised turning-away from a noticed prompt.
     if (p.promptings)
         for (const t of promptingTerms(p, aff.action, terms, aff.tags, ctx.now, ctx.desperation))

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/curiosity/curiosity.d.ts

@@ -0,0 +1,28 @@
+import type { ConsiderContext } from '../cognition/index.ts';
+import type { Affordance, CuriosityReading, CuriositySpec, CuriosityState, Minute, Outcome, Person, Term } from '../types.ts';
+/** Engineering defaults: unknown .8 exceeds mild effort (.1 base) and learned pleasure (.6 scale).
+ * Need relief uses cognition's scale 4; urgency and fear also suppress this entire drive.
+ */
+export declare const CURIOSITY_DEFAULTS: {
+    readonly unknownScale: 0.8;
+    readonly progressScale: 2;
+    readonly varyScale: 0.15;
+    readonly recentMinutes: 60;
+    readonly rewardMax: 0.03;
+    readonly fastAlpha: 0.5;
+    readonly slowAlpha: 0.15;
+    readonly maxKeys: 32;
+    readonly maxRecent: 8;
+};
+/** Enable or reconfigure; retain the bounded history. Invalid overrides use defaults. */
+export declare function enableCuriosity(p: Person, spec?: CuriositySpec): CuriosityState;
+type Context = Pick<ConsiderContext, 'needs' | 'mods' | 'now'>;
+/** Read raw signals and drive without mutation or RNG. `now` changes only the recent-act window. */
+export declare function curiosityOf(p: Person, aff: Affordance, now?: Minute): CuriosityReading;
+/** Cognition uses the actual decision context, including perceived needs. Fixed term order. */
+export declare function curiosityTerms(p: Person, aff: Affordance, ctx: Context): Term[];
+/** Called before memory learns this outcome. Needs owner applies the small, bounded reward. */
+export declare function noteCuriosity(p: Person, aff: Affordance, outcome: Outcome, felt: number): void;
+/** Conservative restore: drop malformed or ambiguous slices; skip malformed entries and bound lists. */
+export declare function sanitizeCuriosity(input: unknown, now: Minute): CuriosityState | undefined;
+export {};

package/dist/curiosity/curiosity.js

@@ -0,0 +1,190 @@
+/**
+ * SCOPE: opt-in intrinsic exploration and play. Uncertainty draws a relaxed person toward unfamiliar
+ * offers; falling prediction error (learning progress) pulls and rewards; recent action kinds invite variation in target or
+ * place. Shapes, not fitted values: learning progress (Oudeyer, Kaplan & Hafner 2007), information gaps
+ * (Loewenstein 1994; Kidd & Hayden 2015; Gottlieb et al. 2013), effectance and competence (White 1959;
+ * Deci & Ryan), relaxed repetition with variation (Burghardt 2005), openness (DeYoung), childhood
+ * exploration (Gopnik 2020). See research/curiosity-and-play.md. All coefficients are engineering defaults.
+ * This owns only p.curiosity. It neither adopts projects nor plans, reads no host novelty tags, and
+ * implements no faith lens, LLM or RNG. Without the slice it adds no state, terms or reward.
+ */
+import { emotionLevel } from '../affect/index.js';
+import { clamp01, isNum, isObj, round } from '../core/index.js';
+import { lifeModifiers } from '../lifecourse/index.js';
+import { expectationKey, expectedEffect } from '../memory/index.js';
+import { satisfy } from '../needs/index.js';
+import { readPerson } from '../person.js';
+import { MAX_MINUTE, PHYSIOLOGICAL_NEEDS } from '../types.js';
+/** Engineering defaults: unknown .8 exceeds mild effort (.1 base) and learned pleasure (.6 scale).
+ * Need relief uses cognition's scale 4; urgency and fear also suppress this entire drive.
+ */
+export const CURIOSITY_DEFAULTS = {
+    unknownScale: 0.8,
+    progressScale: 2,
+    varyScale: 0.15,
+    recentMinutes: 60,
+    rewardMax: 0.03,
+    fastAlpha: 0.5,
+    slowAlpha: 0.15,
+    maxKeys: 32,
+    maxRecent: 8,
+};
+const SPEC_KEYS = ['unknownScale', 'progressScale', 'varyScale', 'recentMinutes', 'rewardMax'];
+function cleanSpec(input) {
+    const out = {};
+    if (!isObj(input))
+        return out;
+    for (const key of SPEC_KEYS) {
+        const x = input[key];
+        const max = key === 'recentMinutes' ? 1440 : CURIOSITY_DEFAULTS[key];
+        if (isNum(x) && x >= 0 && x <= max)
+            out[key] = x;
+    }
+    return out;
+}
+const setting = (s, key) => s.spec?.[key] ?? CURIOSITY_DEFAULTS[key];
+/** Enable or reconfigure; retain the bounded history. Invalid overrides use defaults. */
+export function enableCuriosity(p, spec = {}) {
+    const out = { errors: p.curiosity?.errors ?? [], recent: p.curiosity?.recent ?? [] };
+    const clean = cleanSpec(spec);
+    if (Object.keys(clean).length)
+        out.spec = clean;
+    p.curiosity = out;
+    return out;
+}
+/** Identifiers the slice records and restores; longer ones are not tracked, so a save round-trips. */
+const str = (x) => typeof x === 'string' && x.length > 0 && x.length <= 512;
+function reading(p, aff, ctx) {
+    const s = p.curiosity;
+    if (!s)
+        return { unknown: 0, progress: 0, vary: 0, drive: 0 };
+    let urgency = 0;
+    for (const n of ctx.needs)
+        if (n.id === 'safety' || PHYSIOLOGICAL_NEEDS.includes(n.id))
+            urgency = Math.max(urgency, n.urgency);
+    const drive = (1 - clamp01(urgency)) *
+        (1 - emotionLevel(p, 'fear')) *
+        (0.25 + 0.75 * p.traits.openness) *
+        (1.25 - 0.5 * ctx.mods.maturity);
+    const error = s.errors.find((e) => e.key === expectationKey(aff));
+    const recent = s.recent.filter((r) => r.at <= ctx.now && ctx.now - r.at <= setting(s, 'recentMinutes') && r.action === aff.action);
+    const identical = recent.some((r) => r.targetId === aff.targetId && r.placeId === aff.placeId);
+    return {
+        unknown: clamp01(1 - expectedEffect(p, aff).confidence),
+        progress: error ? clamp01(error.slow - error.fast) : 0,
+        vary: !identical && recent.length > 0 ? 1 : 0,
+        drive,
+    };
+}
+/** Read raw signals and drive without mutation or RNG. `now` changes only the recent-act window. */
+export function curiosityOf(p, aff, now = p.now) {
+    if (!p.curiosity)
+        return { unknown: 0, progress: 0, vary: 0, drive: 0 };
+    return reading(p, aff, { now, needs: readPerson(p).needs, mods: lifeModifiers(p) });
+}
+/** Cognition uses the actual decision context, including perceived needs. Fixed term order. */
+export function curiosityTerms(p, aff, ctx) {
+    const s = p.curiosity;
+    if (!s)
+        return [];
+    const r = reading(p, aff, ctx);
+    return ['unknown', 'progress', 'vary'].map((key) => ({
+        source: `curiosity:${key}`,
+        value: round(Math.min(setting(s, `${key}Scale`), setting(s, `${key}Scale`) * r[key] * r.drive)),
+    }));
+}
+/** Called before memory learns this outcome. Needs owner applies the small, bounded reward. */
+export function noteCuriosity(p, aff, outcome, felt) {
+    const s = p.curiosity;
+    if (!s || outcome.status === 'interrupted')
+        return;
+    const before = curiosityOf(p, aff);
+    const expected = expectedEffect(p, aff);
+    const error = clamp01((Math.abs((outcome.status === 'completed' ? 1 : 0) - expected.successRate) +
+        Math.abs(felt - expected.valence) / 2) /
+        2);
+    const key = expectationKey(aff);
+    if (!str(key) ||
+        !str(aff.action) ||
+        (aff.targetId !== undefined && !str(aff.targetId)) ||
+        (aff.placeId !== undefined && !str(aff.placeId)))
+        return;
+    let entry = s.errors.find((e) => e.key === key);
+    if (!entry) {
+        if (s.errors.length >= CURIOSITY_DEFAULTS.maxKeys) {
+            let oldest = 0;
+            let oldestAt = s.errors[0]?.lastAt ?? p.now;
+            for (const [i, held] of s.errors.entries()) {
+                if (held.lastAt < oldestAt) {
+                    oldest = i;
+                    oldestAt = held.lastAt;
+                }
+            }
+            s.errors.splice(oldest, 1);
+        }
+        entry = { key, fast: error, slow: error, n: 1, lastAt: p.now };
+        s.errors.push(entry);
+    }
+    else {
+        entry.fast = clamp01(entry.fast + CURIOSITY_DEFAULTS.fastAlpha * (error - entry.fast));
+        entry.slow = clamp01(entry.slow + CURIOSITY_DEFAULTS.slowAlpha * (error - entry.slow));
+        entry.n = Math.min(Number.MAX_SAFE_INTEGER, entry.n + 1);
+        entry.lastAt = p.now;
+    }
+    const act = { action: aff.action, at: p.now };
+    if (aff.targetId !== undefined)
+        act.targetId = aff.targetId;
+    if (aff.placeId !== undefined)
+        act.placeId = aff.placeId;
+    s.recent.push(act);
+    if (s.recent.length > CURIOSITY_DEFAULTS.maxRecent)
+        s.recent.shift();
+    const progress = Math.max(0, entry.slow - entry.fast);
+    const reward = Math.min(setting(s, 'rewardMax'), setting(s, 'rewardMax') * progress * before.drive);
+    satisfy(p, { leisure: reward / 2, competence: reward / 2 });
+}
+const unit = (x) => isNum(x) && x >= 0 && x <= 1;
+const minute = (x, now) => isNum(x) && Math.abs(x) <= MAX_MINUTE && x <= now;
+/** Conservative restore: drop malformed or ambiguous slices; skip malformed entries and bound lists. */
+export function sanitizeCuriosity(input, now) {
+    if (!isObj(input) || !Array.isArray(input.errors) || !Array.isArray(input.recent))
+        return undefined;
+    if (input.spec !== undefined && !isObj(input.spec))
+        return undefined;
+    const out = { errors: [], recent: [] };
+    if (input.spec !== undefined) {
+        const spec = cleanSpec(input.spec);
+        if (Object.keys(spec).length !== Object.keys(input.spec).length)
+            return undefined;
+        if (Object.keys(spec).length)
+            out.spec = spec;
+    }
+    const seen = new Set();
+    for (const e of input.errors.slice(0, CURIOSITY_DEFAULTS.maxKeys)) {
+        if (!isObj(e) ||
+            !str(e.key) ||
+            !unit(e.fast) ||
+            !unit(e.slow) ||
+            !minute(e.lastAt, now) ||
+            !Number.isSafeInteger(e.n) ||
+            e.n < 1)
+            continue;
+        if (seen.has(e.key))
+            return undefined;
+        seen.add(e.key);
+        out.errors.push({ key: e.key, fast: e.fast, slow: e.slow, n: e.n, lastAt: e.lastAt });
+    }
+    for (const r of input.recent.slice(-CURIOSITY_DEFAULTS.maxRecent)) {
+        if (!isObj(r) || !str(r.action) || !minute(r.at, now))
+            continue;
+        if ((r.targetId !== undefined && !str(r.targetId)) || (r.placeId !== undefined && !str(r.placeId)))
+            continue;
+        const act = { action: r.action, at: r.at };
+        if (r.targetId !== undefined)
+            act.targetId = r.targetId;
+        if (r.placeId !== undefined)
+            act.placeId = r.placeId;
+        out.recent.push(act);
+    }
+    return out;
+}

package/dist/curiosity/index.d.ts

@@ -0,0 +1 @@
+export * from './curiosity.ts';

package/dist/curiosity/index.js

@@ -0,0 +1 @@
+export * from './curiosity.js';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /** Human Framework public surface. */
-export declare const FRAMEWORK_VERSION = "2.9.1";
+export declare const FRAMEWORK_VERSION = "2.11.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';
@@ -13,6 +13,7 @@ export { COGNITION_DEFAULTS, consider, decide as scoreAndResolve, desperationOf,
 export * from './conscience/index.ts';
 export * from './conversation/index.ts';
 export * from './core/index.ts';
+export { CURIOSITY_DEFAULTS, curiosityOf, enableCuriosity } from './curiosity/index.ts';
 export * from './environment/index.ts';
 export * from './family/index.ts';
 export * from './habits/index.ts';

package/dist/index.js

@@ -1,5 +1,5 @@
 /** Human Framework public surface. */
-export const FRAMEWORK_VERSION = '2.9.1';
+export const FRAMEWORK_VERSION = '2.11.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';
@@ -12,6 +12,7 @@ export { COGNITION_DEFAULTS, consider, decide as scoreAndResolve, desperationOf,
 export * from './conscience/index.js';
 export * from './conversation/index.js';
 export * from './core/index.js';
+export { CURIOSITY_DEFAULTS, curiosityOf, enableCuriosity } from './curiosity/index.js';
 export * from './environment/index.js';
 export * from './family/index.js';
 export * from './habits/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

@@ -18,7 +18,9 @@
  * 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. A migrated save continues under the current engine's rules: it restores and runs,
+ * the earliest-ending one. 2.10.0 to 2.11.0 stamps the version (curiosity starts absent). 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.
  *
@@ -68,6 +70,16 @@ 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.10.0': {
+        to: '2.11.0',
+        note: 'the curiosity slice (Person.curiosity) is optional and starts absent; existing hosts retain exact behavior',
+        apply: stamp,
+    },
+    '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',

package/dist/person.js

@@ -21,13 +21,14 @@
  */
 import { actionTendencies, advanceAffect, appraise, CRISIS_DEFAULTS, checkCrisis, createAffect, easeBreak, emotionLevel, feel, readAffect, regulate, release, skipAffect, skipCrisis, strain, tendencyEmotions, } from './affect/index.js';
 import { advanceAgenda, createAgenda, onFinished, promise, proposeGoals, revisePurposes, } from './agenda/index.js';
-import { advanceBeliefs, attend, believe, confirm, credence } from './beliefs/index.js';
+import { advanceBeliefs, applyContradiction, attend, believe, confirm, credence, noteProvenance, trustOf, } from './beliefs/index.js';
 import { advanceBody, BODY_DEFAULTS, checkDowned, clearDowned, consume, createBody, downedAllows, enableFatigueStore, enableFullness, expose, injure, nextBodyThreshold, readBody, setDowned, sicken, skipBody, } from './body/index.js';
 import { ageCharacter, enableCharacterChange, noteCharacterDay, noteCharacterSocial, } from './character/index.js';
 import { closeDay, enableYearbook, endDay, noteAnswer, noteCommitments, noteDecision, noteMood, noteOutcome, trimChronicle, } from './chronicle/index.js';
 import { decide as cognitionDecide, desperationOf, scoreAll } from './cognition/index.js';
 import { createConscience, guiltLoad, heldNorms, normVeto, recordDeed, recordRepair, repent, } from './conscience/index.js';
 import { clamp01, clampSigned, createRng, dayOf, isObj, minuteOfDay } from './core/index.js';
+import { enableCuriosity, noteCuriosity } from './curiosity/index.js';
 import { ambientBodyParams, ambientModifiers, ambientMood, ambientNeeds } from './environment/index.js';
 import { aptitudeOf, createFamily, pregnancyModifiers } from './family/index.js';
 import { advanceHabits, reinforce, withholdCued } from './habits/index.js';
@@ -40,7 +41,7 @@ import { enablePromptings, nafsPatterns, notePromptings } from './promptings/ind
 import { bodyForecastFor, consumeConsequences, forecastLine, forecastThresholds, pruneConsequences, receiveConsequences, } from './prospection/index.js';
 import { enableReview, reviewIfDue } from './review/index.js';
 import { enableSkillRetention, learnByWatching, practise, seedSkills, } from './skills/index.js';
-import { advanceSocial, applyReputationBelief, careFor, closeness, judge, markDeceased, relationshipWith, seedRelationships, socialEvent, threatAppraisal, } from './social/index.js';
+import { advanceSocial, applyReputationBelief, careFor, closeness, judge, markDeceased, noteKnownBy, relationshipWith, seedRelationships, socialEvent, threatAppraisal, } from './social/index.js';
 import { ENGINE_VERSION, MAX_MINUTE, PERSON_SCHEMA, PHYSIOLOGICAL_NEEDS, PSYCHOLOGICAL_NEEDS, TRAIT_KEYS, VALUE_KEYS, } from './types.js';
 import { advanceWill, answerSuggestion, chargeCommand, commandTargets, createWill, creditedVoices, dischargeAdvice, dutyReviewAt, endCommand, learnFromVoice, noteCommandOutcome, predictResponse, rememberAdvice, resolveCommand, takeCommand, voicesIn, WILL_DEFAULTS, wakeReviewAt, } from './will/index.js';
 export const PERSON_DEFAULTS = {
@@ -159,6 +160,8 @@ export function createPerson(spec) {
         enableFatigueStore(p);
     if (on?.fullness)
         enableFullness(p);
+    if (on?.curiosity)
+        enableCuriosity(p, on.curiosity === true ? {} : on.curiosity);
     if (on?.promptings)
         enablePromptings(p, on.promptings);
     if (on?.review)
@@ -571,9 +574,36 @@ function perceiveOne(p, pc) {
             confirm(p, claim.prop, claim.value, at);
         else
             believe(p, claim.prop, claim.value, claim.confidence, direct ? p.id : (actor ?? 'rumour'), at);
+        // Provenance (2.10.0): recorded only when the claim carries it; first acquisition wins.
+        if (claim.origin !== undefined || claim.lineage !== undefined)
+            noteProvenance(p, claim, direct ? p.id : (actor ?? 'rumour'), at);
         // Hearsay about someone's character moves my relationship with them (reputation).
         applyReputationBelief(p, claim.prop, before, credence(p, claim.prop), at);
     }
+    // Another source's account, reported by the teller (2.10.0): one source telling two people opposite things.
+    if (pc.channel === 'told' && actor !== undefined && Array.isArray(pc.reports)) {
+        // One trust basis for the whole percept: a report that lowers the reporter's own trust must not reweigh the rest.
+        const reporterTrust = trustOf(p, actor);
+        for (const r of pc.reports.slice(0, 4))
+            applyContradiction(p, { ...r, reporterId: actor, at }, reporterTrust);
+    }
+    // My own act, seen by others (2.10.0): what I believe they now think of me.
+    if (byMe && Array.isArray(pc.witnesses)) {
+        for (const w of pc.witnesses.slice(0, 8)) {
+            if (typeof w !== 'string')
+                continue;
+            if (w === p.id)
+                continue;
+            const act = { kind: pc.kind };
+            if (target !== undefined)
+                act.targetId = target;
+            if (pc.valence !== undefined)
+                act.valence = pc.valence;
+            if (pc.norms)
+                act.norms = pc.norms;
+            noteKnownBy(p, { otherId: w, act, at, via: 'seen' });
+        }
+    }
     // Advice carried by testimony keeps pulling after the speaker falls silent (standing advice, N9).
     if (pc.channel === 'told')
         rememberAdvice(p, pc);
@@ -1333,6 +1363,8 @@ export function finish(p, outcome, opts = {}) {
         dischargeAdvice(p, aff.action);
     }
     // Memory.
+    if (p.curiosity)
+        noteCuriosity(p, aff, outcome, felt);
     learnOutcome(p, aff, outcome, realized, felt);
     const episode = {
         at: now,

package/dist/restore.d.ts

@@ -1,3 +1,11 @@
+/**
+ * SCOPE: saving and loading a person. `snapshot` copies a person as plain JSON; `restore` validates a saved person,
+ * upgrades a save from an earlier supported engine (`migrate`), fills defaults for missing or mistyped core fields,
+ * hands every optional slice to its owning module's sanitizer (the chronicle, its day accumulator and the lexicon
+ * need only a type check, done here), and holds every list to the bound the live code keeps.
+ * A save the engine wrote restores to exactly what was saved. It does not repair a save's meaning (a plausible but
+ * wrong value stays), merge two saves, or read any format but the person JSON.
+ */
 import type { Person } from './types.ts';
 /** A deep copy of the person as plain JSON (what a host saves). */
 export declare function snapshot(p: Person): Person;

package/dist/restore.js

@@ -8,10 +8,12 @@
  */
 import { sanitizeCrisis } from './affect/index.js';
 import { sanitizeAgenda } from './agenda/index.js';
+import { sanitizeBeliefMeta } from './beliefs/index.js';
 import { sanitizeBody, sanitizeInjuries } from './body/index.js';
 import { sanitizeCharacter } from './character/index.js';
 import { CHRONICLE_DEFAULTS, sanitizeYears } from './chronicle/index.js';
 import { isNum } from './core/index.js';
+import { sanitizeCuriosity } from './curiosity/index.js';
 import { sanitizeAmbient } from './environment/index.js';
 import { sanitizeFamily } from './family/index.js';
 import { HABIT_DEFAULTS } from './habits/index.js';
@@ -84,6 +86,7 @@ const OPTIONAL_KEYS = new Set([
     'methods',
     'prospection',
     'promptings',
+    'curiosity',
     'review',
 ]);
 /** Kind of a JSON value for the per-field type check in `restore`. */
@@ -188,6 +191,7 @@ export function restore(input) {
     sanitizeCrisis(out.affect);
     sanitizeAgenda(out.agenda);
     sanitizeGists(out.memory);
+    sanitizeBeliefMeta(out.memory);
     // Optional top-level slices (1.8.0 onward), each checked by its owner.
     keepValid(out, 'chronicleYears', sanitizeYears);
     keepValid(out, 'character', sanitizeCharacter);
@@ -198,6 +202,7 @@ export function restore(input) {
     keepValid(out, 'retention', cleanRetention);
     keepValid(out, 'methods', sanitizeMethods);
     keepValid(out, 'prospection', (x) => sanitizeProspection(x, out.now, out.id));
+    keepValid(out, 'curiosity', (x) => sanitizeCuriosity(x, out.now));
     keepValid(out, 'promptings', (x) => sanitizePromptings(x, out.now));
     keepValid(out, 'review', (x) => sanitizeReview(x, out.now));
     boundLists(out);

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.11.0";
 /** A pregnancy carried by this person (host-driven; see `family/`). */
 export interface Pregnancy {
     fatherId: PersonId;
@@ -1007,6 +1052,8 @@ export interface Person {
     prospection?: ProspectionState;
     /** Noticed promptings and practised turnings-away (2.4.0, opt-in via `enablePromptings`). Owned by `promptings/`. */
     promptings?: PromptingsState;
+    /** Intrinsic exploration and varied repetition. Owned by `curiosity/`; absent unless enabled. */
+    curiosity?: CuriosityState;
     /** Evening self-review and its resolves (2.7.0, opt-in via `enableReview`). Owned by `review/`. */
     review?: ReviewState;
     /** Practice consolidation (1.8.0, opt-in via `enableSkillRetention`). Owned by `skills/`. */
@@ -1157,11 +1204,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 +1249,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
@@ -1447,6 +1498,8 @@ export interface PersonSpec {
         fullness?: boolean;
         /** Promptings and turning away (2.4.0): the same as `enablePromptings(p, spec)` after creation. */
         promptings?: PromptingsSpec;
+        /** Enable intrinsic exploration and play, using engineering defaults or bounded overrides. */
+        curiosity?: boolean | CuriositySpec;
         /** Evening self-review (2.7.0): the same as `enableReview(p, spec)` after creation. */
         review?: ReviewSpec;
     };
@@ -1841,3 +1894,39 @@ export interface DayRecord {
      */
     state?: ChronicleState;
 }
+/** Engineering overrides for intrinsic motivation; scales are capped at their defaults. */
+export interface CuriositySpec {
+    unknownScale?: number;
+    progressScale?: number;
+    varyScale?: number;
+    recentMinutes?: number;
+    rewardMax?: number;
+}
+/** Prediction-error history for the same key used by memory expectations. */
+export interface CuriosityError {
+    key: string;
+    fast: Unit;
+    slow: Unit;
+    n: number;
+    lastAt: Minute;
+}
+/** A completed or failed act, retained only for bounded repetition with variation. */
+export interface CuriosityAct {
+    action: string;
+    targetId?: EntityId;
+    placeId?: EntityId;
+    at: Minute;
+}
+/** Optional JSON state owned by curiosity/. */
+export interface CuriosityState {
+    spec?: CuriositySpec;
+    errors: CuriosityError[];
+    recent: CuriosityAct[];
+}
+/** Raw bounded signals and their common drive; no RNG or mutation. */
+export interface CuriosityReading {
+    unknown: Unit;
+    progress: Unit;
+    vary: Unit;
+    drive: number;
+}

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.11.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adam0white/human-framework",
-  "version": "2.9.1",
+  "version": "2.11.0",
   "description": "Deterministic, explainable simulated people: body, needs, affect, memory, beliefs, skills, habits, relationships, values and a will that can refuse a suggestion",
   "keywords": [
     "simulation",