@agenticprimitives/coordination 0.0.0-alpha.2

package/dist/core/reducer.js

@@ -0,0 +1,1164 @@
+// Event-sourced coordination machine (spec 332 §6). The reducer is the ONLY state-transition
+// path (ADR-0013); command validators reject before append; no event encodes authority (§9).
+// Deterministic: ids and instants come from commands/events, never from this module.
+import { COORDINATION_COMMAND_KINDS } from './commands.js';
+import { planContentHash } from '../planning/hash.js';
+import { validatePlanContent } from '../planning/validate.js';
+export function initialCoordinationState() {
+    return {
+        revision: 0,
+        plans: {},
+        participations: {},
+        proposals: {},
+        allocations: {},
+        commitments: {},
+        milestones: {},
+        satisfiedSteps: {},
+        recommendations: {},
+    };
+}
+export class CoordinationEventError extends Error {
+    constructor(message) {
+        super(`[coordination] ${message}`);
+    }
+}
+export const planKey = (planId, revision) => `${planId}@${revision}`;
+const TERMINAL_LIFECYCLES = new Set(['satisfied', 'abandoned']);
+const eventId = (revision, kind) => `evt_${String(revision).padStart(4, '0')}_${kind}`;
+const reject = (reason) => ({ ok: false, reason });
+function activeRoles(state, address) {
+    const roles = new Set();
+    for (const p of Object.values(state.participations)) {
+        if (p.participant === address && p.status === 'active')
+            roles.add(p.role);
+    }
+    return roles;
+}
+function participationStatus(state, address) {
+    let invited = false;
+    for (const p of Object.values(state.participations)) {
+        if (p.participant !== address)
+            continue;
+        if (p.status === 'active')
+            return 'active';
+        if (p.status === 'invited')
+            invited = true;
+    }
+    return invited ? 'invited' : 'none';
+}
+function isSteward(state, address) {
+    const roles = activeRoles(state, address);
+    return roles.has('coordinator') || roles.has('sponsor');
+}
+function endeavorContext(state, endeavorId) {
+    if (!state.endeavor)
+        return { reason: 'no endeavor adopted' };
+    if (state.endeavor.endeavorId !== endeavorId)
+        return { reason: `unknown endeavor ${endeavorId}` };
+    if (TERMINAL_LIFECYCLES.has(state.endeavor.lifecycle)) {
+        return { reason: `endeavor is terminal (${state.endeavor.lifecycle})` };
+    }
+    return { endeavor: state.endeavor };
+}
+function adoptedPlan(state) {
+    const ref = state.endeavor?.adoptedPlanRef;
+    if (!ref)
+        return undefined;
+    return state.plans[planKey(ref.planId, ref.revision)];
+}
+function samePlanRef(a, b) {
+    return a.planId === b.planId && a.revision === b.revision && a.hash === b.hash;
+}
+export function validateCoordinationCommand(state, command) {
+    const nextRevision = state.revision + 1;
+    const at = command.issuedAt;
+    switch (command.kind) {
+        case 'SubmitEndeavorRequest': {
+            if (state.request)
+                return reject('a request was already submitted');
+            if (state.endeavor)
+                return reject('an endeavor already exists');
+            if (command.goal.trim().length === 0)
+                return reject('goal must be non-empty');
+            const request = {
+                schema: 'apcoord/EndeavorRequestV1',
+                requestId: command.requestId,
+                requester: command.actor,
+                targetPrincipal: command.targetPrincipal,
+                goal: command.goal,
+                entryPoint: command.entryPoint,
+                submittedAt: at,
+                ...(command.intentRef ? { intentRef: command.intentRef } : {}),
+                ...(command.intakeContext ? { intakeContext: command.intakeContext } : {}),
+                ...(command.profileRef ? { profileRef: command.profileRef } : {}),
+            };
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'EndeavorRequestSubmitted',
+                        eventId: eventId(nextRevision, 'EndeavorRequestSubmitted'),
+                        requestId: command.requestId,
+                        request,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'AdoptEndeavor': {
+            if (!state.request)
+                return reject('no request to adopt');
+            if (state.request.record.requestId !== command.requestId)
+                return reject('request id mismatch');
+            if (state.request.status !== 'submitted')
+                return reject(`request is ${state.request.status}, not submitted`);
+            if (command.actor !== state.request.record.targetPrincipal) {
+                return reject('only the target principal may adopt');
+            }
+            if (command.initialParticipations.length === 0) {
+                return reject('adoption must assert at least one sponsor/coordinator participation');
+            }
+            const seen = new Set();
+            for (const p of command.initialParticipations) {
+                if (p.role !== 'sponsor' && p.role !== 'coordinator') {
+                    return reject(`initial participation role must be sponsor or coordinator, got ${p.role}`);
+                }
+                if (seen.has(p.participationId))
+                    return reject(`duplicate participation id ${p.participationId}`);
+                seen.add(p.participationId);
+            }
+            if (command.outcome.criteria.length === 0)
+                return reject('outcome must declare at least one criterion');
+            const outcome = {
+                schema: 'apcoord/OutcomeSpecificationV1',
+                outcomeId: command.outcome.outcomeId,
+                endeavorId: command.endeavorId,
+                revision: 1,
+                criteria: command.outcome.criteria,
+            };
+            const events = [
+                {
+                    kind: 'EndeavorAdopted',
+                    eventId: eventId(nextRevision, 'EndeavorAdopted'),
+                    endeavorId: command.endeavorId,
+                    requestId: command.requestId,
+                    managingPrincipal: command.actor,
+                    situationId: command.situationId,
+                    title: command.title,
+                    outcome,
+                    occurredAt: at,
+                    revision: nextRevision,
+                },
+            ];
+            let revision = nextRevision;
+            for (const p of command.initialParticipations) {
+                revision += 1;
+                events.push({
+                    kind: 'ParticipationAsserted',
+                    eventId: eventId(revision, 'ParticipationAsserted'),
+                    endeavorId: command.endeavorId,
+                    participationId: p.participationId,
+                    participant: p.participant,
+                    role: p.role,
+                    assertedBy: 'self-sponsor',
+                    occurredAt: at,
+                    revision,
+                });
+            }
+            return { ok: true, events };
+        }
+        case 'DeclineEndeavorRequest': {
+            if (!state.request)
+                return reject('no request to decline');
+            if (state.request.record.requestId !== command.requestId)
+                return reject('request id mismatch');
+            if (state.request.status !== 'submitted')
+                return reject(`request is ${state.request.status}, not submitted`);
+            if (command.actor !== state.request.record.targetPrincipal) {
+                return reject('only the target principal may decline');
+            }
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'EndeavorRequestDeclined',
+                        eventId: eventId(nextRevision, 'EndeavorRequestDeclined'),
+                        requestId: command.requestId,
+                        declinedBy: command.actor,
+                        reason: command.reason,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'ReviseOutcome': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (command.actor !== ctx.endeavor.managingPrincipal && !isSteward(state, command.actor)) {
+                return reject('only the managing principal or a sponsor/coordinator may revise the outcome');
+            }
+            if (command.outcome.criteria.length === 0)
+                return reject('outcome must declare at least one criterion');
+            const outcome = {
+                schema: 'apcoord/OutcomeSpecificationV1',
+                outcomeId: command.outcome.outcomeId,
+                endeavorId: command.endeavorId,
+                revision: (state.outcome?.revision ?? 0) + 1,
+                criteria: command.outcome.criteria,
+            };
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'OutcomeRevised',
+                        eventId: eventId(nextRevision, 'OutcomeRevised'),
+                        endeavorId: command.endeavorId,
+                        outcome,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'ProposePlan': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (command.actor !== ctx.endeavor.managingPrincipal &&
+                participationStatus(state, command.actor) !== 'active') {
+                return reject('plan proposer must be the managing principal or an active participant');
+            }
+            const content = { steps: command.steps, edges: command.edges, milestones: command.milestones };
+            const structural = validatePlanContent(content);
+            if (!structural.ok)
+                return reject(structural.reason);
+            if (state.plans[planKey(command.planId, command.revision)]) {
+                return reject(`plan revision ${planKey(command.planId, command.revision)} already exists`);
+            }
+            let maxRevision = 0;
+            for (const p of Object.values(state.plans)) {
+                if (p.planId === command.planId && p.revision > maxRevision)
+                    maxRevision = p.revision;
+            }
+            if (command.revision !== maxRevision + 1) {
+                return reject(`plan revision must be ${maxRevision + 1}, got ${command.revision}`);
+            }
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'PlanProposed',
+                        eventId: eventId(nextRevision, 'PlanProposed'),
+                        endeavorId: command.endeavorId,
+                        planId: command.planId,
+                        planRevision: command.revision,
+                        contentHash: planContentHash(content),
+                        steps: command.steps,
+                        edges: command.edges,
+                        milestones: command.milestones,
+                        proposedBy: command.actor,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'AdoptPlan': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (!isSteward(state, command.actor))
+                return reject('only a sponsor/coordinator may adopt a plan');
+            const plan = state.plans[planKey(command.planRef.planId, command.planRef.revision)];
+            if (!plan)
+                return reject(`unknown plan revision ${planKey(command.planRef.planId, command.planRef.revision)}`);
+            if (plan.status !== 'proposed')
+                return reject(`plan revision is ${plan.status}, not proposed`);
+            if (command.planRef.hash !== plan.contentHash) {
+                return reject('plan content hash mismatch — adoption binds an exact revision hash');
+            }
+            const prior = ctx.endeavor.adoptedPlanRef;
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'PlanAdopted',
+                        eventId: eventId(nextRevision, 'PlanAdopted'),
+                        endeavorId: command.endeavorId,
+                        planRef: command.planRef,
+                        adoptedBy: command.actor,
+                        ...(prior ? { supersededPlanRef: prior } : {}),
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'RejectPlan': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (!isSteward(state, command.actor))
+                return reject('only a sponsor/coordinator may reject a plan');
+            const plan = state.plans[planKey(command.planId, command.revision)];
+            if (!plan)
+                return reject(`unknown plan revision ${planKey(command.planId, command.revision)}`);
+            if (plan.status !== 'proposed')
+                return reject(`plan revision is ${plan.status}, not proposed`);
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'PlanRejected',
+                        eventId: eventId(nextRevision, 'PlanRejected'),
+                        endeavorId: command.endeavorId,
+                        planId: command.planId,
+                        planRevision: command.revision,
+                        rejectedBy: command.actor,
+                        ...(command.reason ? { reason: command.reason } : {}),
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'InviteParticipant': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (!isSteward(state, command.actor))
+                return reject('only a sponsor/coordinator may invite');
+            if (state.participations[command.participationId]) {
+                return reject(`participation ${command.participationId} already exists`);
+            }
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'ParticipationInvited',
+                        eventId: eventId(nextRevision, 'ParticipationInvited'),
+                        endeavorId: command.endeavorId,
+                        participationId: command.participationId,
+                        participant: command.participant,
+                        role: command.role,
+                        invitedBy: command.actor,
+                        ...(command.scope ? { scope: command.scope } : {}),
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'AcceptParticipation': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            const participation = state.participations[command.participationId];
+            if (!participation)
+                return reject(`unknown participation ${command.participationId}`);
+            if (participation.status !== 'invited')
+                return reject(`participation is ${participation.status}, not invited`);
+            if (command.actor !== participation.participant)
+                return reject('only the invitee may accept');
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'ParticipationAsserted',
+                        eventId: eventId(nextRevision, 'ParticipationAsserted'),
+                        endeavorId: command.endeavorId,
+                        participationId: command.participationId,
+                        participant: participation.participant,
+                        role: participation.role,
+                        assertedBy: 'invitation-acceptance',
+                        ...(participation.scope ? { scope: participation.scope } : {}),
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'WithdrawParticipation': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            const participation = state.participations[command.participationId];
+            if (!participation)
+                return reject(`unknown participation ${command.participationId}`);
+            if (participation.status !== 'active')
+                return reject(`participation is ${participation.status}, not active`);
+            if (command.actor !== participation.participant)
+                return reject('only the participant may withdraw');
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'ParticipationWithdrawn',
+                        eventId: eventId(nextRevision, 'ParticipationWithdrawn'),
+                        endeavorId: command.endeavorId,
+                        participationId: command.participationId,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'ProposeContribution': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (participationStatus(state, command.actor) === 'none') {
+                return reject('contribution proposer must be a participant or invitee');
+            }
+            if (state.proposals[command.proposalId])
+                return reject(`proposal ${command.proposalId} already exists`);
+            const plan = state.plans[planKey(command.planRef.planId, command.planRef.revision)];
+            if (!plan)
+                return reject(`unknown plan revision ${planKey(command.planRef.planId, command.planRef.revision)}`);
+            if (command.planRef.hash !== plan.contentHash)
+                return reject('plan content hash mismatch');
+            if (command.steps.length === 0)
+                return reject('proposal must name at least one step');
+            const stepIds = new Set(plan.steps.map((s) => s.stepId));
+            for (const stepId of command.steps) {
+                if (!stepIds.has(stepId))
+                    return reject(`step ${stepId} is not in plan revision ${plan.revision}`);
+            }
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'ContributionProposed',
+                        eventId: eventId(nextRevision, 'ContributionProposed'),
+                        endeavorId: command.endeavorId,
+                        proposalId: command.proposalId,
+                        proposer: command.actor,
+                        planRef: command.planRef,
+                        steps: command.steps,
+                        ...(command.note ? { note: command.note } : {}),
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'AllocateContribution': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (!isSteward(state, command.actor))
+                return reject('only a sponsor/coordinator may allocate');
+            const proposal = state.proposals[command.proposalRef];
+            if (!proposal)
+                return reject(`unknown proposal ${command.proposalRef}`);
+            if (proposal.status !== 'open')
+                return reject(`proposal is ${proposal.status}, not open`);
+            if (state.allocations[command.allocationId])
+                return reject(`allocation ${command.allocationId} already exists`);
+            if (participationStatus(state, command.participant) === 'none') {
+                return reject('allocated participant must be a participant or invitee');
+            }
+            const proposed = new Set(proposal.steps);
+            for (const stepId of command.steps) {
+                if (!proposed.has(stepId))
+                    return reject(`step ${stepId} was not proposed in ${command.proposalRef}`);
+            }
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'ContributionAllocated',
+                        eventId: eventId(nextRevision, 'ContributionAllocated'),
+                        endeavorId: command.endeavorId,
+                        allocationId: command.allocationId,
+                        proposalRef: command.proposalRef,
+                        participant: command.participant,
+                        steps: command.steps,
+                        decidedBy: command.actor,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'CommitContribution': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            const allocation = state.allocations[command.allocationRef];
+            if (!allocation)
+                return reject(`unknown allocation ${command.allocationRef}`);
+            if (allocation.status !== 'allocated')
+                return reject(`allocation is ${allocation.status}, not allocated`);
+            if (command.actor !== allocation.participant)
+                return reject('only the allocated participant may commit');
+            if (participationStatus(state, command.actor) === 'none') {
+                return reject('commitment requires an existing participation or invitation');
+            }
+            if (state.commitments[command.commitmentId])
+                return reject(`commitment ${command.commitmentId} already exists`);
+            const adopted = ctx.endeavor.adoptedPlanRef;
+            if (!adopted)
+                return reject('no adopted plan to commit against');
+            if (!samePlanRef(command.planRef, adopted)) {
+                return reject('commitment plan revision hash is stale — commitments bind the adopted revision hash');
+            }
+            const allocated = new Set(allocation.steps);
+            for (const stepId of command.steps) {
+                if (!allocated.has(stepId))
+                    return reject(`step ${stepId} was not allocated in ${command.allocationRef}`);
+            }
+            if (command.signature.signer !== command.actor)
+                return reject('commitment signature signer must be the actor');
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'ContributionCommitted',
+                        eventId: eventId(nextRevision, 'ContributionCommitted'),
+                        endeavorId: command.endeavorId,
+                        commitmentId: command.commitmentId,
+                        allocationRef: command.allocationRef,
+                        participant: command.actor,
+                        planRef: command.planRef,
+                        steps: command.steps,
+                        signature: command.signature,
+                        ...(command.bounds ? { bounds: command.bounds } : {}),
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'WithdrawCommitment': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            const commitment = state.commitments[command.commitmentId];
+            if (!commitment)
+                return reject(`unknown commitment ${command.commitmentId}`);
+            if (commitment.status !== 'active')
+                return reject(`commitment is ${commitment.status}, not active`);
+            if (command.actor !== commitment.participant)
+                return reject('only the committed participant may withdraw');
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'CommitmentWithdrawn',
+                        eventId: eventId(nextRevision, 'CommitmentWithdrawn'),
+                        endeavorId: command.endeavorId,
+                        commitmentId: command.commitmentId,
+                        ...(command.reason ? { reason: command.reason } : {}),
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'ReallocateContribution': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (!isSteward(state, command.actor))
+                return reject('only a sponsor/coordinator may reallocate');
+            const commitment = state.commitments[command.commitmentId];
+            if (!commitment)
+                return reject(`unknown commitment ${command.commitmentId}`);
+            if (commitment.status !== 'active' && commitment.status !== 'withdrawn') {
+                return reject(`commitment is ${commitment.status}; only active/withdrawn commitments reallocate`);
+            }
+            if (state.allocations[command.allocationId])
+                return reject(`allocation ${command.allocationId} already exists`);
+            if (participationStatus(state, command.participant) === 'none') {
+                return reject('reallocated participant must be a participant or invitee');
+            }
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'ContributionReallocated',
+                        eventId: eventId(nextRevision, 'ContributionReallocated'),
+                        endeavorId: command.endeavorId,
+                        commitmentId: command.commitmentId,
+                        allocationId: command.allocationId,
+                        participant: command.participant,
+                        decidedBy: command.actor,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'RecordStepSatisfied': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            const plan = adoptedPlan(state);
+            const adopted = ctx.endeavor.adoptedPlanRef;
+            if (!plan || !adopted)
+                return reject('no adopted plan');
+            if (!plan.steps.some((s) => s.stepId === command.stepId)) {
+                return reject(`step ${command.stepId} is not in the adopted plan`);
+            }
+            if (state.satisfiedSteps[command.stepId])
+                return reject(`step ${command.stepId} already satisfied`);
+            if (command.evidenceRefs.length === 0)
+                return reject('step satisfaction requires completion evidence');
+            if (command.actor !== ctx.endeavor.managingPrincipal &&
+                participationStatus(state, command.actor) !== 'active') {
+                return reject('step satisfaction must be recorded by the managing principal or an active participant');
+            }
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'PlanStepSatisfied',
+                        eventId: eventId(nextRevision, 'PlanStepSatisfied'),
+                        endeavorId: command.endeavorId,
+                        stepId: command.stepId,
+                        planRef: adopted,
+                        evidenceRefs: command.evidenceRefs,
+                        recordedBy: command.actor,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'RecordMilestoneAchieved': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            const plan = adoptedPlan(state);
+            if (!plan)
+                return reject('no adopted plan');
+            if (!plan.milestones.some((m) => m.milestoneId === command.milestoneId)) {
+                return reject(`milestone ${command.milestoneId} is not in the adopted plan`);
+            }
+            if (state.milestones[command.milestoneId])
+                return reject(`milestone ${command.milestoneId} already achieved`);
+            if (command.evidenceRefs.length === 0)
+                return reject('milestone achievement requires criteria evidence');
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'MilestoneAchieved',
+                        eventId: eventId(nextRevision, 'MilestoneAchieved'),
+                        endeavorId: command.endeavorId,
+                        milestoneId: command.milestoneId,
+                        evidenceRefs: command.evidenceRefs,
+                        recordedBy: command.actor,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'SatisfyEndeavor': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (command.actor !== ctx.endeavor.managingPrincipal && !isSteward(state, command.actor)) {
+                return reject('only the managing principal or a sponsor/coordinator may satisfy');
+            }
+            if (!command.outcomeValidationRef)
+                return reject('EndeavorSatisfied requires an outcome validation ref');
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'EndeavorSatisfied',
+                        eventId: eventId(nextRevision, 'EndeavorSatisfied'),
+                        endeavorId: command.endeavorId,
+                        outcomeValidationRef: command.outcomeValidationRef,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'AbandonEndeavor': {
+            const ctx = endeavorContext(state, command.endeavorId);
+            if ('reason' in ctx)
+                return reject(ctx.reason);
+            if (command.actor !== ctx.endeavor.managingPrincipal && !isSteward(state, command.actor)) {
+                return reject('only the managing principal or a sponsor/coordinator may abandon');
+            }
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'EndeavorAbandoned',
+                        eventId: eventId(nextRevision, 'EndeavorAbandoned'),
+                        endeavorId: command.endeavorId,
+                        ...(command.reason ? { reason: command.reason } : {}),
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'ProposeRecommendation': {
+            if (state.recommendations[command.recommendationId]) {
+                return reject(`recommendation ${command.recommendationId} already exists`);
+            }
+            if (command.recommendationKind.trim().length === 0)
+                return reject('recommendation kind must be non-empty');
+            if (command.explanation.trim().length === 0)
+                return reject('recommendation requires an explanation');
+            if (command.proposedCommands.length === 0)
+                return reject('recommendation must propose at least one typed command');
+            for (const t of command.proposedCommands) {
+                if (!COORDINATION_COMMAND_KINDS.has(t.kind)) {
+                    return reject(`proposed command kind ${t.kind} is not a coordination command — templates are typed, never free-form`);
+                }
+            }
+            if (command.confidence !== undefined && (command.confidence < 0 || command.confidence > 1)) {
+                return reject('confidence must be in [0, 1]');
+            }
+            // Producer gate: a request-subject recommendation (pre-adoption triage, spec 334 §10) is
+            // produced by the MANAGING PRINCIPAL's agent; an endeavor-subject one (spec 333 §3) by the
+            // managing principal or an active participant.
+            if (command.subject.kind === 'request') {
+                if (!state.request)
+                    return reject('no request to recommend on');
+                if (state.request.record.requestId !== command.subject.requestId)
+                    return reject('request id mismatch');
+                if (state.request.status !== 'submitted')
+                    return reject(`request is ${state.request.status}, not submitted`);
+                if (command.actor !== state.request.record.targetPrincipal) {
+                    return reject('only the target principal (its agent) may recommend on a pending request');
+                }
+            }
+            else {
+                const ctx = endeavorContext(state, command.subject.endeavorId);
+                if ('reason' in ctx)
+                    return reject(ctx.reason);
+                if (command.actor !== ctx.endeavor.managingPrincipal && participationStatus(state, command.actor) !== 'active') {
+                    return reject('only the managing principal or an active participant may recommend on an endeavor');
+                }
+            }
+            const recommendation = {
+                schema: 'apcoord/RecommendationV1',
+                recommendationId: command.recommendationId,
+                subject: command.subject,
+                producedBy: command.actor,
+                kind: command.recommendationKind,
+                proposedCommands: command.proposedCommands,
+                ...(command.confidence !== undefined ? { confidence: command.confidence } : {}),
+                explanation: command.explanation,
+                evidenceRefs: command.evidenceRefs ?? [],
+                status: 'proposed',
+                proposedAt: at,
+            };
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind: 'RecommendationProposed',
+                        eventId: eventId(nextRevision, 'RecommendationProposed'),
+                        recommendationId: command.recommendationId,
+                        recommendation,
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        case 'ResolveRecommendation': {
+            const rec = state.recommendations[command.recommendationId];
+            if (!rec)
+                return reject(`unknown recommendation ${command.recommendationId}`);
+            if (rec.status !== 'proposed')
+                return reject(`recommendation is ${rec.status}, not proposed`);
+            // Decider gate (spec 334 §10): request-subject → the target principal; endeavor-subject →
+            // the managing principal or a sponsor/coordinator. NOTE: acceptance records the decision
+            // ONLY — the proposed commands replay through ordinary validation at the serving plane;
+            // the reducer never applies templates (spec 333 §3 — acceptance is not a bypass).
+            if (rec.subject.kind === 'request') {
+                if (!state.request || state.request.record.requestId !== rec.subject.requestId) {
+                    return reject('recommendation subject request is missing from state');
+                }
+                if (command.actor !== state.request.record.targetPrincipal) {
+                    return reject('only the target principal may resolve a request recommendation');
+                }
+            }
+            else {
+                if (!state.endeavor || state.endeavor.endeavorId !== rec.subject.endeavorId) {
+                    return reject('recommendation subject endeavor is missing from state');
+                }
+                if (command.actor !== state.endeavor.managingPrincipal && !isSteward(state, command.actor)) {
+                    return reject('only the managing principal or a sponsor/coordinator may resolve an endeavor recommendation');
+                }
+            }
+            const kind = command.resolution === 'accepted' ? 'RecommendationAccepted' : 'RecommendationRejected';
+            return {
+                ok: true,
+                events: [
+                    {
+                        kind,
+                        eventId: eventId(nextRevision, kind),
+                        recommendationId: command.recommendationId,
+                        resolvedBy: command.actor,
+                        ...(command.reason ? { reason: command.reason } : {}),
+                        occurredAt: at,
+                        revision: nextRevision,
+                    },
+                ],
+            };
+        }
+        default:
+            return reject(`unknown command kind ${command.kind ?? '<none>'}`);
+    }
+}
+export function applyCoordinationEvent(state, event) {
+    if (event.revision !== state.revision + 1) {
+        throw new CoordinationEventError(`non-monotonic revision: state at ${state.revision}, event ${event.kind} carries ${event.revision}`);
+    }
+    const endeavorAt = (revision) => {
+        if (!state.endeavor)
+            throw new CoordinationEventError(`${event.kind} applied before EndeavorAdopted`);
+        return { ...state.endeavor, revision };
+    };
+    switch (event.kind) {
+        case 'EndeavorRequestSubmitted':
+            return { ...state, revision: event.revision, request: { record: event.request, status: 'submitted' } };
+        case 'EndeavorRequestDeclined': {
+            if (!state.request)
+                throw new CoordinationEventError('EndeavorRequestDeclined without a request');
+            return { ...state, revision: event.revision, request: { ...state.request, status: 'declined' } };
+        }
+        case 'EndeavorAdopted': {
+            if (!state.request)
+                throw new CoordinationEventError('EndeavorAdopted without a request');
+            const endeavor = {
+                schema: 'apcoord/EndeavorV1',
+                endeavorId: event.endeavorId,
+                managingPrincipal: event.managingPrincipal,
+                situationId: event.situationId,
+                title: event.title,
+                outcomeRef: {
+                    kind: 'resource',
+                    iri: `urn:apcoord:outcome:${event.outcome.outcomeId}:${event.outcome.revision}`,
+                },
+                requestRef: event.requestId,
+                lifecycle: 'adopted',
+                relations: [],
+                revision: event.revision,
+            };
+            return {
+                ...state,
+                revision: event.revision,
+                request: { ...state.request, status: 'adopted' },
+                endeavor,
+                outcome: event.outcome,
+            };
+        }
+        case 'OutcomeRevised': {
+            const endeavor = endeavorAt(event.revision);
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: {
+                    ...endeavor,
+                    outcomeRef: {
+                        kind: 'resource',
+                        iri: `urn:apcoord:outcome:${event.outcome.outcomeId}:${event.outcome.revision}`,
+                    },
+                },
+                outcome: event.outcome,
+            };
+        }
+        case 'PlanProposed': {
+            const plan = {
+                schema: 'apcoord/CoordinationPlanV1',
+                planId: event.planId,
+                endeavorId: event.endeavorId,
+                revision: event.planRevision,
+                contentHash: event.contentHash,
+                steps: event.steps,
+                edges: event.edges,
+                milestones: event.milestones,
+                proposedBy: event.proposedBy,
+                status: 'proposed',
+            };
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                plans: { ...state.plans, [planKey(event.planId, event.planRevision)]: plan },
+            };
+        }
+        case 'PlanAdopted': {
+            const key = planKey(event.planRef.planId, event.planRef.revision);
+            const plan = state.plans[key];
+            if (!plan)
+                throw new CoordinationEventError(`PlanAdopted for unknown plan revision ${key}`);
+            const plans = { ...state.plans, [key]: { ...plan, status: 'adopted' } };
+            if (event.supersededPlanRef) {
+                const priorKey = planKey(event.supersededPlanRef.planId, event.supersededPlanRef.revision);
+                const prior = plans[priorKey];
+                if (prior)
+                    plans[priorKey] = { ...prior, status: 'superseded' };
+            }
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: { ...endeavorAt(event.revision), adoptedPlanRef: event.planRef, lifecycle: 'active' },
+                plans,
+            };
+        }
+        case 'PlanRejected': {
+            const key = planKey(event.planId, event.planRevision);
+            const plan = state.plans[key];
+            if (!plan)
+                throw new CoordinationEventError(`PlanRejected for unknown plan revision ${key}`);
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                plans: { ...state.plans, [key]: { ...plan, status: 'rejected' } },
+            };
+        }
+        case 'ParticipationInvited': {
+            const participation = {
+                schema: 'apcoord/EndeavorParticipationV1',
+                participationId: event.participationId,
+                endeavorId: event.endeavorId,
+                participant: event.participant,
+                role: event.role,
+                validity: { validFrom: event.occurredAt },
+                assertedBy: 'invitation-acceptance',
+                status: 'invited',
+                ...(event.scope ? { scope: event.scope } : {}),
+            };
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                participations: { ...state.participations, [event.participationId]: participation },
+            };
+        }
+        case 'ParticipationAsserted': {
+            const participation = {
+                schema: 'apcoord/EndeavorParticipationV1',
+                participationId: event.participationId,
+                endeavorId: event.endeavorId,
+                participant: event.participant,
+                role: event.role,
+                validity: { validFrom: event.occurredAt },
+                assertedBy: event.assertedBy,
+                status: 'active',
+                ...(event.scope ? { scope: event.scope } : {}),
+            };
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                participations: { ...state.participations, [event.participationId]: participation },
+            };
+        }
+        case 'ParticipationWithdrawn': {
+            const participation = state.participations[event.participationId];
+            if (!participation) {
+                throw new CoordinationEventError(`ParticipationWithdrawn for unknown participation ${event.participationId}`);
+            }
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                participations: {
+                    ...state.participations,
+                    [event.participationId]: {
+                        ...participation,
+                        status: 'withdrawn',
+                        validity: { ...participation.validity, validUntil: event.occurredAt },
+                    },
+                },
+            };
+        }
+        case 'ContributionProposed': {
+            const proposal = {
+                schema: 'apcoord/ContributionProposalV1',
+                proposalId: event.proposalId,
+                endeavorId: event.endeavorId,
+                proposer: event.proposer,
+                planRef: event.planRef,
+                steps: event.steps,
+                proposedAt: event.occurredAt,
+                status: 'open',
+                ...(event.note ? { note: event.note } : {}),
+            };
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                proposals: { ...state.proposals, [event.proposalId]: proposal },
+            };
+        }
+        case 'ContributionAllocated': {
+            const proposal = state.proposals[event.proposalRef];
+            if (!proposal)
+                throw new CoordinationEventError(`ContributionAllocated for unknown proposal ${event.proposalRef}`);
+            const allocation = {
+                schema: 'apcoord/AllocationDecisionV1',
+                allocationId: event.allocationId,
+                endeavorId: event.endeavorId,
+                proposalRef: event.proposalRef,
+                participant: event.participant,
+                steps: event.steps,
+                decidedBy: event.decidedBy,
+                decidedAt: event.occurredAt,
+                status: 'allocated',
+            };
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                proposals: { ...state.proposals, [event.proposalRef]: { ...proposal, status: 'allocated' } },
+                allocations: { ...state.allocations, [event.allocationId]: allocation },
+            };
+        }
+        case 'ContributionCommitted': {
+            const allocation = state.allocations[event.allocationRef];
+            if (!allocation)
+                throw new CoordinationEventError(`ContributionCommitted for unknown allocation ${event.allocationRef}`);
+            const commitment = {
+                schema: 'apcoord/ContributionCommitmentV1',
+                commitmentId: event.commitmentId,
+                endeavorId: event.endeavorId,
+                allocationRef: event.allocationRef,
+                participant: event.participant,
+                planRef: event.planRef,
+                steps: event.steps,
+                signature: event.signature,
+                status: 'active',
+                ...(event.bounds ? { bounds: event.bounds } : {}),
+            };
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                allocations: { ...state.allocations, [event.allocationRef]: { ...allocation, status: 'committed' } },
+                commitments: { ...state.commitments, [event.commitmentId]: commitment },
+            };
+        }
+        case 'CommitmentWithdrawn': {
+            const commitment = state.commitments[event.commitmentId];
+            if (!commitment)
+                throw new CoordinationEventError(`CommitmentWithdrawn for unknown commitment ${event.commitmentId}`);
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                commitments: { ...state.commitments, [event.commitmentId]: { ...commitment, status: 'withdrawn' } },
+            };
+        }
+        case 'ContributionReallocated': {
+            const commitment = state.commitments[event.commitmentId];
+            if (!commitment)
+                throw new CoordinationEventError(`ContributionReallocated for unknown commitment ${event.commitmentId}`);
+            const priorAllocation = state.allocations[commitment.allocationRef];
+            if (!priorAllocation) {
+                throw new CoordinationEventError(`ContributionReallocated: commitment ${event.commitmentId} references unknown allocation ${commitment.allocationRef}`);
+            }
+            const allocation = {
+                schema: 'apcoord/AllocationDecisionV1',
+                allocationId: event.allocationId,
+                endeavorId: event.endeavorId,
+                proposalRef: priorAllocation.proposalRef,
+                participant: event.participant,
+                steps: commitment.steps,
+                decidedBy: event.decidedBy,
+                decidedAt: event.occurredAt,
+                status: 'allocated',
+            };
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                commitments: { ...state.commitments, [event.commitmentId]: { ...commitment, status: 'reallocated' } },
+                allocations: { ...state.allocations, [event.allocationId]: allocation },
+            };
+        }
+        case 'PlanStepSatisfied':
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                satisfiedSteps: {
+                    ...state.satisfiedSteps,
+                    [event.stepId]: {
+                        stepId: event.stepId,
+                        planRef: event.planRef,
+                        evidenceRefs: event.evidenceRefs,
+                        recordedBy: event.recordedBy,
+                        recordedAt: event.occurredAt,
+                    },
+                },
+            };
+        case 'MilestoneAchieved': {
+            const achievement = {
+                schema: 'apcoord/MilestoneAchievementV1',
+                milestoneId: event.milestoneId,
+                endeavorId: event.endeavorId,
+                evidenceRefs: event.evidenceRefs,
+                achievedAt: event.occurredAt,
+            };
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: endeavorAt(event.revision),
+                milestones: { ...state.milestones, [event.milestoneId]: achievement },
+            };
+        }
+        case 'EndeavorSatisfied':
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: { ...endeavorAt(event.revision), lifecycle: 'satisfied' },
+            };
+        case 'EndeavorAbandoned':
+            return {
+                ...state,
+                revision: event.revision,
+                endeavor: { ...endeavorAt(event.revision), lifecycle: 'abandoned' },
+            };
+        case 'RecommendationProposed':
+            return {
+                ...state,
+                revision: event.revision,
+                recommendations: { ...state.recommendations, [event.recommendationId]: event.recommendation },
+            };
+        case 'RecommendationAccepted':
+        case 'RecommendationRejected': {
+            const rec = state.recommendations[event.recommendationId];
+            if (!rec)
+                throw new CoordinationEventError(`${event.kind} for unknown recommendation ${event.recommendationId}`);
+            return {
+                ...state,
+                revision: event.revision,
+                recommendations: {
+                    ...state.recommendations,
+                    [event.recommendationId]: {
+                        ...rec,
+                        status: event.kind === 'RecommendationAccepted' ? 'accepted' : 'rejected',
+                        resolvedBy: event.resolvedBy,
+                        resolvedAt: event.occurredAt,
+                        ...(event.reason ? { resolutionReason: event.reason } : {}),
+                    },
+                },
+            };
+        }
+        default: {
+            const kind = event.kind ?? '<none>';
+            throw new CoordinationEventError(`unknown event kind ${kind}`);
+        }
+    }
+}
+//# sourceMappingURL=reducer.js.map