cbrowser 20.2.2 → 21.0.0

package/dist/cognitive/index.js

@@ -31,7 +31,12 @@ import { isAgentPersonaObject } from "../agent-personas.js";
 import { createInitialEmotionalState, createEmotionalConfig, applyEmotionalTrigger, decayEmotionsWithTraits, deriveSimplifiedState, calculateAbandonmentModifier, describeEmotionalState, shouldConsiderAbandonment, } from "./emotions.js";
 import { calculateFatigueIncrement, calculateFittsMovementTime, shouldSwitchToSystem2, canReturnToSystem1, calculateTypingTime, calculateScanWidthMultiplier, calculateGazeMouseLag, calculatePeripheralVision, createHabituationState, updateHabituationState, classifyUIPattern, } from "../types.js";
 import { loadConfigFile, getDataDir } from "../config.js";
+import { param } from "../visual/model-provenance.js";
+import { defaultJourneyTraits } from "./default-traits.js";
+import { distanceToScreenCentre, smallerOfWidth } from "../visual/demand-laws.js";
 import { writeSecretFile } from "../secure-file.js";
+import { uniqueStamp } from "../temp-files.js";
+import { semanticWeightTable } from "../visual/attention-transport.js";
 import { JourneyTraceWriter, TraceReplayProvider, hashPageState, } from "./journey-trace.js";
 // ============================================================================
 // API Key Management
@@ -421,7 +426,12 @@ const MOUSE_OVERLAY_SCRIPT = `(() => {
  * payload, no dashboard-side overlay positioning. Per-frame compute is
  * sub-millisecond on modern pages because we're just reading bounding boxes.
  *
- * Config is injected as `window.__cbAttentionConfig` by the journey runner.
+ * Config is injected as `window.__cbAttentionConfig` by the journey runner
+ * (attentionOverlayInitScript). Every weight and goal constant comes from it,
+ * that is from attention-transport's semanticWeightTable; this script holds
+ * none of its own (ISC-48.1, 2026-10-22). It is still a simpler model than
+ * analyzeAttention: max per cell, max-normalised, no values layer, no
+ * perceptual filter, no gaze calibration, and its own element classifier.
  */
 const ATTENTION_OVERLAY_SCRIPT = `(() => {
   if (window.__cbAttentionInstalled || window.__cbAttentionPending) return;
@@ -430,9 +440,11 @@ const ATTENTION_OVERLAY_SCRIPT = `(() => {
   const install = () => {
     if (window.__cbAttentionInstalled) return;
     if (!document.documentElement || !document.body) return;
+    // No config, no overlay: drawing with invented weights is what this
+    // replaced.
+    const config = window.__cbAttentionConfig;
+    if (!config) return;
     window.__cbAttentionInstalled = true;
-
-    const config = window.__cbAttentionConfig || { typeWeights: {}, personaMods: {}, goal: "" };
     const cellSize = 16;
 
     const css = \`
@@ -514,15 +526,16 @@ const ATTENTION_OVERLAY_SCRIPT = `(() => {
       return 'content';
     };
 
-    // Sum of weight from goal-keyword matches in element text.
+    // Goal relevance as computeGoalRelevance scores it, with its constants.
+    const stopWords = new Set(config.stopWords || []);
     const goalWords = (config.goal || '').toLowerCase()
-      .split(/\\s+/).filter(w => w.length > 2 && !/^(the|a|an|to|for|of|in|on|at|is|it|my|i|me|and|or|how|do|can)$/.test(w));
+      .split(/\\s+/).filter(w => w.length >= config.minKeywordLength && !stopWords.has(w));
     const goalRelevance = (text) => {
       if (!text || !goalWords.length) return 0;
       const t = text.toLowerCase();
       let m = 0;
       for (const w of goalWords) if (t.includes(w)) m++;
-      return (m / goalWords.length) * 2.0;
+      return (m / goalWords.length) * config.relevanceGain;
     };
 
     let lastCells = null;
@@ -553,9 +566,10 @@ const ATTENTION_OVERLAY_SCRIPT = `(() => {
         if (cs.display === 'none' || cs.visibility === 'hidden' || cs.opacity === '0') continue;
 
         const type = classify(el);
-        let weight = (config.typeWeights && config.typeWeights[type]) || 0.2;
-        const mod = (config.personaMods && config.personaMods[type]) || 1.0;
-        weight *= mod;
+        // As buildSemanticMap: an unknown type takes the fallback weight, and
+        // a type without a modifier is unmodified.
+        let weight = config.typeWeights[type] ?? config.typeFallback;
+        weight *= config.personaMods[type] ?? 1;
         const text = (el.innerText || el.textContent || '').slice(0, 200);
         const gr = goalRelevance(text);
         if (gr > 0) weight *= (1 + gr);
@@ -621,6 +635,11 @@ const ATTENTION_OVERLAY_SCRIPT = `(() => {
       canvas.style.display = visible === false ? 'none' : '';
     };
     window.__cbAttentionRefresh = schedule;
+    // The raw weights of the last frame (before max-normalisation), so a test
+    // can read what was painted rather than decode the canvas.
+    window.__cbAttentionCells = () => lastCells
+      ? { cols: lastDims.cols, rows: lastDims.rows, cellSize, cells: Array.from(lastCells) }
+      : null;
   };
 
   if (typeof window.requestIdleCallback === 'function') {
@@ -632,32 +651,26 @@ const ATTENTION_OVERLAY_SCRIPT = `(() => {
 /**
  * Build the JSON config bundle that drives the in-browser attention heatmap.
  * The browser-side script doesn't have access to the SDK's persona profiles,
- * so we precompute the type-weight × persona-modifier table here and ship it.
+ * so the weight table is computed here and shipped.
+ *
+ * The table is attention-transport's own (semanticWeightTable), not a copy.
+ * Until 2026-10-22 this function held a hand-written mirror "kept in sync by
+ * hand", and it had drifted: navigation still read siteFamiliarity, which the
+ * model dropped on 2026-08-05, so a journey given customTraits
+ * { siteFamiliarity: 0 } drew navigation at 1.0 while attention_analysis drew
+ * it at 0.7. The page script also kept its own fallback weight, goal gain,
+ * keyword length and stop words; they now come from here too. (ISC-48.1)
  */
-function buildAttentionConfig(personaName, goal, traits) {
-    // Mirror of ELEMENT_TYPE_WEIGHTS in attention-transport.ts. Kept in sync by
-    // hand — small enough that drift hasn't been a problem.
-    const typeWeights = {
-        cta: 1.0, heading: 0.8, form: 0.7, search: 0.7,
-        image: 0.5, navigation: 0.4, link: 0.3,
-        content: 0.2, decorative: 0.1, price: 0.9, error: 0.9,
-    };
-    // Trait-driven modifiers. Mirrors computeTraitModifiers in attention-transport.
-    const t = (k) => traits?.[k] ?? 0.5;
-    const personaMods = {
-        cta: 1.0 + (1.0 - t("patience")) * 0.5,
-        search: 0.7 + (1.0 - t("patience")) * 0.6,
-        content: t("readingTendency") > 0.6 ? 0.4 + t("readingTendency") * 0.4 : 0.2 + t("patience") * 0.4,
-        heading: 0.8 + t("curiosity") * 0.4,
-        image: 0.5 + t("curiosity") * 0.5,
-        navigation: 0.4 + (1.0 - t("siteFamiliarity")) * 0.6,
-        error: 0.5 + (1.0 - t("selfEfficacy")) * 0.5,
-        price: 0.5 + (1.0 - t("riskTolerance")) * 0.5,
-        decorative: 0.1 + (1.0 - t("metacognitivePlanning")) * 0.4,
-        form: 0.5 + t("proceduralFluency") * 0.3,
-        link: 1.0,
+export function buildAttentionConfig(personaName, goal, traits) {
+    return {
+        ...semanticWeightTable(personaName, traits),
+        goal: goal || "",
+        persona: personaName,
     };
-    return { typeWeights, personaMods, goal: goal || "", persona: personaName };
+}
+/** The init script that installs the in-page heatmap with `config`. */
+export function attentionOverlayInitScript(config) {
+    return `window.__cbAttentionConfig = ${JSON.stringify(config)};` + ATTENTION_OVERLAY_SCRIPT;
 }
 // Note: CognitiveJourneyOptions accepts `device` to emulate a specific device
 // preset (mobile/tablet/desktop or "iPhone 15", etc.). Wired in below alongside
@@ -702,7 +715,7 @@ export async function runCognitiveJourney(options) {
         (options.replayTrace ? new TraceReplayProvider(options.replayTrace) : liveLLMProvider);
     const nameSlug = options.name ? journeySlug(options.name) : undefined;
     const traceWriter = options.trace
-        ? new JourneyTraceWriter(nameSlug ? { journeyId: `journey-${nameSlug}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` } : undefined)
+        ? new JourneyTraceWriter(nameSlug ? { journeyId: `journey-${nameSlug}-${uniqueStamp()}` } : undefined)
         : null;
     const personaObj = resolveJourneyPersona(options.persona, options.customTraits);
     const profile = getCognitiveProfile(personaObj);
@@ -715,26 +728,31 @@ export async function runCognitiveJourney(options) {
     // (low-vision-magnified, motor-impairment-tremor) get extra penalty so
     // their clicks visibly miss more often.
     const aTraits = personaObj.accessibilityTraits;
-    const motorBase = traits.proceduralFluency ?? 0.5;
+    const motorBase = traits.proceduralFluency ?? param("journey.defaultTrait");
     const motorPenalty = aTraits?.motorControl !== undefined ? aTraits.motorControl : 1.0;
     const inputTraits = {
-        proceduralFluency: traits.proceduralFluency ?? 0.5,
-        motorPrecision: Math.max(0.1, Math.min(1, motorBase * motorPenalty)),
-        patience: traits.patience ?? 0.5,
-        readingTendency: traits.readingTendency ?? 0.5,
+        proceduralFluency: traits.proceduralFluency ?? param("journey.defaultTrait"),
+        motorPrecision: Math.max(param("journey.input.motorPrecisionFloor"), Math.min(1, motorBase * motorPenalty)),
+        patience: traits.patience ?? param("journey.defaultTrait"),
+        readingTendency: traits.readingTendency ?? param("journey.defaultTrait"),
     };
     // Calculate abandonment thresholds
+    // Every limit is registered (journey.abandon.*, src/visual/provenance/journey.ts).
+    const lowComprehension = traits.comprehension < param("journey.band.low.comprehension");
+    const lowPatience = traits.patience < param("journey.band.low.patience");
+    const highPatience = traits.patience > param("journey.band.high.patience");
+    const lowPersistence = traits.persistence < param("journey.band.low.persistence");
+    const highPersistence = traits.persistence > param("journey.band.high.persistence");
     const thresholds = {
-        patienceMin: 0.1,
-        confusionMax: traits.comprehension < 0.4 ? 0.75 : 0.9,
-        frustrationMax: traits.patience < 0.3 ? 0.8 : 0.95,
-        maxStepsWithoutProgress: traits.persistence > 0.7 ? 20 : 15,
-        loopDetectionThreshold: 3,
+        patienceMin: param("journey.abandon.patienceFloor"),
+        confusionMax: lowComprehension ? param("journey.abandon.confusionLimit.lowComprehension") : param("journey.abandon.confusionLimit"),
+        frustrationMax: lowPatience ? param("journey.abandon.frustrationLimit.lowPatience") : param("journey.abandon.frustrationLimit"),
+        maxStepsWithoutProgress: highPersistence ? param("journey.abandon.noProgressSteps.highPersistence") : param("journey.abandon.noProgressSteps"),
         timeLimit: options.maxTime ||
-            (traits.patience > 0.7 ? 180 : traits.patience < 0.3 ? 60 : 120),
+            (highPatience ? param("journey.abandon.timeLimitSeconds.highPatience") : lowPatience ? param("journey.abandon.timeLimitSeconds.lowPatience") : param("journey.abandon.timeLimitSeconds")),
         // Decision fatigue threshold based on persistence (v9.9.0)
         // High persistence = can handle more decisions before giving up
-        decisionFatigueMax: traits.persistence > 0.7 ? 0.95 : traits.persistence < 0.3 ? 0.7 : 0.85,
+        decisionFatigueMax: highPersistence ? param("journey.abandon.fatigueLimit.highPersistence") : lowPersistence ? param("journey.abandon.fatigueLimit.lowPersistence") : param("journey.abandon.fatigueLimit"),
     };
     // Initialize state
     const state = {
@@ -742,7 +760,7 @@ export async function runCognitiveJourney(options) {
         confusionLevel: 0.0,
         frustrationLevel: 0.0,
         goalProgress: 0.0,
-        confidenceLevel: 0.5,
+        confidenceLevel: param("journey.initialConfidence"),
         currentMood: "neutral",
         memory: {
             pagesVisited: [options.startUrl],
@@ -762,8 +780,8 @@ export async function runCognitiveJourney(options) {
         // Dual-process cognitive mode (v10.0.0)
         // Experts start in System 1 (fast), novices in System 2 (slow)
         cognitiveMode: {
-            system: traits.comprehension > 0.7 ? 1 : 2,
-            switchThreshold: traits.comprehension < 0.4 ? 0.4 : 0.6,
+            system: traits.comprehension > param("journey.band.high.comprehension") ? 1 : 2,
+            switchThreshold: lowComprehension ? param("journey.dualProcess.switchThreshold.lowComprehension") : param("journey.dualProcess.switchThreshold"),
             system1Errors: 0,
             timeInSystem1: 0,
             timeInSystem2: 0,
@@ -772,7 +790,7 @@ export async function runCognitiveJourney(options) {
         scanPattern: {
             basePattern: personaObj.humanBehavior?.attention?.pattern || "f-pattern",
             widthMultiplier: 1.0,
-            effectiveWidth: 100,
+            effectiveWidth: param("journey.percentScale"),
         },
         missedDueToTunnelVision: 0,
         // Peripheral vision affected by stress (v10.1.0) - Yerkes-Dodson Law
@@ -784,7 +802,9 @@ export async function runCognitiveJourney(options) {
         // Habituation/banner blindness state (v10.1.0)
         habituation: createHabituationState(
         // Low comprehension = faster blindness (lower threshold)
-        traits.comprehension > 0.7 ? 5 : traits.comprehension < 0.4 ? 2 : 3),
+        traits.comprehension > param("journey.band.high.comprehension")
+            ? param("journey.habituation.exposures.highComprehension")
+            : lowComprehension ? param("journey.habituation.exposures.lowComprehension") : param("journey.habituation.exposures")),
         // Gaze-to-mouse lag based on age (v10.1.0) - WebGazer.js research
         gazeMouseLag: calculateGazeMouseLag(personaObj.demographics?.age_range),
         // Emotional state based on appraisal theory (v13.1.0) - Scherer 2001
@@ -805,14 +825,15 @@ export async function runCognitiveJourney(options) {
         if (ageMatch) {
             const age = parseInt(ageMatch[1], 10);
             // Motor control degrades with age: 1.0 at 25, 1.5 at 65, 2.0 at 85
-            ageModifier = age > 40 ? 1 + (age - 40) / 50 : 1.0;
+            const onset = param("journey.fitts.ageOnset");
+            ageModifier = age > onset ? 1 + (age - onset) / param("journey.fitts.agePerSlowdown") : 1.0;
         }
     }
     // Derive tremor modifier from mouse params or motor traits
     let tremorModifier = 0;
     if (mouseParams) {
         // Higher jitter = more tremor effect
-        tremorModifier = (mouseParams.jitter || 0) / 10;
+        tremorModifier = (mouseParams.jitter || 0) / param("journey.fitts.jitterScale");
     }
     const fittsParams = {
         ageModifier,
@@ -848,14 +869,14 @@ export async function runCognitiveJourney(options) {
     // Window size stays at 1920×1080 so chromium fills Xvfb edge-to-edge.
     // Dashboard overlay positions: top:7.87% (85/1080), height:92.13% (995/1080).
     if (options.enableMouseOverlay) {
-        browserConfig.viewportWidth = 1920;
-        browserConfig.viewportHeight = 995;
-        browserConfig.windowWidth = 1920;
-        browserConfig.windowHeight = 1080;
+        browserConfig.viewportWidth = param("journey.live.screenWidth");
+        browserConfig.viewportHeight = param("journey.live.pageHeight");
+        browserConfig.windowWidth = param("journey.live.screenWidth");
+        browserConfig.windowHeight = param("journey.live.screenHeight");
         // Heavy university / news / e-commerce sites often need >30s to reach
         // domcontentloaded with all their analytics/CDN scripts. Live journeys
         // get a 60s navigation budget per attempt.
-        browserConfig.timeout = 60000;
+        browserConfig.timeout = param("journey.live.navigationTimeoutMs");
         // When a click opens target="_blank" or window.open, follow the new tab
         // so VNC keeps showing where the persona actually went.
         browserConfig.followPopups = true;
@@ -865,7 +886,7 @@ export async function runCognitiveJourney(options) {
         browserConfig.viewportHeight = options.viewport.height;
         browserConfig.viewportOverride = options.viewport;
     }
-    const browser = new CBrowser(browserConfig);
+    const browser = options.createBrowser ? options.createBrowser(browserConfig) : new CBrowser(browserConfig);
     // Helper that re-injects the mouse overlay. The overlay script is idempotent
     // (gates on window.__cbHelperInstalled), so calling this after every navigation
     // is safe and ensures the overlay always survives full page loads.
@@ -892,8 +913,7 @@ export async function runCognitiveJourney(options) {
             // Persona modifiers (type weights × cognitive traits) are precomputed
             // here in Node and serialized into the page as window.__cbAttentionConfig.
             const attentionConfig = buildAttentionConfig(personaObj.name, options.goal, traits);
-            const configBootstrap = `window.__cbAttentionConfig = ${JSON.stringify(attentionConfig)};`;
-            await initialPage.context().addInitScript(configBootstrap + ATTENTION_OVERLAY_SCRIPT);
+            await initialPage.context().addInitScript(attentionOverlayInitScript(attentionConfig));
         }
         catch (e) {
             console.warn(`[cognitive] Overlay context init failed: ${e.message}`);
@@ -908,7 +928,8 @@ export async function runCognitiveJourney(options) {
     // Hard timeout per attempt is browserConfig.timeout (set to 60s above for
     // live mode).
     let lastErr;
-    for (let attempt = 1; attempt <= 4; attempt++) {
+    const navAttempts = param("journey.nav.attempts");
+    for (let attempt = 1; attempt <= navAttempts; attempt++) {
         try {
             await browser.navigate(options.startUrl, { waitStrategy: "domcontentloaded" });
             lastErr = undefined;
@@ -917,11 +938,11 @@ export async function runCognitiveJourney(options) {
         catch (navErr) {
             lastErr = navErr;
             const isTransient = /ERR_NETWORK_CHANGED|ERR_CONNECTION|ERR_TIMED_OUT|Timeout/i.test(lastErr.message);
-            if (attempt === 4 || !isTransient) {
+            if (attempt === navAttempts || !isTransient) {
                 if (!isTransient)
                     throw lastErr;
             }
-            await new Promise(r => setTimeout(r, 2500 * attempt));
+            await new Promise(r => setTimeout(r, param("journey.nav.backoffMs") * attempt));
         }
     }
     if (lastErr)
@@ -931,7 +952,7 @@ export async function runCognitiveJourney(options) {
     // Auto-capture (v18.70.0): recording starts once the journey's start URL is
     // loaded, so frame 0 is the page the persona actually opens on, and stops
     // just before the browser closes. Capture never fails the journey.
-    const captureSession = await startAutoCapture(await browser.getPage(), options.capture, `journey-${nameSlug ?? journeySlug(options.persona)}-${Date.now()}`);
+    const captureSession = await startAutoCapture(await browser.getPage(), options.capture, `journey-${nameSlug ?? journeySlug(options.persona)}-${uniqueStamp()}`);
     // Apply geolocation at runtime as well (ensures permission is granted after context exists)
     if (effectiveLocation.geolocation) {
         await browser.setGeolocationRuntime(effectiveLocation.geolocation);
@@ -939,7 +960,7 @@ export async function runCognitiveJourney(options) {
     const fullMonologue = [];
     const frictionPoints = [];
     const startTime = Date.now();
-    const maxSteps = options.maxSteps || 50;
+    const maxSteps = options.maxSteps || param("journey.maxSteps");
     // ── Returning-visit familiarity boost ─────────────────────────────────
     // The persona's existing siteFamiliarity trait already drives perception
     // (navigation weighting in attention-transport, scan-path defaults, etc.).
@@ -950,8 +971,8 @@ export async function runCognitiveJourney(options) {
     // 5 ≈ +0.72, 10+ ≈ +0.92 — asymptotes near 1.
     if (options.priorMemory && options.priorMemory.visitCount > 0) {
         const v = options.priorMemory.visitCount;
-        const familiarityBoost = 1 - Math.exp(-v / 4);
-        const baseline = traits.siteFamiliarity ?? 0.5;
+        const familiarityBoost = 1 - Math.exp(-v / param("journey.familiarity.visitScale"));
+        const baseline = traits.siteFamiliarity ?? param("journey.defaultTrait");
         // Boost toward 1.0 from baseline. The persona keeps any fundamental
         // cognitive trait (e.g. low transferLearning still matters) but the
         // domain-specific familiarity component lifts.
@@ -973,7 +994,7 @@ export async function runCognitiveJourney(options) {
         temporalState = getTemporalState(tCtx);
         temporalModulators = computeTemporalModulators(temporalState);
         // Apply trait deltas
-        traits.patience = Math.max(0, Math.min(1, (traits.patience ?? 0.5) + temporalModulators.patienceDelta));
+        traits.patience = Math.max(0, Math.min(1, (traits.patience ?? param("journey.defaultTrait")) + temporalModulators.patienceDelta));
         if (traits.workingMemory !== undefined) {
             traits.workingMemory = Math.max(0, Math.min(1, traits.workingMemory + temporalModulators.workingMemoryDelta));
         }
@@ -998,7 +1019,7 @@ export async function runCognitiveJourney(options) {
     if (options.priorMemory && options.priorMemory.visitCount > 0) {
         const m = options.priorMemory;
         const sinceDays = m.lastVisitAt
-            ? Math.round((Date.now() - new Date(m.lastVisitAt.replace(" ", "T") + "Z").getTime()) / (1000 * 60 * 60 * 24))
+            ? Math.round((Date.now() - new Date(m.lastVisitAt.replace(" ", "T") + "Z").getTime()) / param("journey.msPerDay"))
             : null;
         const sinceStr = sinceDays === null
             ? "before"
@@ -1061,7 +1082,7 @@ Right now it's ${temporalState.description}.`;
     // Main cognitive loop
     for (let step = 1; step <= maxSteps; step++) {
         state.stepCount = step;
-        state.timeElapsed = (Date.now() - startTime) / 1000;
+        state.timeElapsed = (Date.now() - startTime) / param("journey.msPerSecond");
         // Check time limit
         if (state.timeElapsed > thresholds.timeLimit) {
             abandonmentReason = "timeout";
@@ -1095,7 +1116,7 @@ Right now it's ${temporalState.description}.`;
         try {
             await Promise.race([
                 page.evaluate("1+1"),
-                new Promise((_, rej) => setTimeout(() => rej(new Error("renderer health check timed out")), 5000)),
+                new Promise((_, rej) => setTimeout(() => rej(new Error("renderer health check timed out")), param("journey.healthCheckMs"))),
             ]);
         }
         catch (healthErr) {
@@ -1116,7 +1137,7 @@ Right now it's ${temporalState.description}.`;
         const screenshotKey = currentUrl.split('?')[0]; // strip query for stable keying
         const lastCapturedScrollY = lastScreenshotScroll.get(screenshotKey);
         const isInitialLoadForUrl = lastCapturedScrollY === undefined;
-        const scrolledEnough = lastCapturedScrollY !== undefined && Math.abs(viewportCtx.scroll.y - lastCapturedScrollY) > 100;
+        const scrolledEnough = lastCapturedScrollY !== undefined && Math.abs(viewportCtx.scroll.y - lastCapturedScrollY) > param("journey.screenshot.scrollPx");
         const shouldCapture = isInitialLoadForUrl || scrolledEnough;
         let screenshotPath;
         let attentionHeatmapBase64;
@@ -1143,8 +1164,9 @@ Right now it's ${temporalState.description}.`;
         // step 2 onward (step 1 has no prior to compare against).
         if (lastActionOutcome) {
             const currentTexts = new Set(availableElements.map(e => e.text));
-            const newClickables = [...currentTexts].filter(t => t && !prevClickableTexts.has(t)).slice(0, 8);
-            const removedClickables = [...prevClickableTexts].filter(t => t && !currentTexts.has(t)).slice(0, 8);
+            // Uncapped: the prompt names the first few (journey.prompt.changedElementsShown).
+            const newClickables = [...currentTexts].filter(t => t && !prevClickableTexts.has(t));
+            const removedClickables = [...prevClickableTexts].filter(t => t && !currentTexts.has(t));
             lastActionOutcome.newClickables = newClickables;
             lastActionOutcome.removedClickables = removedClickables;
             // After a navigation the scroll position belongs to the new page, so the
@@ -1162,9 +1184,20 @@ Right now it's ${temporalState.description}.`;
         // omitted the actual prices, and a long article omitted its body. The new
         // version walks the visible viewport and captures every meaningful text
         // node above-the-fold + a band just below, ordered top-to-bottom.
-        const pageContent = await page.evaluate(() => {
+        // The extractor runs in the page, which cannot call param(); its limits
+        // are read here and passed in.
+        const contentLimits = {
+            lookaheadShare: param("journey.content.lookaheadShare"),
+            aboveViewportPx: param("journey.content.aboveViewportPx"),
+            minWidthPx: param("journey.content.minWidthPx"),
+            minHeightPx: param("journey.content.minHeightPx"),
+            minChars: param("journey.content.minChars"),
+            maxChars: param("journey.content.maxChars"),
+            maxLines: param("journey.content.maxLines"),
+        };
+        const pageContent = await page.evaluate((L) => {
             const vh = window.innerHeight;
-            const lookahead = vh * 0.4; // include a strip just below the fold so AI can plan ahead
+            const lookahead = vh * L.lookaheadShare; // include a strip just below the fold so AI can plan ahead
             const out = [];
             const skipTags = new Set(['SCRIPT', 'STYLE', 'NOSCRIPT', 'svg', 'IFRAME']);
             const nodes = document.querySelectorAll('h1, h2, h3, h4, p, li, td, th, [role="heading"], [data-testid]');
@@ -1172,20 +1205,20 @@ Right now it's ${temporalState.description}.`;
                 if (skipTags.has(el.tagName))
                     return;
                 const r = el.getBoundingClientRect();
-                if (r.bottom < -50)
+                if (r.bottom < -L.aboveViewportPx)
                     return; // above viewport
                 if (r.top > vh + lookahead)
                     return; // far below
-                if (r.width < 20 || r.height < 8)
+                if (r.width < L.minWidthPx || r.height < L.minHeightPx)
                     return;
                 const style = window.getComputedStyle(el);
                 if (style.display === 'none' || style.visibility === 'hidden')
                     return;
                 const text = el.innerText?.trim();
-                if (!text || text.length < 3)
+                if (!text || text.length < L.minChars)
                     return;
                 // Trim long paragraphs but keep prices/key info
-                const trimmed = text.length > 220 ? text.substring(0, 220) + '…' : text;
+                const trimmed = text.length > L.maxChars ? text.substring(0, L.maxChars) + '…' : text;
                 const tag = el.tagName.toLowerCase();
                 const tagLabel = ['h1', 'h2', 'h3', 'h4'].includes(tag) ? tag.toUpperCase() : tag;
                 const visMark = r.top < vh && r.bottom > 0 ? '👁' : '↓';
@@ -1201,8 +1234,8 @@ Right now it's ${temporalState.description}.`;
                     prev = o.line;
                 }
             }
-            return dedup.slice(0, 30).join('\n');
-        }).catch(() => '');
+            return dedup.slice(0, L.maxLines).join('\n');
+        }, contentLimits).catch(() => '');
         // Habituation/Banner Blindness tracking (v10.1.0)
         // Detect UI patterns in available elements and update habituation state
         if (state.habituation) {
@@ -1304,9 +1337,10 @@ Right now it's ${temporalState.description}.`;
             const actionSuccess = parsed.actionSuccess !== false;
             const claudeConfusion = parsed.newConfusion ?? state.emotionalState.confusion;
             const claudeFrustration = parsed.newFrustration ?? state.emotionalState.frustration;
-            const confusionIncreased = claudeConfusion > state.emotionalState.confusion + 0.05;
-            const confusionDecreased = claudeConfusion < state.emotionalState.confusion - 0.05;
-            const frustrationIncreased = claudeFrustration > state.emotionalState.frustration + 0.05;
+            const signalThreshold = param("journey.signal.changeThreshold");
+            const confusionIncreased = claudeConfusion > state.emotionalState.confusion + signalThreshold;
+            const confusionDecreased = claudeConfusion < state.emotionalState.confusion - signalThreshold;
+            const frustrationIncreased = claudeFrustration > state.emotionalState.frustration + signalThreshold;
             // Severity scales with the magnitude of the LLM-reported delta — Claude
             // proposes a value, we use the *delta* (clamped to [0, 1]) as the
             // trigger's intensity, instead of trusting Claude's absolute number.
@@ -1316,7 +1350,7 @@ Right now it's ${temporalState.description}.`;
             // matched signals can fire sequentially below if both are strong.
             const triggersToFire = [];
             if (!actionSuccess && parsed.errorMessage) {
-                triggersToFire.push({ trigger: "error", severity: 1.2, description: parsed.errorMessage });
+                triggersToFire.push({ trigger: "error", severity: param("journey.severity.error"), description: parsed.errorMessage });
             }
             else if (!actionSuccess) {
                 triggersToFire.push({ trigger: "failure", severity: 1.0, description: "Action did not succeed" });
@@ -1325,7 +1359,7 @@ Right now it's ${temporalState.description}.`;
             if (confusionIncreased) {
                 triggersToFire.push({
                     trigger: "confusion_onset",
-                    severity: Math.max(0.5, confusionDelta * 2),
+                    severity: Math.max(param("journey.severity.signalFloor"), confusionDelta * param("journey.severity.signalGain")),
                     description: parsed.frictionDescription || "UI became confusing",
                 });
             }
@@ -1335,7 +1369,7 @@ Right now it's ${temporalState.description}.`;
                 // via decay.
                 triggersToFire.push({
                     trigger: "clarity",
-                    severity: 0.8,
+                    severity: param("journey.severity.clarity"),
                     description: "UI became clear",
                 });
             }
@@ -1343,24 +1377,24 @@ Right now it's ${temporalState.description}.`;
                 // Friction without outright failure
                 triggersToFire.push({
                     trigger: "setback",
-                    severity: Math.max(0.5, frustrationDelta * 2),
+                    severity: Math.max(param("journey.severity.signalFloor"), frustrationDelta * param("journey.severity.signalGain")),
                     description: "Encountered friction",
                 });
             }
             // Time pressure fires when patience is already derived-low (recompute
             // briefly here using current state for the gating check).
             const patiencePreview = deriveSimplifiedState(state.emotionalState, traits).patienceRemaining;
-            if (patiencePreview < 0.3 && !triggersToFire.length) {
+            if (patiencePreview < param("journey.timePressure.patience") && !triggersToFire.length) {
                 triggersToFire.push({
                     trigger: "time_pressure",
-                    severity: 0.8,
+                    severity: param("journey.severity.timePressure"),
                     description: "Running out of patience",
                 });
             }
             if (actionSuccess && !triggersToFire.length) {
                 triggersToFire.push({
                     trigger: "success",
-                    severity: 0.8,
+                    severity: param("journey.severity.success"),
                     description: parsed.action || "Action completed",
                 });
             }
@@ -1401,7 +1435,7 @@ Right now it's ${temporalState.description}.`;
             if (wasInteractive && actionSucceeded) {
                 // Allow up to the LLM's proposed delta; URL-change reconciliation later
                 // expands the cap to full LLM proposal if URL changed.
-                progressDeltaAllowed = Math.min(progressDeltaProposed, 0.05);
+                progressDeltaAllowed = Math.min(progressDeltaProposed, param("journey.progress.inPageCap"));
             }
             // No evidence at all → no progress (Claude was hallucinating advancement)
         }
@@ -1466,10 +1500,11 @@ Right now it's ${temporalState.description}.`;
             const cognitiveLoad = (state.confusionLevel + state.frustrationLevel) / 2;
             const prevWidth = state.scanPattern.widthMultiplier;
             state.scanPattern.widthMultiplier = calculateScanWidthMultiplier(cognitiveLoad);
-            state.scanPattern.effectiveWidth = state.scanPattern.widthMultiplier * 100;
+            state.scanPattern.effectiveWidth = state.scanPattern.widthMultiplier * param("journey.percentScale");
             // Log if pattern narrowed significantly
             if (options.verbose && prevWidth !== state.scanPattern.widthMultiplier) {
-                if (state.scanPattern.widthMultiplier < 0.5) {
+                // The scan width takes only its registered values; the two narrowest are tunnel vision.
+                if (state.scanPattern.widthMultiplier <= param("journey.scan.highWidth")) {
                     console.log(`👁️ Tunnel vision: scanning only left ${state.scanPattern.effectiveWidth.toFixed(0)}% of viewport`);
                 }
                 else if (prevWidth < state.scanPattern.widthMultiplier) {
@@ -1482,8 +1517,9 @@ Right now it's ${temporalState.description}.`;
             const prevArousal = state.peripheralVision.arousalLevel;
             state.peripheralVision = calculatePeripheralVision(state.frustrationLevel, state.confusionLevel);
             // Log significant arousal changes
-            if (options.verbose && Math.abs(state.peripheralVision.arousalLevel - prevArousal) > 0.2) {
-                if (state.peripheralVision.widthFactor < 0.5) {
+            if (options.verbose && Math.abs(state.peripheralVision.arousalLevel - prevArousal) > param("journey.log.arousalChange")) {
+                // The field takes only its registered factors; the severe one is reported.
+                if (state.peripheralVision.widthFactor <= param("journey.peripheral.severeWidth")) {
                     console.log(`😰 Stress tunnel vision: peripheral field reduced to ${(state.peripheralVision.widthFactor * 100).toFixed(0)}%`);
                 }
             }
@@ -1516,13 +1552,14 @@ Right now it's ${temporalState.description}.`;
             viewport: { width: viewportCtx.viewport.width, height: viewportCtx.viewport.height },
         });
         // Record friction point if confusion/frustration spiked
-        if (parsed.frictionDescription && (state.confusionLevel > 0.4 || state.frustrationLevel > 0.4)) {
+        const frictionLevel = param("journey.friction.level");
+        if (parsed.frictionDescription && (state.confusionLevel > frictionLevel || state.frustrationLevel > frictionLevel)) {
             frictionPoints.push({
                 step,
                 url: currentUrl,
                 element: parsed.frictionElement,
                 type: "confusing_ui",
-                frustrationIncrease: parsed.newFrustration ? parsed.newFrustration - state.frustrationLevel : 0.1,
+                frustrationIncrease: parsed.newFrustration ? parsed.newFrustration - state.frustrationLevel : param("journey.friction.defaultIncrease"),
                 monologue: parsed.monologue || "",
             });
         }
@@ -1546,13 +1583,9 @@ Right now it's ${temporalState.description}.`;
                 url: currentUrl,
             });
         }
-        // Live viewer dwell — when a fresh attention map was computed this step,
-        // hold briefly before executing the action so the viewer can register the
-        // heatmap. 1.2s is enough to glance at it without making the journey feel
-        // sluggish. Skipped on non-capture steps so the journey paces normally.
-        if (options.enableMouseOverlay && attentionHeatmapBase64) {
-            await new Promise((r) => setTimeout(r, 1200));
-        }
+        // (A 1.2 s live-viewer dwell after a step with a fresh heatmap stood
+        // here until 21.0. Nothing assigns attentionHeatmapBase64 since the
+        // heatmap moved into the page, so the pause could never run.)
         // Verbose output
         if (options.verbose) {
             console.log(`\n━━━ Step ${step} ━━━`);
@@ -1570,11 +1603,12 @@ Right now it's ${temporalState.description}.`;
             // v18.29.0: Validate goal evidence against actual page content
             if (goalEvidence) {
                 try {
-                    const pageText = await page.evaluate(() => document.body.innerText?.substring(0, 5000) || '');
-                    const evidenceWords = goalEvidence.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+                    const pageText = await page.evaluate((n) => document.body.innerText?.substring(0, n) || '', param("journey.evidence.pageChars"));
+                    const minWordChars = param("journey.evidence.minWordChars");
+                    const evidenceWords = goalEvidence.toLowerCase().split(/\s+/).filter((w) => w.length > minWordChars);
                     const matchCount = evidenceWords.filter((w) => pageText.toLowerCase().includes(w)).length;
                     const matchRatio = evidenceWords.length > 0 ? matchCount / evidenceWords.length : 0;
-                    if (matchRatio < 0.3) {
+                    if (matchRatio < param("journey.evidence.verifiedShare")) {
                         // Evidence doesn't match page content — flag as unverified
                         goalEvidence = `[UNVERIFIED - ${Math.round(matchRatio * 100)}% match] ${goalEvidence}`;
                     }
@@ -1594,8 +1628,8 @@ Right now it's ${temporalState.description}.`;
             fullMonologue.push(abandonment.message);
             // v18.29.0: Capture failure context
             try {
-                const pageText = await page.evaluate(() => document.body.innerText?.substring(0, 1000) || '');
-                failureReason = parsed.failureReason || `Abandoned on "${pageTitle}" (${currentUrl}). Last visible: ${pageText.substring(0, 200)}...`;
+                const pageText = await page.evaluate((n) => document.body.innerText?.substring(0, n) || '', param("journey.quoteChars"));
+                failureReason = parsed.failureReason || `Abandoned on "${pageTitle}" (${currentUrl}). Last visible: ${pageText}...`;
             }
             catch {
                 failureReason = parsed.failureReason || `Abandoned on "${pageTitle}" (${currentUrl})`;
@@ -1617,7 +1651,7 @@ Right now it's ${temporalState.description}.`;
                         // @ts-expect-error window helper installed by overlay script
                         if (window.__cbShowAction)
                             window.__cbShowAction(t);
-                    }, label.slice(0, 120));
+                    }, label.slice(0, param("journey.live.bannerChars")));
                 }
                 catch { /* page navigated mid-call, helper will reinstall */ }
             }
@@ -1629,41 +1663,8 @@ Right now it's ${temporalState.description}.`;
                     target = availableElements[parseInt(indexMatch[1], 10)];
                 }
                 else if (textMatch && !textMatch[1].startsWith("#")) {
-                    // Find best element match by text. Prefer (1) exact match, then
-                    // (2) starts-with, then (3) includes; among ties, pick the one
-                    // closest to the current viewport center.
-                    const wanted = textMatch[1].trim().toLowerCase();
-                    const vc = viewportCtx.viewport.height / 2;
-                    const candidates = availableElements.filter(e => e.text);
-                    const score = (e) => {
-                        const t = (e.text || "").toLowerCase().trim();
-                        if (!t)
-                            return -Infinity;
-                        let base = 0;
-                        if (t === wanted)
-                            base = 1000;
-                        else if (t.startsWith(wanted) || wanted.startsWith(t))
-                            base = 500;
-                        else if (t.includes(wanted) || wanted.includes(t))
-                            base = 100;
-                        else
-                            return -Infinity;
-                        // Penalize distance from viewport center (closer = preferred)
-                        const ey = (e.y ?? 0) + (e.height ?? 0) / 2;
-                        const dist = Math.abs(ey - vc);
-                        return base - Math.min(dist, 5000);
-                    };
-                    let best;
-                    let bestScore = -Infinity;
-                    for (const e of candidates) {
-                        const s = score(e);
-                        if (s > bestScore) {
-                            bestScore = s;
-                            best = e;
-                        }
-                    }
-                    if (best && bestScore > 0)
-                        target = best;
+                    // Find best element match by text (matchClickable).
+                    target = matchClickable(availableElements, textMatch[1], viewportCtx.viewport.height);
                 }
                 let result;
                 const hasBbox = target && typeof target.x === "number" && typeof target.y === "number"
@@ -1673,6 +1674,9 @@ Right now it's ${temporalState.description}.`;
                     const urlBefore = page.url();
                     const cx = target.x + target.width / 2;
                     const cy = target.y + target.height / 2;
+                    // Set once the pointing wait below is paid, so the retry by name
+                    // after a throw does not pay it again.
+                    let pointingPaid = false;
                     try {
                         // Only scroll if the element is OFF-screen. Scrolling an already-
                         // visible element causes pointless jitter that stacks with any
@@ -1685,7 +1689,7 @@ Right now it's ${temporalState.description}.`;
                                 // "instant" behavior — no animation, no stacking with page handlers
                                 window.scrollTo({ top: t, behavior: "instant" });
                             }, { y: cy });
-                            await page.waitForTimeout(150);
+                            await page.waitForTimeout(param("journey.click.scrollSettleMs"));
                         }
                         // Re-read post-scroll coords; click at center via raw mouse so
                         // Playwright's locator auto-scroll-into-view never engages.
@@ -1694,11 +1698,18 @@ Right now it's ${temporalState.description}.`;
                             if (!el)
                                 return null;
                             const r = el.getBoundingClientRect();
-                            return { x: r.left + r.width / 2, y: r.top + r.height / 2, w: r.width, h: r.height };
+                            return { x: r.left + r.width / 2, y: r.top + r.height / 2, w: r.width, h: r.height, left: r.left, top: r.top, scrollY: window.scrollY };
                         }, { sel: target.selector });
                         const ctr = (fresh && fresh.x > 0 && fresh.y > 0)
                             ? { x: fresh.x, y: fresh.y, w: fresh.w, h: fresh.h }
                             : { x: cx, y: cy, w: target.width, h: target.height };
+                        // The pointer's move to the box it is sent to, as a hover's: Stage
+                        // B's law from the centre of the screen, plus the gaze lag.
+                        const sentTo = (fresh && fresh.x > 0 && fresh.y > 0)
+                            ? boxGeometry({ ...target, x: fresh.left, y: fresh.top, width: fresh.w, height: fresh.h }, viewportCtx.viewport, fresh.scrollY)
+                            : boxGeometry(target, viewportCtx.viewport, viewportCtx.scroll.y);
+                        await pointingWait(fittsParams, state.gazeMouseLag, options.humanInput, sentTo);
+                        pointingPaid = true;
                         if (options.humanInput) {
                             const { humanClick } = await import("../visual/human-input.js");
                             await humanClick(page, ctr.x, ctr.y, inputTraits, { width: ctr.w, height: ctr.h });
@@ -1706,20 +1717,21 @@ Right now it's ${temporalState.description}.`;
                         else {
                             await page.mouse.click(ctr.x, ctr.y);
                         }
-                        await page.waitForTimeout(800);
+                        await page.waitForTimeout(param("journey.action.navigationWaitMs"));
                         const urlAfter = page.url();
                         result = { success: true, ...(urlAfter !== urlBefore ? { newUrl: urlAfter } : {}) };
                     }
                     catch (clickErr) {
                         console.warn(`[cognitive] coordinate click failed: ${clickErr.message}`);
                         const fallback = target.text ? `click:${target.text}` : parsed.action;
-                        result = await executeAction(browser, fallback, fittsParams, state.gazeMouseLag, options.humanInput, inputTraits);
+                        result = await executeAction(browser, fallback, fittsParams, state.gazeMouseLag, options.humanInput, inputTraits, boxGeometry(target, viewportCtx.viewport, viewportCtx.scroll.y), pointingPaid);
                     }
                 }
                 else {
                     // No bbox — let executeAction handle (non-click actions, or click
-                    // text not found in availableElements).
-                    result = await executeAction(browser, parsed.action, fittsParams, state.gazeMouseLag, options.humanInput, inputTraits);
+                    // text not found in availableElements). A hover names its element
+                    // the same way; its listed geometry, if any, times the pointing.
+                    result = await executeAction(browser, parsed.action, fittsParams, state.gazeMouseLag, options.humanInput, inputTraits, pointingGeometry(parsed.action, availableElements, viewportCtx.viewport, viewportCtx.scroll.y));
                 }
                 // Inter-action settle pause — humans don't fire actions back-to-back
                 // at machine speed. Modulated by patience + readingTendency so an
@@ -1759,8 +1771,9 @@ Right now it's ${temporalState.description}.`;
                 // Goal progress cap was previously +0.05 max (no-evidence fallback).
                 // If the URL actually changed, expand the cap to the LLM's full
                 // proposed delta — that's strong navigation evidence.
-                if (urlChanged && _llmProposedProgressDelta > 0.05) {
-                    const additionalAllowed = _llmProposedProgressDelta - 0.05;
+                const inPageCap = param("journey.progress.inPageCap");
+                if (urlChanged && _llmProposedProgressDelta > inPageCap) {
+                    const additionalAllowed = _llmProposedProgressDelta - inPageCap;
                     state.goalProgress = Math.min(1, state.goalProgress + additionalAllowed);
                 }
                 // Action result feeds back into the canonical EmotionalState via triggers.
@@ -1768,10 +1781,10 @@ Right now it's ${temporalState.description}.`;
                 // which were overwritten next step by deriveSimplifiedState anyway.
                 if (state.emotionalState) {
                     if (result.success) {
-                        const progressMade = urlChanged || state.goalProgress > 0.1;
+                        const progressMade = urlChanged || state.goalProgress > param("journey.progress.madeLevel");
                         // Progress = stronger positive trigger than plain success
                         const { state: newEmotional, event } = applyEmotionalTrigger(state.emotionalState, progressMade ? "progress" : "success", emotionalConfig, state.stepCount, {
-                            severity: progressMade ? 1.2 : 0.8,
+                            severity: progressMade ? param("journey.severity.progress") : param("journey.severity.success"),
                             description: progressMade
                                 ? `Action advanced goal (${urlChanged ? "URL change" : "in-page progress"})`
                                 : `Action completed: ${parsed.action}`,
@@ -1798,7 +1811,7 @@ Right now it's ${temporalState.description}.`;
                 // Action threw — fire an error trigger on canonical state.
                 if (state.emotionalState) {
                     const { state: newEmotional, event } = applyEmotionalTrigger(state.emotionalState, "error", emotionalConfig, state.stepCount, {
-                        severity: 1.3,
+                        severity: param("journey.severity.actionThrew"),
                         description: error instanceof Error ? error.message : String(error),
                     });
                     state.emotionalState = newEmotional;
@@ -1822,15 +1835,15 @@ Right now it's ${temporalState.description}.`;
                 // Estimate decision complexity: clicks on links = easy (2 options),
                 // form fills = medium (5), navigation choices = hard (8+)
                 const estimatedOptions = parsed.action.toLowerCase().includes("fill")
-                    ? 5
+                    ? param("journey.fatigue.options.fill")
                     : parsed.action.toLowerCase().includes("navigate") || parsed.action.toLowerCase().includes("search")
-                        ? 8
-                        : 3;
+                        ? param("journey.fatigue.options.navigate")
+                        : param("journey.fatigue.options.other");
                 const fatigueIncrement = calculateFatigueIncrement(estimatedOptions);
                 state.decisionFatigue.fatigueLevel = Math.min(1, state.decisionFatigue.fatigueLevel + fatigueIncrement);
                 state.decisionFatigue.lastDecisionComplexity = estimatedOptions;
                 // High fatigue triggers default-seeking behavior
-                if (state.decisionFatigue.fatigueLevel > 0.7) {
+                if (state.decisionFatigue.fatigueLevel > param("journey.fatigue.defaultsLevel")) {
                     state.decisionFatigue.choosingDefaults = true;
                 }
                 if (options.verbose) {
@@ -1839,13 +1852,13 @@ Right now it's ${temporalState.description}.`;
             }
         }
         // Small delay between steps
-        await sleep(500);
+        await sleep(param("journey.stepPauseMs"));
     }
     // Post-journey goal validation — final evaluation of the current page
     if (!goalAchieved) {
         try {
             const page = await browser.getPage();
-            const finalPageText = await page.evaluate(() => document.body.innerText?.substring(0, 3000) || '');
+            const finalPageText = await page.evaluate((n) => document.body.innerText?.substring(0, n) || '', param("journey.finalEval.pageChars"));
             const finalUrl = page.url();
             // Ask Claude: did we actually achieve the goal? Through the decision
             // provider, recorded as the trace's final step, so a replay answers
@@ -1888,7 +1901,7 @@ Answer with JSON:
                 const evalJson = (readReplyJson(evalText).value ?? {});
                 if (evalJson.achieved) {
                     goalAchieved = true;
-                    goalEvidence = `[FINAL EVAL] ${evalJson.evidence || finalPageText.substring(0, 200)}`;
+                    goalEvidence = `[FINAL EVAL] ${evalJson.evidence || finalPageText.substring(0, param("journey.quoteChars"))}`;
                     abandonmentReason = undefined;
                     abandonmentMessage = undefined;
                 }
@@ -1898,13 +1911,13 @@ Answer with JSON:
         catch { }
     }
     // Fallback: only if goalProgress is very high (90%+) AND final monologue explicitly says "found"
-    if (!goalAchieved && state.goalProgress >= 0.9) {
+    if (!goalAchieved && state.goalProgress >= param("journey.fallback.progress")) {
         const lastMonologue = (fullMonologue[fullMonologue.length - 1] || '').toLowerCase();
         const strongSignals = ['found it', 'found exactly', 'this is exactly', 'goal achieved', 'here it is', 'perfect, this is'];
         const hasStrongSignal = strongSignals.some(s => lastMonologue.includes(s));
         if (hasStrongSignal) {
             goalAchieved = true;
-            goalEvidence = `[AUTO-DETECTED: goalProgress=${Math.round(state.goalProgress * 100)}%] ${fullMonologue[fullMonologue.length - 1]?.substring(0, 200) || ''}`;
+            goalEvidence = `[AUTO-DETECTED: goalProgress=${Math.round(state.goalProgress * 100)}%] ${fullMonologue[fullMonologue.length - 1]?.substring(0, param("journey.quoteChars")) || ''}`;
             abandonmentReason = undefined;
             abandonmentMessage = undefined;
         }
@@ -1927,7 +1940,7 @@ Answer with JSON:
         ...(traceWriter ? { tracePath: traceWriter.filePath } : {}),
         abandonmentReason,
         abandonmentMessage,
-        totalTime: (Date.now() - startTime) / 1000,
+        totalTime: (Date.now() - startTime) / param("journey.msPerSecond"),
         stepCount: state.stepCount,
         frictionPoints,
         fullMonologue,
@@ -1936,7 +1949,7 @@ Answer with JSON:
             avgConfusionLevel: emotion.avgConfusionLevel,
             maxFrustrationLevel: emotion.maxFrustrationLevel,
             backtrackCount: state.memory.backtrackCount,
-            timeInConfusion: frictionPoints.length * 2, // Estimate
+            timeInConfusion: frictionPoints.length * param("journey.summary.secondsPerFriction"), // Estimate
             // Decision fatigue metrics (v9.9.0)
             decisionsMade: state.decisionFatigue?.decisionsMade ?? 0,
             finalDecisionFatigue: state.decisionFatigue?.fatigueLevel ?? 0,
@@ -1965,17 +1978,21 @@ Answer with JSON:
 // ============================================================================
 function buildCognitiveSystemPrompt(persona, profile, goal, thresholds) {
     const traits = profile.traits;
+    const lowP = param("journey.band.low.patience"), highP = param("journey.band.high.patience");
+    const lowR = param("journey.band.low.riskTolerance"), highR = param("journey.band.high.riskTolerance");
+    const lowC = param("journey.band.low.comprehension"), highC = param("journey.band.high.comprehension");
+    const lowT = param("journey.band.low.readingTendency"), highT = param("journey.band.high.readingTendency");
     return `You are simulating a "${persona.name}" user navigating a website.
 
 PERSONA DESCRIPTION: ${persona.description}
 
 COGNITIVE TRAITS:
-- Patience: ${traits.patience.toFixed(2)} ${traits.patience < 0.3 ? "(impatient)" : traits.patience > 0.7 ? "(patient)" : "(moderate)"}
-- Risk Tolerance: ${traits.riskTolerance.toFixed(2)} ${traits.riskTolerance < 0.3 ? "(cautious)" : traits.riskTolerance > 0.7 ? "(bold)" : "(moderate)"}
-- Comprehension: ${traits.comprehension.toFixed(2)} ${traits.comprehension < 0.4 ? "(struggles with UI)" : traits.comprehension > 0.7 ? "(expert)" : "(moderate)"}
+- Patience: ${traits.patience.toFixed(2)} ${traits.patience < lowP ? "(impatient)" : traits.patience > highP ? "(patient)" : "(moderate)"}
+- Risk Tolerance: ${traits.riskTolerance.toFixed(2)} ${traits.riskTolerance < lowR ? "(cautious)" : traits.riskTolerance > highR ? "(bold)" : "(moderate)"}
+- Comprehension: ${traits.comprehension.toFixed(2)} ${traits.comprehension < lowC ? "(struggles with UI)" : traits.comprehension > highC ? "(expert)" : "(moderate)"}
 - Persistence: ${traits.persistence.toFixed(2)}
 - Curiosity: ${traits.curiosity.toFixed(2)}
-- Reading Tendency: ${traits.readingTendency.toFixed(2)} ${traits.readingTendency < 0.3 ? "(scans only)" : traits.readingTendency > 0.7 ? "(reads everything)" : "(selective reader)"}
+- Reading Tendency: ${traits.readingTendency.toFixed(2)} ${traits.readingTendency < lowT ? "(scans only)" : traits.readingTendency > highT ? "(reads everything)" : "(selective reader)"}
 
 ATTENTION PATTERN: ${profile.attentionPattern}
 DECISION STYLE: ${profile.decisionStyle}
@@ -2085,7 +2102,7 @@ function buildStepPrompt(state, currentUrl, pageTitle, step, availableElements =
     let viewportStr = "";
     if (viewportCtx) {
         const { viewport, scroll, headings, activeModals, formErrors, bannersBlocking } = viewportCtx;
-        const visHeadings = headings.filter(h => h.visible).slice(0, 6).map(h => `H${h.level}: ${h.text}`).join(' | ');
+        const visHeadings = headings.filter(h => h.visible).slice(0, param("journey.prompt.headings")).map(h => `H${h.level}: ${h.text}`).join(' | ');
         const lines = [
             `- Viewport: ${viewport.width}×${viewport.height}`,
             `- Scroll: ${scroll.y}/${scroll.max}px (${Math.round(scroll.pct * 100)}%)${scroll.atTop ? ' [at top]' : ''}${scroll.atBottom ? ' [at bottom]' : ''}`,
@@ -2113,15 +2130,15 @@ function buildStepPrompt(state, currentUrl, pageTitle, step, availableElements =
         else if (lastOutcome.action.startsWith('click')) {
             lines.push(`- Page did NOT navigate (click had no nav effect — element may be JS-only or wasn't matched)`);
         }
-        if (typeof lastOutcome.scrollDelta === 'number' && Math.abs(lastOutcome.scrollDelta) > 10) {
+        if (typeof lastOutcome.scrollDelta === 'number' && Math.abs(lastOutcome.scrollDelta) > param("journey.prompt.scrollReportPx")) {
             const dir = lastOutcome.scrollDelta > 0 ? 'down' : 'up';
             lines.push(`- Scrolled ${dir} ${Math.abs(lastOutcome.scrollDelta)}px`);
         }
         if (lastOutcome.newClickables?.length) {
-            lines.push(`- New elements appeared: ${lastOutcome.newClickables.slice(0, 5).map(t => `"${t}"`).join(', ')}`);
+            lines.push(`- New elements appeared: ${lastOutcome.newClickables.slice(0, param("journey.prompt.changedElementsShown")).map(t => `"${t}"`).join(', ')}`);
         }
         if (lastOutcome.removedClickables?.length) {
-            lines.push(`- Elements no longer visible: ${lastOutcome.removedClickables.slice(0, 5).map(t => `"${t}"`).join(', ')}`);
+            lines.push(`- Elements no longer visible: ${lastOutcome.removedClickables.slice(0, param("journey.prompt.changedElementsShown")).map(t => `"${t}"`).join(', ')}`);
         }
         outcomeStr = `\nWHAT HAPPENED LAST STEP:\n${lines.join('\n')}\n`;
     }
@@ -2148,14 +2165,16 @@ CURRENT STATE:
 ${(() => {
         // Loop detection: if the last 4 actions are alternating scrolls, surface
         // it loudly so the AI breaks out instead of pumping scroll:down/up forever.
-        const recent = state.memory.actionsAttempted.slice(-4).map(a => a.action || "");
-        if (recent.length >= 4 && recent.every(a => a.startsWith("scroll:"))) {
-            return `\n⚠️ LOOP DETECTED: your last 4 actions were all scrolls (${recent.join(", ")}). Pick a click/back/dismiss/find action instead — scrolling more will not help.`;
+        const scrollLoop = param("journey.prompt.scrollLoop");
+        const recent = state.memory.actionsAttempted.slice(-scrollLoop).map(a => a.action || "");
+        if (recent.length >= scrollLoop && recent.every(a => a.startsWith("scroll:"))) {
+            return `\n⚠️ LOOP DETECTED: your last ${scrollLoop} actions were all scrolls (${recent.join(", ")}). Pick a click/back/dismiss/find action instead — scrolling more will not help.`;
         }
         // Repeated failed actions
-        const lastTwo = state.memory.actionsAttempted.slice(-2);
-        if (lastTwo.length === 2 && lastTwo.every(a => a.success === false)) {
-            return `\n⚠️ Last 2 actions failed (${lastTwo.map(a => a.action).join(", ")}). The element you wanted may not exist with that exact text — try a click:#N index from AVAILABLE ELEMENTS above, or a different element entirely.`;
+        const failedRun = param("journey.prompt.failedRun");
+        const lastTwo = state.memory.actionsAttempted.slice(-failedRun);
+        if (lastTwo.length === failedRun && lastTwo.every(a => a.success === false)) {
+            return `\n⚠️ Last ${failedRun} actions failed (${lastTwo.map(a => a.action).join(", ")}). The element you wanted may not exist with that exact text — try a click:#N index from AVAILABLE ELEMENTS above, or a different element entirely.`;
         }
         return "";
     })()}
@@ -2232,37 +2251,7 @@ export function resolveJourneyPersona(name, customTraits) {
     else if (customTraits) {
         // v16.7.1: full default trait set (was only 7, causing trait dropout).
         // Said 25 until 2026-08-01; the model has 26.
-        const defaultTraits = {
-            // Required traits (7)
-            patience: 0.5,
-            riskTolerance: 0.5,
-            comprehension: 0.5,
-            persistence: 0.5,
-            curiosity: 0.5,
-            workingMemory: 0.5,
-            readingTendency: 0.5,
-            // Optional traits - Tier 1: Core
-            resilience: 0.5,
-            selfEfficacy: 0.5,
-            satisficing: 0.5,
-            trustCalibration: 0.5,
-            interruptRecovery: 0.5,
-            // Optional traits - Tier 2+
-            informationForaging: 0.5,
-            changeBlindness: 0.3,
-            anchoringBias: 0.5,
-            timeHorizon: 0.5,
-            attributionStyle: 0.5,
-            metacognitivePlanning: 0.5,
-            proceduralFluency: 0.5,
-            transferLearning: 0.5,
-            authoritySensitivity: 0.5,
-            emotionalContagion: 0.5,
-            fearOfMissingOut: 0.5,
-            socialProofSensitivity: 0.5,
-            mentalModelFlexibility: 0.5,
-            siteFamiliarity: 0.5,
-        };
+        const defaultTraits = defaultJourneyTraits();
         personaObj = {
             ...existingPersona,
             cognitiveTraits: {
@@ -2291,7 +2280,7 @@ export function createLiveDecisionProvider(anthropic, model) {
         decide: async (ctx) => {
             if (!anthropic)
                 throw new Error("Anthropic API key not configured.");
-            const ask = (messages, maxTokens = 2000) => anthropic.messages.create({
+            const ask = (messages, maxTokens = param("journey.llm.maxTokens")) => anthropic.messages.create({
                 model,
                 max_tokens: maxTokens,
                 ...(ctx.systemPrompt ? { system: ctx.systemPrompt } : {}),
@@ -2315,7 +2304,7 @@ export function createLiveDecisionProvider(anthropic, model) {
                 ...ctx.messages,
                 { role: "assistant", content: firstText.trim() || "(no text)" },
                 { role: "user", content: "Your reply could not be read as the JSON object the response format asks for. Reply again with only that JSON object, nothing before or after it." },
-            ], first.stop_reason === "max_tokens" ? 8000 : 2000);
+            ], first.stop_reason === "max_tokens" ? param("journey.llm.retryMaxTokens") : param("journey.llm.maxTokens"));
             const retryText = textOf(retry);
             if (readReplyJson(retryText).value)
                 return retryText;
@@ -2418,19 +2407,12 @@ function checkAbandonmentTriggers(state, thresholds) {
             message: "Too many choices... I can't think straight anymore. Maybe later.",
         };
     }
-    // Loop detection
-    const recentPages = state.memory.pagesVisited.slice(-5);
-    const uniqueRecent = new Set(recentPages).size;
-    if (recentPages.length >= 5 &&
-        uniqueRecent <= thresholds.loopDetectionThreshold) {
-        return {
-            reason: "loop",
-            message: "I keep ending up on the same pages. Something is wrong.",
-        };
-    }
+    // (Loop detection stood here until 21.0: abandon when the last 5 pages
+    // held 3 or fewer distinct ones. pagesVisited records each page once, so
+    // the last 5 were always 5 distinct pages and it could never fire.)
     // No progress
     if (state.stepCount > thresholds.maxStepsWithoutProgress &&
-        state.goalProgress < 0.1) {
+        state.goalProgress < param("journey.progress.madeLevel")) {
         return {
             reason: "no_progress",
             message: "I'm not making any progress. This isn't working.",
@@ -2440,30 +2422,21 @@ function checkAbandonmentTriggers(state, thresholds) {
     if (state.emotionalState) {
         const emotional = state.emotionalState;
         // High anxiety + high frustration — only abandon if BOTH are extreme AND patience is depleted
-        if (emotional.anxiety > 0.85 && emotional.frustration > 0.8 && state.patienceRemaining < 0.3) {
+        if (emotional.anxiety > param("journey.emotionalAbandon.anxiety") && emotional.frustration > param("journey.emotionalAbandon.frustration") && state.patienceRemaining < param("journey.emotionalAbandon.patience")) {
             return {
                 reason: "emotional",
                 message: "This is too stressful. I need to take a break.",
             };
         }
-        // Extreme boredom — only after significant time with zero engagement
-        if (emotional.boredom > 0.9 && emotional.excitement < 0.1 && state.stepCount > 8) {
-            return {
-                reason: "emotional",
-                message: "This is so boring... I'll do this later.",
-            };
-        }
-        // Overwhelming negative valence — only with sustained high arousal AND low patience
-        if (emotional.valence < -0.85 && emotional.arousal > 0.85 && state.patienceRemaining < 0.4) {
-            return {
-                reason: "emotional",
-                message: "I can't deal with this right now.",
-            };
-        }
+        // Two rules stood here until 21.0 that no journey can reach: extreme
+        // boredom (boredom > 0.9), when no trigger the journey fires raises
+        // boredom above its starting value of at most 0.1; and very negative
+        // valence (< -0.85), when valence is an average of the emotions'
+        // valences and the most negative of those is -0.8.
         // Apply emotional abandonment modifier to patience threshold
         const emotionalModifier = calculateAbandonmentModifier(emotional);
         const adjustedPatienceThreshold = thresholds.patienceMin * emotionalModifier;
-        if (state.patienceRemaining < adjustedPatienceThreshold && emotionalModifier > 1.3) {
+        if (state.patienceRemaining < adjustedPatienceThreshold && emotionalModifier > param("journey.emotionalAbandon.modifier")) {
             return {
                 reason: "emotional",
                 message: "I don't have the energy for this anymore.",
@@ -2495,27 +2468,119 @@ function ordinalSuffix(n) {
         default: return "th";
     }
 }
-async function executeAction(browser, action, fittsParams, gazeMouseLag, humanInput, inputTraits) {
+/**
+ * The listed clickable a text names. Prefer (1) an exact match, then (2)
+ * starts-with, then (3) includes, each scored less its distance from the
+ * viewport's middle (journey.clickMatch.*); none unless the best score is
+ * positive, so a match further away than its own score is never chosen.
+ */
+function matchClickable(elements, text, viewportHeight) {
+    const wanted = text.trim().toLowerCase();
+    const vc = viewportHeight / 2;
+    const candidates = elements.filter(e => e.text);
+    const score = (e) => {
+        const t = (e.text || "").toLowerCase().trim();
+        if (!t)
+            return -Infinity;
+        let base = 0;
+        if (t === wanted)
+            base = param("journey.clickMatch.exact");
+        else if (t.startsWith(wanted) || wanted.startsWith(t))
+            base = param("journey.clickMatch.prefix");
+        else if (t.includes(wanted) || wanted.includes(t))
+            base = param("journey.clickMatch.contains");
+        else
+            return -Infinity;
+        const ey = (e.y ?? 0) + (e.height ?? 0) / 2;
+        const dist = Math.abs(ey - vc);
+        return base - dist;
+    };
+    let best;
+    let bestScore = -Infinity;
+    for (const e of candidates) {
+        const s = score(e);
+        if (s > bestScore) {
+            bestScore = s;
+            best = e;
+        }
+    }
+    return best && bestScore > 0 ? best : undefined;
+}
+/**
+ * The Fitts geometry of a listed element, as Stage B measures pointing: the
+ * distance from the centre of the screen it is seen on (the pointer's assumed
+ * start) to the element's centre, and the smaller of its width and height.
+ * The box is in viewport coordinates, taken with the page scrolled to
+ * `scrollY`. An element whose centre is on the current screen is seen there;
+ * one above or below is seen once scrolled to, on the screen-sized band of
+ * the page that holds its centre (Stage B's full-page tiling). Undefined when
+ * the element has no usable box.
+ */
+function boxGeometry(el, viewport, scrollY) {
+    if (!el || typeof el.x !== "number" || typeof el.y !== "number" || typeof el.width !== "number" || typeof el.height !== "number")
+        return undefined;
+    if (!(viewport.width > 0 && viewport.height > 0 && el.width >= 0 && el.height >= 0 && Number.isFinite(scrollY)))
+        return undefined;
+    const centreY = el.y + el.height / 2;
+    const onScreen = centreY >= 0 && centreY <= viewport.height;
+    const box = { x: el.x, y: el.y + scrollY, width: el.width, height: el.height };
+    return {
+        distance: distanceToScreenCentre(box, { viewportWidth: viewport.width, viewportHeight: viewport.height, scrollY }, onScreen ? "viewport" : "full_page"),
+        width: smallerOfWidth(box.width, box.height),
+    };
+}
+/**
+ * The Fitts geometry of the element a click, hover or hover-click names: by
+ * index (#N), by selector, or by text (matchClickable). Undefined for an
+ * action that moves no pointer, or one whose element is not listed; executeAction
+ * then charges the registered fallback move (journey.fitts.unlocated*).
+ */
+function pointingGeometry(action, elements, viewport, scrollY) {
+    const [type, ...args] = action.split(":");
+    if (!["click", "hover", "hoverclick"].includes(type))
+        return undefined;
+    const name = type === "hoverclick" ? (args[0] ?? "") : args.join(":");
+    const index = /^#(\d+)$/.exec(name);
+    const el = index
+        ? elements[parseInt(index[1], 10)]
+        : elements.find(e => e.selector === name) ?? matchClickable(elements, name, viewport.height);
+    return boxGeometry(el, viewport, scrollY);
+}
+/**
+ * The wait before a mouse action reaches its target: Fitts' law (v9.9.0,
+ * Stage B's law) on the target's measured geometry, or the registered
+ * fallback move for one the journey has not found, plus the gaze-to-mouse
+ * lag. Returns the time, and sleeps it unless humanClick will drive the
+ * pointer (`pacedByHumanClick`).
+ */
+async function pointingWait(fittsParams, gazeMouseLag, pacedByHumanClick, pointing) {
+    const distance = pointing ? pointing.distance : param("journey.fitts.unlocatedDistancePx");
+    const width = pointing ? pointing.width : param("journey.fitts.unlocatedTargetWidthPx");
+    let movementTimeMs = calculateFittsMovementTime(distance, width, fittsParams);
+    // Add gaze-to-mouse lag (v10.1.0) - WebGazer.js research
+    // Eye movements precede mouse movements by 200-500ms
+    if (gazeMouseLag) {
+        movementTimeMs += gazeMouseLag;
+    }
+    // With human input on, the coordinate click hands the pointer to
+    // humanClick, whose move and pre-click dwell replace this wait, so the two
+    // don't compound (which would make live mode slower than non-live). A
+    // hover, hover-click or click by name goes through Playwright, which has no
+    // human pacing, so it waits this time with human input on or off.
+    if (!pacedByHumanClick) {
+        await sleep(movementTimeMs);
+    }
+    return movementTimeMs;
+}
+async function executeAction(browser, action, fittsParams, gazeMouseLag, humanInput, inputTraits, pointing, pointingPaid = false) {
     const [type, ...args] = action.split(":");
-    // Apply Fitts' Law timing for mouse actions (v9.9.0)
+    // Mouse actions wait their pointing time (pointingWait), unless the caller
+    // already paid it: the retry by name after a coordinate click throws.
+    // Playwright drives the pointer here, never humanClick, so the wait is
+    // slept with human input on too.
     let movementTimeMs = 0;
-    if (["click", "hover", "hoverclick"].includes(type) && fittsParams) {
-        // Estimate target size and distance
-        // Average button width ~80px, average screen movement distance ~300px
-        const estimatedDistance = 300;
-        const estimatedTargetWidth = 80;
-        movementTimeMs = calculateFittsMovementTime(estimatedDistance, estimatedTargetWidth, fittsParams);
-        // Add gaze-to-mouse lag (v10.1.0) - WebGazer.js research
-        // Eye movements precede mouse movements by 200-500ms
-        if (gazeMouseLag) {
-            movementTimeMs += gazeMouseLag;
-        }
-        // When humanInput is enabled, humanClick provides its own hover-and-dwell
-        // pacing — skip the pre-action sleep here so they don't compound (which
-        // would make live mode slower than non-live, defeating the purpose).
-        if (!humanInput) {
-            await sleep(movementTimeMs);
-        }
+    if (["click", "hover", "hoverclick"].includes(type) && fittsParams && !pointingPaid) {
+        movementTimeMs = await pointingWait(fittsParams, gazeMouseLag, false, pointing);
     }
     switch (type) {
         case "click": {
@@ -2527,8 +2592,8 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
             try {
                 const escapedSel = selector.replace(/"/g, '\\"');
                 const link = page.locator(`a:has-text("${escapedSel}")`).first();
-                if (await link.isVisible({ timeout: 1500 }).catch(() => false)) {
-                    await link.click({ timeout: 3000 });
+                if (await link.isVisible({ timeout: param("journey.action.linkVisibleMs") }).catch(() => false)) {
+                    await link.click({ timeout: param("journey.action.clickTimeoutMs") });
                     clicked = true;
                 }
             }
@@ -2537,8 +2602,8 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
                 try {
                     const escapedSel = selector.replace(/"/g, '\\"');
                     const btn = page.locator(`button:has-text("${escapedSel}"), [role="button"]:has-text("${escapedSel}")`).first();
-                    if (await btn.isVisible({ timeout: 1000 }).catch(() => false)) {
-                        await btn.click({ timeout: 3000 });
+                    if (await btn.isVisible({ timeout: param("journey.action.buttonVisibleMs") }).catch(() => false)) {
+                        await btn.click({ timeout: param("journey.action.clickTimeoutMs") });
                         clicked = true;
                     }
                 }
@@ -2550,7 +2615,7 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
                     return { success: false, movementTimeMs };
             }
             try {
-                await page.waitForTimeout(1000);
+                await page.waitForTimeout(param("journey.action.clickSettleMs"));
             }
             catch { }
             let urlAfter = page.url();
@@ -2561,12 +2626,12 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
                     const escapedSel = selector.replace(/"/g, '\\"');
                     const href = await page.locator(`a:has-text("${escapedSel}")`).first().getAttribute('href').catch(() => null);
                     if (href && href.startsWith('http')) {
-                        await page.goto(href, { waitUntil: 'domcontentloaded', timeout: 10000 });
+                        await page.goto(href, { waitUntil: 'domcontentloaded', timeout: param("journey.action.gotoTimeoutMs") });
                         urlAfter = page.url();
                     }
                     else if (href && href.startsWith('/')) {
                         const base = new URL(urlBefore).origin;
-                        await page.goto(base + href, { waitUntil: 'domcontentloaded', timeout: 10000 });
+                        await page.goto(base + href, { waitUntil: 'domcontentloaded', timeout: param("journey.action.gotoTimeoutMs") });
                         urlAfter = page.url();
                     }
                 }
@@ -2601,8 +2666,8 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
                         const r = await browser.fill(selector, value);
                         return { success: r.success };
                     }
-                    await loc.scrollIntoViewIfNeeded({ timeout: 2000 }).catch(() => { });
-                    await loc.click({ timeout: 3000 });
+                    await loc.scrollIntoViewIfNeeded({ timeout: param("journey.action.focusScrollMs") }).catch(() => { });
+                    await loc.click({ timeout: param("journey.action.clickTimeoutMs") });
                     // Clear if there's existing content
                     await page.keyboard.press("Control+A").catch(() => { });
                     await page.keyboard.press("Delete").catch(() => { });
@@ -2620,7 +2685,7 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
             // Use age modifier as proxy for typing expertise (younger = faster)
             const expertise = fittsParams?.ageModifier
                 ? Math.max(0, 1 - (fittsParams.ageModifier - 1))
-                : 0.5;
+                : param("journey.typing.defaultExpertise");
             const typingTimeMs = calculateTypingTime(value, expertise, true);
             // Add realistic typing delay
             await sleep(typingTimeMs);
@@ -2639,10 +2704,11 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
             const page = await browser.getPage();
             try {
                 const beforeY = await page.evaluate(() => window.scrollY);
+                const step = param("journey.action.scrollPx");
                 if (humanInput && (direction === "down" || direction === "up")) {
                     // Human-realistic scroll: variable delta + occasional glance-back.
                     const { humanScroll } = await import("../visual/human-input.js");
-                    const baseDelta = direction === "down" ? 400 : -400;
+                    const baseDelta = direction === "down" ? step : -step;
                     await humanScroll(page, baseDelta, inputTraits);
                 }
                 else {
@@ -2654,20 +2720,20 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
                             await page.evaluate(() => window.scrollTo({ top: document.body.scrollHeight, behavior: "smooth" }));
                             break;
                         case "up":
-                            await page.evaluate(() => window.scrollBy({ top: -400, behavior: "smooth" }));
+                            await page.evaluate((d) => window.scrollBy({ top: -d, behavior: "smooth" }), step);
                             break;
                         case "down":
                         default:
-                            await page.evaluate(() => window.scrollBy({ top: 400, behavior: "smooth" }));
+                            await page.evaluate((d) => window.scrollBy({ top: d, behavior: "smooth" }), step);
                             break;
                     }
-                    await sleep(300);
+                    await sleep(param("journey.action.scrollSettleMs"));
                 }
                 // Report success only if the page actually moved. A no-op scroll
                 // (already at top/bottom, or scroll blocked) returns failure so the
                 // AI knows to try something else instead of looping scroll:up/down.
                 const afterY = await page.evaluate(() => window.scrollY);
-                const moved = Math.abs(afterY - beforeY) > 5;
+                const moved = Math.abs(afterY - beforeY) > param("journey.action.scrollMovedPx");
                 return { success: moved };
             }
             catch {
@@ -2678,8 +2744,8 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
             // Browser back button — most common recovery action
             const page = await browser.getPage();
             try {
-                await page.goBack({ waitUntil: "domcontentloaded", timeout: 10000 });
-                await sleep(500);
+                await page.goBack({ waitUntil: "domcontentloaded", timeout: param("journey.action.gotoTimeoutMs") });
+                await sleep(param("journey.action.backSettleMs"));
                 return { success: true, newUrl: page.url() };
             }
             catch {
@@ -2706,7 +2772,7 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
                     }
                     return false;
                 }, query);
-                await sleep(500);
+                await sleep(param("journey.action.findSettleMs"));
                 return { success: found };
             }
             catch {
@@ -2718,9 +2784,9 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
             const page = await browser.getPage();
             const count = parseInt(args[0] || "1", 10);
             try {
-                for (let i = 0; i < Math.min(count, 10); i++) {
+                for (let i = 0; i < Math.min(count, param("journey.action.maxTabs")); i++) {
                     await page.keyboard.press("Tab");
-                    await sleep(150);
+                    await sleep(param("journey.action.tabIntervalMs"));
                 }
                 return { success: true };
             }
@@ -2733,7 +2799,7 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
             const page = await browser.getPage();
             try {
                 await page.keyboard.press("Enter");
-                await sleep(800);
+                await sleep(param("journey.action.navigationWaitMs"));
                 const newUrl = page.url();
                 return { success: true, newUrl };
             }
@@ -2757,7 +2823,7 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
         case "dismiss": {
             // Dismiss overlay/popup/modal — close cookie banners, newsletter popups
             try {
-                await browser.dismissOverlay({ type: "auto", timeout: 3000 });
+                await browser.dismissOverlay({ type: "auto", timeout: param("journey.action.dismissTimeoutMs") });
                 return { success: true };
             }
             catch {
@@ -2770,7 +2836,7 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
             const page = await browser.getPage();
             try {
                 await page.click(`details:has(summary:has-text("${selector}")) summary, [role="tab"]:has-text("${selector}"), button:has-text("${selector}")`);
-                await sleep(400);
+                await sleep(param("journey.action.expandSettleMs"));
                 return { success: true };
             }
             catch {
@@ -2781,7 +2847,7 @@ async function executeAction(browser, action, fittsParams, gazeMouseLag, humanIn
         }
         case "wait": {
             // Wait for page to load / content to appear
-            await sleep(parseInt(args[0] || "1000", 10));
+            await sleep(args[0] ? parseInt(args[0], 10) : param("journey.action.waitDefaultMs"));
             return { success: true };
         }
         default: