@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/simulation/intervention_material.js

@@ -0,0 +1,81 @@
+import { isDeepStrictEqual } from 'node:util';
+import { applyBeliefUpdate, applyRelationshipDelta, validFailedAdjudicationCauses } from './toolkit/dynamic_agents.js';
+const intentKey = (intent) => intent === null ? null : [intent.mechanic, intent.goalId, intent.targetActorId ?? null];
+const words = (value) => value.normalize('NFKC').toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+const normalized = (value) => words(value).join(' ');
+/** A conservative lexical witness, not a claim to decide semantic equivalence. */
+function distinctClaim(left, right) {
+    const a = new Set(words(left));
+    const b = new Set(words(right));
+    const difference = [...a].filter(word => !b.has(word)).length + [...b].filter(word => !a.has(word)).length;
+    return difference >= 2 && difference / Math.max(1, new Set([...a, ...b]).size) >= 0.25;
+}
+function hasAcceptedAdjudicationCause(entry, actorId, proposalId) {
+    if (!entry.characterProposals.some(proposal => proposal.proposalId === proposalId && proposal.actorId === actorId))
+        return false;
+    const ruling = entry.gmProposal.adjudications.find(item => item.characterProposalId === proposalId);
+    if (!ruling)
+        return false;
+    if (ruling.outcome === 'failed')
+        return true;
+    return ruling.outcome === 'deferred' && ruling.actionIds.length === 0 && (entry.meetings ?? []).some(meeting => meeting.status === 'accepted' && meeting.meetingId === ruling.meetingId && meeting.revision === entry.revision
+        && meeting.participantActorIds.includes(actorId) && meeting.sourceProposalIds.includes(proposalId)
+        && meeting.decision?.deferProposalIds.includes(proposalId));
+}
+/** Check the claimed change or a permitted no-change decision; canonical transition validation owns the world. */
+export function hasMaterialInterventionChange(before, entry, result, after, agencyVersion, beliefEvidenceHistory) {
+    const emergent = agencyVersion === 'emergent-v1';
+    if (result.change === null)
+        return emergent && result.disposition !== 'acted'
+            && before.actorId === result.actorId && isDeepStrictEqual(result.causeIds, [result.inputId]);
+    if (result.disposition === 'ignored' || result.disposition === 'deferred')
+        return false;
+    const own = entry.gmProposal.agentUpdates.find(update => update.actorId === result.actorId);
+    if (!own || before.actorId !== result.actorId || own.sourceEventId !== entry.eventId)
+        return false;
+    const actionCauses = own.sourceActionIds;
+    const adjudicationCauses = own.sourceAdjudicationProposalIds ?? [];
+    const expectedCauses = [result.inputId, ...actionCauses, ...adjudicationCauses];
+    const validAdjudications = emergent
+        ? validFailedAdjudicationCauses(own, entry.gmProposal, entry.characterProposals, before.humanControlled ? [before.actorId] : [], agencyVersion)
+        : adjudicationCauses.every(id => hasAcceptedAdjudicationCause(entry, result.actorId, id));
+    if (expectedCauses.length < (emergent ? 1 : 2) || new Set(expectedCauses).size !== expectedCauses.length
+        || !isDeepStrictEqual([...result.causeIds].sort(), [...expectedCauses].sort())
+        || actionCauses.some(id => !entry.acceptedActionIds.includes(id))
+        || !validAdjudications)
+        return false;
+    const recordId = result.change.recordId;
+    if (result.change.kind === 'intent') {
+        const next = own.nextIntent;
+        if (emergent)
+            return (recordId === result.actorId || next?.goalId === recordId)
+                && !isDeepStrictEqual(before.currentIntent, next)
+                && (after === undefined || isDeepStrictEqual(next, after.currentIntent));
+        return next !== null && next.goalId === recordId && !isDeepStrictEqual(intentKey(before.currentIntent), intentKey(next))
+            && (after === undefined || isDeepStrictEqual(next, after.currentIntent));
+    }
+    if (result.change.kind === 'belief') {
+        const prior = before.beliefs.find(item => item.id === recordId);
+        const update = own.beliefUpdates.find(item => item.beliefId === recordId);
+        const appended = own.beliefsToAppend.find(item => item.id === recordId);
+        if ((prior && (!update || appended)) || (!prior && (!appended || update)))
+            return false;
+        const evidence = update?.evidenceEventIds ?? appended.evidenceEventIds;
+        if (!evidence.includes(entry.eventId) || new Set(evidence).size !== evidence.length)
+            return false;
+        const next = prior ? applyBeliefUpdate(prior, update, beliefEvidenceHistory?.[recordId]) : appended;
+        if (!emergent && (words(next.claim).length === 0 || words(next.subject).length === 0))
+            return false;
+        const changed = prior ? next.confidence !== prior.confidence
+            : emergent ? before.beliefs.every(item => item.subject !== next.subject || item.claim !== next.claim || item.confidence !== next.confidence)
+                : before.beliefs.every(item => normalized(item.subject) !== normalized(next.subject) || distinctClaim(item.claim, next.claim));
+        return changed && (after === undefined || isDeepStrictEqual(next, after.beliefs.find(item => item.id === recordId)));
+    }
+    const prior = before.relationships.find(item => item.targetActorId === recordId);
+    const delta = own.relationshipDeltas.find(item => item.targetActorId === recordId);
+    if (!prior || !delta || (!emergent && actionCauses.length === 0))
+        return false;
+    const next = applyRelationshipDelta(prior, delta, entry.eventId);
+    return (next.trust !== prior.trust || next.affinity !== prior.affinity || next.obligation !== prior.obligation)
+        && (after === undefined || isDeepStrictEqual(next, after.relationships.find(item => item.targetActorId === recordId)));
+}