@adam0white/human-framework 2.23.0 → 3.0.0

package/README.md

@@ -4,10 +4,50 @@ HF is a TypeScript library for simulated people in games and headless simulation
 possible actions. Each person weighs needs, habits, duties, goals and suggestions, then chooses.
 A player can suggest an action; the person can defer or refuse it.
 
-HF 2.14.1 uses utility scoring and seeded randomness, with no LLM in the actor loop and no runtime
+HF 3.0.0 uses utility scoring and seeded randomness, with no LLM in the actor loop and no runtime
 dependencies. Decision records expose scored terms and template narration. Person state is plain JSON.
 This is an authored simulation model, not a validated predictor of real people.
 
+## Migrating to v3
+
+The API migration keeps engine `2.23.0`. Relative to HF 2.23.0, it does not change seeded draws, numeric rules or saved Person state. The package version is `3.0.0`; publication is recorded separately in the release history.
+
+| Before                                                                         | v3                                                                                                |
+| ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------- |
+| `glimpse(p, id, signs, { at, clarity })`                                       | `glimpse(p, id, signs, at, clarity)`                                                              |
+| `glimpseOf(p, target, at, clarity)` or `glimpseOf(p, target, { at, clarity })` | `glimpsePerson(p, target, at, clarity)`                                                           |
+| `acquaintWith(p, target, familiarity, at)`                                     | `acquaintPerson(p, target, familiarity, at)`                                                      |
+| `hear(p, id, key, value, { at, weight })`                                      | `hear(p, id, key, value, at, weight)`                                                             |
+| `conceive(mother, father, { seed, at })`                                       | `conceive(mother, father, seed, at)`                                                              |
+| `retell(teller, listener, { at, trust, limit, placeIds })`                     | `retell(teller, listener, at, { trust, limit, placeIds })`                                        |
+| `TRAIT_NAMES`                                                                  | `TRAIT_KEYS` (same order)                                                                         |
+| `expit(x)`                                                                     | `sigmoid(x)` (same function body)                                                                 |
+| `keysOf(record)`                                                               | `Object.keys(record)` (same enumeration order; narrow host key types explicitly when needed)      |
+| `repent(p, breachId, unusedTime)`                                              | `repent(p, breachId)`                                                                             |
+| `recordRepair(p, victimId, unusedTime)`                                        | `recordRepair(p, victimId)`                                                                       |
+| `liveRoutine(p, to, fixedRoutine)`                                             | `liveRoutine(p, to, () => fixedRoutine)`                                                          |
+| `routineFor: (p, day, community) => choose(p, day, community)`                 | `routineFor: (p, day) => choose(p, day, community)` with `community` captured from the host scope |
+
+Removed options-object calls from untyped JavaScript throw `TypeError` before changing Person state. Their time argument must be a finite number in the positional slot.
+
+Both routine drivers use `RoutineSource = (p: Person, day: number) => Routine`. `day` is the absolute day being started. Existing two-argument sources continue unchanged. A community source closes over the community for that run; bind a new closure after restoring a different community. Sources still run immediately before each person's routine day. Community dawn hooks still run first, and earlier people's days are already applied when later sources read community state. Do not precompute all routines at dawn if that would change those reads.
+
+The primitive names `glimpse` and `acquaint` stay. Their Person composites use the explicit `Person` suffix. The proposed `skip` → `skipTo` rename is dropped (Q15): it provides no player value and `skip` is clear in context.
+
+### Tuning defaults (Q5)
+
+Assignment to existing mutable defaults remains the tuning API in v3. These settings apply to every run in the same module instance. Set them before creating or restoring a run, then keep them fixed while it runs. Already-frozen defaults remain frozen.
+
+Deterministic replay requires the same engine version, effective tuning values, initial state, seeded streams, inputs and call order. Person snapshots do not store these global settings. A host that tunes must store its complete effective configuration or its overrides relative to a known pristine baseline in its save or replay envelope. Before restoring or continuing, restore that baseline first, then apply the saved overrides. A fresh module instance is another way to start from the baseline. Applying overrides over a previous run's settings can leak tuning between runs.
+
+Two worlds with different settings cannot safely share one module instance. Tests that tune must restore values in a `finally` block and must not mutate them concurrently. This decision preserves existing hosts and seeded behavior. It adds no global configuration function or per-person settings. A future isolated settings API must first demonstrate exact snapshot, restore and continuation under overrides.
+
+## Ordering inputs for one logical tick (opt-in)
+
+`canonicalTickInputs(tick, inputs, expected)` waits for the complete declared sender/sequence set and returns a new envelope array sorted by sender, then sequence. It returns `undefined` while an input is missing and throws for duplicate, unexpected or wrong-tick inputs. Payloads remain host-owned. Use the returned array only after the barrier completes; save pending input with host state.
+
+This is a bounded host convention, not transport, consensus or fairness. It reads no Person or RNG. Existing actor calls never use it implicitly. The H3 controls compare reordered deliveries, withheld input, restore and a behaviorally different unsorted control. The copyable two-person starter in `examples/h3-starter` owns its own clock and replay envelope; it is not a complete game engine or part of the npm artifact.
+
 ## Try the games
 
 - [Twice at the Well](https://human.adamwhite.work/colony/): compare a colony without and with HF.
@@ -20,21 +60,23 @@ This is an authored simulation model, not a validated predictor of real people.
 Use Node 24 or newer. In an empty directory, install the version this README describes:
 
 ```sh
-npm install @adam0white/human-framework@2.14.1
+npm install @adam0white/human-framework@3.0.0
 ```
 
 Save these 20 lines as `quickstart.mjs`, then run `node quickstart.mjs`:
 
 ```js
 import {
-  createCommunity, createPerson, createVillage,
-  predict, stepCommunity, villagerSpec,
+  createCommunity,
+  createPerson,
+  createVillage,
+  predict,
+  stepCommunity,
+  villagerSpec,
 } from '@adam0white/human-framework';
 const start = 6 * 60; // simulation minutes
 const ids = ['ada', 'bora'];
-const people = ids.map((id, i) => createPerson(
-  villagerSpec(id, id, i + 1, { now: start, others: ids }),
-));
+const people = ids.map((id, i) => createPerson(villagerSpec(id, id, i + 1, { now: start, others: ids })));
 const world = createVillage(people, { seed: 7 });
 const community = createCommunity(people);
 const ada = community.people[0];
@@ -83,14 +125,14 @@ A suggestion is one urge among many. Its weight is strength × trust in the voic
 fits the person's motives, and a suggestion alone never overrides a veto. Each one resolves to a typed
 verdict (`SuggestionResolution`):
 
-| verdict | meaning | `kind` |
-|---|---|---|
-| `assented` | the suggested option won | none |
-| `deferred` | the person's own preference won; carries a `counterOffer` ("after I eat lunch") | `notNow` |
-| `modified` | a near alternative with the same action or aim won; the `counterOffer` names it | `notNow` |
-| `refused` | cannot (asleep, exhausted, skill far too low, a pressing bodily need) or will not (a firmly held norm, broken trust) | `cannot` / `willNot` |
-| `complied` | the voice insisted on a "not now"; done under protest (`activity.protest`), at a cost to autonomy and trust | `notNow` |
-| `commanded` | the host took direct control (see [Direct control](#direct-control)); the person does the order whatever they would have chosen | none |
+| verdict     | meaning                                                                                                                         | `kind`               |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------- | -------------------- |
+| `assented`  | the suggested option won                                                                                                        | none                 |
+| `deferred`  | the person's own preference won; carries a `counterOffer` ("after I eat lunch")                                                 | `notNow`             |
+| `modified`  | a near alternative with the same action or aim won; the `counterOffer` names it                                                 | `notNow`             |
+| `refused`   | cannot (asleep, exhausted, skill far too low, a pressing bodily need) or will not (a firmly held norm, broken trust)            | `cannot` / `willNot` |
+| `complied`  | the voice insisted on a "not now"; done under protest (`activity.protest`), at a cost to autonomy and trust                     | `notNow`             |
+| `commanded` | the host took direct control (see [Direct control](#direct-control)); the person does the order whatever they would have chosen | none                 |
 
 Insisting (`insist: true`) turns only a `notNow` into compliance, and not when a bodily need is pressing. It
 never overrides `cannot` or `willNot`.
@@ -132,11 +174,12 @@ An offer describes expected effects. An outcome reports what happened. The host
 contact, inventory and payment; HF uses the reported outcome to update the person. Do not copy
 `Affordance.advertises` into `Outcome.needs` as a general completion rule.
 
-| Host situation | Offer | Completion report |
-|---|---|---|
-| A person sleeps for part of the planned night. | Advertise typical sleep/rest benefits and set `mode: 'sleep'`. | Leave `sleep` and `rest` absent from `Outcome.needs`. `finish` advances the body to the actual end time and measures their change since the activity began. Explicit values replace that measurement; copying the advertisement can overstate the realized recovery reported to learning. |
-| A task promises four coins but actually pays two. | Set expected `Affordance.material` to four host units. | Update the host ledger by two and report `Outcome.material: 2`. A completed task does not imply the promised payment arrived. Report zero for no payment and a negative value for an actual cost. HF does not maintain the host's money ledger. |
-| A person can talk with someone who is present. | Tag the offer `social` when it really involves social contact; put participants in `with`. | Resolve actual participation. An empty room, a sleeping neighbour or someone who arrives after the conversation ends is not a completed encounter. Do not award contact or belonging merely because the activity uses a shared place. |
+<!-- biome-ignore format: Biome 2.6.3 adds column padding on each pass for this inline-code table; preserve stable source. -->
+| Host situation                                    | Offer                                                                                      | Completion report                                                                                                                                                                                                                                                                        |
+| ------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| A person sleeps for part of the planned night.    | Advertise typical sleep/rest benefits and set `mode: 'sleep'`.                             | Leave `sleep` and `rest` absent from `Outcome.needs`.`finish` advances the body to the actual end time and measures their change since the activity began. Explicit values replace that measurement; copying the advertisement can overstate the realized recovery reported to learning. |
+| A task promises four coins but actually pays two. | Set expected `Affordance.material` to four host units.                                     | Update the host ledger by two and report `Outcome.material: 2`. A completed task does not imply the promised payment arrived. Report zero for no payment and a negative value for an actual cost. HF does not maintain the host's money ledger.                                          |
+| A person can talk with someone who is present.    | Tag the offer `social` when it really involves social contact; put participants in `with`. | Resolve actual participation. An empty room, a sleeping neighbour or someone who arrives after the conversation ends is not a completed encounter. Do not award contact or belonging merely because the activity uses a shared place.                                                    |
 
 For in-person activities, the host must establish co-presence and overlapping participation. HF has
 no map and does not discover companions. `with` names people taking part, not everyone assigned to a
@@ -211,7 +254,7 @@ reference host: `createVillage`.
   const village2 = createVillage(people, { seed: 0, state: s.world });
   const c2 = createCommunity(people, s.community); // continues exactly as the unsaved run would
   ```
-- **Time arguments.** A host event takes `at` as its last required argument, with optional knobs after it (`glimpseOf(observer, target, at, clarity?)`, `retell(teller, listener, at, opts?)`); a query evaluated at a time takes `now`. The 2.0 options-object forms still work and are deprecated until 3.0. See docs/framework.md, "Argument order".
+- **Time arguments.** A host event takes `at` as its last required argument, with optional knobs after it (`glimpsePerson(observer, target, at, clarity?)`, `retell(teller, listener, at, opts?)`); a query evaluated at a time takes `now`. The former 2.0 options-object forms are removed in v3. See docs/framework.md, "Argument order".
 - Hosts that live people sparsely over decades can shrink what a save carries per person with
   `setRetention(p, { trace, chronicleDays })` (or `PersonSpec.retention`): fewer decision records, and day records
   bounded by age as well as count. No decision changes. `restore` also refuses a non-finite or out-of-range `now`
@@ -222,7 +265,7 @@ reference host: `createVillage`.
 
 There are two version numbers, and they move independently.
 
-- **The release version** is the package version (`package.json`, currently `2.23.0`) and `FRAMEWORK_VERSION`, the same
+- **The release version** is the package version (`package.json`, currently `3.0.0`) and `FRAMEWORK_VERSION`, the same
   string compiled into the build; a test keeps them equal. It versions the public API under
   [semver](https://semver.org/): a breaking change to an exported name or signature bumps the major, a new
   faculty or export the minor, a fix the patch. Each release is a tag `vX.Y.Z` and a GitHub release whose notes
@@ -269,8 +312,8 @@ of it runs as before.
 - **Surroundings.** `setAmbient` (cold, dark, crowding, beauty, weather, day length) shifts mood, body and needs.
 - **Multi-year stepping.** `liveRoutine` and `liveCommunity` live people by routine a coarse day at a time, with
   natural death, chronic onsets, deaths told and minors raised.
-- **Impressions of others.** What one person believes about another (`glimpseOf(observer, target, at, clarity?)`, `observeAct`, `hear(observer, targetId, key, value, at, weight?)`,
-  `acquaintWith`), with confidence; `predictAs` runs a prediction on the person as the observer pictures them.
+- **Impressions of others.** What one person believes about another (`glimpsePerson(observer, target, at, clarity?)`, `observeAct`, `hear(observer, targetId, key, value, at, weight?)`,
+  `acquaintPerson`), with confidence; `predictAs` runs a prediction on the person as the observer pictures them.
 - **Switching on at creation.** `PersonSpec.enable: { gists, yearbook, character, skillRetention }` turns the long-run faculties above on when the person is created.
 - **Answering between decisions.** `answerNow` books a refusal at once without touching the running activity.
 
@@ -314,7 +357,7 @@ that place lose appeal until the fear fades. Groups and factions themselves stay
   the bundled `DEFAULT_NORMS` is Islam-guided; each reference's verification status is listed in
   [research/norm-sources.md](https://github.com/adam0white/human-framework/blob/main/research/norm-sources.md)). A host with its own catalog passes it as
   `World.catalog`, so necessity excuses and exemptions read that catalog; a norm not in it is not excused.
-  A person holds an *understanding* of a norm, with a standing and a conviction. That understanding is
+  A person holds an _understanding_ of a norm, with a standing and a conviction. That understanding is
   not a ruling. The library never computes divine acceptance. Where schools of thought differ, the
   position the bundled catalog takes, and why, is recorded in
   [research/decisions.md](https://github.com/adam0white/human-framework/blob/main/research/decisions.md).
@@ -341,18 +384,30 @@ Use observations the person actually received; the host owns what those observat
 ```ts
 receiveMethodCues(learner, {
   contextId: 'observed-example',
-  cues: [{ cue: 'route', value: 'north' }, { cue: 'signal', value: 'clear' }],
+  cues: [
+    { cue: 'route', value: 'north' },
+    { cue: 'signal', value: 'clear' },
+  ],
 });
 demonstrateMethod(learner, {
-  id: 'routing-north', demonstrationId: 'example-1',
-  contextId: 'observed-example', sourceId: 'instructor',
-  conditions: [{ cue: 'route', value: 'north' }, { cue: 'signal', value: 'clear' }],
-  action: 'send-north', outcome: 'success',
+  id: 'routing-north',
+  demonstrationId: 'example-1',
+  contextId: 'observed-example',
+  sourceId: 'instructor',
+  conditions: [
+    { cue: 'route', value: 'north' },
+    { cue: 'signal', value: 'clear' },
+  ],
+  action: 'send-north',
+  outcome: 'success',
 });
 // A new parcel can share the learned observation structure.
 receiveMethodCues(learner, {
   contextId: 'new-parcel',
-  cues: [{ cue: 'route', value: 'north' }, { cue: 'signal', value: 'clear' }],
+  cues: [
+    { cue: 'route', value: 'north' },
+    { cue: 'signal', value: 'clear' },
+  ],
 });
 const evidence = methodEvidence(learner, 'send-north', 'new-parcel');
 // Offers for that parcel carry methodContext: 'new-parcel'.
@@ -369,39 +424,67 @@ HF 2.3.0 lets an attended explanation connect one current action to one possible
 
 ```ts
 import {
-  type Affordance, type ReceivedConsequence,
-  consequenceEvidence, createPerson, decide, perceive,
+  type Affordance,
+  type ReceivedConsequence,
+  consequenceEvidence,
+  createPerson,
+  decide,
+  perceive,
 } from '@adam0white/human-framework';
 
 const person = createPerson({
-  id: 'courier', name: 'Courier', seed: 19, now: 600,
-  bornAt: -30 * 365 * 1440, sex: 'female',
-  goals: [{
-    id: 'delivery', label: 'Deliver the parcel', serves: ['achievement'],
-    advancedBy: [{ action: 'deliver', amount: 1 }], importance: 0.8,
-    temporal: { halfLifeMinutes: 30 },
-  }],
+  id: 'courier',
+  name: 'Courier',
+  seed: 19,
+  now: 600,
+  bornAt: -30 * 365 * 1440,
+  sex: 'female',
+  goals: [
+    {
+      id: 'delivery',
+      label: 'Deliver the parcel',
+      serves: ['achievement'],
+      advancedBy: [{ action: 'deliver', amount: 1 }],
+      importance: 0.8,
+      temporal: { halfLifeMinutes: 30 },
+    },
+  ],
 });
 const route: ReceivedConsequence = {
-  id: 'access-window', revision: 0,
+  id: 'access-window',
+  revision: 0,
   trigger: { action: 'ask-access', targetId: 'keeper' },
   successor: { action: 'deliver', duration: 20, effort: 0.1 },
-  availableFrom: 620, availableUntil: 680, expiresAt: 800,
-  chance: 0.8, confidence: 0.9,
+  availableFrom: 620,
+  availableUntil: 680,
+  expiresAt: 800,
+  chance: 0.8,
+  confidence: 0.9,
 };
-perceive(person, [{
-  at: 600, channel: 'told', kind: 'explanation', actorId: 'keeper',
-  targetId: person.id, salience: 1,
-  summary: 'If your request succeeds, this route may become available.',
-  consequences: [route],
-}]);
+perceive(person, [
+  {
+    at: 600,
+    channel: 'told',
+    kind: 'explanation',
+    actorId: 'keeper',
+    targetId: person.id,
+    salience: 1,
+    summary: 'If your request succeeds, this route may become available.',
+    consequences: [route],
+  },
+]);
 const request: Affordance = {
-  id: 'ask', action: 'ask-access', label: 'Request access', targetId: 'keeper',
-  duration: 10, effort: 0.1, advertises: {},
+  id: 'ask',
+  action: 'ask-access',
+  label: 'Request access',
+  targetId: 'keeper',
+  duration: 10,
+  effort: 0.1,
+  advertises: {},
 };
-const offers: Affordance[] = [request,
-  { id: 'direct', action: 'deliver', label: 'Deliver directly',
-    duration: 180, effort: 0.1, advertises: {} },
+const offers: Affordance[] = [
+  request,
+  { id: 'direct', action: 'deliver', label: 'Deliver directly', duration: 180, effort: 0.1, advertises: {} },
 ];
 const decision = decide(person, offers);
 const evidence = consequenceEvidence(person, request); // pure; no RNG consumed

package/dist/agenda/agenda.js

@@ -897,7 +897,7 @@ function boundOwed(state) {
         return;
     while (owed.length > AGENDA_DEFAULTS.maxOwed) {
         const i = owed.findIndex((o) => o.scheduledAs !== undefined);
-        owed.splice(i >= 0 ? i : 0, 1);
+        owed.splice(Math.max(i, 0), 1);
     }
 }
 /** A kept, closed instance is positive recorded evidence; scheduling or missing history is not. */

package/dist/beliefs/beliefs.js

@@ -24,7 +24,7 @@
  * 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, isNum, isObj, logit } from '../core/index.js';
+import { clamp, clamp01, decay, dpow, isNum, isObj, logit, sigmoid } from '../core/index.js';
 import { MAX_MINUTE, MINUTES_PER_DAY } from '../types.js';
 export const BELIEF_DEFAULTS = {
     maxBeliefs: 300,
@@ -229,7 +229,7 @@ export function believe(p, prop, value, confidence, sourceId, now) {
 }
 export function credence(p, prop) {
     const b = findBelief(p, prop);
-    return b ? expit(b.logOdds) : 0.5;
+    return b ? sigmoid(b.logOdds) : 0.5;
 }
 /**
  * Direct observation of the truth: set the belief firmly and recalibrate the sources that spoke on it.

package/dist/conscience/conscience.d.ts

@@ -100,13 +100,11 @@ 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;
+export declare function repent(p: Person, id: string): 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;
+export declare function recordRepair(p: Person, victimId: string): 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

@@ -278,7 +278,7 @@ function breachId(p, at, normId) {
 function boundBreaches(c) {
     while (c.breaches.length > CONSCIENCE_DEFAULTS.maxBreaches) {
         const i = c.breaches.findIndex((b) => b.repaired);
-        c.breaches.splice(i >= 0 ? i : 0, 1);
+        c.breaches.splice(Math.max(i, 0), 1);
     }
 }
 /**
@@ -358,9 +358,8 @@ 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) {
+export function repent(p, id) {
     const breach = p.conscience.breaches.find((b) => b.id === id);
     if (!breach)
         return false;
@@ -371,9 +370,8 @@ export function repent(p, id, _now) {
 }
 /**
  * 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) {
+export function recordRepair(p, victimId) {
     let count = 0;
     for (const b of p.conscience.breaches) {
         if (!b.repaired && b.victimId === victimId) {

package/dist/conversation/conversation.d.ts

@@ -1,44 +1,3 @@
-/**
- * SCOPE: one conversation turn between two people: what the speaker tells the listener, drawn from the
- * speaker's own confident beliefs, and what advice they give, drawn from the speaker's beliefs about what the
- * listener should do. Output is plain data: `told` percepts (testimony with claims at the speaker's credence)
- * and advice percepts that the host delivers through the listener's `perceive`, a `Suggestion` per piece of
- * advice for the listener's next decision, and social events for both sides. Reputation is nothing more than
- * these claims spreading belief by belief (`social.applyReputationBelief` turns a changed character belief
- * into a changed relationship).
- *
- * Choice of what to say is deterministic and explainable: each candidate claim gets a relevance score
- * (confidence, recency, host topics, the speaker's feeling about its subject); an unfavourable claim about an
- * absent third party is tagged with the catalog norm 'backbiting' (Qur'an 49:12, as catalogued in
- * `conscience/catalog.ts`) and costs the speaker in proportion to their OWN held understanding of that norm and
- * their honesty-humility, so a speaker who holds it firmly withholds it and one who does not tells it. The
- * definition used here (an unfavourable character claim about someone not present) is an engineering
- * assumption for the tag, not a ruling on what counts as backbiting. Deceit happens only when the host offers a
- * temptation (the speaker gains if the listener believes something the speaker does not): temptation scales
- * with (1 − honesty-humility) and is opposed by the speaker's held 'lying' norm. The lie is a host-visible flag
- * (`ToldClaim.deceit`); the listener cannot see it. Named shapes: honesty-humility as the HEXACO factor most
- * predictive of lower dishonesty (Hilbig & Zettler 2009; Heck et al. 2018 meta-analysis), gossip as a large
- * share of conversation about absent third parties that spreads reputational information (Dunbar 2004), and
- * extraversion as talkativeness (how many claims are offered).
- *
- * SCOPE (host options): `loyalWarning` admits only unfavourable listener claims when affection is at least
- * 0.5 (an engineering threshold). `confidentMin` sets a per-call relay threshold. `phrase` renders selected
- * testimony only; the host owns authored facts, delivery and subsequent disclosure. No hidden relay occurs.
- *
- * It does NOT generate language, model turn-taking, persuasion beyond source trust, what the speaker believes
- * the listener already knows, lies of omission, white lies told to spare feelings, or the speaker's fear of
- * being found out. Coefficients are engineering defaults, not calibrated estimates. Nothing here judges the
- * worth of either person; norms are the people's own understandings with catalog provenance.
- * Repetition (integration, 2026-10-03): a claim the listener already holds at the told confidence produces no
- * 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 { type TraitEffect } from '../social/index.ts';
 import type { EntityId, Minute, NormTag, Percept, Person, PersonId, SocialEvent, Suggestion, Unit } from '../types.ts';
 export declare const CONVERSATION_DEFAULTS: {

package/dist/conversation/conversation.js

@@ -39,7 +39,7 @@
  * 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 { clamp01, round, sigmoid } from '../core/index.js';
 import { nameOf as listenerNameOf } from '../narrate/lexicon.js';
 import { isDeceased, isUnfavourableTrait, parseTraitProp, REPUTATION_TRAITS, relationshipWith, } from '../social/index.js';
 import { MINUTES_PER_DAY } from '../types.js';
@@ -157,7 +157,7 @@ export function converse(speaker, listener, ctx) {
         const subject = b.prop.split(':')[0];
         if (subject === speaker.id)
             continue;
-        const cred = expit(b.logOdds);
+        const cred = sigmoid(b.logOdds);
         const threshold = Number.isFinite(ctx.confidentMin) &&
             ctx.confidentMin >= 0 &&
             ctx.confidentMin <= 0.5
@@ -181,7 +181,7 @@ export function converse(speaker, listener, ctx) {
     // Temptations: claims the speaker would gain from the listener believing.
     for (const t of [...(ctx.temptations ?? [])].sort((a, b) => (a.prop < b.prop ? -1 : 1))) {
         const b = speaker.memory.beliefs.find((x) => x.prop === t.prop);
-        const cred = b ? expit(b.logOdds) : 0.5;
+        const cred = b ? sigmoid(b.logOdds) : 0.5;
         const forValue = t.value ? cred : 1 - cred;
         const gain = clamp01(t.gain);
         if (forValue >= 0.5) {
@@ -234,7 +234,7 @@ export function converse(speaker, listener, ctx) {
         // deed (counted above) but yields no percept, so the same gossip retold at every tea is not judged afresh.
         const heard = listener.memory.beliefs.find((x) => x.prop === c.prop);
         if (heard) {
-            const cred = expit(heard.logOdds);
+            const cred = sigmoid(heard.logOdds);
             if ((c.value ? cred : 1 - cred) >= c.confidence)
                 continue;
         }
@@ -281,7 +281,7 @@ export function converse(speaker, listener, ctx) {
     for (const b of beliefs) {
         if (!b.prop.startsWith(prefix))
             continue;
-        const cred = expit(b.logOdds);
+        const cred = sigmoid(b.logOdds);
         if (cred < C.adviceMin)
             continue;
         const strength = clamp01((cred - 0.5) * 2 * (0.3 + 0.7 * care) * (0.5 + benevolence));

package/dist/core/index.d.ts

@@ -1,4 +1,3 @@
-export * from './keys.ts';
 export * from './libm.ts';
 export * from './math.ts';
 export * from './random.ts';

package/dist/core/index.js

@@ -1,4 +1,3 @@
-export * from './keys.js';
 export * from './libm.js';
 export * from './math.js';
 export * from './random.js';

package/dist/core/math.d.ts

@@ -5,8 +5,6 @@ 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;
 export declare const minuteOfDay: (now: number) => number;

package/dist/core/math.js

@@ -1,7 +1,9 @@
 import { MINUTES_PER_DAY } from '../types.js';
 import { dexp, dlog, dpow } from './libm.js';
 /** Clamp into [min, max]. NaN maps to `min`, so one bad host number cannot propagate through state. */
-export const clamp = (value, min, max) => Number.isNaN(value) ? min : value < min ? min : value > max ? max : value;
+export const clamp = (value, min, max) => 
+// biome-ignore lint/complexity/useMathMinMax: Comparisons preserve signed zero and NaN bounds; Math.min/max change them.
+Number.isNaN(value) ? min : value < min ? min : value > max ? max : value;
 export const clamp01 = (value) => clamp(value, 0, 1);
 export const clampSigned = (value) => clamp(value, -1, 1);
 /** A finite number. Restore sanitizers use it. @internal */
@@ -36,8 +38,6 @@ 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) {
     if (halfLife <= 0)

package/dist/family/family.d.ts

@@ -40,11 +40,6 @@ export declare function conceptionChance(mother: Person, father: Person, days: n
  * median (an engineering bound against extreme draws). Returns the pregnancy, or undefined if one is already open.
  */
 export declare function conceive(mother: Person, father: Person | PersonId, seed: number, at: Minute): Pregnancy | undefined;
-/** @deprecated since 2.1: pass `at` (and the optional knobs) positionally. Removed in 3.0. */
-export declare function conceive(mother: Person, father: Person | PersonId, opts: {
-    at: Minute;
-    seed: number;
-}): Pregnancy | undefined;
 /**
  * Weeks since conception (0 when not pregnant). Counted from conception, not from the last menstrual period, which
  * is where obstetric weeks and trimesters are conventionally counted from (about two weeks earlier). The second

package/dist/family/family.js

@@ -161,19 +161,25 @@ export function conceptionChance(mother, father, days) {
         return 0;
     return clamp01(1 - dpow(1 - c, days / FAMILY_DEFAULTS.cycleDays));
 }
-export function conceive(mother, father, seedOrOpts, when) {
-    const opts = typeof seedOrOpts === 'number' ? { seed: seedOrOpts, at: when } : seedOrOpts;
+/**
+ * Record that `mother` has conceived by `father` at `at`. The due date is drawn from a stream derived from `seed`;
+ * `seed` also becomes the child's seed at delivery. The drawn length is clamped to 4 sd below and 3 sd above the
+ * median (an engineering bound against extreme draws). Returns the pregnancy, or undefined if one is already open.
+ */
+export function conceive(mother, father, seed, at) {
+    if (!Number.isFinite(at))
+        throw new TypeError('conceive requires a finite positional time');
     const fam = familyOf(mother);
     if (fam.pregnancy)
         return undefined;
-    const rng = createRng((opts.seed ^ 0x9e3779b9) >>> 0);
+    const rng = createRng((seed ^ 0x9e3779b9) >>> 0);
     const F = FAMILY_DEFAULTS;
     const days = clamp(normal(rng, F.gestationDays, F.gestationSdDays), F.gestationDays - 4 * F.gestationSdDays, F.gestationDays + 3 * F.gestationSdDays);
     const pregnancy = {
         fatherId: typeof father === 'string' ? father : father.id,
-        conceivedAt: opts.at,
-        dueAt: opts.at + Math.round(days * MINUTES_PER_DAY),
-        seed: opts.seed,
+        conceivedAt: at,
+        dueAt: at + Math.round(days * MINUTES_PER_DAY),
+        seed,
     };
     fam.pregnancy = pregnancy;
     return { ...pregnancy };

package/dist/impression.d.ts

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

package/dist/impression.js

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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /** Human Framework public surface. */
-export declare const FRAMEWORK_VERSION = "2.23.0";
+export declare const FRAMEWORK_VERSION = "3.0.0";
 export type { CrisisEvent, PracticeKind } from './affect/index.ts';
 export { AFFECT_DEFAULTS, actionTendencies, advanceAffect, appraise, breakAllows, breakBehaviour, breakHazard, CRISIS_DEFAULTS, checkCrisis, createAffect, easeBreak, emotionLevel, enableBreaks, feel, inBreak, readAffect, regulate, release as releaseEmotion, skipCrisis, strain, tendencyEmotions, } from './affect/index.ts';
 export type { GoalTemplate, MakeUpReceipt, PrayerCalendar, PrayerSchedule, PrayerTimes, Retimer, } from './agenda/index.ts';
@@ -46,5 +46,6 @@ export * from './scenarios/index.ts';
 export * from './sim/index.ts';
 export * from './skills/index.ts';
 export * from './social/index.ts';
+export { canonicalTickInputs, type TickInput, type TickInputKey } from './tick-input.ts';
 export * from './types.ts';
 export * from './will/index.ts';

package/dist/index.js

@@ -1,5 +1,5 @@
 /** Human Framework public surface. */
-export const FRAMEWORK_VERSION = '2.23.0';
+export const FRAMEWORK_VERSION = '3.0.0';
 export { AFFECT_DEFAULTS, actionTendencies, advanceAffect, appraise, breakAllows, breakBehaviour, breakHazard, CRISIS_DEFAULTS, checkCrisis, createAffect, easeBreak, emotionLevel, enableBreaks, feel, inBreak, readAffect, regulate, release as releaseEmotion, skipCrisis, strain, tendencyEmotions, } from './affect/index.js';
 // `agenda.release` collides with `affect.release`; the agenda one is re-exported under a clearer name.
 export { AGENDA_DEFAULTS, abandonGoal, adoptGoal, advanceAgenda, agendaTerms, applyExemptions, CARE_DEFAULTS, calendarRetimer, careDuty, commitmentPressure, createAgenda, DEFAULT_PRAYER_TIMES, EID_PRAYER_IMPORTANCE, EXEMPTION_DEFAULTS, eidPrayer, eidWindow, fastWindow, iftarWindow, inMakruhTime, isContinuingCommitment, isUnderWay, MAKRUH_DEFAULTS, makruhWindows, missedExcuse, onFinished, owedMakeUps, PRAYER_IMPORTANCE, PURPOSE_DEFAULTS, prayerWindows, pressureReachedAt, promise, proposeGoals, RAMADAN_DEFAULTS, ramadanFast, ramadanMeals, release as releaseCommitment, retimeCommitments, retirePaidMakeUps, revisePurposes, scheduleMakeUp, spanMeetsWindow, suhoorWindow, timesFor, violatesAbstention, } from './agenda/index.js';
@@ -42,5 +42,6 @@ export * from './scenarios/index.js';
 export * from './sim/index.js';
 export * from './skills/index.js';
 export * from './social/index.js';
+export { canonicalTickInputs } from './tick-input.js';
 export * from './types.js';
 export * from './will/index.js';

package/dist/longrun.d.ts

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

package/dist/longrun.js

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

package/dist/memory/memory.d.ts

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

package/dist/memory/memory.js

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

package/dist/person.js

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

package/dist/sim/longrun.d.ts

@@ -15,9 +15,9 @@
  * since a routine day writes only its own person. Births and arrivals are the host's (`birth`, `addPerson` in
  * `onDay`); a person added during the stretch starts on the next day.
  */
-import { type Routine, type RoutineDay } from '../longrun.ts';
+import { type RoutineDay, type RoutineSource } from '../longrun.ts';
 import type { SkillTransfer } from '../skills/index.ts';
-import type { Minute, Person, PersonId } from '../types.ts';
+import type { Minute, PersonId } from '../types.ts';
 import { type Community, type LifecourseOptions, type SimEvent } from './sim.ts';
 export declare const LIVE_COMMUNITY_DEFAULTS: {
     /** Upbringing time a day with the parents (engineering assumption: a few waking hours together). */
@@ -25,7 +25,7 @@ export declare const LIVE_COMMUNITY_DEFAULTS: {
 };
 export interface LiveCommunityOptions {
     /** Each living person's routine for a day (`day` is the day number being lived). */
-    routineFor(p: Person, day: number, c: Community): Routine;
+    routineFor: RoutineSource;
     /** At each dawn, before anyone's day: births, arrivals, routine changes. */
     onDay?(c: Community, day: number, at: Minute): void;
     /** Tell each death to everyone with a tie (default true; see `tellDeath`). */

package/dist/sim/longrun.js

@@ -70,7 +70,7 @@ export function liveCommunity(c, until, opts) {
                 tick(p, now);
             if (p.now !== now)
                 continue; // added mid-stretch with a later clock: joins when the day catches up
-            const r = routineDay(p, opts.routineFor(p, day, c), routineOpts);
+            const r = routineDay(p, opts.routineFor(p, day), routineOpts);
             if (r.episodes.length > 0 || r.onsets.length > 0 || r.stage || r.died) {
                 const list = days[p.id] ?? [];
                 list.push(r);

package/dist/social/impressions.d.ts

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

package/dist/social/impressions.js

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

package/dist/social/social.js

@@ -12,7 +12,7 @@
  * 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 { clamp, clamp01, clampSigned, cmpStr, decay, dlog, round, sigmoid } from '../core/index.js';
 import { MINUTES_PER_DAY, MINUTES_PER_YEAR } from '../types.js';
 import { careFor } from './groups.js';
 import { regardOf } from './impressions.js';
@@ -554,7 +554,7 @@ export function reputation(people, targetId, table = REPUTATION_TRAITS) {
                 continue;
             knows = true;
             const slot = traitSum[parsed.trait] ?? { sum: 0, n: 0 };
-            slot.sum += expit(b.logOdds);
+            slot.sum += sigmoid(b.logOdds);
             slot.n += 1;
             traitSum[parsed.trait] = slot;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adam0white/human-framework",
-  "version": "2.23.0",
+  "version": "3.0.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",