@adam0white/human-framework 2.7.0 → 2.9.0

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

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

@@ -125,6 +125,11 @@ export interface BodyPerceptionContext {
     fastingDays: number;
 }
 export type BodyParams = typeof BODY_DEFAULTS;
+/**
+ * Turn on fullness (2.8.0): consumption for a need already past its comfort level carries a small cost in choice
+ * (see the fullness SCOPE in `cognition/`). Idempotent; off by default so existing hosts replay exactly.
+ */
+export declare function enableFullness(p: Person): void;
 /** Turn on the fatigue store (2.6.0): accumulated exertion that recovers with rest and sleep. Idempotent. */
 export declare function enableFatigueStore(p: Person): void;
 export declare function createBody(init: PersonSpec['body'] | undefined, now: Minute): BodyState;

package/dist/body/body.js

@@ -238,9 +238,18 @@ export function sanitizeBody(b, now) {
         delete b.lastSleep;
     if (b.lastDowned !== undefined && !span(b.lastDowned))
         delete b.lastDowned;
+    if (b.fullness !== undefined && b.fullness !== true)
+        delete b.fullness;
     if (b.depletion !== undefined)
         b.depletion = typeof b.depletion === 'number' && Number.isFinite(b.depletion) ? clamp01(b.depletion) : 0;
 }
+/**
+ * Turn on fullness (2.8.0): consumption for a need already past its comfort level carries a small cost in choice
+ * (see the fullness SCOPE in `cognition/`). Idempotent; off by default so existing hosts replay exactly.
+ */
+export function enableFullness(p) {
+    p.body.fullness = true;
+}
 /** Turn on the fatigue store (2.6.0): accumulated exertion that recovers with rest and sleep. Idempotent. */
 export function enableFatigueStore(p) {
     if (p.body.depletion === undefined)

package/dist/cognition/cognition.d.ts

@@ -66,6 +66,16 @@ export declare const COGNITION_DEFAULTS: {
     commitmentInertiaFade: number;
     /** Social pull per partner on a joint offer: jointTrust × (relationship trust - 0.5). */
     jointTrust: number;
+    /**
+     * Staying with a partner who is going (2.8.0, `Affordance.alongside`): 'together:<id>' = togetherScale ×
+     * closeness. It does not satiate with belonging: being together now does not remove the pull of not being left.
+     */
+    togetherScale: number;
+    /**
+     * Fullness (2.8.0, opt-in `body.fullness`): 'full:<need>' = -fullnessScale × gain × over², over = how far the
+     * need's level is past its comfort threshold toward 1, for food, water and relief.
+     */
+    fullnessScale: number;
     /** Multiplier on standing advice terms relative to a live suggestion of the same strength (N9). */
     rememberedScale: number;
     /**
@@ -129,6 +139,8 @@ export interface DecideContext extends ConsiderContext {
     quiet?: boolean;
     /** A host command in force (1.6.0); passed to the will. */
     command?: Command;
+    /** Drop the running activity's inertia bonus (2.8.0); passed to the will. */
+    reconsider?: boolean;
 }
 export interface Decision {
     record: DecisionRecord;

package/dist/cognition/cognition.js

@@ -23,6 +23,17 @@
  * bias; and because losses are amplified too, a host must carry the benefit of paying a debt (a commitment,
  * an advertised `safety` gain) or paying looks only like a loss. The spec's "security need" is read as the
  * `safety` need: `security` is a value, not a need, and no need is added.
+ *
+ * SCOPE (2.8.0, both additive): an offer naming `alongside` partners (people already taking that course) gets one
+ * `together:<id>` term per known, living partner, `togetherScale` × closeness, without belonging satiation: the
+ * pull is not to be left behind, which stays when the pair is together and belonging is full (The Rope's resting
+ * partner, 2026-10-18 reproduction: belonging terms near 0.01 against inertia of 0.07-0.15). Shape only, after
+ * joint commitment and the sense of commitment in joint action (Gilbert 1990; Michael and Pacherie 2015; cited unaudited, research/empirical-models.md §6b); it does
+ * not model who leads, negotiation, or obligations between the partners. With opt-in `body.fullness`, an offer
+ * that advertises food, water or relief while that need is past its comfort threshold gets `full:<need>` =
+ * -fullnessScale × gain × over²: eating or drinking when full is mildly unpleasant (negative alliesthesia, unaudited citation, Cabanac
+ * 1971), so idle choice stops cycling short consumption at full hydration (The Rope, owner Kestrel export
+ * 2026-10-19). It models no bladder, sensory-specific satiety by food, or overeating for comfort.
  */
 import { emotionLevel, inBreak } from '../affect/index.js';
 import { agendaTermsWithGoalEstimates } from '../agenda/index.js';
@@ -32,12 +43,12 @@ import { clamp01, cmpStr, dexp, minuteOfDay, round } from '../core/index.js';
 import { habitEase, habitPull } from '../habits/index.js';
 import { expectedEffect } from '../memory/index.js';
 import { methodEvidence } from '../methods/index.js';
-import { urgencyOf } from '../needs/index.js';
+import { levelOf, needThreshold, urgencyOf } from '../needs/index.js';
 import { partneringTerms } from '../partnering/index.js';
 import { promptIn, promptingTerms } from '../promptings/index.js';
 import { bodyForecastTerm, receivedGoalRoute } from '../prospection/index.js';
 import { reviewTerms } from '../review/index.js';
-import { companionSteadiness, socialTerms } from '../social/index.js';
+import { closeness, companionSteadiness, isDeceasedTie, relationshipWith, socialTerms, } from '../social/index.js';
 import { PHYSIOLOGICAL_NEEDS, VALUE_KEYS } from '../types.js';
 import { adviceWeight, resolveChoice, safeUtility, standingAdvice, suggestionTargets, voicesIn, } from '../will/index.js';
 export const COGNITION_DEFAULTS = {
@@ -103,6 +114,16 @@ export const COGNITION_DEFAULTS = {
     commitmentInertiaFade: 0.15,
     /** Social pull per partner on a joint offer: jointTrust × (relationship trust - 0.5). */
     jointTrust: 0.6,
+    /**
+     * Staying with a partner who is going (2.8.0, `Affordance.alongside`): 'together:<id>' = togetherScale ×
+     * closeness. It does not satiate with belonging: being together now does not remove the pull of not being left.
+     */
+    togetherScale: 0.12,
+    /**
+     * Fullness (2.8.0, opt-in `body.fullness`): 'full:<need>' = -fullnessScale × gain × over², over = how far the
+     * need's level is past its comfort threshold toward 1, for food, water and relief.
+     */
+    fullnessScale: 0.03,
     // --- lane will+cognition ---
     /** Multiplier on standing advice terms relative to a live suggestion of the same strength (N9). */
     rememberedScale: 1,
@@ -226,16 +247,18 @@ export function materialValue(p, material, scarcity) {
     const sat = Math.sign(material) * (1 - dexp(-Math.abs(material) / scale));
     return K.materialWeight * sat * 2 * weight * (1 + K.scarcityMaterialGain * scarcity);
 }
+/** Needs whose consumption can overfill (2.8.0 fullness): what `body.consume` feeds. */
+const FULL_NEEDS = ['food', 'water', 'relief'];
 /** Score one option. Pure apart from reads; terms are rounded for stable snapshots. */
 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);
@@ -248,6 +271,19 @@ export function consider(p, aff, ctx) {
         const scarce = id === 'safety' ? 1 + K.scarcitySafetyGain * scarcity : 1;
         push(`need:${id}`, K.needScale * u * gain * success * scarce);
     }
+    // Fullness (2.8.0, opt-in): consuming for a need already past comfort is mildly unpleasant (alliesthesia).
+    if (p.body.fullness) {
+        for (const id of FULL_NEEDS) {
+            const gain = aff.advertises[id] ?? 0;
+            if (!(gain > 0))
+                continue;
+            const level = levelOf(ctx.needs, id);
+            const comfort = needThreshold(p, id);
+            const over = clamp01((level - comfort) / Math.max(1e-6, 1 - comfort));
+            if (over > 0)
+                push(`full:${id}`, -K.fullnessScale * Math.min(1, gain) * over * over);
+        }
+    }
     if (expected.samples > 0) {
         let relevance = 1;
         if (expected.valence > 0) {
@@ -324,6 +360,16 @@ export function consider(p, aff, ctx) {
     // Social pulls. Per-person emotion tendencies enter at the same scale as tag tendencies.
     for (const t of socialTerms(p, aff, social))
         push(t.source, K.socialScale * (t.value > 0 ? social.satiation * refractory() : 1) * t.value);
+    // Going with partners who are already taking this course (2.8.0).
+    if (aff.alongside) {
+        for (const id of [...new Set(aff.alongside)].sort()) {
+            if (id === p.id || !p.social.relationships.some((r) => r.otherId === id))
+                continue;
+            if (isDeceasedTie(relationshipWith(p, id)))
+                continue;
+            push(`together:${id}`, K.togetherScale * closeness(p, id));
+        }
+    }
     // Joint offers: whether I trust the partners to do their share.
     if (tags.includes('joint')) {
         for (const id of [...(aff.with ?? [])].sort()) {
@@ -413,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;
@@ -453,6 +499,8 @@ export function scoreAll(p, affordances, ctx) {
     };
     if (ctx.command)
         willCtx.command = ctx.command;
+    if (ctx.reconsider)
+        willCtx.reconsider = true;
     return { sorted, considered, willCtx };
 }
 /**
@@ -479,6 +527,8 @@ export function decide(p, affordances, ctx) {
     };
     if (res.suggestion)
         record.suggestion = res.suggestion;
+    if (ctx.reconsider)
+        record.reconsider = true;
     if (res.suggestions && (res.suggestions.length > 1 || ctx.suggestions !== undefined))
         record.suggestions = res.suggestions;
     const needDeltas = {};
@@ -491,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/index.d.ts

@@ -1,5 +1,5 @@
 /** Human Framework v1 public surface. */
-export declare const FRAMEWORK_VERSION = "2.7.0";
+export declare const FRAMEWORK_VERSION = "2.9.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';
@@ -30,7 +30,7 @@ export * from './partnering/index.ts';
 export * from './person.ts';
 export * from './promptings/index.ts';
 export type { ConsequenceEvidence } from './prospection/index.ts';
-export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, PROSPECTION_DEFAULTS, } from './prospection/index.ts';
+export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, forecastThresholds, PROSPECTION_DEFAULTS, } from './prospection/index.ts';
 export * from './restore.ts';
 export * from './review/index.ts';
 export * from './scenarios/index.ts';

package/dist/index.js

@@ -1,5 +1,5 @@
 /** Human Framework v1 public surface. */
-export const FRAMEWORK_VERSION = '2.7.0';
+export const FRAMEWORK_VERSION = '2.9.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';
@@ -26,7 +26,7 @@ export * from './needs/index.js';
 export * from './partnering/index.js';
 export * from './person.js';
 export * from './promptings/index.js';
-export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, PROSPECTION_DEFAULTS, } from './prospection/index.js';
+export { bodyForecastFor, bodyForecastTerm, consequenceEvidence, FORECAST_DEFAULTS, forecastLine, forecastThresholds, PROSPECTION_DEFAULTS, } from './prospection/index.js';
 export * from './restore.js';
 export * from './review/index.js';
 export * from './scenarios/index.js';

package/dist/migrate.js

@@ -58,6 +58,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.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',
+        apply: stamp,
+    },
     '2.6.0': {
         to: '2.7.0',
         note: 'the evening review (review) is optional and starts absent; existing hosts retain exact behavior',

package/dist/person.d.ts

@@ -103,6 +103,12 @@ export interface DecideOptions {
     necessity?: boolean;
     /** Why this decision was forced (recorded on the decision); defaults to the activity's pending interrupt. */
     interrupt?: string;
+    /**
+     * Reconsider on the merits (2.8.0): the running activity gets no inertia bonus in this decision, for a review the
+     * host forces because something changed (a partner leaving, a call). Promise inertia (`begin` with a promise) and
+     * every other term stay. Absent = the usual hysteresis.
+     */
+    reconsider?: boolean;
 }
 /**
  * How this person would answer a suggestion right now, without changing them or consuming randomness

package/dist/person.js

@@ -22,7 +22,7 @@
 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 { advanceBody, BODY_DEFAULTS, checkDowned, clearDowned, consume, createBody, downedAllows, enableFatigueStore, expose, injure, nextBodyThreshold, readBody, setDowned, sicken, skipBody, } from './body/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';
@@ -37,7 +37,7 @@ import { intentionFor, narrateDecision, voiceLine } from './narrate/index.js';
 import { advanceNeeds, createNeeds, levelOf, meanSatisfaction, readNeeds, satisfy, urgencyOf, } from './needs/index.js';
 import { widow } from './partnering/index.js';
 import { enablePromptings, nafsPatterns, notePromptings } from './promptings/index.js';
-import { bodyForecastFor, consumeConsequences, forecastLine, pruneConsequences, receiveConsequences, } from './prospection/index.js';
+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';
@@ -157,6 +157,8 @@ export function createPerson(spec) {
         enableSkillRetention(p);
     if (on?.fatigueStore)
         enableFatigueStore(p);
+    if (on?.fullness)
+        enableFullness(p);
     if (on?.promptings)
         enablePromptings(p, on.promptings);
     if (on?.review)
@@ -756,6 +758,8 @@ function decisionInputs(p, affordances, id, opts) {
     const cmd = opts.command ?? p.will.command;
     if (cmd)
         ctx.command = commandOf(cmd);
+    if (opts.reconsider)
+        ctx.reconsider = true;
     return { list, ctx };
 }
 /** The `Command` part of a command in force (without the will's bookkeeping). */
@@ -1430,5 +1434,5 @@ export function nafsReading(p) {
  */
 export function bodyForecast(p, aff) {
     const spans = bodyForecastFor(p, aff, lifeModifiers(p), fastingCtx(p));
-    return { spans, line: forecastLine(spans) };
+    return { spans, line: forecastLine(spans, forecastThresholds(aff)) };
 }

package/dist/promptings/promptings.d.ts

@@ -26,8 +26,17 @@ export declare const PROMPTINGS_DEFAULTS: {
  * keeps its practice and last use (the spec's `practice` only seeds new responses). Returns the state.
  */
 export declare function enablePromptings(p: Person, spec?: PromptingsSpec): PromptingsState;
-/** Practice of a response at `now`, after disuse decay. Pure. */
-export declare function practiceAt(r: PromptingResponse, now: Minute): Unit;
+/** Practice of a response at `now`, after disuse decay (`halfLifeDays` defaults to 60, as before 2.9.0). Pure. */
+export declare function practiceAt(r: PromptingResponse, now: Minute, halfLifeDays?: number): Unit;
+/** What a prompt offers a cue to match (2.9.0). */
+export interface PromptContext {
+    action: string;
+    tags?: readonly string[] | undefined;
+    /** The opposing term's source: 'norm:x' or 'goal:g'. */
+    opposedBy: string;
+}
+/** Whether a response's cue matches a prompt: its action, one of its tags, or the opposing norm or goal. Pure. */
+export declare function responseCueMatches(cue: string, at: PromptContext): boolean;
 /** Whether an option's terms carry a noticed prompt: its strongest pull and the opposing term. Pure. */
 export declare function promptIn(terms: readonly Term[], tags: readonly string[] | undefined): {
     source: string;
@@ -46,6 +55,8 @@ export interface PromptingSeen {
     opposedBy: string;
     /** Whether a turning-away term was applied. */
     turnApplied: boolean;
+    /** The offer's tags (2.9.0), for matching a response's cue. */
+    tags?: readonly string[] | undefined;
 }
 /** What `notePromptings` did, for the composite (the `fault` guilt goes through affect). */
 export interface PromptingsNoted {
@@ -68,10 +79,12 @@ export interface PromptingsReadingView {
     turned: number;
     passed: number;
     assented: number;
+    /** `cue` only when the response has one (2.9.0). */
     responses: {
         id: string;
         kind: PromptingResponseKind;
         practice: Unit;
+        cue?: string;
     }[];
     /** Vocabulary for the last few prompts, newest last. */
     lines: string[];

package/dist/promptings/promptings.js

@@ -8,7 +8,8 @@
  *
  * Detection reads an option's traced terms and changes none of them: the pull is the sum of positive `habit`,
  * `emotion:*`, `need:*` and `promptings:echo` terms (every positive term on an offer tagged `temptation`); it is a
- * prompt when the pull reaches `noticeAt` while a `norm:*` or `goal:*` term on the same option is negative.
+ * prompt when the pull reaches `noticeAt` while a `norm:*` or `goal:*` term on the same option is negative (goal
+ * terms are never negative, see `agendaTerms`, so in practice the opposition is a held norm).
  * Abstention windows are not detected (they veto, and carry no term). A person with a response gets one extra
  * term, `promptings:turn` = -turnMax × practice, on that option; it is bounded and absent at survival desperation,
  * so a desperate bodily need still wins (2:286). Each prompt is recorded once per decision point (a review that
@@ -16,6 +17,16 @@
  * or `passed` (not chosen, no response). Practice grows with diminishing gains once per decision point where the
  * response was used (more when it held; a vetoed option earns none, since the will blocked it), and halves over `practiceHalfLifeDays` of disuse.
  *
+ * Cued responses and host time (2.9.0, both opt-in): a response may carry a `cue` (an action, an offer tag, or the
+ * opposing norm or goal), for a phrase learned at one pull. At a prompt the person uses the most practised response
+ * whose cue matches it; when none matches, the most practised response without a cue. A cued response never serves
+ * a prompt it does not match, so a phrase learned at the alarm does not also turn the person from gossip (the
+ * literal "global best" fallback would bring that back). Each response used at a decision point gains once. Without
+ * cues every response is uncued and this is the 2.4.0 rule exactly. `practiceHalfLifeDays` in `enablePromptings`
+ * replaces the 60-day half-life for the whole person (a one-week game can let a phrase fade); it is one setting per
+ * person, not per response, because the need is the host's time scale and no source gives phrases different decay.
+ * Practice is decayed lazily from `lastUsedAt`, so a new half-life also applies to disuse already elapsed.
+ *
  * Held readings (reconciliation.md §5): `whisper`, `inclination`, `intrusion` and `none` give identical decisions
  * and differ only in the vocabulary of `promptingLine`. `fault` (the scrupulous reading, which both the tradition
  * and clinicians reject) adds a small guilt emotion at the prompt itself, from the person's own understanding;
@@ -71,7 +82,14 @@ export function enablePromptings(p, spec = {}) {
             continue;
         const held = prev?.responses.find((x) => x.id === r.id);
         const seed = Number.isFinite(r.practice) ? clamp01(r.practice) : 0.1;
-        responses.push(held ? { ...held, kind: r.kind } : { id: r.id, kind: r.kind, practice: seed, lastUsedAt: p.now });
+        const next = held
+            ? { ...held, kind: r.kind }
+            : { id: r.id, kind: r.kind, practice: seed, lastUsedAt: p.now };
+        // The spec's cue wins; a response re-enabled without one loses its old cue.
+        delete next.cue;
+        if (cueOk(r.cue))
+            next.cue = r.cue;
+        responses.push(next);
     }
     const state = {
         reading: spec.reading && READINGS.includes(spec.reading) ? spec.reading : 'none',
@@ -82,22 +100,44 @@ export function enablePromptings(p, spec = {}) {
     };
     if (spec.readingSource !== undefined)
         state.readingSource = spec.readingSource;
+    if (halfLifeOk(spec.practiceHalfLifeDays))
+        state.practiceHalfLifeDays = spec.practiceHalfLifeDays;
     p.promptings = state;
     return state;
 }
-/** Practice of a response at `now`, after disuse decay. Pure. */
-export function practiceAt(r, now) {
-    return clamp01(halve(r.practice, now - r.lastUsedAt, PROMPTINGS_DEFAULTS.practiceHalfLifeDays));
+const cueOk = (x) => typeof x === 'string' && x !== '' && x.length <= 200;
+const halfLifeOk = (x) => typeof x === 'number' && Number.isFinite(x) && x > 0 && x <= 36500;
+const halfLifeOf = (s) => s.practiceHalfLifeDays ?? PROMPTINGS_DEFAULTS.practiceHalfLifeDays;
+/** Practice of a response at `now`, after disuse decay (`halfLifeDays` defaults to 60, as before 2.9.0). Pure. */
+export function practiceAt(r, now, halfLifeDays = PROMPTINGS_DEFAULTS.practiceHalfLifeDays) {
+    return clamp01(halve(r.practice, now - r.lastUsedAt, halfLifeDays));
+}
+/** Whether a response's cue matches a prompt: its action, one of its tags, or the opposing norm or goal. Pure. */
+export function responseCueMatches(cue, at) {
+    if (cue === at.action || cue === at.opposedBy || (at.tags?.includes(cue) ?? false))
+        return true;
+    const colon = at.opposedBy.indexOf(':');
+    return colon >= 0 && cue === at.opposedBy.slice(colon + 1);
 }
-/** The response a person would use now: highest practice, ties by id. */
-function bestResponse(s, now) {
-    let best;
+/**
+ * The response a person would use now at prompt `at`: the most practised whose cue matches, else the most
+ * practised without a cue; ties by id. Without cues this is the most practised response (2.4.0).
+ */
+function bestResponse(s, now, at) {
+    let cued;
+    let plain;
+    const better = (b, r, x) => !b || x > b.practice || (x === b.practice && r.id < b.r.id);
+    const half = halfLifeOf(s);
     for (const r of s.responses) {
-        const practice = practiceAt(r, now);
-        if (!best || practice > best.practice || (practice === best.practice && r.id < best.r.id))
-            best = { r, practice };
+        const practice = practiceAt(r, now, half);
+        if (r.cue === undefined) {
+            if (better(plain, r, practice))
+                plain = { r, practice };
+        }
+        else if (responseCueMatches(r.cue, at) && better(cued, r, practice))
+            cued = { r, practice };
     }
-    return best;
+    return cued ?? plain;
 }
 const isPull = (source, tagged) => tagged ||
     source === 'habit' ||
@@ -145,10 +185,13 @@ export function promptingTerms(p, action, terms, tags, now, desperation) {
     }
     if (desperation >= PROMPTINGS_DEFAULTS.survivalDesperation)
         return out;
-    const best = bestResponse(s, now);
-    if (!best || best.practice <= 0)
+    if (s.responses.length === 0)
         return out;
-    if (!promptIn([...terms, ...out], tags))
+    const seen = promptIn([...terms, ...out], tags);
+    if (!seen)
+        return out;
+    const best = bestResponse(s, now, { action, tags, opposedBy: seen.opposedBy });
+    if (!best || best.practice <= 0)
         return out;
     const v = round(-PROMPTINGS_DEFAULTS.turnMax * best.practice);
     if (v < 0)
@@ -165,11 +208,12 @@ export function notePromptings(p, seen, chosenId, now) {
     if (!s || seen.length === 0)
         return noted;
     const D = PROMPTINGS_DEFAULTS;
-    const best = bestResponse(s, now);
-    // One practice gain per decision point, however many options carried a prompt: the larger one if any held.
-    let gain = 0;
+    // One practice gain per response per decision point, however many options it served: the larger one if any held.
+    // Responses are chosen before any practice moves, as `promptingTerms` chose them.
+    const gains = new Map();
     for (const x of seen) {
         const assented = x.affordanceId === chosenId;
+        const best = bestResponse(s, now, x);
         const used = x.turnApplied && best !== undefined;
         const rec = {
             at: now,
@@ -181,7 +225,7 @@ export function notePromptings(p, seen, chosenId, now) {
         };
         if (used && best) {
             rec.responseId = best.r.id;
-            gain = Math.max(gain, assented ? D.gainAttempt : D.gainTurned);
+            gains.set(best.r, Math.max(gains.get(best.r) ?? 0, assented ? D.gainAttempt : D.gainTurned));
         }
         s.recent.push(rec);
         noted.records.push(rec);
@@ -194,10 +238,12 @@ export function notePromptings(p, seen, chosenId, now) {
             }
         }
     }
-    if (best && gain > 0) {
-        const practice = practiceAt(best.r, now);
-        best.r.practice = round(clamp01(practice + gain * (1 - practice)));
-        best.r.lastUsedAt = now;
+    for (const [r, gain] of gains) {
+        if (gain <= 0)
+            continue;
+        const practice = practiceAt(r, now, halfLifeOf(s));
+        r.practice = round(clamp01(practice + gain * (1 - practice)));
+        r.lastUsedAt = now;
     }
     if (s.recent.length > D.maxRecent)
         s.recent.splice(0, s.recent.length - D.maxRecent);
@@ -249,7 +295,12 @@ export function promptingsReading(p, now = p.now) {
         turned: count('turned'),
         passed: count('passed'),
         assented: count('assented'),
-        responses: s.responses.map((r) => ({ id: r.id, kind: r.kind, practice: round(practiceAt(r, now)) })),
+        responses: s.responses.map((r) => ({
+            id: r.id,
+            kind: r.kind,
+            practice: round(practiceAt(r, now, halfLifeOf(s))),
+            ...(r.cue !== undefined ? { cue: r.cue } : {}),
+        })),
         lines: s.recent.slice(-5).map((r) => promptingLine(s.reading, r.outcome, kindOf(r.responseId))),
     };
     if (s.readingSource !== undefined)
@@ -298,12 +349,15 @@ export function sanitizePromptings(input, now) {
             continue;
         if (!minute(r.lastUsedAt) || r.lastUsedAt > now || responses.some((x) => x.id === r.id))
             continue;
-        responses.push({
+        const kept = {
             id: r.id,
             kind: r.kind,
             practice: r.practice,
             lastUsedAt: r.lastUsedAt,
-        });
+        };
+        if (cueOk(r.cue))
+            kept.cue = r.cue;
+        responses.push(kept);
     }
     const recent = [];
     for (const r of input.recent.slice(-D.maxRecent)) {
@@ -344,5 +398,7 @@ export function sanitizePromptings(input, now) {
     };
     if (str(input.readingSource))
         out.readingSource = input.readingSource;
+    if (halfLifeOk(input.practiceHalfLifeDays))
+        out.practiceHalfLifeDays = input.practiceHalfLifeDays;
     return out;
 }

package/dist/prospection/forecast.d.ts

@@ -16,7 +16,8 @@
  * open wound can read as being spent, and death in the forecast reads as fully spent. The term is absolute
  * (see `bodyForecastTerm`). It does not plan, search routes, schedule rests on the way or
  * predict injuries, and it is not a calibrated estimate of human anticipation. Every number is an engineering
- * default.
+ * default. 2.8.0: an offer may carry its own thresholds (`Affordance.forecastAt`, from The Glance's night
+ * keepers); offers without it read exactly as before.
  */
 import { type BodyForecastSpan, type BodyPerceptionContext } from '../body/index.ts';
 import type { Affordance, LifeModifiers, Person, Term } from '../types.ts';
@@ -31,6 +32,14 @@ export declare const FORECAST_DEFAULTS: {
     readonly maxSpans: 4;
     readonly maxMinutes: number;
 };
+/**
+ * The forecast thresholds for an offer (2.8.0): its `forecastAt` when it forms a valid pair, else the defaults.
+ * Pure.
+ */
+export declare function forecastThresholds(aff: Pick<Affordance, 'forecastAt'>): {
+    comfortAt: number;
+    spentAt: number;
+};
 /** The person's forecast for an offer: the act, then its follow-on spans. Empty without `followedBy`. Pure. */
 export declare function bodyForecastFor(p: Person, aff: Affordance, mods: LifeModifiers, perception?: BodyPerceptionContext): BodyForecastSpan[];
 /**
@@ -41,5 +50,8 @@ export declare function bodyForecastFor(p: Person, aff: Affordance, mods: LifeMo
  * too, which cancelled the very case the forecast exists for. Pure.
  */
 export declare function bodyForecastTerm(p: Person, aff: Affordance, mods: LifeModifiers, perception?: BodyPerceptionContext): Term | undefined;
-/** A first-person line for the forecast (narration only). */
-export declare function forecastLine(spans: readonly BodyForecastSpan[]): string;
+/** A first-person line for the forecast (narration only); `at` is the offer's thresholds (2.8.0, default as before). */
+export declare function forecastLine(spans: readonly BodyForecastSpan[], at?: {
+    comfortAt: number;
+    spentAt: number;
+}): string;

package/dist/prospection/forecast.js

@@ -16,7 +16,8 @@
  * open wound can read as being spent, and death in the forecast reads as fully spent. The term is absolute
  * (see `bodyForecastTerm`). It does not plan, search routes, schedule rests on the way or
  * predict injuries, and it is not a calibrated estimate of human anticipation. Every number is an engineering
- * default.
+ * default. 2.8.0: an offer may carry its own thresholds (`Affordance.forecastAt`, from The Glance's night
+ * keepers); offers without it read exactly as before.
  */
 import { BODY_DEFAULTS, forecastBody, } from '../body/index.js';
 import { clamp01, round } from '../core/index.js';
@@ -31,6 +32,21 @@ export const FORECAST_DEFAULTS = {
     maxSpans: 4,
     maxMinutes: 24 * 60,
 };
+/**
+ * The forecast thresholds for an offer (2.8.0): its `forecastAt` when it forms a valid pair, else the defaults.
+ * Pure.
+ */
+export function forecastThresholds(aff) {
+    const D = FORECAST_DEFAULTS;
+    const at = aff.forecastAt;
+    if (!at || typeof at !== 'object')
+        return { comfortAt: D.comfortAt, spentAt: D.spentAt };
+    const c = Number.isFinite(at.comfortAt) ? at.comfortAt : D.comfortAt;
+    const s = Number.isFinite(at.spentAt) ? at.spentAt : D.spentAt;
+    return c >= 0 && c < s && s <= 1
+        ? { comfortAt: c, spentAt: s }
+        : { comfortAt: D.comfortAt, spentAt: D.spentAt };
+}
 const smooth = (a, b, x) => {
     const t = clamp01((x - a) / (b - a));
     return t * t * (3 - 2 * t);
@@ -81,12 +97,13 @@ export function bodyForecastTerm(p, aff, mods, perception) {
     if (spans.length === 0)
         return undefined;
     const D = FORECAST_DEFAULTS;
+    const at = forecastThresholds(aff);
     const worst = Math.max(...spans.map((s) => s.worst));
-    const v = round(-D.forecastScale * smooth(D.comfortAt, D.spentAt, worst));
+    const v = round(-D.forecastScale * smooth(at.comfortAt, at.spentAt, worst));
     return v < 0 ? { source: 'forecast:body', value: v } : undefined;
 }
-/** A first-person line for the forecast (narration only). */
-export function forecastLine(spans) {
+/** A first-person line for the forecast (narration only); `at` is the offer's thresholds (2.8.0, default as before). */
+export function forecastLine(spans, at = FORECAST_DEFAULTS) {
     const after = spans.slice(1);
     if (after.length === 0)
         return '';
@@ -95,9 +112,9 @@ export function forecastLine(spans) {
         if (s.worst > w.worst)
             w = s;
     const what = { fatigue: 'spent', sleepiness: 'too sleepy', hunger: 'too hungry', thirst: 'too thirsty' }[w.worstOf];
-    if (w.worst >= FORECAST_DEFAULTS.spentAt)
+    if (w.worst >= at.spentAt)
         return `I can do it, but I'll be ${what} for ${w.label}.`;
-    if (w.worst >= FORECAST_DEFAULTS.comfortAt)
+    if (w.worst >= at.comfortAt)
         return `I can do it, though ${w.label} will be hard.`;
     return `I'll still have enough for ${w.label}.`;
 }

package/dist/review/review.js

@@ -3,7 +3,8 @@
  * the commitments the chronicle recorded as kept or broken since their last review, and for each one they broke
  * forms or renews a *resolve*: an if–then intention for that commitment's next occasion (Gollwitzer & Sheeran
  * 2006, research/reconciliation.md E1). While a matching commitment is pending, the resolve adds one bounded term,
- * `review:resolve` (each resolve counted once per option, the sum clamped to ±`resolveScale`), with the sign of the commitment's own term (toward a duty, away from an abstention's breaking
+ * `review:resolve` (each resolve counted once per option, the sum clamped to ±`resolveScale`; 2.9.0: the term's
+ * `ref` is the resolve's key when exactly one resolve weighed in), with the sign of the commitment's own term (toward a duty, away from an abstention's breaking
  * act), scaled by its strength. Strength grows with diminishing gains at each further lapse, relaxes once the
  * commitment is kept, and fades over `halfLifeDays` of disuse. Released and excused commitments (exemptions,
  * sleep, necessity) form no resolve: what was beyond capacity is not held against the person (2:286). The review
@@ -23,6 +24,11 @@
  * piety, repentance as a ruling (tawba conditions are not modelled), effects on sleep onset (Harvey's model, E6, is
  * not evidence enough), or that review improves outcomes beyond the borrowed if–then shape. It draws no randomness;
  * without `enableReview` nothing here runs and existing runs replay byte for byte.
+ *
+ * Host notes (2.9.0, docs only). `reviewLine` sets commitment labels into "I didn't keep …" and "Today I kept …",
+ * so a label should be a noun phrase ("my call to Mum", "the evening prayer"), not a verb phrase ("calling Mum").
+ * A recurring commitment lapses on any day its window passes unlived: a host that skips a day (no service, a
+ * fast-forward) should still live, or release, that day's occasions, or the review counts each one as missed.
  */
 import { clamp01, dexp, isObj, minuteOfDay, round } from '../core/index.js';
 export const REVIEW_DEFAULTS = {
@@ -72,6 +78,7 @@ export function reviewTerms(p, terms) {
         return [];
     let value = 0;
     const used = new Set();
+    let only;
     for (const t of terms) {
         const m = /^(commitment|abstain):(.+)$/.exec(t.source);
         if (!m || t.value === 0)
@@ -83,11 +90,18 @@ export function reviewTerms(p, terms) {
         if (!r || used.has(r.key))
             continue;
         used.add(r.key);
+        only = r.key;
         value += Math.sign(t.value) * REVIEW_DEFAULTS.resolveScale * r.strength;
     }
     const max = REVIEW_DEFAULTS.resolveScale;
     value = Math.max(-max, Math.min(max, value));
-    return value === 0 ? [] : [{ source: 'review:resolve', value: round(value) }];
+    if (value === 0)
+        return [];
+    const term = { source: 'review:resolve', value: round(value) };
+    // Name the resolve when exactly one weighed in (2.9.0, The Pass): "he turned from the jar, as he said he would".
+    if (used.size === 1 && only !== undefined)
+        term.ref = only;
+    return [term];
 }
 const fade = (s, days) => days <= 0 ? s : s * dexp((-Math.LN2 * days) / REVIEW_DEFAULTS.halfLifeDays);
 /**

package/dist/types.d.ts

@@ -91,6 +91,11 @@ export interface BodyState {
      * recovering with rest and faster with sleep. Raises felt fatigue and lowers capacity. Absent = no store.
      */
     depletion?: Unit;
+    /**
+     * Fullness (2.8.0, opt-in via `enableFullness`): when true, eating, drinking or taking relief for a need already
+     * past its comfort level costs a little (`full:<need>` term) instead of being free. Absent = no term.
+     */
+    fullness?: boolean;
     asleep: boolean;
     /** Minute the current sleep or wake period began. */
     since: Minute;
@@ -506,7 +511,10 @@ export interface Commitment {
     status: 'pending' | 'kept' | 'broken' | 'released';
     /** Optional recurrence: re-create after it closes (e.g. daily prayer windows). */
     recurEvery?: number;
-    /** Optional display name, e.g. 'Maghrib'; used in counter-offers ("after I pray Maghrib"). */
+    /**
+     * Optional display name, e.g. 'Maghrib'; used in counter-offers ("after I pray Maghrib") and in `reviewLine`
+     * ("I didn't keep my call to Mum"), so write it as a noun phrase.
+     */
     label?: string;
     /** For kind 'abstain': action ids whose completion inside the window breaks it. */
     violatedBy?: string[];
@@ -832,7 +840,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.7.0";
+export declare const ENGINE_VERSION = "2.9.0";
 /** A pregnancy carried by this person (host-driven; see `family/`). */
 export interface Pregnancy {
     fatherId: PersonId;
@@ -1067,6 +1075,12 @@ export interface Affordance {
     placeId?: EntityId;
     /** Other people taking part. */
     with?: PersonId[];
+    /**
+     * People already taking this course (2.8.0): a partner moving on, a companion leaving for home. Choosing it keeps
+     * the person with them, a `together:<id>` term from closeness (`cognition` SCOPE). Unlike `with`, it says who is
+     * going this way, not who would take part. Absent = no term, exactly as before.
+     */
+    alongside?: PersonId[];
     /** Minutes the activity occupies (including travel if the host folds it in). */
     duration: number;
     /** Physical exertion 0..1. */
@@ -1089,7 +1103,11 @@ export interface Affordance {
     /** Free tags: 'work', 'leisure', 'social', 'worship', 'risky', 'outdoors', ... */
     tags?: string[];
     norms?: NormTag[];
-    /** Commitment ids this would fulfil if completed. */
+    /**
+     * Commitment ids this would fulfil if completed. Listing two or more keeps every listed one that is pending and
+     * in window, and no other (2.9.0), not even an earlier-ending match by action; listing one keeps the
+     * earliest-ending match, explicit or by action, as before.
+     */
     fulfills?: string[];
     /** Goal ids this advances. */
     advances?: string[];
@@ -1105,6 +1123,16 @@ export interface Affordance {
      * spent during them. Absent = no forecast, exactly as before.
      */
     followedBy?: FollowOn[];
+    /**
+     * Readout thresholds for this offer's forecast (2.8.0), for hosts whose people live higher on a readout (a
+     * night keeper at sleepiness 0.7). `comfortAt` is where the forecast starts to weigh and `spentAt` where it
+     * weighs fully; either absent, or a pair that is not 0 ≤ comfortAt < spentAt ≤ 1, falls back to
+     * `FORECAST_DEFAULTS`. Ignored without `followedBy`.
+     */
+    forecastAt?: {
+        comfortAt?: Unit;
+        spentAt?: Unit;
+    };
     /** Set on a partner's mirror offer by the joint protocol in `sim/` (the proposal id). */
     jointId?: string;
     /** Material gain/cost in host units (e.g. coins). Valued via security/achievement/power values. */
@@ -1228,7 +1256,11 @@ export interface Outcome {
      * under protest and 1 otherwise. Lower quality lowers felt valence and therefore learned expectations.
      */
     quality?: Unit;
-    /** Commitment ids this outcome keeps (defaults to the activity's `Affordance.fulfills`). */
+    /**
+     * Commitment ids this outcome keeps (defaults to the activity's `Affordance.fulfills`). With two or more listed,
+     * every listed one pending and in window is kept, and no other (2.9.0); with one, one completion keeps the
+     * earliest-ending match.
+     */
     fulfills?: string[];
     /** Goal ids this outcome advances (defaults to the activity's `Affordance.advances`). */
     advances?: string[];
@@ -1312,9 +1344,16 @@ export interface Term {
      *  'goal:g1', 'habit', 'emotion:fear:risky' (emotion id, then the tag it acts through), 'effort', 'risk',
      *  'suggestion:player', 'social:p2', 'expectation', 'autonomy' (reactance to a pushing voice),
      *  'promptings:turn' (a practised turning-away), 'forecast:body' (expected
-     *  bodily state during `followedBy` spans), 'promptings:echo' (recurrence under the `fault` reading) */
+     *  bodily state during `followedBy` spans), 'promptings:echo' (recurrence under the `fault` reading),
+     *  'review:resolve' (a resolve from the evening review) */
     source: string;
     value: number;
+    /**
+     * What a generic source refers to (2.9.0), so `source` stays stable for hosts that match it exactly. Set on
+     * `review:resolve` to the resolve's key (`Resolve.key`) when exactly one resolve weighed in; absent when several
+     * did. Absent on every other term.
+     */
+    ref?: string;
 }
 export interface Considered {
     affordanceId: string;
@@ -1354,6 +1393,8 @@ export interface DecisionRecord {
     review?: boolean;
     /** Why this decision was brought forward, when `interrupt()` forced it (e.g. 'percept:injury'). */
     interrupt?: string;
+    /** Made with `DecideOptions.reconsider` (2.8.0): the running activity had no inertia bonus. */
+    reconsider?: true;
     /**
      * One resolution per voice that suggested something in this decision, in voice-id order (N1). `suggestion` is
      * the credited voice's resolution (same object), or the only one when a single voice spoke.
@@ -1402,6 +1443,8 @@ export interface PersonSpec {
         skillRetention?: boolean;
         /** Accumulated exertion (2.6.0): the same as `enableFatigueStore(p)` after creation. */
         fatigueStore?: boolean;
+        /** Fullness (2.8.0): the same as `enableFullness(p)` after creation. */
+        fullness?: boolean;
         /** Promptings and turning away (2.4.0): the same as `enablePromptings(p, spec)` after creation. */
         promptings?: PromptingsSpec;
         /** Evening self-review (2.7.0): the same as `enableReview(p, spec)` after creation. */
@@ -1430,6 +1473,13 @@ export interface PromptingResponse {
     /** Skill-like practice 0..1 as of `lastUsedAt`; it decays slowly with disuse. */
     practice: Unit;
     lastUsedAt: Minute;
+    /**
+     * What this response was learned for (2.9.0): an action, an offer tag, or the opposing norm or goal (`n1`,
+     * `norm:n1` or `goal:g1`). A cued response serves only prompts it matches; a response without a cue serves every
+     * prompt that no cued response matches. A norm or goal cue matches only the prompt's strongest opposing term.
+     * Cues longer than 200 characters are ignored.
+     */
+    cue?: string;
 }
 export interface PromptingRecord {
     at: Minute;
@@ -1457,6 +1507,8 @@ export interface PromptingsState {
     }>;
     /** Echo gained per prompt under `fault`. Default 0: the recurrence term is a host-set assumption (P3 contested). */
     echoRate: number;
+    /** Days over which disused practice halves (2.9.0, host-set); absent = `PROMPTINGS_DEFAULTS.practiceHalfLifeDays`. */
+    practiceHalfLifeDays?: number;
 }
 /**
  * How a person reviews a day (2.7.0, a held reading): `accounting` (muhasaba: name the lapse and resolve for its
@@ -1503,12 +1555,21 @@ export interface ReviewSpec {
 export interface PromptingsSpec {
     reading?: PromptingReading;
     readingSource?: string;
+    /** `cue` (2.9.0): what the response was learned for; see `PromptingResponse.cue`. */
     responses?: {
         id: string;
         kind: PromptingResponseKind;
         practice?: Unit;
+        cue?: string;
     }[];
     echoRate?: number;
+    /**
+     * Days over which disused practice halves (2.9.0), for hosts whose time runs short (a one-week game). Applies to
+     * every response of the person, including disuse since a response's last use. Absent = 60 days, as before.
+     * Read on every `enablePromptings` call: re-enabling without it returns the person to the default. Values outside
+     * (0, 36500] are ignored.
+     */
+    practiceHalfLifeDays?: number;
 }
 /** What the body is doing over an interval. */
 export interface BodyLoad {

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.7.0';
+export const ENGINE_VERSION = '2.9.0';

package/dist/will/will.d.ts

@@ -28,6 +28,9 @@
  * when the answer leaves the person doing what they are doing. A host command is a separate input that yields the
  * `commanded` verdict (see the commanded-control SCOPE on `commandOutcome`); `learnFromVoice` learns from assented,
  * complied and commanded activities, and `adoptVoiceTrust` moves trust toward a target without a suggestion.
+ * 2.8.0: `seedVoice` sets an authored starting trust after creation; `noteVoicePromise` learns from whether the
+ * voice kept its own promise; a decision with `reconsider` (WillContext) gives the running activity no inertia
+ * bonus, for a review the host forces because something changed (promise inertia, a cognition term, stays).
  */
 import type { Affordance, BodyReadout, Command, Considered, EntityId, Minute, Percept, Person, RefusalKind, Signed, StandingAdvice, Suggestion, SuggestionResolution, Unit, VoiceConflict, VoiceRelation, WillState } from '../types.ts';
 export declare const WILL_DEFAULTS: {
@@ -108,6 +111,14 @@ export declare const WILL_DEFAULTS: {
     maxCredited: number;
     /** Share of a tie's inertia bonus that remains when the activity is about to end. */
     inertiaFloor: number;
+    /**
+     * A voice's own promise (2.8.0, `noteVoicePromise`): a kept promise moves trust this share of the way toward 1, a
+     * broken one this share toward 0. Broken weighs more than kept (trust asymmetry, unaudited citations in research/empirical-models.md §6b: Slovic 1993; broken promises
+     * damage trust and kept ones restore it only gradually, Schweitzer, Hershey and Bradlow 2006: research/
+     * empirical-models.md §6b). Shape only; the numbers are engineering defaults equal to `trustGain`/`trustLoss`.
+     */
+    promiseKeptGain: number;
+    promiseBrokenLoss: number;
     /**
      * Insisting cannot override survival: at this desperation (same scale as conscience's necessity threshold),
      * or when the person's own choice is driven by a bodily need at `survivalNeedUrgency`, the verdict is
@@ -151,6 +162,8 @@ export interface WillContext {
     }[];
     /** A host command in force (1.6.0); see the command SCOPE on `commandOutcome`. */
     command?: Command;
+    /** No inertia bonus for the running activity in this decision (2.8.0, `DecideOptions.reconsider`). */
+    reconsider?: boolean;
 }
 /**
  * How a command fared in one decision. `holds`: the commanded option was chosen. Otherwise `ends` says whether
@@ -194,6 +207,32 @@ export declare function voiceOf(p: Person, voiceId: EntityId): VoiceRelation | u
  * records no history event and no credit, since no suggestion of that voice was weighed.
  */
 export declare function adoptVoiceTrust(p: Person, voiceId: EntityId, target: Unit, rate: Unit): VoiceRelation;
+/**
+ * Give `p` an authored starting trust in a voice after creation (2.8.0), marked `seeded` as `PersonSpec.voices`
+ * would (a seeded voice is never evicted to make room). A no-op returning the existing relation when the voice is
+ * already known, unless `replace` is set; replacing keeps counters and history and marks the voice seeded. Records
+ * no history event: no suggestion was weighed. A non-finite trust falls back to `defaultVoiceTrust`.
+ */
+export declare function seedVoice(p: Person, voiceId: EntityId, trust: Unit, opts?: {
+    replace?: boolean;
+}): VoiceRelation;
+/**
+ * SCOPE (a voice's own promise, 2.8.0): the voice said it would do something ("I will carry food up by 18:00") and
+ * the host reports whether it did. This is evidence about the voice's word, separate from how following its advice
+ * felt (`learnFromVoice`), so it needs no suggestion resolution and works for a request that was only deferred.
+ * Kept moves trust `promiseKeptGain` of the way toward 1, divided by 1 + n where n is the decayed count of kept
+ * promises already credited for the same action (key `promise:<action>` in `credited`), so a string of trivial
+ * promises cannot farm trust (these keys share `credited` and its `maxCredited` bound with advice credits, so a
+ * host with many promise actions can evict older entries of either kind, which only shortens a discount);
+ * broken moves it `promiseBrokenLoss` toward 0, undiscounted. History reasons are
+ * `promise-kept` and `promise-broken`. The voice is added if absent (bounded like any new voice). Does not model
+ * excuses, partial keeping, apology, or the size of what was promised; the host judges kept or broken.
+ */
+export declare function noteVoicePromise(p: Person, voiceId: EntityId, event: {
+    kept: boolean;
+    at?: Minute;
+    action?: string;
+}): VoiceRelation;
 /**
  * The next minute after `now` at which a pending commitment reaches `wakeCommitmentPressure`, the level at which a
  * sleeper may wake to serve it (the asleep veto lifts). The composite caps a sleeper's review there so a duty whose

package/dist/will/will.js

@@ -28,6 +28,9 @@
  * when the answer leaves the person doing what they are doing. A host command is a separate input that yields the
  * `commanded` verdict (see the commanded-control SCOPE on `commandOutcome`); `learnFromVoice` learns from assented,
  * complied and commanded activities, and `adoptVoiceTrust` moves trust toward a target without a suggestion.
+ * 2.8.0: `seedVoice` sets an authored starting trust after creation; `noteVoicePromise` learns from whether the
+ * voice kept its own promise; a decision with `reconsider` (WillContext) gives the running activity no inertia
+ * bonus, for a review the host forces because something changed (promise inertia, a cognition term, stays).
  */
 import { breakAllows, inBreak } from '../affect/index.js';
 import { commitmentPressure, isUnderWay, pressureReachedAt } from '../agenda/index.js';
@@ -114,6 +117,14 @@ export const WILL_DEFAULTS = {
     maxCredited: 8,
     /** Share of a tie's inertia bonus that remains when the activity is about to end. */
     inertiaFloor: 0.5,
+    /**
+     * A voice's own promise (2.8.0, `noteVoicePromise`): a kept promise moves trust this share of the way toward 1, a
+     * broken one this share toward 0. Broken weighs more than kept (trust asymmetry, unaudited citations in research/empirical-models.md §6b: Slovic 1993; broken promises
+     * damage trust and kept ones restore it only gradually, Schweitzer, Hershey and Bradlow 2006: research/
+     * empirical-models.md §6b). Shape only; the numbers are engineering defaults equal to `trustGain`/`trustLoss`.
+     */
+    promiseKeptGain: 0.1,
+    promiseBrokenLoss: 0.25,
     /**
      * Insisting cannot override survival: at this desperation (same scale as conscience's necessity threshold),
      * or when the person's own choice is driven by a bodily need at `survivalNeedUrgency`, the verdict is
@@ -224,6 +235,61 @@ export function adoptVoiceTrust(p, voiceId, target, rate) {
     v.trust = clamp01(v.trust + r * (t - v.trust));
     return v;
 }
+/**
+ * Give `p` an authored starting trust in a voice after creation (2.8.0), marked `seeded` as `PersonSpec.voices`
+ * would (a seeded voice is never evicted to make room). A no-op returning the existing relation when the voice is
+ * already known, unless `replace` is set; replacing keeps counters and history and marks the voice seeded. Records
+ * no history event: no suggestion was weighed. A non-finite trust falls back to `defaultVoiceTrust`.
+ */
+export function seedVoice(p, voiceId, trust, opts = {}) {
+    const existing = voiceOf(p, voiceId);
+    if (existing && !opts.replace)
+        return existing;
+    const v = existing ?? ensureVoice(p, voiceId);
+    v.trust = clamp01(Number.isFinite(trust) ? trust : WILL_DEFAULTS.defaultVoiceTrust);
+    v.seeded = true;
+    return v;
+}
+/**
+ * SCOPE (a voice's own promise, 2.8.0): the voice said it would do something ("I will carry food up by 18:00") and
+ * the host reports whether it did. This is evidence about the voice's word, separate from how following its advice
+ * felt (`learnFromVoice`), so it needs no suggestion resolution and works for a request that was only deferred.
+ * Kept moves trust `promiseKeptGain` of the way toward 1, divided by 1 + n where n is the decayed count of kept
+ * promises already credited for the same action (key `promise:<action>` in `credited`), so a string of trivial
+ * promises cannot farm trust (these keys share `credited` and its `maxCredited` bound with advice credits, so a
+ * host with many promise actions can evict older entries of either kind, which only shortens a discount);
+ * broken moves it `promiseBrokenLoss` toward 0, undiscounted. History reasons are
+ * `promise-kept` and `promise-broken`. The voice is added if absent (bounded like any new voice). Does not model
+ * excuses, partial keeping, apology, or the size of what was promised; the host judges kept or broken.
+ */
+export function noteVoicePromise(p, voiceId, event) {
+    const W = WILL_DEFAULTS;
+    const v = ensureVoice(p, voiceId);
+    const at = event.at !== undefined && Number.isFinite(event.at) ? event.at : p.now;
+    const before = v.trust;
+    if (event.kept) {
+        const key = `promise:${event.action ?? ''}`;
+        v.credited ??= [];
+        const list = v.credited;
+        const prior = list.find((c) => c.action === key);
+        const n = prior ? decay(prior.n, Math.max(0, at - prior.at), W.creditHalfLife) : 0;
+        v.trust = clamp01(v.trust + (W.promiseKeptGain * (1 - v.trust)) / (1 + n));
+        if (prior) {
+            prior.n = n + 1;
+            prior.at = at;
+        }
+        else
+            list.push({ action: key, n: 1, at });
+        if (list.length > W.maxCredited) {
+            list.sort((a, b) => b.at - a.at);
+            list.length = W.maxCredited;
+        }
+    }
+    else
+        v.trust = clamp01(v.trust - W.promiseBrokenLoss * v.trust);
+    noteTrust(v, v.trust - before, event.kept ? 'promise-kept' : 'promise-broken', at, event.action);
+    return v;
+}
 const finite = (x) => x === undefined || Number.isFinite(x);
 /** Host numbers the framework computes with must be finite; a NaN offer is vetoed, never chosen. */
 function wellFormed(aff) {
@@ -547,7 +613,7 @@ function evaluate(p, input, ctx, given, draw) {
     const live = considered.filter((c) => !c.vetoed);
     const current = p.activity;
     const score = (c) => {
-        if (!current || c.affordanceId !== current.affordanceId)
+        if (!current || c.affordanceId !== current.affordanceId || ctx.reconsider)
             return safeUtility(c.utility);
         const span = Math.max(1, current.endsAt - current.startedAt);
         const remaining = clamp01((current.endsAt - ctx.now) / span);

package/package.json

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