cbrowser 20.2.2 → 21.0.0

package/dist/visual/cognitive-transport-chain.js

@@ -2,7 +2,7 @@
  * Cognitive Optimal Transport — Sequential Transport Chain
  *
  * Implements the CHI 2027 paper's core contribution:
- * - 26-dimensional demand distribution computed from page features
+ * - 29-dimensional demand distribution computed from page features
  * - Sequential transport chain where each layer depletes capacity
  * - Asymmetric deficit-surplus cost
  * - Layer interaction terms
@@ -14,13 +14,24 @@
  * @see Section 3.4 of "Cognitive Optimal Transport: A Unified Framework"
  * @since v18.39.0
  */
-import { extractPageMetrics, } from './cognitive-transport.js';
+import { deriveMetrics, extractPageMetrics, } from './cognitive-transport.js';
+import { activeOverrides, param, readsOf } from './model-provenance.js';
+import { timeDemand } from './demand-laws.js';
+import { bootstrapPercentileInterval, intervalAt, percentileAt, percentileCurve, referencePopulation, referenceRaw, } from './ctc-reference.js';
 // ── Constants ──
 /**
- * The 26 demand dimensions used by the sequential transport chain.
- * Superset of the base 25 OT cognitive traits — includes extended traits
- * from CognitiveTraits that capture decision biases, learning transfer,
- * and emotional regulation.
+ * The 29 demand dimensions used by the sequential transport chain, covering
+ * the core capacities plus decision biases, learning transfer, emotional
+ * regulation and the bridged reading/motor/attention capacities.
+ *
+ * NOT the same space as COGNITIVE_TRAITS (29). Four dimensions exist only here
+ * (attentionPattern, motorPrecision, processingSpeed, textProcessing: no persona
+ * in the tool path carries them, so they read the missing-trait fallback, and
+ * none is in a layer). Four traits exist only there (attributionStyle,
+ * timeHorizon, authoritySensitivity: no demand term; siteFamiliarity: a visit
+ * state the demand reads, DemandOptions, since 21.0). Both differences are
+ * pinned in tests/transport-dimension-alignment.test.ts, so a new one fails a
+ * test; nothing asserts the two sets are equal.
  */
 export const DEMAND_DIMENSIONS = [
     // Core capacity traits
@@ -44,19 +55,11 @@ export const DEMAND_DIMENSIONS = [
     'mentalModelFlexibility', 'curiosity',
     // Processing
     'processingSpeed', 'textProcessing',
-    // Experience
-    //
-    // Absent until 2026-08-02, which is why the siteFamiliarity parameter was
-    // inert. It is a member of COGNITIVE_TRAITS, so a persona carried a capacity
-    // on this dimension, but the demand vector had no slot for it -- so the
-    // capacity was transported against a demand that did not exist and
-    // contributed nothing. Runs at familiarity 0 and 1 came back byte-identical
-    // while the tool attested the parameter had been applied.
-    //
-    // The two vectors are supposed to be the same space. A dimension present in
-    // one and missing from the other is silently dropped, and there is now a test
-    // asserting COGNITIVE_TRAITS and DEMAND_DIMENSIONS do not diverge.
-    'siteFamiliarity',
+    // siteFamiliarity left the vector in 21.0 (Stage C). It is the visit's
+    // state, not the person's: Cockburn, Gutwin & Greenberg's (2007) expertise e
+    // on the choosing time, supplied per run (DemandOptions) and the same for
+    // every persona in it. As a capacity it read a navigation-depth demand that
+    // was a constant on 92% of real pages, so every persona paid the same 0.056.
     // Capacity, bridged from the formal reading and pointing models.
     //
     // These layers previously read DISPOSITION traits -- readingTendency for
@@ -87,21 +90,38 @@ export const DEMAND_DIMENSIONS = [
  */
 export const LAYER_DEFINITIONS = [
     {
-        name: 'saliency',
-        traits: ['changeBlindness', 'attentionPattern'],
+        // Named `saliency` until 21.0, which claimed a mechanism this layer does not
+        // have. Its demand is pageMetrics.visualComplexity (a count of visual
+        // elements) and the animation level; the fitted attention model (UEyes,
+        // attention-transport.ts) never reaches it. The name now says what it reads.
+        //
+        // attentionPattern left this layer in 21.0. It is not a CognitiveTraits
+        // field, so as cognitive_effort builds a persona its capacity was the
+        // missing-trait fallback for everyone: a term that moved every score and
+        // told no two personas apart.
+        name: 'visualComplexity',
+        traits: ['changeBlindness'],
     },
     {
         name: 'cognitiveLoad',
-        // siteFamiliarity added 2026-08-02. It was in COGNITIVE_TRAITS and in no
-        // layer, so it reached the profile, got a capacity, and then contributed to
-        // nothing -- the third and final reason the parameter was inert. Knowing a
-        // site is a substitute for holding its layout in working memory, which is
-        // exactly this layer, and the demand term for it comes from the same
-        // navigationDepth signal that already feeds workingMemory here.
-        // `transferLearning` moved here from readability 2026-08-02: applying a
-        // pattern learned on one interface to another is a load question, not a
-        // decoding one, and readability is now decoding-only.
-        traits: ['comprehension', 'workingMemory', 'informationForaging', 'siteFamiliarity', 'transferLearning'],
+        // STAGE C (21.0): four abilities asked the choosing time. Each takes the
+        // decision demand, d = T_choose / (T_choose + tau), with no share, so a
+        // value reads as tolerated reference choosing time tau c / (1 - c): the
+        // claim is the persona value (a hypothesis, provenance/personas.ts), not a
+        // coefficient. Through 20.x the layer read text features (word and
+        // sentence length, a lexical diversity that is 1 on any page with 100
+        // distinct words, a nested text count) that the reading law now prices,
+        // against `comprehension`, which is grasp of UI conventions, not reading.
+        // The channel is where the evidence points (convention knowledge and web
+        // experience act on finding things: research/stage-c-design.md, 3.5); the
+        // magnitude is the persona's value. Same seconds, second layer: decision
+        // prices dispositions against them, this layer abilities, as reading
+        // seconds feed both readability and readingAttention.
+        //
+        // siteFamiliarity left this layer: it is the visit's e on the choosing
+        // time (DemandOptions), not a capacity. `transferLearning` moved here from
+        // readability 2026-08-02.
+        traits: ['comprehension', 'workingMemory', 'informationForaging', 'transferLearning'],
     },
     {
         name: 'decision',
@@ -154,7 +174,16 @@ export const LAYER_DEFINITIONS = [
     },
     {
         name: 'frustration',
-        traits: ['resilience', 'selfEfficacy', 'patience', 'emotionalContagion'],
+        // Two traits, not four, as of 21.0. resilience and selfEfficacy sat here
+        // through 20.x, but no page feature writes demand to either, so in the
+        // asymmetric mode every tool runs they could only ever be surplus on
+        // surplus-free dimensions: cost 0, every time. All they did there was halve
+        // the content gate, which is the mean demand over this list, so frustration
+        // scored at roughly half its own demand. (In the symmetric ablation, where
+        // all surplus is billed, they instead charged their whole capacity squared
+        // against a page that asked nothing of them.) They remain dimensions --
+        // abandonment reads resilience -- and are no longer in a layer.
+        traits: ['patience', 'emotionalContagion'],
     },
     {
         name: 'readability',
@@ -208,19 +237,21 @@ export const LAYER_DEFINITIONS = [
     },
 ];
 /**
- * Pairwise interaction definitions — the top 5 cross-layer effects
- * identified in the CHI 2027 paper's empirical calibration (Table 3).
+ * Pairwise interaction definitions: five cross-layer couplings, each a
+ * hand-set hypothesis registered in provenance/chain.ts (no empirical
+ * calibration exists for them; an earlier comment claimed one). The weight
+ * is read through param() so a run records that it depended on it.
  */
-const INTERACTION_PAIRS = [
-    { a: 'cognitiveLoad', b: 'decision', weight: 0.15 },
-    { a: 'saliency', b: 'cognitiveLoad', weight: 0.15 },
-    { a: 'frustration', b: 'readability', weight: 0.15 },
-    { a: 'cognitiveLoad', b: 'motor', weight: 0.15 },
-    { a: 'frustration', b: 'decision', weight: 0.15 },
+export const INTERACTION_PAIRS = [
+    { a: 'cognitiveLoad', b: 'decision', weight: 'chain.interaction.cognitiveLoadXdecision' },
+    { a: 'visualComplexity', b: 'cognitiveLoad', weight: 'chain.interaction.visualComplexityXcognitiveLoad' },
+    { a: 'frustration', b: 'readability', weight: 'chain.interaction.frustrationXreadability' },
+    { a: 'cognitiveLoad', b: 'motor', weight: 'chain.interaction.cognitiveLoadXmotor' },
+    { a: 'frustration', b: 'decision', weight: 'chain.interaction.frustrationXdecision' },
 ];
-/** Asymmetric cost weights (Theorem 2 in paper) */
-const WEIGHT_DEFICIT = 1.0; // demand > capacity: high cost
-const WEIGHT_SURPLUS = 0.3; // capacity > demand: low cost (surplus is cheap)
+// Asymmetric cost weights (chain.weightDeficit 1, chain.weightSurplus 0.3):
+// hand-set hypotheses registered in provenance/chain.ts, not a theorem. Read
+// into CHAIN_PARAMS at function entry.
 /**
  * Dimensions where having MORE than the page asks for costs nothing at all.
  *
@@ -250,22 +281,46 @@ const WEIGHT_SURPLUS = 0.3; // capacity > demand: low cost (surplus is cheap)
  * That is the same defect as every other one this campaign found: a number that
  * does not mean what its name says.
  *
- * Four dimensions are billed BECAUSE THEIR SCALE IS INVERTED -- changeBlindness,
- * trustCalibration, curiosity and attentionPattern name a deficit at their high
- * end ("misses most changes", "accepts claims at face value", "easily
- * distracted"). Surplus there is more of the deficit, and billing it is
- * correct.
+ * Three dimensions stay billed BECAUSE THEIR SCALE IS INVERTED -- trustCalibration,
+ * curiosity and attentionPattern name a deficit at their high end ("accepts
+ * claims at face value", "easily distracted"), and none is in a layer, so the
+ * billing moves no number. changeBlindness was the fourth until 2026-10-24
+ * (below).
  *
  * `selfEfficacy` is the weakest call in the free set: over-confidence is a real
  * hazard, but its cost surfaces through riskTolerance and trustCalibration
  * rather than as effort spent, so it is treated as the ability its high end
  * describes.
+ *
+ * A STIMULUS NEVER MAKES A PAGE CHEAPER (2026-10-24, option f of
+ * research/surplus-billing-design.md). A billed surplus costs
+ * weightSurplus (c - d)^2, which FALLS as the page's demand d rises toward the
+ * persona's value c. Measured on the 514 reference pages, one carousel on a
+ * static page lowered the typical user's viewport totalCTC by 0.085 and was
+ * cheaper on 92% of them, because emotionalContagion's only demand is motion
+ * (0 on a calm page) and its calm-page surplus was the largest bill on the
+ * page. So:
+ *  - emotionalContagion is priced by EXPOSURE (EXPOSURE_DIMENSIONS):
+ *    weightSurplus x c x d. Contagion is caught from an expression (Hatfield,
+ *    Bensman, Thornton & Rapson 2014), so with no stimulus nothing is caught
+ *    and with no susceptibility nothing is caught either. The product form,
+ *    the weight and animation as the stimulus are hypotheses.
+ *  - changeBlindness is surplus-free: missing more changes than a page makes
+ *    costs nothing on a page that makes none (Simons & Levin 1997: change
+ *    blindness is "the inability to detect changes"). Its deficit side still
+ *    prices a good noticer on a complex page, a named limit.
+ *  - patience is surplus-free: its value reads as tolerated reading time
+ *    (Stage C), and tolerance left unused is not time spent; the page's time
+ *    is priced by the reading and decision layers.
+ * The decision-layer susceptibilities (fearOfMissingOut,
+ * socialProofSensitivity, anchoringBias, riskTolerance) are DEFERRED, a named
+ * limit: they still get cheaper as choosing time grows, because the cue each
+ * responds to (urgency, reviews, a first option, uncertain controls) is not
+ * measured and a share of choosing time stands in for it.
  */
-const SURPLUS_FREE_DIMENSIONS = new Set([
+export const SURPLUS_FREE_DIMENSIONS = new Set([
     // Derived capacity bridges -- pure abilities by construction.
     'readingCapacity', 'motorCapacity', 'sustainedAttention', 'processingSpeed', 'textProcessing', 'motorPrecision',
-    // Experience. Knowing a site better cannot make it harder to use.
-    'siteFamiliarity',
     // Abilities: every one of these has a highEnd naming something a person CAN
     // do, not something they TEND to do.
     'comprehension', // "Instant recognition of all conventions"
@@ -277,27 +332,36 @@ const SURPLUS_FREE_DIMENSIONS = new Set([
     'interruptRecovery', // "Seamlessly resumes exactly where left off"
     'mentalModelFlexibility', // "Highly adaptive - quickly forms new mental models"
     'informationForaging', // "Follows information scent efficiently, abandons low-yield paths"
+    // Free since 2026-10-24 (see above): neither surplus is effort spent.
+    'changeBlindness', // "Misses most changes outside focus area" -- nothing to miss where nothing changes
+    'patience', // "Waits indefinitely" -- a tolerance; unused, it is not time spent
+]);
+/**
+ * Dimensions priced by exposure rather than by a gap: weightSurplus x c x d,
+ * the persona's susceptibility times the stimulus, in asymmetric mode (the
+ * symmetric ablation keeps the gap). 0 when the page presents nothing, never
+ * lower for more stimulus or more susceptibility. See the note above.
+ */
+export const EXPOSURE_DIMENSIONS = new Set([
+    'emotionalContagion', // "Adopts UI's emotional tone completely" -- a susceptibility to the page's tone
 ]);
 /**
  * Dimensions whose surplus IS billed, and why each one earns it.
  *
  * Stated explicitly rather than left as "everything else", so that a dimension
  * added to DEMAND_DIMENSIONS cannot acquire a billing treatment by default. A
- * test asserts every dimension appears in exactly one of the two sets.
+ * test asserts every dimension appears in exactly one of the three sets.
  */
 const SURPLUS_BILLED_DIMENSIONS = new Set([
-    'patience', // "Waits indefinitely" -- waiting longer than needed is time spent
-    'riskTolerance', // "Clicks anything that might work" -- a tendency, and a hazard
+    'riskTolerance', // "Clicks anything that might work" -- a tendency, and a hazard (deferred, see above)
     'persistence', // "Keeps trying same approach repeatedly" -- repeating unnecessary work
     'readingTendency', // "Reads every word before acting" -- reading a page that did not need it
-    'emotionalContagion', // susceptibility to the interface's tone
     'satisficing', // a decision STRATEGY, not an ability
-    'anchoringBias', // a bias, by name
-    'fearOfMissingOut', // susceptibility to urgency and scarcity
-    'socialProofSensitivity', // susceptibility to what others chose
+    'anchoringBias', // a bias, by name (deferred, see above)
+    'fearOfMissingOut', // susceptibility to urgency and scarcity (deferred, see above)
+    'socialProofSensitivity', // susceptibility to what others chose (deferred, see above)
     'metacognitivePlanning', // "Careful planning before any action" -- planning a trivial page is waste
     // Inverted scales: the HIGH end is the deficit, so surplus is more deficit.
-    'changeBlindness', // "Misses most changes outside focus area"
     'trustCalibration', // "Highly trusting, accepts claims at face value"
     'curiosity', // "Easily distracted by interesting elements"
     'attentionPattern', // scanning-vs-thorough disposition
@@ -321,7 +385,7 @@ const SURPLUS_BILLED_DIMENSIONS = new Set([
  * or a dose-response fit on real session data. Until then it is a shape someone
  * chose, not a shape anyone measured. (2026-08-03)
  */
-export const ABANDONMENT_HILL_EXPONENT = 2;
+export const ABANDONMENT_HILL_EXPONENT = param('chain.abandonmentHillExponent');
 /**
  * Relative weighting between the two motor layers. BOTH DEFAULT TO 1.0 AND ARE
  * UNCALIBRATED.
@@ -342,66 +406,104 @@ export const MOTOR_LAYER_WEIGHTS = {
     /** UNCALIBRATED. Sequence execution. */
     motorProcedure: 1.0,
 };
-/** Capacity depletion rate per layer (alpha_i, Section 3.4) */
-const DEPLETION_RATE = 0.15;
-/** Minimum residual capacity floor (prevents total exhaustion) */
-const CAPACITY_FLOOR = 0.05;
-/**
- * Numerical floor on residual capacity. NOT a behavioural limit.
- *
- * CAPACITY_FLOOR above was doing behavioural work it should not have: at 0.05
- * it was reachable inside a single page, and once reached the account stopped
- * responding to cost at all. Proportional drawdown asymptotes toward zero
- * instead, so this exists only to keep the value away from denormals and to
- * keep `gap = demand - capacity` finite. It is three orders of magnitude below
- * anything a persona reaches in practice. (2026-08-03)
- */
-const CAPACITY_EPSILON = 1e-4;
-/**
- * Largest fraction of remaining capacity one layer may draw. UNCALIBRATED.
- *
- * Prevents a single very expensive layer from emptying the account outright,
- * which would reintroduce the saturation this replaced. 0.5 means no layer can
- * take more than half of what is left, whatever its cost.
- *
- * What would settle it: within-session effort measurements across a task
- * sequence. Same status as ABANDONMENT_HILL_EXPONENT and MOTOR_LAYER_WEIGHTS.
- */
-const MAX_DRAWDOWN_FRACTION = 0.5;
+// ── Registry reads ──
+//
+// Every hand-set number the chain uses lives in provenance/chain.ts and is
+// read through param() once per call, at function entry. The code cannot
+// drift from the registry (an unregistered id throws), and a run under
+// withProvenance records exactly which constants its answer rested on.
+//
+// Depletion (chain.depletionRate 0.15, chain.maxDrawdownFraction 0.5,
+// chain.indirectDepletionShare 0.5) and the numerical floor
+// (chain.capacityEpsilon 1e-4) are registered there with their status and what
+// would settle them. The floor binds only when a residual falls below it; through
+// 20.x siteFamiliarity sat at 0 in the tool path and was lifted to 1e-4 on every
+// run, and since it left the vector in 21.0 no built-in persona starts below 0.1.
+// The old CAPACITY_FLOOR (0.05)
+// was removed 2026-10-21: nothing read it since proportional drawdown replaced
+// the clamp on 2026-08-03.
+/** Read every id in `ids` through param(); one object per call so the reads are recorded. */
+function readParams(ids) {
+    const out = {};
+    for (const k in ids)
+        out[k] = param(ids[k]);
+    return out;
+}
+const DEMAND_IDS = {
+    animationSigmoidThreshold: 'chain.demand.animation.sigmoidThreshold',
+    animationSigmoidScale: 'chain.demand.animation.sigmoidScale',
+    animationChangeBlindness: 'chain.demand.animation.changeBlindness',
+    animationEmotionalContagion: 'chain.demand.animation.emotionalContagion',
+    distractorAnimationShare: 'chain.demand.distractor.animationShare',
+    distractorVisualShare: 'chain.demand.distractor.visualShare',
+    sustainedBase: 'chain.demand.sustained.base',
+    sustainedDistractorGain: 'chain.demand.sustained.distractorGain',
+    choiceAnchoringBias: 'chain.demand.choice.anchoringBias',
+    choiceFearOfMissingOut: 'chain.demand.choice.fearOfMissingOut',
+    choiceSocialProofSensitivity: 'chain.demand.choice.socialProofSensitivity',
+    decisionRiskTolerance: 'chain.demand.decision.riskTolerance',
+};
+const CHAIN_IDS = {
+    missingTraitCapacity: 'chain.missingTraitCapacity',
+    engagementAtSkim: 'chain.engagement.atSkim',
+    engagementRange: 'chain.engagement.range',
+    weightDeficit: 'chain.weightDeficit',
+    weightSurplus: 'chain.weightSurplus',
+    contentScaleGain: 'chain.contentScaleGain',
+    depletionGate: 'chain.depletionGate',
+    depletionRate: 'chain.depletionRate',
+    indirectDepletionShare: 'chain.indirectDepletionShare',
+    maxDrawdownFraction: 'chain.maxDrawdownFraction',
+    capacityEpsilon: 'chain.capacityEpsilon',
+    roundingScale: 'chain.roundingScale',
+    patienceShare: 'chain.abandonment.patienceShare',
+    resilienceShare: 'chain.abandonment.resilienceShare',
+    toleranceGain: 'chain.abandonment.toleranceGain',
+    toleranceFloor: 'chain.abandonment.toleranceFloor',
+    abandonmentHillExponent: 'chain.abandonmentHillExponent',
+};
 // ── Sigmoid Helper ──
 /**
  * Standard logistic sigmoid for mapping raw page metrics to demand values.
- * Calibrated thresholds ensure typical web pages produce demands in [0.1, 0.9].
+ * The threshold and scale are hand-set hypotheses (see provenance/chain.ts),
+ * chosen so typical web pages produce demands in [0.1, 0.9]; not calibrated.
  */
 function sigmoid(raw, threshold, scale) {
+    // No exponent clamp. One was registered (chain.sigmoidExponentClamp, 500)
+    // and could not change a value: x > 500 needs raw below zero, which the
+    // input sanitiser forbids, and for x < -500 the plain form already returns
+    // exactly 1. Math.exp overflows to Infinity, which this form maps to 0, not
+    // NaN. Removed in 21.0 when the dead-constant test found it.
     const x = -(raw - threshold) / scale;
-    // Clamp exponent to prevent overflow
-    if (x > 500)
-        return 0;
-    if (x < -500)
-        return 1;
     return 1 / (1 + Math.exp(x));
 }
 // ── 1. Demand Distribution Computation ──
 /**
- * Compute the 26-dimensional demand distribution from page metrics.
+ * Compute the 29-dimensional demand distribution from page metrics.
  *
- * Each page feature maps to specific trait dimensions via calibrated
- * sigmoid functions. The mapping encodes HOW each page characteristic
- * creates cognitive demand on specific user capacities.
+ * Since Stage B and C the demand is law times against one time budget, d =
+ * T / (T + tau) (demand-laws.ts, law.timeBudget): pointing (Fitts), choosing
+ * (Cockburn et al.'s menu model), reading (Brysbaert), procedure (KLM). What
+ * remains hand-set are the shares of those demands some traits take and the
+ * motion and clutter curves, every one a hypothesis in provenance/chain.ts.
+ * The text features (informationDensity, textDensity, word and sentence
+ * length, lexical diversity, long and technical words) and navigationDepth
+ * are reported on PageMetrics and drive no demand: reading time prices text,
+ * and depth is a property of the path, not the page (research/stage-c-design.md).
  *
  * Traits not affected by any page feature receive demand = 0.0 (no demand).
  *
  * @param pageMetrics - Extracted page analysis metrics
- * @returns DemandDistribution with per-trait demand and variance
+ * @param options - The visit: siteFamiliarity, Cockburn et al.'s expertise e
+ *   on the choosing time, the same for every persona scored in a run
+ * @returns DemandDistribution with per-trait demand
  */
-export function computeDemandDistribution(pageMetrics) {
+export function computeDemandDistribution(pageMetrics, options) {
+    const D = readParams(DEMAND_IDS);
     const demands = {};
-    const variance = {};
-    // Initialize all 26 dimensions to zero demand
+    // Initialize every dimension to zero demand
     for (const dim of DEMAND_DIMENSIONS) {
         demands[dim] = 0;
-        variance[dim] = 0;
     }
     // Sanitize inputs — guard against NaN, undefined, negative
     const safe = (v, fallback = 0) => {
@@ -409,100 +511,80 @@ export function computeDemandDistribution(pageMetrics) {
             return fallback;
         return Math.max(0, v);
     };
-    const infoDensity = safe(pageMetrics.informationDensity);
     const visCplx = safe(pageMetrics.visualComplexity);
-    const interactiveCount = safe(pageMetrics.interactiveElementCount);
-    const textDens = safe(pageMetrics.textDensity);
     const animLevel = safe(pageMetrics.animationLevel);
-    const choices = safe(pageMetrics.choiceCount);
-    const navDepth = safe(pageMetrics.navigationDepth);
-    // ── informationDensity → comprehension, workingMemory, readingTendency, informationForaging
-    // Page metrics already use logScale (0-1) — pass through directly for differentiation
-    const infoDemand = infoDensity;
-    demands.comprehension = Math.max(demands.comprehension, infoDemand);
-    demands.workingMemory = Math.max(demands.workingMemory, infoDemand * 0.9);
-    demands.readingTendency = Math.max(demands.readingTendency, infoDemand * 0.85);
-    demands.informationForaging = Math.max(demands.informationForaging, infoDemand * 0.8);
-    variance.comprehension += infoDensity * 0.1;
-    variance.workingMemory += infoDensity * 0.08;
-    variance.readingTendency += infoDensity * 0.07;
-    variance.informationForaging += infoDensity * 0.06;
-    // ── visualComplexity → changeBlindness, mentalModelFlexibility, attentionPattern (inferred)
+    // ── The law times, each a demand against one budget ──
+    // d = T / (T + tau), tau = law.timeBudget: 0 at no work, 0.5 at the budget.
+    // No fallback: a PageMetrics without them was not derived from a measurement
+    // (deriveMetrics) and has no motor, decision, procedure or reading demand to
+    // give. interactiveElementCount and choiceCount stay on PageMetrics as
+    // reported counts; no demand reads them now.
+    const seconds = (k) => {
+        const v = pageMetrics[k];
+        if (typeof v !== 'number' || !Number.isFinite(v) || v < 0) {
+            throw new Error(`computeDemandDistribution: pageMetrics.${k} must be a finite number of seconds >= 0 (got ${String(v)}). Derive the metrics from a measurement (extractPageMetrics, deriveMetrics) or pass the law times to computeDemandFromRawMetrics.`);
+        }
+        return v;
+    };
+    // The visit. Cockburn, Gutwin & Greenberg (2007), Eq. 4: decision/search time
+    // interpolates from novice linear search to the Hick-Hyman expert limit by
+    // expertise e, because the expert's "visual search time decreases towards
+    // zero". A first visit (e = 0) is the default and what the reference curve is
+    // built at, and it reads the novice time alone, exactly as before.
+    const e = options?.siteFamiliarity ?? 0;
+    if (typeof e !== 'number' || !Number.isFinite(e) || e < 0 || e > 1) {
+        throw new Error(`computeDemandDistribution: siteFamiliarity must be a number in [0, 1], Cockburn et al.'s expertise e (got ${String(e)})`);
+    }
+    const novice = seconds('choosingSeconds');
+    const expert = seconds('choosingSecondsExpert');
+    const pointingDemand = timeDemand(seconds('pointingSeconds'));
+    // The decision dispositions keep the first-visit choosing time on every run
+    // (Stage B). Familiarity acts on the finding abilities below instead: the
+    // dispositions bill surplus, so a shorter choosing time would turn a small
+    // deficit into billed surplus, and measured on the reference pages a familiar
+    // visit then cost MORE than a first one on 72 of 513 for the typical user.
+    // Knowing a site cannot make it harder.
+    const decisionDemand = timeDemand(novice);
+    // What familiarity shortens: the search for where things are, the work the
+    // cognitiveLoad abilities are asked. At e = 0 this is 1 x novice + 0, the
+    // novice time to the last bit, so a first visit is unchanged.
+    const findingDemand = timeDemand((1 - e) * novice + e * expert);
+    const readingDemand = timeDemand(seconds('readingSeconds'));
+    const procedureDemand = timeDemand(seconds('procedureSeconds'));
+    // Demand is written only to dimensions some layer reads. Through 20.x these
+    // curves also wrote readingTendency, mentalModelFlexibility,
+    // interruptRecovery, metacognitivePlanning, persistence and motorPrecision,
+    // none of which is in a layer, so those terms (and eight registered weights)
+    // changed no number. Removed in 21.0; the dimensions themselves remain.
+    // ── visualComplexity → changeBlindness
     const visDemand = visCplx; // already 0-1 from logScale
     demands.changeBlindness = Math.max(demands.changeBlindness, visDemand);
-    demands.mentalModelFlexibility = Math.max(demands.mentalModelFlexibility, visDemand * 0.7);
-    demands.attentionPattern = Math.max(demands.attentionPattern, visDemand * 0.85);
-    variance.changeBlindness += visCplx * 0.12;
-    variance.mentalModelFlexibility += visCplx * 0.08;
-    variance.attentionPattern += visCplx * 0.1;
-    // ── interactiveElementCount → riskTolerance, satisficing, proceduralFluency, motorPrecision (inferred)
-    // Use logScale for element count — 20 elements = 0.5, 100 = 0.83, 500 = 0.96
-    const interDemand = interactiveCount / (interactiveCount + 20);
-    demands.riskTolerance = Math.max(demands.riskTolerance, interDemand * 0.75);
-    demands.satisficing = Math.max(demands.satisficing, interDemand * 0.8);
-    demands.proceduralFluency = Math.max(demands.proceduralFluency, interDemand * 0.9);
-    demands.motorPrecision = Math.max(demands.motorPrecision, interDemand);
-    variance.riskTolerance += interDemand * 0.06;
-    variance.satisficing += interDemand * 0.07;
-    variance.proceduralFluency += interDemand * 0.08;
-    variance.motorPrecision += interDemand * 0.1;
-    // ── textDensity → readingTendency, patience, comprehension
-    const textDemand = textDens; // already 0-1 from logScale
-    demands.readingTendency = Math.max(demands.readingTendency, textDemand);
-    demands.patience = Math.max(demands.patience, textDemand * 0.7);
-    demands.comprehension = Math.max(demands.comprehension, textDemand * 0.85);
-    variance.readingTendency += textDens * 0.09;
-    variance.patience += textDens * 0.06;
-    variance.comprehension += textDens * 0.08;
-    // ── Text Readability Metrics (v18.56) ──
-    // These measure HOW HARD the text is to read, not just how much there is.
-    // Captures language effects (German compound words), technical jargon, prose complexity.
-    const avgWordLen = safe(pageMetrics.avgWordLength);
-    const avgSentLen = safe(pageMetrics.avgSentenceLength);
-    const lexDiv = safe(pageMetrics.lexicalDiversity);
-    const longWordR = safe(pageMetrics.longWordRatio);
-    const techDens = safe(pageMetrics.technicalDensity);
-    if (avgWordLen > 0 || avgSentLen > 0) {
-        // avgWordLength → comprehension, readingTendency
-        // Longer words = harder to parse (especially for dyslexic, ADHD, non-native speakers)
-        demands.comprehension = Math.max(demands.comprehension, avgWordLen * 0.9);
-        demands.readingTendency = Math.max(demands.readingTendency, avgWordLen * 0.85);
-        variance.comprehension += avgWordLen * 0.12;
-        variance.readingTendency += avgWordLen * 0.1;
-        // avgSentenceLength → workingMemory, patience, comprehension
-        // Longer sentences demand more working memory to hold clause structure
-        demands.workingMemory = Math.max(demands.workingMemory, avgSentLen * 0.85);
-        demands.patience = Math.max(demands.patience, avgSentLen * 0.7);
-        demands.comprehension = Math.max(demands.comprehension, avgSentLen * 0.8);
-        variance.workingMemory += avgSentLen * 0.1;
-        variance.patience += avgSentLen * 0.07;
-        // lexicalDiversity → comprehension, transferLearning
-        // High vocabulary diversity = more cognitive effort to track meaning
-        demands.comprehension = Math.max(demands.comprehension, lexDiv * 0.75);
-        demands.transferLearning = Math.max(demands.transferLearning, lexDiv * 0.65);
-        variance.comprehension += lexDiv * 0.08;
-        // longWordRatio → readingTendency, comprehension
-        // Pages with many 7+ character words are harder to skim
-        demands.readingTendency = Math.max(demands.readingTendency, longWordR * 0.9);
-        demands.comprehension = Math.max(demands.comprehension, longWordR * 0.8);
-        variance.readingTendency += longWordR * 0.11;
-        // technicalDensity → comprehension, transferLearning, mentalModelFlexibility
-        // 10+ character words signal compound terms, jargon, domain-specific vocabulary
-        demands.comprehension = Math.max(demands.comprehension, techDens * 0.95);
-        demands.transferLearning = Math.max(demands.transferLearning, techDens * 0.8);
-        demands.mentalModelFlexibility = Math.max(demands.mentalModelFlexibility, techDens * 0.7);
-        variance.comprehension += techDens * 0.13;
-        variance.transferLearning += techDens * 0.09;
-        variance.mentalModelFlexibility += techDens * 0.07;
-    }
-    // ── animationLevel → changeBlindness, interruptRecovery, emotionalContagion
-    const animDemand = sigmoid(animLevel, 0.3, 0.15);
-    demands.changeBlindness = Math.max(demands.changeBlindness, animDemand * 0.9);
-    demands.interruptRecovery = Math.max(demands.interruptRecovery, animDemand * 0.85);
-    demands.emotionalContagion = Math.max(demands.emotionalContagion, animDemand * 0.7);
-    variance.changeBlindness += animLevel * 0.1;
-    variance.interruptRecovery += animLevel * 0.09;
-    variance.emotionalContagion += animLevel * 0.07;
+    // ── procedure (KLM M per entry step) → proceduralFluency
+    demands.proceduralFluency = Math.max(demands.proceduralFluency, procedureDemand);
+    // ── reading → patience (Stage C)
+    //
+    // patience is "tolerance for delays, loading, friction before abandoning",
+    // and its registered measure is a time to abandonment. It takes the reading
+    // demand whole, so a value reads as tolerated reference reading time,
+    // tau c / (1 - c): 0.5 tolerates the budget itself, the median first-visit
+    // stay the budget is. Through 20.x it took 0.7 of textDensity (a nested text
+    // count per unit area) and 0.7 of sentence length, two hand-set shares of two
+    // text features the reading law now prices.
+    demands.patience = Math.max(demands.patience, readingDemand);
+    // ── animationLevel → changeBlindness, emotionalContagion
+    //
+    // ZERO AT REST, as of 21.0. The logistic is centred at the threshold (0.3),
+    // so at animationLevel 0 it already reads 0.119, and that offset was demand:
+    // a page with nothing moving asked ~0.107 of changeBlindness and ~0.083 of
+    // emotionalContagion and fed distractor pressure, so an empty page had a
+    // non-zero raw cost. The curve is now shifted and rescaled by its own value at
+    // 0: still monotone in animationLevel, 0 at rest, below 1 and approaching it.
+    // No new constant: the offset is the registered curve evaluated at 0.
+    const animRaw = sigmoid(animLevel, D.animationSigmoidThreshold, D.animationSigmoidScale);
+    const animAtRest = sigmoid(0, D.animationSigmoidThreshold, D.animationSigmoidScale);
+    const animDemand = animAtRest < 1 ? Math.max(0, (animRaw - animAtRest) / (1 - animAtRest)) : 0;
+    demands.changeBlindness = Math.max(demands.changeBlindness, animDemand * D.animationChangeBlindness);
+    demands.emotionalContagion = Math.max(demands.emotionalContagion, animDemand * D.animationEmotionalContagion);
     // ── textDensity × distractor pressure → sustainedAttention
     //
     // How much attention the page asks you to HOLD, as opposed to how hard its
@@ -527,7 +609,7 @@ export function computeDemandDistribution(pageMetrics) {
     // re-creates the exact inversion that removing readingTendency fixed --
     // measured: at a flat 1.0 base, ADHD outscored dyslexic on readability on a
     // page with animationLevel 0, which is the wrong answer.
-    const distractorPressure = Math.min(1, animDemand * 0.7 + visDemand * 0.3);
+    const distractorPressure = Math.min(1, animDemand * D.distractorAnimationShare + visDemand * D.distractorVisualShare);
     // `max(textDens, infoDensity)`, not `textDens` alone -- the same base
     // readingCapacity uses below, and for the same reason.
     //
@@ -545,90 +627,82 @@ export function computeDemandDistribution(pageMetrics) {
     // Sharing the base makes the two halves of reading agree about how much there is
     // to read; the 0.7 vs 0.9 coefficients still order them.
     //
-    // NOT applied to saliency, whose fall has a different cause: its inputs
-    // (visualComplexity, animationLevel) are counts and RISE with page size. It falls
-    // because its traits are surplus-BILLED, so rising demand shrinks the surplus gap
-    // and the 0.3-weighted cost with it. Same symptom, unrelated mechanism, and it
-    // needs its own decision rather than this one applied twice.
-    const sustainBase = Math.max(textDemand, infoDensity);
-    const sustainDemand = Math.min(1, sustainBase * 0.7 * (1 + distractorPressure * 0.7));
-    demands.sustainedAttention = Math.max(demands.sustainedAttention, sustainDemand);
-    variance.sustainedAttention += textDens * 0.1 + animLevel * 0.08;
-    // ── choiceCount → satisficing, anchoringBias, fearOfMissingOut, socialProofSensitivity
-    // LogScale: 10 choices = 0.5, 30 = 0.75, 100 = 0.91
-    const choiceDemand = choices / (choices + 10);
-    demands.satisficing = Math.max(demands.satisficing, choiceDemand);
-    demands.anchoringBias = Math.max(demands.anchoringBias, choiceDemand * 0.85);
-    demands.fearOfMissingOut = Math.max(demands.fearOfMissingOut, choiceDemand * 0.75);
-    demands.socialProofSensitivity = Math.max(demands.socialProofSensitivity, choiceDemand * 0.7);
-    variance.satisficing += Math.min(1, choices / 20) * 0.1;
-    variance.anchoringBias += Math.min(1, choices / 20) * 0.08;
-    variance.fearOfMissingOut += Math.min(1, choices / 20) * 0.07;
-    variance.socialProofSensitivity += Math.min(1, choices / 20) * 0.06;
-    // ── navigationDepth → workingMemory, metacognitivePlanning, persistence, transferLearning
-    // LogScale: depth 2 = 0.4, depth 5 = 0.63, depth 10 = 0.77
-    const navDemand = navDepth / (navDepth + 3);
-    demands.workingMemory = Math.max(demands.workingMemory, navDemand * 0.95);
-    demands.metacognitivePlanning = Math.max(demands.metacognitivePlanning, navDemand * 0.8);
-    demands.persistence = Math.max(demands.persistence, navDemand * 0.7);
-    demands.transferLearning = Math.max(demands.transferLearning, navDemand * 0.65);
-    // ── navigationDepth → siteFamiliarity
+    // NOT applied to visualComplexity, whose fall had a different cause: its inputs
+    // (visualComplexity, animationLevel) are counts and RISE with page size. It fell
+    // because its trait was surplus-BILLED, so rising demand shrank the surplus gap
+    // and the 0.3-weighted cost with it. That got its own decision: changeBlindness
+    // is surplus-free since 2026-10-24 (see SURPLUS_FREE_DIMENSIONS).
     //
-    // This dimension had NO demand term at all. It was initialised to 0 and never
-    // raised, so the persona's familiarity was transported against zero demand and
-    // contributed exactly nothing to the chain — three runs at familiarity unset,
-    // 1 and 0 returned byte-identical results while the tool reported the
-    // parameter as applied. The value was never overridden; nothing ever asked
-    // for it.
+    // STAGE B: the base is the reading demand (reading seconds against the time
+    // budget), which is absolute in the amount of prose, the property the
+    // max(textDensity, informationDensity) base above was chosen for.
+    const sustainDemand = Math.min(1, readingDemand * D.sustainedBase * (1 + distractorPressure * D.sustainedDistractorGain));
+    demands.sustainedAttention = Math.max(demands.sustainedAttention, sustainDemand);
+    // ── choosing (novice linear search, Cockburn et al. 2007) → the decision traits
+    // satisficing takes the whole decision demand; the others hand-set shares of it.
+    demands.satisficing = Math.max(demands.satisficing, decisionDemand);
+    demands.anchoringBias = Math.max(demands.anchoringBias, decisionDemand * D.choiceAnchoringBias);
+    demands.fearOfMissingOut = Math.max(demands.fearOfMissingOut, decisionDemand * D.choiceFearOfMissingOut);
+    demands.socialProofSensitivity = Math.max(demands.socialProofSensitivity, decisionDemand * D.choiceSocialProofSensitivity);
+    demands.riskTolerance = Math.max(demands.riskTolerance, decisionDemand * D.decisionRiskTolerance);
+    // ── choosing → comprehension, workingMemory, informationForaging, transferLearning (Stage C)
     //
-    // Navigation depth is the honest driver: the further content sits from the
-    // entry point, the more the page asks you to already know where things are.
-    // A one-click page demands no site knowledge no matter who you are, which is
-    // why this is proportional to navDemand rather than a constant. Weighted just
-    // under workingMemory (0.95), since knowing the layout substitutes for
-    // holding it in mind. (2026-08-02)
-    demands.siteFamiliarity = Math.max(demands.siteFamiliarity, navDemand * 0.85);
-    // Reading capacity is demanded by how much text there is to decode, and motor
-    // capacity by how many things there are to hit. Both proportional, so a page
-    // with no text asks nothing of decoding and a page with no controls asks
-    // nothing of pointing.
-    demands.readingCapacity = Math.max(demands.readingCapacity, Math.max(textDens, infoDensity) * 0.9);
-    demands.motorCapacity = Math.max(demands.motorCapacity, interDemand * 0.9);
-    variance.readingCapacity += textDens * 0.08;
-    variance.motorCapacity += interDemand * 0.08;
-    variance.siteFamiliarity += Math.min(1, navDepth / 5) * 0.08;
-    variance.workingMemory += Math.min(1, navDepth / 5) * 0.09;
-    variance.metacognitivePlanning += Math.min(1, navDepth / 5) * 0.07;
-    variance.persistence += Math.min(1, navDepth / 5) * 0.06;
-    variance.transferLearning += Math.min(1, navDepth / 5) * 0.05;
-    // Clamp all demands and variances to [0, 1]
+    // The four abilities of cognitiveLoad take the choosing demand whole, as
+    // satisficing does on a first visit, so each value reads as tolerated
+    // reference choosing time. On a familiar run they take it at the run's e.
+    // Through 20.x they read text features (and siteFamiliarity a
+    // navigation-depth constant); see LAYER_DEFINITIONS.
+    demands.comprehension = Math.max(demands.comprehension, findingDemand);
+    demands.workingMemory = Math.max(demands.workingMemory, findingDemand);
+    demands.informationForaging = Math.max(demands.informationForaging, findingDemand);
+    demands.transferLearning = Math.max(demands.transferLearning, findingDemand);
+    // Reading capacity is demanded by the time the prose takes to read, and motor
+    // capacity by the time its targets take to acquire, each against the same
+    // budget as the persona's rate-ratio capacity (cognitive-models.ts), so a
+    // deficit means the persona's own time exceeds the budget. A page with no
+    // prose asks nothing of decoding, one with no controls nothing of pointing.
+    demands.readingCapacity = Math.max(demands.readingCapacity, readingDemand);
+    demands.motorCapacity = Math.max(demands.motorCapacity, pointingDemand);
+    // Clamp all demands to [0, 1]
     for (const dim of DEMAND_DIMENSIONS) {
         demands[dim] = Math.max(0, Math.min(1, demands[dim]));
-        variance[dim] = Math.max(0, Math.min(1, variance[dim]));
     }
-    return { demands, variance };
+    // Per-dimension demand variance was computed here from 41 hand-set
+    // coefficients and returned, but nothing in the chain or any tool read it, so
+    // it changed no score. Removed in 21.0 rather than registered as 41 more
+    // hypotheses that do nothing. (2026-10-21)
+    //
+    // The scope travels with the demand so totalCTC can be ranked against
+    // reference pages measured the same way, without every caller having to
+    // repeat a scope it already gave extractPageMetrics.
+    return pageMetrics.scope ? { demands, scope: pageMetrics.scope } : { demands };
 }
 // ── 2. Sequential Transport Chain ──
 /**
  * Resolve a trait value from the persona's trait record.
- * Falls back to 0.5 (neutral midpoint) for missing traits.
+ * Falls back to chain.missingTraitCapacity (0.5, a hypothesis) for missing traits.
+ */
+/**
+ * A persona's capacity vector over DEMAND_DIMENSIONS, exactly as the chain reads
+ * it at the start of a page: each trait through traitValue (clamped to [0, 1],
+ * missing or non-numeric traits at chain.missingTraitCapacity).
+ * The Wasserstein-DRO bound (dro-bound.ts) works on these vectors.
  */
-function traitValue(traits, trait) {
+export function capacityVector(traits) {
+    const P = readParams(CHAIN_IDS);
+    const out = {};
+    for (const dim of DEMAND_DIMENSIONS)
+        out[dim] = traitValue(traits, dim, P);
+    return out;
+}
+function traitValue(traits, trait, P) {
     const v = traits?.[trait];
-    // Handle string enum traits (e.g. attentionPattern: "targeted" | "f-pattern" | ...)
-    if (typeof v === 'string') {
-        const STRING_TRAIT_MAP = {
-            'targeted': 0.9,
-            'sequential': 0.8,
-            'f-pattern': 0.7,
-            'z-pattern': 0.6,
-            'exploratory': 0.3,
-        };
-        return STRING_TRAIT_MAP[v] ?? 0.5;
-    }
+    // A string attentionPattern ("targeted", "f-pattern", ...) used to map to five
+    // hand-set levels. attentionPattern is in no layer since 21.0, so the levels
+    // moved nothing and were removed; a non-numeric trait reads as missing.
     if (typeof v === 'number' && !isNaN(v))
         return Math.max(0, Math.min(1, v));
-    return 0.5;
+    return P.missingTraitCapacity;
 }
 /**
  * Schwartz Value → Trait Demand Modulation Coefficients
@@ -636,6 +710,9 @@ function traitValue(traits, trait) {
  * Each entry maps a Schwartz value to the cognitive traits it amplifies or
  * dampens in the demand distribution. The coefficient represents how much
  * a high value score (1.0) amplifies (+) or dampens (-) the demand on that trait.
+ * Every coefficient is a hand-set hypothesis registered in provenance/chain.ts
+ * (the citations below motivate a direction, not a number) and is read
+ * through param() by id.
  *
  * Theoretical basis:
  * - Security-driven personas demand MORE trustCalibration (Fogg 2003)
@@ -646,54 +723,51 @@ function traitValue(traits, trait) {
  * @see Schwartz (1992) "Universals in the content and structure of values"
  * @see Section 4.2 of "Cognitive Optimal Transport: A Unified Framework"
  * @since v18.54.0
+ *
+ * Exported so cognitive_effort's useValues description can be checked against
+ * it; this table is the only place values reach a transport score.
  */
-const VALUE_DEMAND_MODULATION = [
-    // ── Saliency Layer Modulations ──
+export const VALUE_DEMAND_MODULATION = [
+    // Seven entries were removed in 21.0 because their trait is in no layer, so
+    // the modulated demand was never read: stimulation and conformity on
+    // attentionPattern, security on trustCalibration, stimulation on curiosity,
+    // selfDirection on metacognitivePlanning, tradition on mentalModelFlexibility
+    // and universalism on readingTendency.
+    // ── Visual Complexity Layer Modulations ──
     // Stimulation → reduces changeBlindness threshold (novelty-seekers notice changes more)
-    { value: 'stimulation', trait: 'changeBlindness', coefficient: -0.20, layer: 'saliency' },
-    // Stimulation → amplifies attentionPattern demand (drawn to novel visual elements)
-    { value: 'stimulation', trait: 'attentionPattern', coefficient: 0.20, layer: 'saliency' },
+    { value: 'stimulation', trait: 'changeBlindness', coefficient: 'chain.valueModulation.stimulation.changeBlindness', layer: 'visualComplexity' },
     // Security → amplifies changeBlindness demand (vigilant scanners notice more changes)
-    { value: 'security', trait: 'changeBlindness', coefficient: -0.15, layer: 'saliency' },
-    // Conformity → dampens attentionPattern (follows expected scan patterns, less exploratory)
-    { value: 'conformity', trait: 'attentionPattern', coefficient: -0.15, layer: 'saliency' },
-    // ── Frustration Layer ──
-    // Security → amplifies trust demand (Fogg 2003: high-security users need more trust signals)
-    { value: 'security', trait: 'trustCalibration', coefficient: 0.25, layer: 'frustration' },
+    { value: 'security', trait: 'changeBlindness', coefficient: 'chain.valueModulation.security.changeBlindness', layer: 'visualComplexity' },
+    // ── Decision Layer ──
     // Achievement → reduces satisficing demand (optimizers don't settle for "good enough")
-    { value: 'achievement', trait: 'satisficing', coefficient: -0.20, layer: 'decision' },
+    { value: 'achievement', trait: 'satisficing', coefficient: 'chain.valueModulation.achievement.satisficing', layer: 'decision' },
     // Achievement → increases riskTolerance capacity (confident decision-makers)
-    { value: 'achievement', trait: 'riskTolerance', coefficient: -0.15, layer: 'decision' },
+    { value: 'achievement', trait: 'riskTolerance', coefficient: 'chain.valueModulation.achievement.riskTolerance', layer: 'decision' },
     // Conformity → amplifies social proof demand (Cialdini 2001: need validation from others)
-    { value: 'conformity', trait: 'socialProofSensitivity', coefficient: 0.30, layer: 'decision' },
+    { value: 'conformity', trait: 'socialProofSensitivity', coefficient: 'chain.valueModulation.conformity.socialProofSensitivity', layer: 'decision' },
     // Conformity → amplifies anchoring (defer to first/default option)
-    { value: 'conformity', trait: 'anchoringBias', coefficient: 0.20, layer: 'decision' },
-    // Stimulation → amplifies curiosity demand (explore more, bored faster)
-    { value: 'stimulation', trait: 'curiosity', coefficient: 0.25, layer: 'cognitiveLoad' },
-    // Stimulation → depletes patience (novelty-seekers abandon monotonous pages)
-    { value: 'stimulation', trait: 'patience', coefficient: 0.20, layer: 'motor' },
+    { value: 'conformity', trait: 'anchoringBias', coefficient: 'chain.valueModulation.conformity.anchoringBias', layer: 'decision' },
     // Self-Direction → reduces conformity-related demand (independent thinkers)
-    { value: 'selfDirection', trait: 'socialProofSensitivity', coefficient: -0.20, layer: 'decision' },
-    // Self-Direction → amplifies metacognitive planning (plan their own path)
-    { value: 'selfDirection', trait: 'metacognitivePlanning', coefficient: -0.15, layer: 'cognitiveLoad' },
-    // Tradition → amplifies mentalModelFlexibility (resist new UI patterns)
-    { value: 'tradition', trait: 'mentalModelFlexibility', coefficient: 0.25, layer: 'cognitiveLoad' },
-    // Benevolence → reduces emotionalContagion cost (emotionally regulated)
-    { value: 'benevolence', trait: 'emotionalContagion', coefficient: -0.15, layer: 'frustration' },
+    { value: 'selfDirection', trait: 'socialProofSensitivity', coefficient: 'chain.valueModulation.selfDirection.socialProofSensitivity', layer: 'decision' },
     // Power → reduces fear of missing out (confident, not swayed by urgency)
-    { value: 'power', trait: 'fearOfMissingOut', coefficient: -0.20, layer: 'decision' },
-    // Universalism → amplifies readingTendency (reads everything, values completeness)
-    { value: 'universalism', trait: 'readingTendency', coefficient: 0.15, layer: 'readability' },
+    { value: 'power', trait: 'fearOfMissingOut', coefficient: 'chain.valueModulation.power.fearOfMissingOut', layer: 'decision' },
+    // ── Frustration Layer ──
+    // Stimulation → depletes patience (novelty-seekers abandon monotonous pages).
+    // Labelled `motor` through 20.x; patience is in frustration.
+    { value: 'stimulation', trait: 'patience', coefficient: 'chain.valueModulation.stimulation.patience', layer: 'frustration' },
+    // Benevolence → reduces emotionalContagion cost (emotionally regulated)
+    { value: 'benevolence', trait: 'emotionalContagion', coefficient: 'chain.valueModulation.benevolence.emotionalContagion', layer: 'frustration' },
 ];
 /**
  * Compute the Sequential Cognitive Transport Cost (CTC).
  *
  * Unlike additive cognitive load models, the sequential chain depletes
  * capacity at each processing layer. A user who spends cognitive resources
- * on saliency detection has LESS available for subsequent decision-making.
+ * on visual clutter and motion has LESS available for subsequent decision-making.
  *
- * The algorithm processes layers in temporal order:
- *   Saliency -> Cognitive Load -> Decision -> Motor -> Frustration -> Readability
+ * The algorithm processes the eight layers of LAYER_DEFINITIONS in order:
+ *   visualComplexity -> cognitiveLoad -> decision -> motor -> motorProcedure
+ *   -> frustration -> readability -> readingAttention
  *
  * Each layer:
  * 1. Applies Schwartz value modulation to demand (v18.54.0)
@@ -702,11 +776,38 @@ const VALUE_DEMAND_MODULATION = [
  * 4. Records the remaining capacity for downstream layers
  *
  * @param persona - OTCognitiveProfile with trait values
- * @param demand - 26D demand distribution from page analysis
+ * @param demand - 29D demand distribution from page analysis
  * @param options - Enable/disable asymmetric costs, interaction terms, and value modulation
  * @returns Complete sequential transport result with per-layer breakdown
  */
 export function computeSequentialCTC(persona, demand, options) {
+    const cost = transportChain(persona, demand, options);
+    const referenceScope = demand.scope ?? 'viewport';
+    const reference = ctcReferenceCurve(referenceScope, options);
+    // totalCTC depends on every constant the curve was built from, the demand
+    // curves included. Re-read them here so a run under withProvenance records
+    // the same dependencies whether the curve was built in this call or cached.
+    for (const id of reference.reads)
+        param(id);
+    // Read on every call for the same reason, and checked: the registered page
+    // count must be the count the curve was built from, so a reference file
+    // swapped without its registry entry is refused rather than ranked against.
+    const registeredPages = param(`ctcReference.${referenceScope}`);
+    if (registeredPages !== reference.pages) {
+        throw new Error(`ctcReference.${referenceScope} registers ${registeredPages} pages; the shipped reference has ${reference.pages}`);
+    }
+    const totalCTC = percentileAt(reference.curve, cost.rawCTC);
+    return { ...cost, totalCTC, totalCTCInterval: intervalAt(reference.interval, cost.rawCTC, totalCTC), referenceScope };
+}
+/**
+ * The transport chain itself: demand against capacity, layer by layer, ending
+ * at rawCTC. computeSequentialCTC adds the percentile; the reference curve is
+ * built from this function directly, since ranking the reference against
+ * itself would need the curve it is building. Only `traits` is read from the
+ * persona.
+ */
+function transportChain(persona, demand, options) {
+    const P = readParams(CHAIN_IDS);
     const useAsymmetric = options?.asymmetric !== false; // default true
     const useInteractions = options?.interactions !== false; // default true
     const values = options?.schwartzValues;
@@ -714,7 +815,6 @@ export function computeSequentialCTC(persona, demand, options) {
     // Values amplify or dampen demands on specific traits, changing what the page "asks" of the user
     const modulatedDemand = {
         demands: { ...demand.demands },
-        variance: { ...demand.variance },
     };
     // readingTendency modulates DEMAND, not capacity.
     //
@@ -736,7 +836,7 @@ export function computeSequentialCTC(persona, demand, options) {
     // than ADHD on a text-dense page after this. (2026-08-02)
     const readingTendency = persona.traits?.readingTendency;
     if (typeof readingTendency === "number") {
-        const engagement = 0.75 + readingTendency * 0.5; // 0.75 at pure skim, 1.25 at careful
+        const engagement = P.engagementAtSkim + readingTendency * P.engagementRange; // 0.75 at pure skim, 1.25 at careful
         // ATTENTIONAL demand only. Applied to `readingCapacity` as well for one
         // commit, and that was wrong on the merits as well as breaking a contract.
         //
@@ -757,22 +857,25 @@ export function computeSequentialCTC(persona, demand, options) {
         }
     }
     if (values && Object.keys(values).length > 0) {
+        const demandFloor = param('chain.valueModulation.demandFloor');
         for (const mod of VALUE_DEMAND_MODULATION) {
+            // Read before the skip so a run records every coefficient it could have used.
+            const coefficient = param(mod.coefficient);
             const valueScore = values[mod.value];
             if (valueScore === undefined || valueScore === null)
                 continue;
             const currentDemand = modulatedDemand.demands[mod.trait] ?? 0;
             // Modulation: demand += coefficient * valueScore * currentDemand
             // High value score amplifies the modulation effect
-            // Multiplicative on current demand — no effect on zero-demand traits
-            const modulation = mod.coefficient * valueScore * Math.max(0.1, currentDemand);
+            // Multiplicative on current demand, floored so a zero-demand trait still moves a little
+            const modulation = coefficient * valueScore * Math.max(demandFloor, currentDemand);
             modulatedDemand.demands[mod.trait] = Math.max(0, Math.min(1, currentDemand + modulation));
         }
     }
     // Initialize residual capacity from persona traits
     const residualCapacity = {};
     for (const dim of DEMAND_DIMENSIONS) {
-        residualCapacity[dim] = options?.carriedCapacity?.[dim] ?? traitValue(persona.traits, dim);
+        residualCapacity[dim] = options?.carriedCapacity?.[dim] ?? traitValue(persona.traits, dim, P);
     }
     const layers = [];
     const traitCosts = {};
@@ -799,17 +902,25 @@ export function computeSequentialCTC(persona, demand, options) {
         let layerHeadroom = 0;
         for (const trait of layerDef.traits) {
             const d = modulatedDemand.demands[trait] ?? 0;
-            const c = residualCapacity[trait] ?? 0.5;
+            const c = residualCapacity[trait] ?? P.missingTraitCapacity;
             const gap = d - c;
             let cost;
-            if (gap > 0) {
+            if (useAsymmetric && EXPOSURE_DIMENSIONS.has(trait)) {
+                // Exposure: the stimulus acting on a susceptibility, w c d (see
+                // EXPOSURE_DIMENSIONS). A cost the page imposes, so it is counted with
+                // the deficit, which abandonment reads. Depletion can only lower c, so
+                // on a page with no stimulus it stays 0.
+                cost = P.weightSurplus * c * d;
+                layerDeficit += cost;
+            }
+            else if (gap > 0) {
                 // Deficit: demand exceeds capacity — expensive
-                cost = (useAsymmetric ? WEIGHT_DEFICIT : 1.0) * gap * gap;
+                cost = (useAsymmetric ? P.weightDeficit : 1.0) * gap * gap;
                 layerDeficit += cost;
             }
             else {
                 // Surplus: capacity exceeds demand — cheap
-                const surplusWeight = SURPLUS_FREE_DIMENSIONS.has(trait) ? 0 : WEIGHT_SURPLUS;
+                const surplusWeight = SURPLUS_FREE_DIMENSIONS.has(trait) ? 0 : P.weightSurplus;
                 cost = (useAsymmetric ? surplusWeight : 1.0) * gap * gap;
                 layerSurplus += cost;
             }
@@ -821,7 +932,7 @@ export function computeSequentialCTC(persona, demand, options) {
         layerHeadroom = layerHeadroom / Math.max(1, layerDef.traits.length);
         // Scale layer cost by demand presence — empty pages shouldn't produce high costs
         const layerDemandMagnitude = layerDef.traits.reduce((sum, t) => sum + (modulatedDemand.demands[t] ?? 0), 0) / layerDef.traits.length;
-        const contentScale = Math.min(1.0, layerDemandMagnitude * 3); // 0-1 scale, saturates at demand=0.33
+        const contentScale = Math.min(1.0, layerDemandMagnitude * P.contentScaleGain); // 0-1 scale, saturates at demand=0.33
         layerCost *= contentScale;
         layerDeficit *= contentScale;
         layerSurplus *= contentScale;
@@ -830,8 +941,15 @@ export function computeSequentialCTC(persona, demand, options) {
         additiveCTC += layerCost;
         // Deplete capacity for next layers (only when page has meaningful content)
         // Each trait in this layer loses capacity proportional to the layer's total cost
-        const capacityConsumed = DEPLETION_RATE * layerCost;
-        if (contentScale > 0.1) {
+        const DEPLETION_RATE = P.depletionRate;
+        const MAX_DRAWDOWN_FRACTION = P.maxDrawdownFraction;
+        const INDIRECT_DEPLETION_SHARE = P.indirectDepletionShare;
+        const CAPACITY_EPSILON = P.capacityEpsilon;
+        // What this layer actually removed, summed over every dimension from the
+        // balances themselves (LayerResult.capacityConsumed). It stays 0 when the
+        // gate below keeps the layer from depleting.
+        let capacityConsumed = 0;
+        if (contentScale > P.depletionGate) {
             // PROPORTIONAL DRAWDOWN, not subtraction against a clamp.
             //
             // Capacity used to be spent as a flat amount and clamped at
@@ -855,17 +973,22 @@ export function computeSequentialCTC(persona, demand, options) {
             // three and no `k` anywhere in the arithmetic. (2026-08-03)
             const drawFraction = Math.min(MAX_DRAWDOWN_FRACTION, DEPLETION_RATE * layerCost);
             for (const trait of layerDef.traits) {
+                const before = residualCapacity[trait];
                 residualCapacity[trait] *= (1 - drawFraction);
                 residualCapacity[trait] = Math.max(CAPACITY_EPSILON, residualCapacity[trait]);
+                // A floor lift (a dimension below CAPACITY_EPSILON raised to it) is not a draw.
+                capacityConsumed += Math.max(0, before - residualCapacity[trait]);
             }
             // Also deplete shared traits that appear in later layers
             // (cross-layer fatigue: cognitive exhaustion bleeds across boundaries)
-            const indirectFraction = Math.min(MAX_DRAWDOWN_FRACTION, (DEPLETION_RATE * 0.5) * layerCost);
+            const indirectFraction = Math.min(MAX_DRAWDOWN_FRACTION, (DEPLETION_RATE * INDIRECT_DEPLETION_SHARE) * layerCost);
             for (const dim of DEMAND_DIMENSIONS) {
                 if (!layerDef.traits.includes(dim)) {
                     // Indirect depletion at half rate
+                    const before = residualCapacity[dim];
                     residualCapacity[dim] *= (1 - indirectFraction);
                     residualCapacity[dim] = Math.max(CAPACITY_EPSILON, residualCapacity[dim]);
+                    capacityConsumed += Math.max(0, before - residualCapacity[dim]);
                 }
             }
         }
@@ -877,7 +1000,7 @@ export function computeSequentialCTC(persona, demand, options) {
             // Mean spare capacity across this layer's dimensions. Only meaningful
             // when the cost is at or near zero; above that the cost carries the
             // signal itself.
-            headroom: Math.round(layerHeadroom * 1000) / 1000,
+            headroom: Math.round(layerHeadroom * P.roundingScale) / P.roundingScale,
         });
     }
     // Compute interaction terms
@@ -891,7 +1014,7 @@ export function computeSequentialCTC(persona, demand, options) {
         for (const pair of INTERACTION_PAIRS) {
             const costA = layerCostMap[pair.a] ?? 0;
             const costB = layerCostMap[pair.b] ?? 0;
-            const interaction = costA * costB * pair.weight;
+            const interaction = costA * costB * param(pair.weight);
             const key = `${pair.a}x${pair.b}`;
             interactions[key] = interaction;
             interactionTotal += interaction;
@@ -901,14 +1024,14 @@ export function computeSequentialCTC(persona, demand, options) {
     // Note: additiveCTC is layers-only (no interactions, no sequential effects)
     // The sequential effect is already embedded in layer costs via capacity depletion
     const rawCTC = layers.reduce((sum, l) => sum + l.transportCost, 0) + interactionTotal;
-    // Normalize CTC to a 0-1 scale that maps to human-interpretable difficulty
-    // Calibration: raw CTC from the W₂ formula tends to be 0.3-3.0 for real pages.
-    // We normalize using a sigmoid so: 0.5 raw → 0.2, 1.0 → 0.4, 2.0 → 0.7, 3.0 → 0.9
-    // This ensures "easy" pages (simple layout, clear content) land below 0.3
-    const totalCTC = 1 / (1 + Math.exp(-2.5 * (rawCTC - 1.2)));
+    // No normalisation here. Through 21.0 totalCTC was a logistic of rawCTC,
+    // slope 2.5 and centre 1.2 (chain.ctcSigmoidSlope / chain.ctcSigmoidCentre,
+    // both hand-set), which nothing tied to where real pages fall: at viewport
+    // scope it put half of them between 0.055 and 0.133. computeSequentialCTC
+    // now ranks rawCTC against real pages instead.
     // Find bottleneck layer
     let maxLayerCost = 0;
-    let bottleneckLayer = layers[0]?.name ?? 'saliency';
+    let bottleneckLayer = layers[0]?.name ?? LAYER_DEFINITIONS[0].name;
     for (const layer of layers) {
         if (layer.transportCost > maxLayerCost) {
             maxLayerCost = layer.transportCost;
@@ -939,21 +1062,37 @@ export function computeSequentialCTC(persona, demand, options) {
     // equal to tolerance gives 50%, and it approaches 1 from below. The
     // "centre at 1.5x blended patience" intent is unchanged and so is the
     // persona ordering; what is gone is the offset. (2026-08-03, BUG-17)
-    const patienceCapacity = traitValue(persona.traits, 'patience');
-    const resilienceCapacity = traitValue(persona.traits, 'resilience');
-    const effectivePatience = patienceCapacity * 0.7 + resilienceCapacity * 0.3; // blended tolerance
-    const adjustedCost = Math.max(0, totalDeficit - totalSurplus * 0.3); // surplus comfort (30%)
+    //
+    // UNMET DEMAND ONLY, as of 21.0. Through 20.x the hazard's input was
+    // deficit - 0.3 x surplus: billed surplus (a maximiser over-deliberating a
+    // trivial page) was RELIEF here while the same surplus was COST in totalCTC.
+    // One quantity cannot be both. A disposition surplus is effort spent, not
+    // comfort, so it no longer offsets the deficit; chain.abandonment.surplusRelief
+    // is gone. The per-screen hazard in computeSequentialScrollCTC reads this
+    // value, so it changed with it.
+    //
+    // RESIDUAL TOLERANCE, as of 21.0. The page spends patience in the
+    // frustration layer and drains resilience through cross-layer depletion;
+    // judging abandonment against the persona as it ARRIVED treated that spending
+    // as free. Tolerance now comes from what the page left (residualCapacity at
+    // the end of the layer loop), so a later screen in a scroll is judged against
+    // the smaller budget it actually has.
+    const patienceCapacity = residualCapacity.patience;
+    const resilienceCapacity = residualCapacity.resilience;
+    const effectivePatience = patienceCapacity * P.patienceShare + resilienceCapacity * P.resilienceShare; // blended tolerance
+    const unmetDemand = totalDeficit;
     // Floored so a persona with no patience at all does not divide by zero and
     // read as certain abandonment on a blank page.
-    const tolerance = Math.max(0.05, effectivePatience * 1.5);
-    const ABANDONMENT_STEEPNESS = ABANDONMENT_HILL_EXPONENT;
-    const abandonmentRisk = adjustedCost <= 0 ? 0 : Math.max(0, Math.min(1, Math.pow(adjustedCost, ABANDONMENT_STEEPNESS) /
-        (Math.pow(adjustedCost, ABANDONMENT_STEEPNESS) + Math.pow(tolerance, ABANDONMENT_STEEPNESS))));
+    const tolerance = Math.max(P.toleranceFloor, effectivePatience * P.toleranceGain);
+    // The same registry value ABANDONMENT_HILL_EXPONENT exports; read here so the
+    // dependency is recorded per run.
+    const ABANDONMENT_STEEPNESS = P.abandonmentHillExponent;
+    const abandonmentRisk = unmetDemand <= 0 ? 0 : Math.max(0, Math.min(1, Math.pow(unmetDemand, ABANDONMENT_STEEPNESS) /
+        (Math.pow(unmetDemand, ABANDONMENT_STEEPNESS) + Math.pow(tolerance, ABANDONMENT_STEEPNESS))));
     return {
-        totalCTC,
-        // The un-normalized cost, exposed because totalCTC is a SIGMOID of it and
-        // the two are not interchangeable. Every ratio against additiveCTC has to
-        // use this one: additiveCTC is a raw sum, totalCTC is squashed to 0-1, and
+        // The un-normalized cost, exposed because totalCTC is a PERCENTILE of it
+        // and the two are not interchangeable. Every ratio against additiveCTC has
+        // to use this one: additiveCTC is a raw sum, totalCTC is a rank in 0-1, and
         // dividing one by the other compares different units. (2026-08-02)
         rawCTC,
         layers,
@@ -967,12 +1106,84 @@ export function computeSequentialCTC(persona, demand, options) {
         remainingCapacity: { ...residualCapacity },
     };
 }
+const referenceCurves = new Map();
+const overriddenReferenceCurves = new WeakMap();
+/**
+ * The percentile curve for one scope and option set: rawCTC of every graded
+ * reference page (ctc-reference.ts) for every built-in persona, through this
+ * chain, pooled. Each page's metrics are derived from its stored raw
+ * measurement (deriveMetrics) inside the build, so the page-metric
+ * normalisers move the curve exactly as the chain's constants do.
+ *
+ * WHICH OPTIONS SELECT A CURVE. `asymmetric` and `interactions` change the
+ * cost function, so each pair has its own curve: a symmetric raw cost ranked
+ * among asymmetric ones would compare two different quantities.
+ * `schwartzValues` and `carriedCapacity` do not. Both describe the person
+ * being scored (what they value, what earlier screens left them), not the
+ * yardstick, and a curve that moved with them would cancel part of the effect
+ * it is there to show. So a values-modulated score, and every screen after the
+ * first in a scroll, are ranked against the reference population as it
+ * arrives at a page. cognitive_effort's useValues edits demand before the chain
+ * runs, which lands in the same place.
+ *
+ * COST AND CACHE. One build is one deriveMetrics per page, one chain run per
+ * page per persona, and the page bootstrap (ctcReference.interval.*), under a
+ * second for the whole reference; cached per scope and option set for the
+ * life of the process, so every later score pays two binary searches. While a
+ * test overrides registered constants (activeOverrides() is non-null) a curve
+ * is cached against that override object instead: a change to any chain or
+ * page-metric constant re-derives the curve rather than reusing one built
+ * under other constants.
+ */
+export function ctcReferenceCurve(scope, options) {
+    const asymmetric = options?.asymmetric !== false;
+    const interactions = options?.interactions !== false;
+    const overrides = activeOverrides();
+    let cache = referenceCurves;
+    if (overrides) {
+        cache = overriddenReferenceCurves.get(overrides) ?? new Map();
+        overriddenReferenceCurves.set(overrides, cache);
+    }
+    const key = `${scope}|${asymmetric}|${interactions}`;
+    const hit = cache.get(key);
+    if (hit)
+        return hit;
+    const population = referencePopulation();
+    const { result: { costs, pages, settings }, ids } = readsOf(() => {
+        const raws = referenceRaw(scope);
+        // Page-major, every persona of a page together: the bootstrap resamples pages.
+        const out = new Float64Array(raws.length * population.length);
+        let k = 0;
+        for (const raw of raws) {
+            const demand = computeDemandDistribution(deriveMetrics(raw));
+            for (const persona of population)
+                out[k++] = transportChain(persona, demand, { asymmetric, interactions }).rawCTC;
+        }
+        const settings = {
+            replicates: param('ctcReference.interval.replicates'),
+            seed: param('ctcReference.interval.seed'),
+            level: param('ctcReference.interval.level'),
+            grid: param('ctcReference.interval.grid'),
+        };
+        return { costs: out, pages: raws.length, settings };
+    });
+    const curve = percentileCurve(costs);
+    const built = {
+        scope, asymmetric, interactions,
+        pages, personas: population.length,
+        reads: [...ids].sort(),
+        curve,
+        interval: bootstrapPercentileInterval(costs, population.length, settings),
+    };
+    cache.set(key, built);
+    return built;
+}
 // ── 3. Convenience: Full COT Pipeline ──
 /**
  * End-to-end Cognitive Optimal Transport computation.
  *
  * Extracts page metrics from a live Playwright page, computes the
- * 26D demand distribution, and runs the full sequential transport chain.
+ * 29D demand distribution, and runs the full sequential transport chain.
  *
  * This is the primary entry point for MCP tools that need a single
  * CTC score with full breakdown.
@@ -984,7 +1195,7 @@ export function computeSequentialCTC(persona, demand, options) {
 export async function computeFullCOT(persona, page) {
     // Extract page metrics via Playwright's page.evaluate()
     const metrics = await extractPageMetrics(page);
-    // Compute 26D demand distribution
+    // Compute 29D demand distribution
     const demand = computeDemandDistribution(metrics);
     // Run sequential transport chain with full options
     return computeSequentialCTC(persona, demand, {
@@ -996,17 +1207,30 @@ export async function computeFullCOT(persona, page) {
 /**
  * Compute demand distribution from raw metric values (no page required).
  * Useful for testing, simulation, and sensitivity analysis.
+ *
+ * informationDensity, textDensity and navigationDepth are carried onto the
+ * PageMetrics as reported values; since Stage C no demand reads them.
+ * choosingSecondsExpert (Stage C) is the choosing time's Hick-Hyman expert
+ * limit. It is required like the other law times and moves a demand only when
+ * options.siteFamiliarity is above 0.
  */
-export function computeDemandFromRawMetrics(informationDensity, visualComplexity, interactiveElementCount, textDensity, animationLevel, choiceCount, navigationDepth) {
+export function computeDemandFromRawMetrics(informationDensity, visualComplexity, textDensity, animationLevel, navigationDepth, pointingSeconds, choosingSeconds, readingSeconds, procedureSeconds, choosingSecondsExpert, options) {
+    // interactiveElementCount and choiceCount are reported counts that no demand
+    // reads since Stage B; the law times replace them.
     return computeDemandDistribution({
         informationDensity,
         visualComplexity,
-        interactiveElementCount,
+        interactiveElementCount: 0,
         textDensity,
         animationLevel,
-        choiceCount,
+        choiceCount: 0,
         navigationDepth,
-    });
+        pointingSeconds,
+        choosingSeconds,
+        readingSeconds,
+        procedureSeconds,
+        choosingSecondsExpert,
+    }, options);
 }
 /**
  * Compare sequential vs. additive CTC to quantify the sequential effect.
@@ -1062,11 +1286,9 @@ export function topCostlyTraits(result, n = 5) {
 export function baselineCTC(persona) {
     const emptyDemand = {
         demands: {},
-        variance: {},
     };
     for (const dim of DEMAND_DIMENSIONS) {
         emptyDemand.demands[dim] = 0;
-        emptyDemand.variance[dim] = 0;
     }
     return computeSequentialCTC(persona, emptyDemand);
 }
@@ -1098,29 +1320,30 @@ export function baselineCTC(persona) {
  * is load-bearing here too and remains uncalibrated.
  */
 export function computeSequentialScrollCTC(persona, screenDemands, options) {
+    const P = readParams(CHAIN_IDS);
+    const R = P.roundingScale;
+    const depthR = param('chain.depthRoundingScale');
     const screens = [];
     let carried;
     let survive = 1;
-    const patience = traitValue(persona.traits, 'patience');
-    const resilience = traitValue(persona.traits, 'resilience');
-    const tolerance = Math.max(0.05, (patience * 0.7 + resilience * 0.3) * 1.5);
     for (let i = 0; i < screenDemands.length; i++) {
         const r = computeSequentialCTC(persona, screenDemands[i], { ...options, carriedCapacity: carried });
         carried = r.remainingCapacity;
-        // Hazard for THIS screen, from this screen's own unmet demand. Surplus
-        // relief applies as it does in the aggregate.
-        const screenCost = Math.max(0, r.deficitCost - r.surplusCost * 0.3);
-        const stopHazard = screenCost <= 0 ? 0 : Math.min(1, Math.pow(screenCost, ABANDONMENT_HILL_EXPONENT) /
-            (Math.pow(screenCost, ABANDONMENT_HILL_EXPONENT) + Math.pow(tolerance, ABANDONMENT_HILL_EXPONENT)));
+        // Hazard for THIS screen: the screen's own abandonment risk, which is the
+        // Hill hazard of its unmet demand. One formula, read from the chain run,
+        // rather than a second copy here that could drift from it (the copy that
+        // was here applied surplus relief in step with the aggregate; 21.0 removed
+        // it from both by removing this copy).
+        const stopHazard = r.abandonmentRisk;
         const reachProbability = survive;
         survive = survive * (1 - stopHazard);
         screens.push({
             screen: i + 1,
             layers: r.layers,
-            screenCTC: Math.round(r.totalCTC * 1000) / 1000,
-            stopHazard: Math.round(stopHazard * 1000) / 1000,
-            cumulativeAbandonment: Math.round((1 - survive) * 1000) / 1000,
-            reachProbability: Math.round(reachProbability * 1000) / 1000,
+            screenCTC: Math.round(r.totalCTC * R) / R,
+            stopHazard: Math.round(stopHazard * R) / R,
+            cumulativeAbandonment: Math.round((1 - survive) * R) / R,
+            reachProbability: Math.round(reachProbability * R) / R,
             bottleneckLayer: r.bottleneckLayer,
             remainingCapacity: r.remainingCapacity,
         });
@@ -1131,18 +1354,18 @@ export function computeSequentialScrollCTC(persona, screenDemands, options) {
     for (const s of screens) {
         const lost = s.reachProbability * s.stopHazard;
         if (!dropOff || lost > dropOff.share) {
-            dropOff = { screen: s.screen, layer: s.bottleneckLayer, share: Math.round(lost * 1000) / 1000 };
+            dropOff = { screen: s.screen, layer: s.bottleneckLayer, share: Math.round(lost * R) / R };
         }
     }
     if (dropOff && dropOff.share <= 0)
         dropOff = null;
     return {
         screens,
-        totalAbandonment: Math.round((1 - survive) * 1000) / 1000,
+        totalAbandonment: Math.round((1 - survive) * R) / R,
         // Sum of reach probabilities: the expected count of screens actually seen.
-        expectedDepthScreens: Math.round(screens.reduce((a, s) => a + s.reachProbability, 0) * 100) / 100,
+        expectedDepthScreens: Math.round(screens.reduce((a, s) => a + s.reachProbability, 0) * depthR) / depthR,
         dropOff,
-        reachWeightedCTC: Math.round(screens.reduce((a, s) => a + s.reachProbability * s.screenCTC, 0) * 1000) / 1000,
+        reachWeightedCTC: Math.round(screens.reduce((a, s) => a + s.reachProbability * s.screenCTC, 0) * R) / R,
     };
 }
 //# sourceMappingURL=cognitive-transport-chain.js.map