@adam0white/human-framework 2.15.0 → 2.17.0

package/dist/persona-calendar.js

@@ -0,0 +1,411 @@
+/**
+ * SCOPE: opt-in calendar transport between declared chapter clocks. Hosts map every retained reference and
+ * supply identical source-backed norm meanings. Carries pending/continuing duties, owed records and their
+ * receipts, held understanding and lapse timestamps. Does not choose dates, waive debt, simulate travel,
+ * create rulings, migrate activities/projects or change the v1 persona path. Neither input is mutated.
+ */
+import { isContinuingCommitment } from './agenda/agenda.js';
+import { createPerson } from './person.js';
+import { admitPersona, projectPersona, validatePersonaProjection, } from './persona.js';
+import { restore, snapshot } from './restore.js';
+import { MAX_MINUTE, } from './types.js';
+function fail(message) {
+    throw new Error(`persona calendar: ${message}`);
+}
+function object(x) {
+    if (!x || typeof x !== 'object' || Array.isArray(x))
+        fail('expected object');
+}
+function keys(x, allowed, required = allowed) {
+    object(x);
+    if (Object.keys(x).some((k) => !allowed.includes(k)) || required.some((k) => !Object.hasOwn(x, k)))
+        fail('unsupported or missing field');
+}
+function text(x) {
+    if (typeof x !== 'string' ||
+        !x.length ||
+        x.length > 1024 ||
+        ['__proto__', 'constructor', 'prototype'].includes(x))
+        fail('invalid reference');
+}
+function num(x, min = -MAX_MINUTE, max = MAX_MINUTE) {
+    if (typeof x !== 'number' || !Number.isFinite(x) || x < min || x > max)
+        fail('invalid timestamp/number');
+}
+function list(x) {
+    if (!Array.isArray(x) || x.length > 128)
+        fail('invalid bounded list');
+}
+function strings(x) {
+    list(x);
+    for (const v of x)
+        text(v);
+}
+function same(a, b) {
+    const canonical = (x) => JSON.stringify(x, (_k, v) => v && typeof v === 'object' && !Array.isArray(v)
+        ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
+        : v);
+    return canonical(a) === canonical(b);
+}
+function choice(value, allowed) {
+    return typeof value === 'string' && allowed.includes(value);
+}
+const standings = ['obligatory', 'recommended', 'permitted', 'disliked', 'forbidden'];
+const kinds = ['promise', 'duty', 'appointment', 'worship', 'job', 'abstain'];
+const reasons = ['illness', 'travel', 'necessity', 'sleep', 'unconscious', 'missed', 'broken'];
+function sources(x) {
+    list(x);
+    if (!x.length)
+        fail('norm provenance required');
+    for (const v of x) {
+        keys(v, ['kind', 'ref']);
+        text(v.ref);
+        if (!choice(v.kind, ['revelation', 'hadith', 'interpretation', 'empirical', 'assumption']))
+            fail('invalid provenance');
+    }
+}
+function catalog(x) {
+    list(x);
+    const ids = new Set();
+    for (const v of x) {
+        keys(v, ['id', 'label', 'standing', 'sources', 'exemptions'], ['id', 'label', 'standing', 'sources']);
+        text(v.id);
+        text(v.label);
+        sources(v.sources);
+        if (ids.has(v.id) || !choice(v.standing, standings))
+            fail('invalid norm catalog');
+        ids.add(v.id);
+        if (v.exemptions !== undefined) {
+            list(v.exemptions);
+            const conditions = new Set();
+            for (const e of v.exemptions) {
+                keys(e, ['when', 'makeUp', 'sources']);
+                if (!choice(e.when, ['illness', 'travel']) || typeof e.makeUp !== 'boolean' || conditions.has(e.when))
+                    fail('invalid exemption');
+                conditions.add(e.when);
+                sources(e.sources);
+            }
+        }
+    }
+}
+function calendarCommitment(x) {
+    keys(x, [
+        'id',
+        'kind',
+        'toId',
+        'actions',
+        'targetId',
+        'from',
+        'until',
+        'normId',
+        'importance',
+        'status',
+        'recurEvery',
+        'label',
+        'violatedBy',
+        'firm',
+        'exemptWhen',
+        'exempt',
+        'makeUpOf',
+        'chain',
+        'recurUntil',
+    ], ['id', 'kind', 'actions', 'from', 'until', 'importance', 'status']);
+    for (const field of ['id', 'toId', 'targetId', 'normId', 'label', 'makeUpOf', 'chain'])
+        if (x[field] !== undefined)
+            text(x[field]);
+    if (!choice(x.kind, kinds) || !choice(x.status, ['pending', 'kept', 'broken', 'released']))
+        fail('invalid commitment');
+    strings(x.actions);
+    num(x.from);
+    num(x.until);
+    num(x.importance, 0, 1);
+    if (x.until < x.from || (x.kind !== 'abstain' && !x.actions.length))
+        fail('invalid commitment window/actions');
+    if (x.violatedBy !== undefined)
+        strings(x.violatedBy);
+    if (x.recurEvery !== undefined)
+        num(x.recurEvery, 1);
+    if (x.recurUntil !== undefined)
+        num(x.recurUntil);
+    if (x.firm !== undefined && x.firm !== true)
+        fail('invalid firm');
+    if (x.exemptWhen !== undefined) {
+        strings(x.exemptWhen);
+        if (x.exemptWhen.some((v) => !['illness', 'travel'].includes(v)))
+            fail('invalid exemption condition');
+    }
+    if (x.exempt !== undefined) {
+        keys(x.exempt, ['reason', 'at']);
+        num(x.exempt.at);
+        if (!choice(x.exempt.reason, ['illness', 'travel', 'necessity', 'sleep', 'unconscious']))
+            fail('invalid exemption reason');
+    }
+}
+function owed(x) {
+    keys(x, ['ofId', 'normId', 'kind', 'violatedBy', 'actions', 'reason', 'lapseSince', 'at', 'label', 'scheduledAs'], ['ofId', 'kind', 'actions', 'reason', 'at']);
+    for (const field of ['ofId', 'normId', 'label', 'scheduledAs'])
+        if (x[field] !== undefined)
+            text(x[field]);
+    if (!choice(x.kind, kinds) || !choice(x.reason, reasons))
+        fail('invalid owed record');
+    strings(x.actions);
+    num(x.at);
+    if (x.violatedBy !== undefined)
+        strings(x.violatedBy);
+    if (x.lapseSince !== undefined)
+        num(x.lapseSince);
+}
+function boundedJson(input) {
+    const pending = [{ value: input, depth: 0 }];
+    const seen = new Set();
+    let nodes = 0;
+    while (pending.length) {
+        const item = pending.pop();
+        if (!item)
+            break;
+        if (++nodes > 16384 || item.depth > 16)
+            fail('JSON bounds exceeded');
+        const { value, depth } = item;
+        if (value === null || typeof value === 'boolean')
+            continue;
+        if (typeof value === 'string') {
+            if (value.length > 1024)
+                fail('text bounds exceeded');
+            continue;
+        }
+        if (typeof value === 'number') {
+            num(value);
+            continue;
+        }
+        if (typeof value !== 'object' || seen.has(value))
+            fail('non-JSON or cyclic input');
+        seen.add(value);
+        if (!Array.isArray(value) &&
+            Object.getPrototypeOf(value) !== Object.prototype &&
+            Object.getPrototypeOf(value) !== null)
+            fail('non-JSON object');
+        for (const [key, child] of Object.entries(value)) {
+            if (['__proto__', 'constructor', 'prototype'].includes(key))
+                fail('unsafe reference');
+            pending.push({ value: child, depth: depth + 1 });
+        }
+    }
+}
+/** Validate portable calendar data strictly; no restore defaults or debt settlement. */
+export function validateCalendarPersona(input) {
+    boundedJson(input);
+    keys(input, ['format', 'person', 'calendar']);
+    if (input.format !== 'hf-persona-calendar/1')
+        fail('unsupported format');
+    const person = validatePersonaProjection(input.person);
+    if (person.commitments.length)
+        fail('calendar owns portable commitments');
+    const c = input.calendar;
+    keys(c, ['offset', 'commitments', 'owed', 'lapse', 'heldNorms', 'norms']);
+    num(c.offset);
+    list(c.commitments);
+    for (const v of c.commitments)
+        calendarCommitment(v);
+    list(c.owed);
+    for (const v of c.owed)
+        owed(v);
+    const commitments = c.commitments;
+    const debts = c.owed;
+    if (new Set(commitments.map((v) => v.id)).size !== c.commitments.length ||
+        new Set(debts.map((v) => v.ofId)).size !== c.owed.length)
+        fail('duplicate obligation id');
+    if (c.lapse !== null) {
+        keys(c.lapse, ['since', 'missed']);
+        num(c.lapse.since);
+        num(c.lapse.missed, 0);
+        if (!Number.isInteger(c.lapse.missed))
+            fail('invalid lapse');
+    }
+    catalog(c.norms);
+    list(c.heldNorms);
+    for (const v of c.heldNorms) {
+        keys(v, ['normId', 'standing', 'conviction']);
+        text(v.normId);
+        num(v.conviction, 0, 1);
+        if (!choice(v.standing, standings))
+            fail('invalid held understanding');
+    }
+    const heldNorms = c.heldNorms;
+    if (new Set(heldNorms.map((v) => v.normId)).size !== c.heldNorms.length)
+        fail('duplicate held norm');
+    const normIds = new Set(c.norms.map((n) => n.id));
+    for (const record of [...commitments, ...debts, ...heldNorms])
+        if (record.normId !== undefined && !normIds.has(record.normId))
+            fail('missing norm definition');
+    const arrival = person.source.now + c.offset;
+    num(arrival);
+    for (const debt of debts) {
+        const scheduled = commitments.find((v) => v.id === debt.scheduledAs);
+        // Pruned source history stays absent and unresolved; never invent a paid receipt.
+        if (scheduled && scheduled.makeUpOf !== debt.ofId)
+            fail('conflicting scheduled make-up reference');
+        if (debt.at > arrival || (debt.lapseSince !== undefined && debt.lapseSince > arrival))
+            fail('future owed evidence');
+    }
+    if (c.lapse !== null && c.lapse.since > arrival)
+        fail('future lapse evidence');
+    for (const duty of commitments)
+        if (duty.exempt && duty.exempt.at > arrival)
+            fail('future exemption evidence');
+    // Match the engine's owning-slice bounds exactly. A rejected import cannot be silently truncated.
+    const probe = createPerson({
+        id: 'calendar-validation',
+        name: 'validation',
+        seed: 0,
+        bornAt: 0,
+        sex: 'female',
+    });
+    probe.agenda.commitments = structuredClone(c.commitments);
+    probe.agenda.owed = structuredClone(c.owed);
+    if (c.lapse !== null)
+        probe.agenda.lapse = structuredClone(c.lapse);
+    probe.conscience.norms = structuredClone(c.heldNorms);
+    const checked = restore(probe);
+    if (!same(probe.agenda, checked.agenda) || !same(probe.conscience.norms, checked.conscience.norms))
+        fail('calendar exceeds supported engine bounds');
+    return { format: 'hf-persona-calendar/1', person, calendar: structuredClone(c) };
+}
+/** Source declares a complete semantic ID map, a clock offset and source-backed norm catalog. */
+export function projectCalendarPersona(source, mapping) {
+    const p = restore(snapshot(source));
+    const m = mapping.calendar;
+    keys(m, ['version', 'offset', 'references', 'sourceNorms']);
+    if (m.version !== 'hf-persona-calendar-map/1')
+        fail('unsupported calendar mapping');
+    num(m.offset);
+    keys(m.references, ['commitments', 'chains', 'actions', 'entities', 'norms']);
+    for (const record of Object.values(m.references)) {
+        object(record);
+        if (Object.keys(record).length > 512)
+            fail('too many references');
+        for (const [key, value] of Object.entries(record)) {
+            text(key);
+            text(value);
+        }
+        if (new Set(Object.values(record)).size !== Object.values(record).length)
+            fail('duplicate mapped reference');
+    }
+    catalog(m.sourceNorms);
+    const ref = (kind, id) => {
+        const value = Object.hasOwn(m.references[kind], id) ? m.references[kind][id] : undefined;
+        if (value === undefined)
+            fail(`unmapped ${kind} reference ${id}`);
+        return value;
+    };
+    const shift = (at) => {
+        const value = at + m.offset;
+        num(value);
+        return value;
+    };
+    const debts = p.agenda.owed ?? [];
+    const selected = p.agenda.commitments.filter((c) => isContinuingCommitment(p.agenda, c) || debts.some((d) => d.ofId === c.id || d.scheduledAs === c.id));
+    const commitments = selected.map((old) => {
+        const c = structuredClone(old);
+        c.id = ref('commitments', old.id);
+        c.actions = old.actions.map((a) => ref('actions', a));
+        c.from = shift(old.from);
+        c.until = shift(old.until);
+        for (const [field, kind] of [
+            ['toId', 'entities'],
+            ['targetId', 'entities'],
+            ['normId', 'norms'],
+            ['chain', 'chains'],
+            ['makeUpOf', 'commitments'],
+        ]) {
+            const value = old[field];
+            if (value !== undefined)
+                c[field] = ref(kind, value);
+        }
+        if (old.violatedBy !== undefined)
+            c.violatedBy = old.violatedBy.map((a) => ref('actions', a));
+        if (old.recurUntil !== undefined)
+            c.recurUntil = shift(old.recurUntil);
+        if (c.exempt !== undefined)
+            c.exempt.at = shift(c.exempt.at);
+        return c;
+    });
+    const mappedOwed = debts.map((old) => {
+        const d = structuredClone(old);
+        d.ofId = ref('commitments', old.ofId);
+        d.at = shift(old.at);
+        d.actions = old.actions.map((a) => ref('actions', a));
+        if (old.normId !== undefined)
+            d.normId = ref('norms', old.normId);
+        if (old.scheduledAs !== undefined)
+            d.scheduledAs = ref('commitments', old.scheduledAs);
+        if (old.violatedBy !== undefined)
+            d.violatedBy = old.violatedBy.map((a) => ref('actions', a));
+        if (old.lapseSince !== undefined)
+            d.lapseSince = shift(old.lapseSince);
+        return d;
+    });
+    const heldNorms = p.conscience.norms.map((n) => ({ ...n, normId: ref('norms', n.normId) }));
+    const norms = m.sourceNorms.map((n) => ({ ...structuredClone(n), id: ref('norms', n.id) }));
+    const stripped = snapshot(p);
+    stripped.agenda.commitments = [];
+    delete stripped.agenda.owed;
+    delete stripped.agenda.lapse;
+    const person = projectPersona(stripped, {
+        version: mapping.version,
+        skills: mapping.skills,
+        ...(mapping.episodes === undefined ? {} : { episodes: mapping.episodes }),
+    });
+    person.limitations = person.limitations.map((line) => line === 'source habits/methods/beliefs/social/conscience omitted; target authored state'
+        ? 'source habits/methods/beliefs/social and conscience breaches omitted; target authored state; held norms transported'
+        : line);
+    for (const debt of mappedOwed) {
+        if (debt.scheduledAs !== undefined && !commitments.some((c) => c.id === debt.scheduledAs))
+            person.limitations.push(`owed:${debt.ofId}:scheduled history absent; payment unproven`);
+    }
+    return validateCalendarPersona({
+        format: 'hf-persona-calendar/1',
+        person,
+        calendar: {
+            offset: m.offset,
+            commitments,
+            owed: mappedOwed,
+            lapse: p.agenda.lapse ? { ...p.agenda.lapse, since: shift(p.agenda.lapse.since) } : null,
+            heldNorms,
+            norms,
+        },
+    });
+}
+/** Receiver declares identical norm meanings and a clean calendar at the exact declared opening clock. */
+export function admitCalendarPersona(input, target, policy) {
+    const projection = validateCalendarPersona(input);
+    catalog(policy.targetNorms);
+    const c = projection.calendar;
+    if (target.now - projection.person.source.now !== c.offset)
+        fail('calendar clock offset conflict');
+    const ordered = (ns) => [...ns].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    if (!same(ordered(c.norms), ordered(policy.targetNorms)))
+        fail('norm semantic compatibility conflict');
+    if (target.agenda.commitments.length || target.agenda.owed?.length || target.agenda.lapse)
+        fail('target calendar must be empty');
+    const result = admitPersona(projection.person, target, policy);
+    const p = result.person;
+    p.agenda.commitments = c.commitments;
+    if (c.owed.length)
+        p.agenda.owed = c.owed;
+    if (c.lapse !== null)
+        p.agenda.lapse = c.lapse;
+    p.conscience.norms = c.heldNorms;
+    p.agenda.nextId = Math.max(p.agenda.nextId, p.agenda.commitments.length + 1);
+    // Agenda-generated ids are c<N>; reserve imported ids before normal host scheduling resumes.
+    for (const record of [
+        ...c.commitments.map((x) => x.id),
+        ...c.owed.flatMap((x) => [x.ofId, ...(x.scheduledAs === undefined ? [] : [x.scheduledAs])]),
+    ]) {
+        if (/^c\d+$/.test(record))
+            p.agenda.nextId = Math.max(p.agenda.nextId, Number(record.slice(1)) + 1);
+    }
+    const checked = restore(p);
+    if (!same(p, checked))
+        fail('admitted calendar exceeds supported engine bounds');
+    return { ...result, person: checked };
+}

package/dist/persona.d.ts

@@ -31,7 +31,7 @@ export interface PersonaProjectionSnapshot {
     format: 'hf-persona-state/1';
     mappingVersion: string;
     source: {
-        schema: number;
+        schema: Person['schema'];
         engine: string;
         id: string;
         now: number;

package/dist/persona.js

@@ -4,7 +4,8 @@
  * identity, age, family and health compatibility before returning a new Person. Neither input is mutated.
  * This is not a world migration, identity registry, transport, hash, authentication or general calendar mapper.
  * v1 admits zero-duration travel and healthy compatible bodies only; family/bonds remain host-authored and must
- * match source provenance. Pregnancy and nonempty temporal bonds are unsupported in v1. All other world-dependent stores stay with the source and are disclosed as omitted.
+ * match source provenance. Portable v1 accepts its published 2.14.1 stamp and the current engine;
+ * the 2.14.1 to 2.17.0 migration changes no portable field semantics. Pregnancy and nonempty temporal bonds are unsupported in v1. All other world-dependent stores stay with the source and are disclosed as omitted.
  */
 import { hasUnresolvedMakeUps, sameChain } from './agenda/agenda.js';
 import { createPerson } from './person.js';
@@ -185,7 +186,9 @@ export function validatePersonaProjection(input) {
     text(input.mappingVersion);
     text(input.name);
     keys(input.source, ['schema', 'engine', 'id', 'now']);
-    if (input.source.schema !== PERSON_SCHEMA || input.source.engine !== ENGINE_VERSION)
+    // Both published passport releases used 2.14.1; the next engine upgrade is stamp-only here.
+    const compatibleEngine = input.source.engine === ENGINE_VERSION || input.source.engine === '2.14.1';
+    if (input.source.schema !== PERSON_SCHEMA || !compatibleEngine)
         fail('unsupported source schema/engine; migrate the source before projection');
     text(input.source.id);
     num(input.source.now);

package/dist/projects/projects.d.ts

@@ -1,4 +1,4 @@
-import type { Minute, Person, ProjectsSpec, ProjectsState, Prospect } from '../types.ts';
+import type { Goal, Minute, Person, ProjectsSpec, ProjectsState, Prospect } from '../types.ts';
 export declare const PROJECTS_DEFAULTS: {
     readonly maxProspects: 8;
     readonly maxHistory: 8;
@@ -13,10 +13,16 @@ export declare const PROJECTS_DEFAULTS: {
 };
 /** Enable or reconfigure without discarding retained prospects and history. */
 export declare function enableProjects(p: Person, spec?: ProjectsSpec): ProjectsState;
+/** Turn an active held project into a host task. Undefined means there is no active held project.
+ * Reuses identity, adoption time, progress, peak and progress clock; never revives an abandoned project.
+ * Retains its temporal horizon unless the task supplies a valid replacement.
+ * The caller supplies task meaning and deadlines. No second goal or fresh progress is created.
+ */
+export declare function adoptProjectTask(p: Person, prospectId: string, task: Omit<Goal, 'id' | 'status' | 'progress' | 'adoptedAt' | 'project' | 'lastAdvancedAt'>, now?: Minute): Goal | undefined;
 /** Read-only, deterministic appeal. Thresholds close the relaxed gate before the bounded bonus. */
 export declare function projectAppeal(p: Person, prospect: Prospect, now?: Minute): number;
 /** Only the composite calls this, after attention. Newest event minute wins; equal-minute input order wins. */
-export declare function perceiveProspect(p: Person, input: Prospect, at: Minute): void;
+export declare function perceiveProspect(p: Person, input: Prospect, at: Minute, attributeOwnAct?: boolean): void;
 /** Called on each tick segment, including one-minute begin/tick/finish host loops. No RNG. */
 export declare function considerProjects(p: Person, now: Minute): void;
 /** Conservative restore: bounded fields, finite past timestamps, and no ambiguous duplicate ids. */

package/dist/projects/projects.js

@@ -9,7 +9,12 @@
  * goals. All kinds serve competence and leisure: making is chosen as a free-time pursuit, not duty.
  * Behaviour 2 credits only new perceived highs; event-credited projects cannot observe reversals and stay unchanged.
  * Restore recovers one active project, keeping the newest (id breaks ties) and abandoning extras.
- * No invented prospects, host task interpretation, world search, persistence, shielding, faith lens,
+ * Explicit protectProgress blocks goal credit for host-declared reductions and exact contextual acts
+ * followed within five minutes by an attended drop after one's own completion. This is a bounded
+ * causal assumption, not proof of causation. Only direct saw/outcome readings without another actor
+ * can teach that link. It learns no effects from unattended world state or testimony.
+ * adoptProjectTask reuses an active project goal, preserving net credit and pursuit identity.
+ * No invented prospects, implicit host task interpretation, world search, persistence, shielding, faith lens,
  * LLM or RNG. Without the slice, perception and minute bookkeeping write nothing.
  */
 import { emotionLevel } from '../affect/index.js';
@@ -44,6 +49,8 @@ function cleanSpec(input) {
     const out = {};
     if (!isObj(input))
         return out;
+    if (typeof input.protectProgress === 'boolean')
+        out.protectProgress = input.protectProgress;
     for (const key of KEYS) {
         const x = input[key];
         const unit = key === 'calmUrgency' || key === 'fearBelow' || key === 'adoptAppeal';
@@ -90,6 +97,70 @@ export function enableProjects(p, spec = {}) {
     p.projects = state;
     return state;
 }
+/** Whether this offer is understood to undo this prospect. Read-only; exact context, no action-only generalisation. @internal */
+export function diminishesProject(p, aff, prospectId) {
+    const s = p.projects;
+    return (s?.spec?.protectProgress === true &&
+        ((aff.diminishes?.includes(prospectId) ?? false) ||
+            (s.setbacks?.some((x) => x.prospectId === prospectId &&
+                x.action === aff.action &&
+                x.targetId === aff.targetId &&
+                x.placeId === aff.placeId) ??
+                false)));
+}
+/** Own completed acts alone can explain the next attended drop. Failed/interrupted acts clear attribution. @internal */
+export function noteProjectAct(p, aff, completed, at) {
+    const s = p.projects;
+    if (!s?.spec?.protectProgress)
+        return;
+    delete s.pendingAct;
+    if (!completed ||
+        !str(aff.action) ||
+        (aff.targetId !== undefined && !str(aff.targetId)) ||
+        (aff.placeId !== undefined && !str(aff.placeId)))
+        return;
+    const readings = s.prospects
+        .filter((x) => x.progress !== undefined &&
+        p.agenda.goals.some((g) => g.status === 'active' && g.project?.prospectId === x.id))
+        .map((x) => ({ prospectId: x.id, progress: x.progress }));
+    if (!readings.length)
+        return;
+    s.pendingAct = {
+        action: aff.action,
+        at,
+        readings,
+        ...(aff.targetId !== undefined ? { targetId: aff.targetId } : {}),
+        ...(aff.placeId !== undefined ? { placeId: aff.placeId } : {}),
+    };
+}
+/** Turn an active held project into a host task. Undefined means there is no active held project.
+ * Reuses identity, adoption time, progress, peak and progress clock; never revives an abandoned project.
+ * Retains its temporal horizon unless the task supplies a valid replacement.
+ * The caller supplies task meaning and deadlines. No second goal or fresh progress is created.
+ */
+export function adoptProjectTask(p, prospectId, task, now = p.now) {
+    if (!p.projects || !minute(now, p.now))
+        return undefined;
+    const held = p.agenda.goals.find((g) => g.status === 'active' && g.project?.prospectId === prospectId);
+    if (!held)
+        return undefined;
+    // Use agenda's copying and sanitization, then retain the existing goal rather than allocating a new id.
+    const nextId = p.agenda.nextId;
+    const staged = adoptGoal(p, task, now);
+    p.agenda.goals.pop();
+    p.agenda.nextId = nextId;
+    held.label = staged.label;
+    held.serves = staged.serves;
+    held.advancedBy = staged.advancedBy;
+    held.importance = staged.importance;
+    held.baseImportance = staged.baseImportance;
+    delete held.deadline;
+    if (staged.deadline !== undefined)
+        held.deadline = staged.deadline;
+    if (staged.temporal !== undefined)
+        held.temporal = staged.temporal;
+    return held;
+}
 function relaxed(p) {
     const needs = readPerson(p).needs;
     return {
@@ -166,7 +237,7 @@ export function noteProjectStatus(p, now) {
         recordProjectStatus(p, g, now);
 }
 /** Only the composite calls this, after attention. Newest event minute wins; equal-minute input order wins. */
-export function perceiveProspect(p, input, at) {
+export function perceiveProspect(p, input, at, attributeOwnAct = false) {
     const s = p.projects;
     if (!s || !minute(at, p.now))
         return;
@@ -178,6 +249,32 @@ export function perceiveProspect(p, input, at) {
         return;
     if (p.now - at > setting(s, 'forgetMinutes'))
         return;
+    const act = s.pendingAct;
+    if (s.spec?.protectProgress && act && at >= act.at) {
+        const before = act.readings.find((x) => x.prospectId === prospect.id);
+        if (before && prospect.progress !== undefined) {
+            if (attributeOwnAct && at - act.at <= 5 && prospect.progress < before.progress) {
+                const learned = {
+                    prospectId: prospect.id,
+                    action: act.action,
+                    ...(act.targetId !== undefined ? { targetId: act.targetId } : {}),
+                    ...(act.placeId !== undefined ? { placeId: act.placeId } : {}),
+                };
+                const list = s.setbacks ?? [];
+                if (!list.some((x) => x.prospectId === learned.prospectId &&
+                    x.action === learned.action &&
+                    x.targetId === learned.targetId &&
+                    x.placeId === learned.placeId))
+                    list.push(learned);
+                s.setbacks = list.slice(-16);
+            }
+            act.readings = act.readings.filter((x) => x.prospectId !== prospect.id);
+            if (!act.readings.length)
+                delete s.pendingAct;
+        }
+        if (at - act.at > 5)
+            delete s.pendingAct;
+    }
     const held = { ...prospect, lastSeenAt: at };
     if (old)
         s.prospects[s.prospects.indexOf(old)] = held;
@@ -268,6 +365,49 @@ export function sanitizeProjects(input, now) {
             return undefined;
         out.currentGoalId = input.currentGoalId;
     }
+    if (input.setbacks !== undefined) {
+        if (!Array.isArray(input.setbacks) || input.setbacks.length > 16)
+            return undefined;
+        out.setbacks = [];
+        for (const x of input.setbacks) {
+            if (!isObj(x) ||
+                !str(x.prospectId) ||
+                !str(x.action) ||
+                (x.targetId !== undefined && !str(x.targetId)) ||
+                (x.placeId !== undefined && !str(x.placeId)))
+                return undefined;
+            out.setbacks.push({
+                prospectId: x.prospectId,
+                action: x.action,
+                ...(x.targetId !== undefined ? { targetId: x.targetId } : {}),
+                ...(x.placeId !== undefined ? { placeId: x.placeId } : {}),
+            });
+        }
+    }
+    const act = input.pendingAct;
+    if (act !== undefined) {
+        if (!isObj(act) ||
+            !str(act.action) ||
+            !minute(act.at, now) ||
+            (act.targetId !== undefined && !str(act.targetId)) ||
+            (act.placeId !== undefined && !str(act.placeId)) ||
+            !Array.isArray(act.readings) ||
+            act.readings.length > PROJECTS_DEFAULTS.maxProspects)
+            return undefined;
+        const readings = [];
+        for (const x of act.readings) {
+            if (!isObj(x) || !str(x.prospectId) || !unit(x.progress))
+                return undefined;
+            readings.push({ prospectId: x.prospectId, progress: x.progress });
+        }
+        out.pendingAct = {
+            action: act.action,
+            at: act.at,
+            readings,
+            ...(act.targetId !== undefined ? { targetId: act.targetId } : {}),
+            ...(act.placeId !== undefined ? { placeId: act.placeId } : {}),
+        };
+    }
     const seen = new Set();
     for (const entry of input.prospects.slice(0, PROJECTS_DEFAULTS.maxProspects)) {
         const prospect = cleanProspect(entry);

package/dist/promptings/promptings.d.ts

@@ -70,7 +70,9 @@ export interface PromptingsNoted {
  */
 export declare function notePromptings(p: Person, seen: readonly PromptingSeen[], chosenId: string | null, now: Minute): PromptingsNoted;
 /** Vocabulary for one prompt under a held reading (narration only; it changes nothing). */
-export declare function promptingLine(reading: PromptingReading, outcome: PromptingRecord['outcome'], kind?: PromptingResponseKind): string;
+export declare function promptingLine(reading: PromptingReading, outcome: PromptingRecord['outcome'], kind?: PromptingResponseKind, options?: {
+    voice?: 'first' | 'third';
+}): string;
 /** Read-only summary of recent prompts (a lens; computes nothing new about the person). */
 export interface PromptingsReadingView {
     reading: PromptingReading;