@ixo/topic-protocol 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/src/shapes/now.js.map

@@ -1 +1 @@
-{"version":3,"file":"now.js","sourceRoot":"","sources":["../../../src/shapes/now.ts"],"names":[],"mappings":"AAQA,SAAS,gBAAgB,CACvB,UAA6B,EAC7B,SAAiC;IAEjC,IAAI,UAAU,CAAC,UAAU,CAAC,IAAI,KAAK,OAAO;QAAE,OAAO,UAAU,CAAC,UAAU,CAAC,KAAK,KAAK,SAAS,CAAC,QAAQ,CAAC;IACtG,OAAO,SAAS,CAAC,eAAe,CAAC,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;AACvG,CAAC;AAED,SAAS,UAAU,CACjB,UAA6B,EAC7B,SAAiC;IAEjC,OAAO,SAAS,CAAC,WAAW;WACvB,SAAS,CAAC,iBAAiB,CAAC,QAAQ,CAAC,UAAU,CAAC,eAAe,CAAC;WAChE,gBAAgB,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;AAC/C,CAAC;AAED,SAAS,YAAY,CAAC,WAAyC;IAC7D,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,YAAY,KAAK,MAAM,CAAC;QAAE,OAAO,8BAA8B,CAAC;IAC3G,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,KAAK,WAAW,IAAI,KAAK,KAAK,UAAU,CAAC;QAAE,OAAO,wBAAwB,CAAC;IACpH,OAAO,WAAW,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,wBAAwB,CAAC;AACtE,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,QAAmC,EACnC,SAAiC;IAEjC,MAAM,WAAW,GAAG,QAAQ,CAAC,UAAU;SACpC,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC;SACnC,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;IAC7D,MAAM,SAAS,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC;IAC5C,MAAM,UAAU,GAAG,SAAS,KAAK,MAAM;QACrC,CAAC,CAAC,QAAQ,CAAC,UAAU;QACrB,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,IAAI,QAAQ,CAAC,UAAU,CAAC;IACpE,OAAO;QACL,OAAO,EAAE,CAAC;QACV,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,SAAS;QACT,UAAU;QACV,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,WAAW;QACX,QAAQ,EAAE;YACR,aAAa,EAAE,QAAQ,CAAC,aAAa;YACrC,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB;YAC3C,WAAW,EAAE,QAAQ,CAAC,WAAW;SAClC;QACD,GAAG,CAAC,QAAQ,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;KAC9E,CAAC;AACJ,CAAC"}
+{"version":3,"file":"now.js","sourceRoot":"","sources":["../../../src/shapes/now.ts"],"names":[],"mappings":"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"}

package/dist/src/shapes/progress.d.ts

@@ -1,3 +1,3 @@
-import type { TopicProgressInputV1, TopicProgressProjectionV1 } from "./types.js";
-export declare function projectTopicProgress(input: TopicProgressInputV1): TopicProgressProjectionV1;
-export declare function replayTopicShape(input: Omit<TopicProgressInputV1, "axisStates">, initialAxisStates?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
+import type { TopicProgressInputV2, TopicProgressProjectionV2 } from "./types.js";
+export declare function projectTopicProgress(input: TopicProgressInputV2): TopicProgressProjectionV2;
+export declare function replayTopicShape(input: Omit<TopicProgressInputV2, "axisStates">, initialAxisStates?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;

package/dist/src/shapes/progress.js

@@ -1,11 +1,16 @@
 import { SHAPE_PHASES } from "./types.js";
+const EMPTY_DIGEST = `sha256:${"0".repeat(64)}`;
+const PAUSED_PHASES = new Set(["verifying", "deciding", "effecting", "settling", "complete"]);
 const CONDITION_PRIORITY = {
-    disputed: 700,
-    failed: 650,
-    blocked: 600,
-    waiting: 500,
-    "needs-input": 400,
-    "needs-acceptance": 350,
+    degraded: 900,
+    disputed: 800,
+    failed: 750,
+    expired: 700,
+    blocked: 650,
+    waiting: 600,
+    "needs-input": 500,
+    "needs-confirmation": 450,
+    "review-due": 300,
     "on-track": 0,
 };
 function terminal(axis, state) {
@@ -18,8 +23,89 @@ function activePhase(input) {
     if (input.status === "archived" || input.status === "redirected")
         return "dormant";
     const axes = [...(input.shape?.shape.axes ?? [])].sort((left, right) => phaseIndex(left.phase) - phaseIndex(right.phase));
-    const incomplete = axes.find((axis) => axis.required && !terminal(axis, input.axisStates[axis.code]));
-    return incomplete?.phase ?? "complete";
+    return axes.find((axis) => axis.required && !terminal(axis, input.axisStates[axis.code]))?.phase ?? "complete";
+}
+function resolveSubjects(subjects, input) {
+    return [...new Set(subjects.flatMap((subject) => subject.kind === "actor"
+            ? [subject.id]
+            : input.actorAssignments?.[subject.id] ?? []))].sort();
+}
+function sourceIsCurrent(source, input) {
+    return source.contractRevision === input.contractRevision
+        && source.bodyHash === input.contractBodyHash
+        && source.policyDigest === input.policyDigest
+        && typeof source.authorityProofRef === "string"
+        && source.authorityProofRef.length > 0;
+}
+function activeActors(type, withdrawal, input) {
+    const active = new Set();
+    for (const source of input.sources) {
+        if (!sourceIsCurrent(source, input) || source.actor === undefined)
+            continue;
+        if (source.kind === "operation" && source.type === type)
+            active.add(source.actor);
+        if (source.kind === "operation" && source.type === withdrawal)
+            active.delete(source.actor);
+    }
+    return [...active];
+}
+function requiredCount(policy) {
+    if (policy.mode === "any")
+        return 1;
+    if (policy.mode === "threshold")
+        return policy.threshold ?? Number.POSITIVE_INFINITY;
+    return "subjects" in policy ? policy.subjects.length : policy.signatories.length;
+}
+function policySatisfied(policy, actors, subjects, input) {
+    const resolved = resolveSubjects(subjects, input);
+    if (resolved.length === 0 || resolved.length < subjects.length)
+        return false;
+    const matching = resolved.filter((actor) => actors.includes(actor));
+    if (policy.mode === "all")
+        return matching.length === resolved.length;
+    return matching.length >= requiredCount(policy);
+}
+function timeUsable(input) {
+    const time = input.evaluationTime;
+    if (time === undefined || !time.trusted)
+        return false;
+    if (time.freshUntil === undefined)
+        return true;
+    return Date.parse(time.freshUntil) >= Date.parse(time.at);
+}
+function reached(at, input) {
+    return at === undefined || (timeUsable(input) && Date.parse(input.evaluationTime.at) >= Date.parse(at));
+}
+function confirmationSatisfied(input) {
+    const policy = input.activationPolicy?.confirmation;
+    if (policy === undefined)
+        return false;
+    return policySatisfied(policy, activeActors("confirm-setup", "withdraw-setup-confirmation", input), policy.subjects, input);
+}
+function assentSatisfied(input) {
+    const policy = input.assentPolicy;
+    if (policy === undefined)
+        return true;
+    return policySatisfied(policy, activeActors("record-assent", "withdraw-assent", input), policy.signatories, input);
+}
+function activationSatisfied(input) {
+    const policy = input.activationPolicy;
+    return policy !== undefined
+        && resolveSubjects(policy.editors ?? [], input).length > 0
+        && resolveSubjects(policy.dispute?.resolvers ?? [], input).length > 0
+        && policy.lifecycle !== undefined
+        && confirmationSatisfied(input)
+        && assentSatisfied(input)
+        && reached(policy.lifecycle.effectiveAt, input);
+}
+function activationPolicyComplete(input) {
+    const policy = input.activationPolicy;
+    return policy !== undefined
+        && resolveSubjects(policy.editors ?? [], input).length > 0
+        && policy.confirmation !== undefined
+        && resolveSubjects(policy.confirmation.subjects, input).length > 0
+        && policy.lifecycle !== undefined
+        && resolveSubjects(policy.dispute?.resolvers ?? [], input).length > 0;
 }
 function sourceMatches(source, kind, type, status) {
     if (source.kind !== kind || source.type !== type)
@@ -39,71 +125,265 @@ function gateSatisfied(gate, input) {
     }
     if (gate.kind === "binding")
         return input.bindings?.includes(gate.type) === true;
-    if (gate.kind === "condition")
+    if (gate.kind === "condition") {
+        if (gate.states.includes("disputed") && input.dispute?.status === "open")
+            return true;
         return input.block !== undefined && gate.states.includes(input.block.condition);
+    }
     return input.sources.some((source) => sourceMatches(source, gate.kind, gate.type, gate.status));
 }
+function transitionActors(transition, input) {
+    if (transition.code === "confirm-setup") {
+        return resolveSubjects(input.activationPolicy?.confirmation?.subjects ?? [], input);
+    }
+    if (transition.code === "resolve-dispute" && input.dispute !== undefined) {
+        return resolveSubjects([input.dispute.resolver], input);
+    }
+    if (transition.assignedTo.kind === "actor")
+        return [transition.assignedTo.value];
+    return input.actorAssignments?.[transition.assignedTo.value] ?? [];
+}
 function transitionCandidate(transition, input) {
-    const gateStatus = transition.gates.map((gate) => ({ gate, satisfied: gateSatisfied(gate, input) }));
-    const actors = transition.assignedTo.kind === "role" ? input.actorAssignments?.[transition.assignedTo.value] : [transition.assignedTo.value];
+    const assignedActors = transitionActors(transition, input);
     return {
         transition,
-        ...(actors?.[0] === undefined ? {} : { assignedActor: actors[0] }),
-        gateStatus,
+        ...(assignedActors[0] === undefined ? {} : { assignedActor: assignedActors[0] }),
+        assignedActors,
+        gateStatus: transition.gates.map((gate) => ({ gate, satisfied: gateSatisfied(gate, input) })),
     };
 }
-function matchingTransitions(input, phase) {
+function potentialTransitions(input, phase) {
     const transitions = input.shape?.shape.transitions ?? [];
-    const recovery = transitions.filter(({ gates }) => gates.some(({ kind }) => kind === "condition"));
-    const available = input.block === undefined ? transitions.filter(({ gates }) => gates.every(({ kind }) => kind !== "condition")) : recovery;
-    return available
-        .filter(({ predecessor, phase: transitionPhase }) => (input.block !== undefined || transitionPhase === phase) && input.axisStates[predecessor.axis] === predecessor.state)
+    const recoveryOnly = input.block !== undefined || input.dispute?.status === "open";
+    return transitions
+        .filter((transition) => {
+        const recovery = transition.gates.some(({ kind }) => kind === "condition");
+        if (recoveryOnly)
+            return recovery;
+        return !recovery && transition.phase === phase;
+    })
+        .filter(({ predecessor }) => input.axisStates[predecessor.axis] === predecessor.state)
         .map((transition) => transitionCandidate(transition, input));
 }
-function sourceCondition(input) {
-    if (input.sources.some(({ status }) => status === "disputed"))
-        return "disputed";
-    if (input.sources.some(({ status }) => status === "failed"))
-        return "failed";
-    return undefined;
+function missingRequirements(matches, input) {
+    const gates = matches.flatMap(({ gateStatus }) => gateStatus.filter(({ satisfied, gate }) => !satisfied && gate.requirement !== undefined));
+    const unique = new Map();
+    for (const { gate } of gates) {
+        const requirement = gate.requirement;
+        const responsibility = requirement.assignedTo;
+        const assignedActors = responsibility === undefined ? [] : resolveSubjects([
+            { kind: responsibility.kind, id: responsibility.value },
+        ], input);
+        unique.set(requirement.code, {
+            id: `requirement:${requirement.code}`,
+            code: requirement.code,
+            kind: "input",
+            phase: "forming",
+            status: "open",
+            priority: requirement.priority,
+            blocking: true,
+            ...(responsibility === undefined ? {} : { responsibility }),
+            assignedActors,
+            requiredAbility: "topic/write",
+            consequence: "shared-state",
+            ...((requirement.focusPath ?? (gate.kind === "field" ? gate.path : undefined)) === undefined
+                ? {}
+                : { focusPath: requirement.focusPath ?? (gate.kind === "field" ? gate.path : undefined) }),
+            presentation: {
+                labelKey: requirement.labelKey,
+                promptKey: requirement.promptKey,
+                purposeKey: requirement.purposeKey,
+                unlocksKey: "topic.requirement.setup.unlocks",
+            },
+            provenance: input.sources.map(({ id }) => id),
+        });
+    }
+    return [...unique.values()].sort((left, right) => left.priority - right.priority || left.code.localeCompare(right.code));
+}
+function obligationForTransition(candidate, input) {
+    const { transition } = candidate;
+    const presentation = transition.presentation;
+    return {
+        id: `transition:${transition.code}`,
+        code: transition.code,
+        kind: transition.code === "confirm-setup" ? "confirmation" : "transition",
+        phase: transition.phase,
+        status: "ready",
+        priority: presentation?.priority ?? 900,
+        blocking: transition.phase !== "working" || transition.code === "confirm-setup",
+        responsibility: transition.assignedTo,
+        assignedActors: candidate.assignedActors ?? [],
+        requiredAbility: transition.requiredAbility,
+        consequence: transition.consequence,
+        ...(presentation?.focusPath === undefined ? {} : { focusPath: presentation.focusPath }),
+        transitionCode: transition.code,
+        command: transition.command,
+        ...(transition.handoff === undefined ? {} : { handoff: transition.handoff }),
+        presentation: {
+            labelKey: presentation?.actionLabelKey ?? `topic.action.${transition.code}.label`,
+            promptKey: presentation?.bodyKey ?? `topic.action.${transition.code}.prompt`,
+            purposeKey: presentation?.purposeKey ?? `topic.action.${transition.code}.purpose`,
+            ...(presentation?.unlocksKey === undefined ? {} : { unlocksKey: presentation.unlocksKey }),
+        },
+        provenance: input.sources.map(({ id }) => id),
+    };
+}
+function policyInputObligation(input, code, priority, focusPath) {
+    const key = code.replace("setup.", "");
+    const editors = input.actorAssignments?.["setup-editor"] ?? [];
+    return {
+        id: `requirement:${code}`, code, kind: "input", phase: "forming", status: "open", priority,
+        blocking: true, responsibility: { kind: "role", value: "setup-editor" }, assignedActors: editors,
+        requiredAbility: "topic/write", consequence: "shared-state", focusPath,
+        presentation: { labelKey: `topic.requirement.${key}.label`, promptKey: `topic.requirement.${key}.prompt`, purposeKey: `topic.requirement.${key}.purpose`, unlocksKey: "topic.requirement.setup.unlocks" },
+        provenance: input.sources.map(({ id }) => id),
+    };
+}
+function policyObligations(input) {
+    const obligations = [];
+    if (resolveSubjects(input.activationPolicy?.editors ?? [], input).length === 0) {
+        obligations.push(policyInputObligation(input, "setup.editors", 600, "/activationPolicy/editors"));
+    }
+    if (input.activationPolicy?.confirmation === undefined) {
+        obligations.push(policyInputObligation(input, "setup.confirmation-policy", 610, "/activationPolicy/confirmation"));
+    }
+    if (input.activationPolicy?.lifecycle === undefined) {
+        obligations.push(policyInputObligation(input, "setup.lifecycle-policy", 620, "/activationPolicy/lifecycle"));
+    }
+    if (resolveSubjects(input.activationPolicy?.dispute?.resolvers ?? [], input).length === 0) {
+        obligations.push(policyInputObligation(input, "setup.dispute-resolvers", 630, "/activationPolicy/dispute/resolvers"));
+    }
+    if (input.assentPolicy !== undefined && !assentSatisfied(input)) {
+        obligations.push({
+            id: "assent:record-assent", code: "setup.assent", kind: "assent", phase: "forming", status: "open",
+            priority: 720, blocking: true, assignedActors: resolveSubjects(input.assentPolicy.signatories, input),
+            requiredAbility: "topic/record-assent", consequence: "shared-state", command: "topic.record-assent",
+            presentation: { labelKey: "topic.assent.label", promptKey: "topic.assent.prompt", purposeKey: "topic.assent.purpose", unlocksKey: "topic.assent.unlocks" },
+            provenance: input.sources.map(({ id }) => id),
+        });
+    }
+    const effectiveAt = input.activationPolicy?.lifecycle?.effectiveAt;
+    if (confirmationSatisfied(input) && assentSatisfied(input) && effectiveAt !== undefined && !reached(effectiveAt, input)) {
+        obligations.push({
+            id: "lifecycle:scheduled", code: "setup.scheduled", kind: "wait", phase: "forming", status: "waiting",
+            priority: 100, blocking: true, assignedActors: [], consequence: "none",
+            presentation: { labelKey: "topic.lifecycle.scheduled.label", promptKey: "topic.lifecycle.scheduled.prompt", purposeKey: "topic.lifecycle.scheduled.purpose", unlocksKey: "topic.lifecycle.scheduled.unlocks" },
+            provenance: input.sources.map(({ id }) => id),
+        });
+    }
+    return obligations;
+}
+function lifecycleState(input) {
+    const lifecycle = input.activationPolicy?.lifecycle;
+    if (lifecycle === undefined || !timeUsable(input))
+        return { expired: false, reviewDue: false };
+    const at = Date.parse(input.evaluationTime.at);
+    return {
+        expired: lifecycle.expiresAt !== undefined && at >= Date.parse(lifecycle.expiresAt),
+        reviewDue: lifecycle.reviewAt !== undefined && at >= Date.parse(lifecycle.reviewAt),
+    };
+}
+function contextualObligations(input, phase) {
+    const obligations = [];
+    if (!timeUsable(input))
+        obligations.push({
+            id: "safety:time-untrusted", code: "safety.time-untrusted", kind: "safety", phase, status: "unavailable",
+            priority: 50, blocking: PAUSED_PHASES.has(phase), assignedActors: [], consequence: "none",
+            presentation: { labelKey: "topic.safety.time-untrusted.label", promptKey: "topic.safety.time-untrusted.prompt", purposeKey: "topic.safety.time-untrusted.purpose" },
+            provenance: input.sources.map(({ id }) => id),
+        });
+    if (input.dispute?.status === "open")
+        obligations.push({
+            id: `dispute:${input.dispute.id}`, code: "dispute.resolve", kind: "dispute", phase, status: "blocked", priority: 10,
+            blocking: true, responsibility: { kind: input.dispute.resolver.kind, value: input.dispute.resolver.id }, assignedActors: resolveSubjects([input.dispute.resolver], input),
+            requiredAbility: "topic/resolve-dispute", consequence: "shared-state", transitionCode: "resolve-dispute", command: "topic.resolve-dispute",
+            presentation: { labelKey: "topic.dispute.resolve.label", promptKey: "topic.dispute.resolve.prompt", purposeKey: "topic.dispute.resolve.purpose", unlocksKey: "topic.dispute.resolve.unlocks" },
+            provenance: [input.dispute.id],
+        });
+    const lifecycle = lifecycleState(input);
+    if (lifecycle.expired)
+        obligations.push({
+            id: "lifecycle:setup-expired", code: "setup.expired", kind: "expiry", phase, status: "blocked", priority: 20,
+            blocking: true, responsibility: { kind: "role", value: "setup-editor" }, assignedActors: input.actorAssignments?.["setup-editor"] ?? [],
+            requiredAbility: "topic/write", consequence: "shared-state", command: "topic.edit-setup",
+            presentation: { labelKey: "topic.lifecycle.expired.label", promptKey: "topic.lifecycle.expired.prompt", purposeKey: "topic.lifecycle.expired.purpose", unlocksKey: "topic.lifecycle.expired.unlocks" },
+            provenance: input.sources.map(({ id }) => id),
+        });
+    if (input.block !== undefined)
+        obligations.push({
+            id: `block:${input.block.sourceId}`, code: input.block.reasonCode, kind: "wait", phase,
+            status: input.block.condition === "waiting" ? "waiting" : "blocked", priority: 30, blocking: true,
+            ...(input.block.target.kind === "actor" ? { responsibility: { kind: "actor", value: input.block.target.id } } : {}),
+            assignedActors: input.block.target.kind === "actor" ? [input.block.target.id] : [], consequence: "none",
+            presentation: { labelKey: "topic.block.label", promptKey: input.block.reasonCode, purposeKey: "topic.block.purpose", unlocksKey: "topic.block.unlocks" },
+            provenance: [input.block.sourceId],
+        });
+    if (lifecycle.reviewDue)
+        obligations.push({
+            id: "lifecycle:review-due", code: "setup.review-due", kind: "review", phase, status: "ready", priority: 1000,
+            blocking: false, responsibility: { kind: "role", value: "setup-editor" }, assignedActors: input.actorAssignments?.["setup-editor"] ?? [],
+            requiredAbility: "topic/write", consequence: "shared-state", command: "topic.review-setup",
+            presentation: { labelKey: "topic.lifecycle.review-due.label", promptKey: "topic.lifecycle.review-due.prompt", purposeKey: "topic.lifecycle.review-due.purpose", unlocksKey: "topic.lifecycle.review-due.unlocks" },
+            provenance: input.sources.map(({ id }) => id),
+        });
+    return obligations;
+}
+function obligationRank(obligation, input) {
+    if (input.status === "archived" || input.status === "redirected" || obligation.code.startsWith("safety.shape"))
+        return 0;
+    if (obligation.kind === "dispute" || input.sources.some(({ status }) => status === "failed"))
+        return 10;
+    if (obligation.kind === "expiry")
+        return 20;
+    if (obligation.kind === "wait")
+        return 30;
+    if (obligation.kind === "input")
+        return 40;
+    if (obligation.kind === "confirmation" || obligation.kind === "assent")
+        return 50;
+    if (obligation.kind === "transition")
+        return 60;
+    if (obligation.kind === "review")
+        return 70;
+    return 80;
 }
-function deriveCondition(input, phase, matches) {
+function choosePrimary(obligations, input) {
+    return [...obligations].sort((left, right) => obligationRank(left, input) - obligationRank(right, input)
+        || left.priority - right.priority || left.code.localeCompare(right.code))[0]?.id;
+}
+function deriveCondition(input, obligations) {
     if (input.shape === undefined || !input.historyCompatible)
         return "degraded";
-    const conditions = [];
-    const observed = sourceCondition(input);
-    if (observed !== undefined)
-        conditions.push(observed);
-    if (input.block !== undefined)
-        conditions.push(input.block.condition);
-    if (conditions.length > 0)
-        return conditions.sort((left, right) => CONDITION_PRIORITY[right] - CONDITION_PRIORITY[left])[0] ?? "on-track";
-    if (matches.some(({ gateStatus }) => gateStatus.some(({ gate, satisfied }) => (gate.kind === "field" || gate.kind === "field-any") && !satisfied)))
+    if (input.dispute?.status === "open" || input.sources.some(({ status }) => status === "disputed"))
+        return "disputed";
+    if (input.sources.some(({ status }) => status === "failed"))
+        return "failed";
+    if (obligations.some(({ kind }) => kind === "expiry"))
+        return "expired";
+    if (input.block?.condition === "blocked")
+        return "blocked";
+    if (input.block?.condition === "waiting")
+        return "waiting";
+    if (obligations.some(({ kind }) => kind === "input"))
         return "needs-input";
-    if (phase === "forming")
-        return "needs-acceptance";
+    if (obligations.some(({ kind }) => kind === "confirmation" || kind === "assent"))
+        return "needs-confirmation";
+    if (obligations.some(({ kind }) => kind === "review"))
+        return "review-due";
     return "on-track";
 }
 function phaseTag(input, phase) {
     const axis = input.shape?.shape.axes.find((candidate) => candidate.phase === phase);
-    return {
-        code: `phase:${phase}`,
-        source: axis === undefined
-            ? { progressRule: `phase:${phase}` }
-            : { axis: axis.code, state: input.axisStates[axis.code] ?? axis.initialState },
-        priority: 100,
-        tone: phase === "complete" ? "positive" : "neutral",
-        provenance: input.sources.map(({ id }) => id),
-    };
+    return { code: `phase:${phase}`, source: axis === undefined ? { progressRule: `phase:${phase}` } : { axis: axis.code, state: input.axisStates[axis.code] ?? axis.initialState }, priority: 100, tone: phase === "complete" ? "positive" : "neutral", provenance: input.sources.map(({ id }) => id) };
 }
 function conditionTone(condition) {
     if (condition === "disputed" || condition === "failed")
         return "critical";
-    if (condition === "blocked" || condition === "degraded")
+    if (condition === "blocked" || condition === "degraded" || condition === "expired")
         return "warning";
     if (condition === "waiting")
         return "info";
-    if (condition === "needs-input" || condition === "needs-acceptance")
+    if (["needs-input", "needs-confirmation", "review-due"].includes(condition))
         return "attention";
     return "neutral";
 }
@@ -111,66 +391,100 @@ function stateTags(input, phase, condition) {
     const tags = [phaseTag(input, phase)];
     if (condition === "on-track")
         return tags;
-    return [...tags, {
-            code: `condition:${condition}`,
-            source: { progressRule: `condition:${condition}` },
-            priority: condition === "degraded" ? 800 : CONDITION_PRIORITY[condition],
-            tone: conditionTone(condition),
-            provenance: input.block === undefined ? input.sources.map(({ id }) => id) : [input.block.sourceId],
-        }];
-}
-function reasonCode(phase, condition, candidates) {
-    if (phase === "dormant")
-        return "topic-dormant";
-    if (condition !== "on-track")
-        return `topic-${condition}`;
-    if (phase === "complete")
-        return candidates.some(({ transition }) => transition.completesTopic === true)
-            ? "topic-completion-required"
-            : "topic-complete";
-    return `topic-${phase}`;
+    return [...tags, { code: `condition:${condition}`, source: { progressRule: `condition:${condition}` }, priority: CONDITION_PRIORITY[condition], tone: conditionTone(condition), provenance: input.block === undefined ? input.sources.map(({ id }) => id) : [input.block.sourceId] }];
+}
+function readyCandidates(matches, input) {
+    let candidates = matches.filter(({ gateStatus }) => gateStatus.every(({ satisfied }) => satisfied));
+    if (!activationPolicyComplete(input))
+        candidates = candidates.filter(({ transition }) => transition.code !== "confirm-setup");
+    if (input.dispute?.status === "open")
+        candidates = candidates.filter(({ transition }) => transition.code === "resolve-dispute");
+    const lifecycle = lifecycleState(input);
+    if (lifecycle.expired || !timeUsable(input))
+        candidates = candidates.filter(({ transition }) => !PAUSED_PHASES.has(transition.phase));
+    return candidates;
+}
+function safetyObligation(input, phase) {
+    if (input.status === "archived" || input.status === "redirected")
+        return {
+            id: "safety:dormant", code: "safety.dormant", kind: "safety", phase, status: "unavailable", priority: 0,
+            blocking: true, assignedActors: [], consequence: "none", presentation: { labelKey: "topic.safety.dormant.label", promptKey: "topic.safety.dormant.prompt", purposeKey: "topic.safety.dormant.purpose" }, provenance: input.sources.map(({ id }) => id),
+        };
+    if (input.shape === undefined || !input.historyCompatible)
+        return {
+            id: "safety:shape-unavailable", code: "safety.shape-unavailable", kind: "safety", phase, status: "unavailable", priority: 0,
+            blocking: true, assignedActors: [], consequence: "none", presentation: { labelKey: "topic.safety.shape-unavailable.label", promptKey: "topic.safety.shape-unavailable.prompt", purposeKey: "topic.safety.shape-unavailable.purpose" }, provenance: input.sources.map(({ id }) => id),
+        };
+    return undefined;
 }
 export function projectTopicProgress(input) {
     const phase = activePhase(input);
-    const matches = phase === "dormant" ? [] : matchingTransitions(input, phase);
-    const condition = deriveCondition(input, phase, matches);
-    const suppress = phase === "dormant" || condition === "degraded";
-    const candidates = suppress ? [] : matches.filter(({ gateStatus }) => gateStatus.every(({ satisfied }) => satisfied));
+    const safety = safetyObligation(input, phase);
+    const matches = safety === undefined ? potentialTransitions(input, phase) : [];
+    const missing = phase === "forming" ? missingRequirements(matches, input) : [];
+    const policies = phase === "forming" && missing.length === 0 ? policyObligations(input) : [];
+    const candidates = safety === undefined ? readyCandidates(matches, input) : [];
+    const transitionObligations = candidates
+        .filter(({ transition }) => transition.code !== "edit-setup" || missing.length > 0)
+        .map((candidate) => obligationForTransition(candidate, input));
+    const obligations = [
+        ...(safety === undefined ? [] : [safety]),
+        ...contextualObligations(input, phase),
+        ...missing,
+        ...policies,
+        ...transitionObligations,
+    ];
+    const condition = phase === "dormant" ? "on-track" : deriveCondition(input, obligations);
+    const primaryObligationId = choosePrimary(obligations, input);
     return {
-        version: 1,
+        version: 2,
         topicId: input.topicId,
         topicRevision: input.topicRevision,
         contractRevision: input.contractRevision,
-        shapeDigest: input.shape?.digest ?? "sha256:0000000000000000000000000000000000000000000000000000000000000000",
+        shapeDigest: input.shape?.digest ?? EMPTY_DIGEST,
         phase,
         condition,
-        reasonCode: reasonCode(phase, condition, candidates),
+        reasonCode: phase === "complete" && candidates.some(({ transition }) => transition.completesTopic === true)
+            ? "topic-completion-required"
+            : primaryObligationId === undefined
+                ? (phase === "complete" ? "topic-complete" : `topic-${phase}`)
+                : `obligation:${obligations.find(({ id }) => id === primaryObligationId)?.code}`,
         axisStates: input.axisStates,
         stateTags: stateTags(input, phase, condition),
         candidates,
+        obligations,
+        ...(primaryObligationId === undefined ? {} : { primaryObligationId }),
+        ...(input.evaluationTime === undefined ? {} : { evaluatedAt: input.evaluationTime }),
         provenance: input.sources.map(({ id }) => id),
         ...(input.block === undefined ? {} : { block: input.block }),
+        ...(input.dispute === undefined ? {} : { dispute: input.dispute }),
     };
 }
 function evidenceMatches(source, transition) {
     const evidence = transition.evidence;
     if (source.kind !== evidence.kind || source.type !== evidence.type)
         return false;
-    if (evidence.finality === undefined)
-        return true;
-    return source.finality === evidence.finality;
+    return evidence.finality === undefined || source.finality === evidence.finality;
 }
 export function replayTopicShape(input, initialAxisStates = {}) {
     const axes = input.shape?.shape.axes ?? [];
     let states = Object.fromEntries(axes.map((axis) => [axis.code, initialAxisStates[axis.code] ?? axis.initialState]));
+    const processedSources = [];
     for (const source of input.sources) {
-        const replayInput = { ...input, axisStates: states };
-        const transition = input.shape?.shape.transitions.find((candidate) => states[candidate.predecessor.axis] === candidate.predecessor.state
+        processedSources.push(source);
+        const replayInput = { ...input, sources: processedSources, axisStates: states };
+        if (states.contract === "proposed" && activationSatisfied(replayInput))
+            states = { ...states, contract: "effective" };
+        const transition = input.shape?.shape.transitions.find((candidate) => candidate.predecessor.axis !== "contract"
+            && states[candidate.predecessor.axis] === candidate.predecessor.state
             && evidenceMatches(source, candidate)
             && candidate.gates.every((gate) => gateSatisfied(gate, replayInput)));
         if (transition !== undefined)
             states = { ...states, [transition.target.axis]: transition.target.state };
     }
+    const finalInput = { ...input, sources: processedSources, axisStates: states };
+    if (states.contract === "proposed" && activationSatisfied(finalInput))
+        states = { ...states, contract: "effective" };
     return states;
 }
 //# sourceMappingURL=progress.js.map