@adam0white/human-framework 2.8.0 → 2.9.1

package/dist/agenda/agenda.d.ts

@@ -108,13 +108,21 @@ export declare const violatesAbstention: (c: Commitment, action: string, start:
  * keeps by the same rule, so a pull never leads to an activity that cannot keep the commitment.
  */
 export declare const spanMeetsWindow: (c: Commitment, start: Minute, end: Minute) => boolean;
+/**
+ * The agenda's utility terms for one offer: `commitment:<id>` toward a pending commitment it serves,
+ * `abstain:<id>` against an act that would break an open abstention, and `goal:<id>` toward an active goal it
+ * advances. Goal terms are never negative, by design: a goal draws a person toward what advances it and is silent
+ * about everything else, so it cannot weigh against a temptation. A host that wants an act opposed links it to a
+ * held norm (`norms: violates`), an `abstain` commitment, or a commitment kept by the alternative.
+ */
 export declare function agendaTerms(p: Person, aff: Affordance, now: Minute): Term[];
 /**
  * Apply a finished activity. Only completed outcomes count. A completed violating action breaks every open
  * abstention whose window its span overlaps (returned as `broken`; the composite routes them like missed
  * commitments, with a breach when a norm is linked). One completion keeps the earliest-ending
  * matching pending commitment whose window the activity's span [startedAt, outcome.at] overlaps (see
- * `spanMeetsWindow`; `startedAt` defaults to `outcome.at`); goals advance by their listed amount.
+ * `spanMeetsWindow`; `startedAt` defaults to `outcome.at`), except that when `outcome.fulfills` lists two or more
+ * ids, every listed commitment that qualifies is kept and no other (2.9.0); goals advance by their listed amount.
  * Matching is by action (and target), or explicitly by `outcome.fulfills` / `outcome.advances` (the composite
  * defaults these to the activity's `Affordance.fulfills` / `advances`), mirroring `agendaTerms`.
  */

package/dist/agenda/agenda.js

@@ -489,7 +489,7 @@ function deadlinePressure(g, now) {
     return 1 + AGENDA_DEFAULTS.goalDeadlineBoost * clamp01((now - g.adoptedAt) / span);
 }
 /** Shared existing amount and urgency reader; no future knowledge is consulted here. @internal */
-export function goalValue(g, aff, now) {
+function goalValue(g, aff, now) {
     const amount = goalAmount(g, aff);
     return amount > 0
         ? g.importance * clamp01(amount * AGENDA_DEFAULTS.goalAmountGain) * deadlinePressure(g, now)
@@ -504,6 +504,13 @@ export function temporalGoalValue(p, g, aff, now, completion) {
             dpow(0.5, Math.max(0, completion - now) / g.temporal.halfLifeMinutes)
         : base;
 }
+/**
+ * The agenda's utility terms for one offer: `commitment:<id>` toward a pending commitment it serves,
+ * `abstain:<id>` against an act that would break an open abstention, and `goal:<id>` toward an active goal it
+ * advances. Goal terms are never negative, by design: a goal draws a person toward what advances it and is silent
+ * about everything else, so it cannot weigh against a temptation. A host that wants an act opposed links it to a
+ * held norm (`norms: violates`), an `abstain` commitment, or a commitment kept by the alternative.
+ */
 export function agendaTerms(p, aff, now) {
     return agendaTermsWithGoalEstimates(p, aff, now);
 }
@@ -599,7 +606,8 @@ function excuseUnderNecessity(p, c, at, catalog) {
  * abstention whose window its span overlaps (returned as `broken`; the composite routes them like missed
  * commitments, with a breach when a norm is linked). One completion keeps the earliest-ending
  * matching pending commitment whose window the activity's span [startedAt, outcome.at] overlaps (see
- * `spanMeetsWindow`; `startedAt` defaults to `outcome.at`); goals advance by their listed amount.
+ * `spanMeetsWindow`; `startedAt` defaults to `outcome.at`), except that when `outcome.fulfills` lists two or more
+ * ids, every listed commitment that qualifies is kept and no other (2.9.0); goals advance by their listed amount.
  * Matching is by action (and target), or explicitly by `outcome.fulfills` / `outcome.advances` (the composite
  * defaults these to the activity's `Affordance.fulfills` / `advances`), mirroring `agendaTerms`.
  */
@@ -627,21 +635,34 @@ export function onFinished(p, outcome, startedAt = outcome.at, opts = {}) {
         broken.push(c);
         oweFor(p, c, 'broken', outcome.at);
     }
-    let best;
-    for (const c of p.agenda.commitments) {
-        if (c.status !== 'pending' || c.kind === 'abstain')
-            continue;
-        const explicit = outcome.fulfills?.includes(c.id) ?? false;
-        if (!explicit && !matchesCommitment(c, outcome.action, outcome.targetId))
-            continue;
-        if (!spanMeetsWindow(c, Math.min(startedAt, outcome.at), outcome.at))
-            continue;
-        if (!best || c.until < best.until)
-            best = c;
+    // Commitments named explicitly (2.9.0): when `fulfills` lists two or more ids, every listed commitment that is
+    // eligible is kept and no other (one dinner keeps a word to a friend and the daily call). With one id listed, or
+    // none of several eligible, one completion keeps the earliest-ending match, explicit or by action, as before.
+    const eligible = (c) => c.status === 'pending' && c.kind !== 'abstain' && spanMeetsWindow(c, start, outcome.at);
+    const named = outcome.fulfills
+        ? p.agenda.commitments.filter((c) => (outcome.fulfills?.includes(c.id) ?? false) && eligible(c))
+        : [];
+    if (new Set(outcome.fulfills ?? []).size > 1 && named.length > 0) {
+        for (const c of named) {
+            c.status = 'kept';
+            kept.push(c);
+        }
     }
-    if (best) {
-        best.status = 'kept';
-        kept.push(best);
+    else {
+        let best;
+        for (const c of p.agenda.commitments) {
+            if (!eligible(c))
+                continue;
+            const explicit = outcome.fulfills?.includes(c.id) ?? false;
+            if (!explicit && !matchesCommitment(c, outcome.action, outcome.targetId))
+                continue;
+            if (!best || c.until < best.until)
+                best = c;
+        }
+        if (best) {
+            best.status = 'kept';
+            kept.push(best);
+        }
     }
     for (const g of p.agenda.goals) {
         if (g.status !== 'active')

package/dist/beliefs/beliefs.d.ts

@@ -39,7 +39,29 @@ export interface AttendContext {
 }
 /** Attention as limited capacity: keep the K most relevant percepts plus any that cannot be ignored. */
 export declare function attend(p: Person, percepts: Percept[], ctx: AttendContext): Percept[];
+/** Information-source trust, independent of relationship trust and advising-voice trust. */
 export declare function trustOf(p: Person, sourceId: EntityId): Unit;
+/**
+ * Set authored trust in an information source, clamped to 0..1. Writes only `memory.sourceTrust`;
+ * it does not change relationship trust or advising-voice trust. Nonfinite trust and self ids throw.
+ * Later `believe` (including testimony through `perceive`) reads this trust; `confirm` recalibrates it.
+ */
+export declare function seedSourceTrust(p: Person, sourceId: EntityId, trust: Unit): Unit;
+/**
+ * Set or replace an authored belief without applying source trust or recording an observation.
+ * `credence` is the probability that `value` holds, clamped to 0..1 and stored as bounded signed
+ * log-odds. `at` defaults to the person's current minute. Nonfinite credence or time throws.
+ * Only `memory.beliefs` changes, with ordinary belief eviction. An omitted source leaves no sources;
+ * a named source records its claim for later `confirm`, without changing any trust store now. The person's own id
+ * and 'self' are refused (they mark observation): use `confirm` for something the person saw.
+ * It does not apply reputation to relationships; use `seedTie` to author a relationship.
+ */
+export declare function seedBelief(p: Person, prop: string, spec: {
+    value: boolean;
+    credence: Unit;
+    at?: Minute;
+    source?: EntityId;
+}): Belief;
 /** Testimony or inference: add reliability-weighted log-odds evidence for (or against) `prop`. */
 export declare function believe(p: Person, prop: string, value: boolean, confidence: Unit, sourceId: EntityId, now: Minute): Belief;
 export declare function credence(p: Person, prop: string): Unit;

package/dist/beliefs/beliefs.js

@@ -8,6 +8,12 @@
  * gained, the trust-asymmetry finding). It does NOT model motivated reasoning, belief networks or
  * inference between propositions, source memory errors, or social consensus effects; parameters are
  * engineering defaults for game time scales.
+ *
+ * Three independent stores: `social.relationships[].trust` moves through authored ties, social events
+ * (including forgiveness), judged acts and reputation; `will.voices[].trust` moves through followed-advice
+ * outcomes, insisting, commands, `noteVoicePromise`, `seedVoice` and `adoptVoiceTrust` (also used by upbringing).
+ * This module owns `memory.sourceTrust`: `seedSourceTrust` authors it and `confirm` recalibrates it.
+ * `believe`, including testimony delivered by `perceive`, weights claims by source trust, read by `trustOf`.
  */
 import { clamp, clamp01, decay, dpow, expit, logit } from '../core/index.js';
 import { MINUTES_PER_DAY } from '../types.js';
@@ -97,11 +103,31 @@ export function attend(p, percepts, ctx) {
     }
     return out;
 }
+/** Information-source trust, independent of relationship trust and advising-voice trust. */
 export function trustOf(p, sourceId) {
     if (sourceId === p.id || sourceId === 'self')
         return BELIEF_DEFAULTS.selfTrust;
     return p.memory.sourceTrust[sourceId] ?? BELIEF_DEFAULTS.defaultTrust;
 }
+/**
+ * Set authored trust in an information source, clamped to 0..1. Writes only `memory.sourceTrust`;
+ * it does not change relationship trust or advising-voice trust. Nonfinite trust and self ids throw.
+ * Later `believe` (including testimony through `perceive`) reads this trust; `confirm` recalibrates it.
+ */
+export function seedSourceTrust(p, sourceId, trust) {
+    if (!Number.isFinite(trust))
+        throw new Error('human: source trust must be finite');
+    if (sourceId === p.id || sourceId === 'self')
+        throw new Error('human: self trust cannot be seeded');
+    const value = clamp01(trust);
+    Object.defineProperty(p.memory.sourceTrust, sourceId, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+    return value;
+}
 /** Testimony weight from trust: 0 at or below the floor, never negative, so low trust alone never flips a claim. @internal */
 export function testimonyWeight(trust) {
     const d = BELIEF_DEFAULTS;
@@ -141,6 +167,31 @@ function ensureBelief(p, prop, now) {
     }
     return b;
 }
+/**
+ * Set or replace an authored belief without applying source trust or recording an observation.
+ * `credence` is the probability that `value` holds, clamped to 0..1 and stored as bounded signed
+ * log-odds. `at` defaults to the person's current minute. Nonfinite credence or time throws.
+ * Only `memory.beliefs` changes, with ordinary belief eviction. An omitted source leaves no sources;
+ * a named source records its claim for later `confirm`, without changing any trust store now. The person's own id
+ * and 'self' are refused (they mark observation): use `confirm` for something the person saw.
+ * It does not apply reputation to relationships; use `seedTie` to author a relationship.
+ */
+export function seedBelief(p, prop, spec) {
+    const at = spec.at ?? p.now;
+    if (!Number.isFinite(spec.credence))
+        throw new Error('human: belief credence must be finite');
+    if (!Number.isFinite(at))
+        throw new Error('human: belief time must be finite');
+    // The person's own id and 'self' mark direct observation (`observedDiscount`, `confirm`); authoring is not seeing.
+    if (spec.source === p.id || spec.source === 'self')
+        throw new Error('human: an authored belief cannot name the person as its source; use confirm for an observation');
+    const b = ensureBelief(p, prop, at);
+    const limit = BELIEF_DEFAULTS.maxLogOdds;
+    b.logOdds = clamp((spec.value ? 1 : -1) * logit(clamp01(spec.credence)), -limit, limit);
+    b.updatedAt = at;
+    b.sources = spec.source === undefined ? [] : [{ id: spec.source, value: spec.value }];
+    return b;
+}
 /** Testimony or inference: add reliability-weighted log-odds evidence for (or against) `prop`. */
 export function believe(p, prop, value, confidence, sourceId, now) {
     const d = BELIEF_DEFAULTS;

package/dist/cognition/cognition.js

@@ -225,7 +225,7 @@ export function socialContext(ctx) {
     };
 }
 /** Same perceived-body effort estimate for actual offers and received successors. @internal */
-export function effortValue(p, aff, ctx) {
+function effortValue(p, aff, ctx) {
     const K = COGNITION_DEFAULTS;
     const per = ctx.body.perceived;
     const effort = clamp01(aff.effort);
@@ -239,7 +239,7 @@ export function effortValue(p, aff, ctx) {
     return -K.effortScale * effortCost;
 }
 /** Same material valuation for actual offers and received successor costs. @internal */
-export function materialValue(p, material, scarcity) {
+function materialValue(p, material, scarcity) {
     const K = COGNITION_DEFAULTS;
     const v = p.values;
     const weight = (v.security + v.achievement + v.power) / 3;
@@ -254,11 +254,11 @@ export function consider(p, aff, ctx) {
     const K = COGNITION_DEFAULTS;
     const scarcity = clamp01(Number.isFinite(ctx.scarcity) ? ctx.scarcity : 0);
     const terms = [];
-    const push = (source, value) => {
+    const push = (source, value, ref) => {
         const v = round(value);
         // A non-finite term (bad host number) is dropped; the will vetoes the offer as invalid.
         if (v !== 0 && Number.isFinite(v))
-            terms.push({ source, value: v });
+            terms.push(ref === undefined ? { source, value: v } : { source, value: v, ref });
     };
     // Needs: urgency × believed gain × believed success.
     const expected = expectedEffect(p, aff);
@@ -459,7 +459,7 @@ export function consider(p, aff, ctx) {
     // Evening review (2.7.0, opt-in): a resolve formed after a lapse leans on that commitment's own term.
     if (p.review)
         for (const t of reviewTerms(p, terms))
-            push(t.source, t.value);
+            push(t.source, t.value, t.ref);
     let utility = 0;
     for (const t of terms)
         utility += t.value;
@@ -541,12 +541,14 @@ export function decide(p, affordances, ctx) {
         const prompts = [];
         const tagsOf = new Map(sorted.map((a) => [a.id, a.tags]));
         for (const c of res.considered) {
-            const seen = promptIn(c.terms, tagsOf.get(c.affordanceId));
+            const tags = tagsOf.get(c.affordanceId);
+            const seen = promptIn(c.terms, tags);
             if (seen)
                 prompts.push({
                     affordanceId: c.affordanceId,
                     action: c.action,
                     ...seen,
+                    ...(tags !== undefined ? { tags } : {}),
                     // A vetoed option was not turned from: the will blocked it, so the response earns no practice.
                     turnApplied: c.vetoed === undefined && c.terms.some((t) => t.source === 'promptings:turn'),
                 });

package/dist/conscience/conscience.d.ts

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

package/dist/conscience/conscience.js

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

package/dist/core/math.d.ts

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

package/dist/core/math.js

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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-/** Human Framework v1 public surface. */
-export declare const FRAMEWORK_VERSION = "2.8.0";
+/** Human Framework public surface. */
+export declare const FRAMEWORK_VERSION = "2.9.1";
 export type { CrisisEvent, PracticeKind } from './affect/index.ts';
 export { AFFECT_DEFAULTS, actionTendencies, advanceAffect, appraise, breakAllows, breakBehaviour, breakHazard, CRISIS_DEFAULTS, checkCrisis, createAffect, easeBreak, emotionLevel, enableBreaks, feel, inBreak, readAffect, regulate, release as releaseEmotion, skipCrisis, strain, tendencyEmotions, } from './affect/index.ts';
 export type { GoalTemplate, PrayerCalendar, PrayerSchedule, PrayerTimes, Retimer, } from './agenda/index.ts';
@@ -31,7 +31,7 @@ export * from './person.ts';
 export * from './promptings/index.ts';
 export type { ConsequenceEvidence } from './prospection/index.ts';
 export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, forecastThresholds, PROSPECTION_DEFAULTS, } from './prospection/index.ts';
-export * from './restore.ts';
+export { fingerprint, restore, snapshot } from './restore.ts';
 export * from './review/index.ts';
 export * from './scenarios/index.ts';
 export * from './sim/index.ts';

package/dist/index.js

@@ -1,5 +1,5 @@
-/** Human Framework v1 public surface. */
-export const FRAMEWORK_VERSION = '2.8.0';
+/** Human Framework public surface. */
+export const FRAMEWORK_VERSION = '2.9.1';
 export { AFFECT_DEFAULTS, actionTendencies, advanceAffect, appraise, breakAllows, breakBehaviour, breakHazard, CRISIS_DEFAULTS, checkCrisis, createAffect, easeBreak, emotionLevel, enableBreaks, feel, inBreak, readAffect, regulate, release as releaseEmotion, skipCrisis, strain, tendencyEmotions, } from './affect/index.js';
 // `agenda.release` collides with `affect.release`; the agenda one is re-exported under a clearer name.
 export { AGENDA_DEFAULTS, abandonGoal, adoptGoal, advanceAgenda, agendaTerms, applyExemptions, CARE_DEFAULTS, calendarRetimer, careDuty, commitmentPressure, createAgenda, DEFAULT_PRAYER_TIMES, EID_PRAYER_IMPORTANCE, EXEMPTION_DEFAULTS, eidPrayer, eidWindow, fastWindow, iftarWindow, inMakruhTime, isUnderWay, MAKRUH_DEFAULTS, makruhWindows, missedExcuse, onFinished, owedMakeUps, PRAYER_IMPORTANCE, PURPOSE_DEFAULTS, prayerWindows, pressureReachedAt, promise, proposeGoals, RAMADAN_DEFAULTS, ramadanFast, ramadanMeals, release as releaseCommitment, retimeCommitments, revisePurposes, scheduleMakeUp, spanMeetsWindow, suhoorWindow, timesFor, violatesAbstention, } from './agenda/index.js';
@@ -27,7 +27,7 @@ export * from './partnering/index.js';
 export * from './person.js';
 export * from './promptings/index.js';
 export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, forecastThresholds, PROSPECTION_DEFAULTS, } from './prospection/index.js';
-export * from './restore.js';
+export { fingerprint, restore, snapshot } from './restore.js';
 export * from './review/index.js';
 export * from './scenarios/index.js';
 export * from './sim/index.js';

package/dist/migrate.js

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