npm - forge-openclaw-plugin - Versions diffs - 0.2.94 → 0.2.97 - Mend

forge-openclaw-plugin 0.2.94 → 0.2.97

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/assets/{board-D1HbyD4u.js → board-Ju0h0SeG.js} +1 -1
package/dist/assets/index-Cn5Wpwau.css +1 -0
package/dist/assets/{index-DWZd3qT-.js → index-CwvGs8n4.js} +55 -55
package/dist/assets/{motion-D2OqILg_.js → motion-DRPJkN3a.js} +1 -1
package/dist/assets/{table-YWWjPjC_.js → table-DewbFlTh.js} +1 -1
package/dist/assets/{ui-DikPZj8S.js → ui-C2IvSrAz.js} +1 -1
package/dist/assets/{vendor-BS9OPVNh.js → vendor-DL2K5ayT.js} +230 -225
package/dist/index.html +7 -7
package/dist/openclaw/tools.js +1 -1
package/dist/server/server/src/app.js +23 -5
package/dist/server/server/src/health.js +463 -24
package/dist/server/server/src/openapi.js +13 -0
package/dist/server/server/src/web.js +6 -0
package/dist/server/src/components/ui/info-tooltip.js +7 -3
package/openclaw.plugin.json +1 -1
package/package.json +1 -1
package/skills/forge-openclaw/SKILL.md +5 -4
package/skills/forge-openclaw/entity_conversation_playbooks.md +41 -4
package/dist/assets/index-PA_Ih223.css +0 -1

package/dist/index.html CHANGED Viewed

@@ -13,14 +13,14 @@
     />
     <link rel="icon" type="image/png" href="/forge/assets/favicon-BCHm9dUV.ico" />
     <link rel="alternate icon" href="/forge/assets/favicon-BCHm9dUV.ico" />
-    <script type="module" crossorigin src="/forge/assets/index-DWZd3qT-.js"></script>
-    <link rel="modulepreload" crossorigin href="/forge/assets/vendor-BS9OPVNh.js">
-    <link rel="modulepreload" crossorigin href="/forge/assets/board-D1HbyD4u.js">
-    <link rel="modulepreload" crossorigin href="/forge/assets/ui-DikPZj8S.js">
-    <link rel="modulepreload" crossorigin href="/forge/assets/motion-D2OqILg_.js">
-    <link rel="modulepreload" crossorigin href="/forge/assets/table-YWWjPjC_.js">
+    <script type="module" crossorigin src="/forge/assets/index-CwvGs8n4.js"></script>
+    <link rel="modulepreload" crossorigin href="/forge/assets/vendor-DL2K5ayT.js">
+    <link rel="modulepreload" crossorigin href="/forge/assets/board-Ju0h0SeG.js">
+    <link rel="modulepreload" crossorigin href="/forge/assets/ui-C2IvSrAz.js">
+    <link rel="modulepreload" crossorigin href="/forge/assets/motion-DRPJkN3a.js">
+    <link rel="modulepreload" crossorigin href="/forge/assets/table-DewbFlTh.js">
     <link rel="stylesheet" crossorigin href="/forge/assets/vendor-B-Lq_OG3.css">
-    <link rel="stylesheet" crossorigin href="/forge/assets/index-PA_Ih223.css">
+    <link rel="stylesheet" crossorigin href="/forge/assets/index-Cn5Wpwau.css">
   </head>
   <body class="bg-canvas text-ink antialiased">
     <div id="root"></div>

package/dist/openclaw/tools.js CHANGED Viewed

@@ -755,7 +755,7 @@ export function registerForgePluginTools(api, config) {
     registerReadTool(api, config, {
         name: "forge_get_training_load_overview",
         label: "Forge Training Load Overview",
-        description: "Read the cardiovascular training-load surface with acute/chronic load, HR zone distribution, weekly intensity targets, and data-quality flags.",
+        description: "Read the cardiovascular training-load surface with acute/chronic load, HR zone-time buckets, smart training modes, weekly targets, next-workout guidance, and data-quality flags.",
         parameters: scopedReadSchema,
         path: (params) => withUserIds("/api/v1/health/training-load", params.userIds)
     });

package/dist/server/server/src/app.js CHANGED Viewed

@@ -2247,7 +2247,7 @@ function buildPreferredMutationPath(entityType) {
         case "sports_overview":
             return "Read-only surface. Use batch CRUD for workout_session records or the review enrichment route for reflective notes.";
         case "training_load":
-            return "Read-only surface. Use it for cardiovascular load, HR zones, acute/chronic stress, VO2max context, and target analysis; use batch CRUD for underlying workout_session records.";
+            return "Read-only surface. Use it for cardiovascular load, HR zones, zone-time buckets, smart training modes, acute/chronic stress, VO2max context, next-workout guidance, and target analysis; use batch CRUD for underlying workout_session records.";
         default:
             return "Read-only surface.";
     }
@@ -3044,14 +3044,14 @@ const AGENT_ONBOARDING_ENTITY_CATALOG = [
     }),
     enrichOnboardingEntityGuide({
         entityType: "training_load",
-        purpose: "The read-model cardiovascular training-load workspace for acute/chronic load, HR zone distribution, intensity targets, and VO2max context.",
+        purpose: "The read-model cardiovascular training-load workspace for acute/chronic load, HR zone distribution, zone-time buckets, smart training modes, next-workout guidance, intensity targets, and VO2max context.",
         minimumCreateFields: [],
         relationshipRules: [
             "Use this surface for review and interpretation.",
             "Create, update, delete, or search the underlying workout_session records through batch CRUD by default."
         ],
         searchHints: [
-            "Read this surface before advising on high-intensity balance, recovery load, or cardiovascular training targets."
+            "Read this surface before advising on high-intensity balance, recovery load, Zone 2/base work, 4x4 suitability, next-workout guidance, or cardiovascular training targets."
         ],
         fieldGuide: []
     })
@@ -3071,6 +3071,7 @@ const AGENT_ONBOARDING_CONVERSATION_RULES = [
     "Do not over-therapize logistical entities. For tasks, calendar events, work blocks, timeboxes, and task runs, one brief confirming sentence plus one question is usually enough.",
     "After each substantive answer, briefly say what is becoming clearer and ask only for the next thing that still changes the record shape or usefulness.",
     "For strategic, reflective, or emotionally meaningful non-Psyche records, ask what feels important to keep true before you ask for labels, dates, or taxonomy.",
+    "For reflection-sensitive non-Psyche records such as questionnaire_instrument, questionnaire_run, self_observation, reflective note, wiki_page, sleep_session, workout_session, preference_judgment, and preference_signal, first ask what the reflection should help the user understand, decide, notice, remember, or change later; then keep the API posture exact: batch CRUD for normal stored records, questionnaire run actions for answer lifecycle, self-observation calendar reads plus observed-note writes, and wiki routes for wiki pages.",
     "For reusable records such as tags, event types, emotion definitions, preference contexts, or questionnaires, ask what distinction or decision the record should help with before you ask for wording.",
     "When useful, help the user name, define, and connect the record in that order: offer a working label, clarify what belongs inside it, then ask about links only after the record itself feels steady.",
     "When the meaning is clearer than the wording, offer a tentative title or formulation yourself and invite correction instead of forcing the user to wordsmith alone.",
@@ -4261,14 +4262,14 @@ const AGENT_ONBOARDING_TOOL_INPUT_CATALOG = [
     },
     {
         toolName: "forge_get_training_load_overview",
-        summary: "Read the cardiovascular training-load surface with acute/chronic load, HR zone distribution, weekly intensity targets, and data-quality flags.",
+        summary: "Read the cardiovascular training-load surface with acute/chronic load, HR zone distribution, zone-time buckets, smart training modes, weekly targets, next-workout guidance, and data-quality flags.",
         whenToUse: "Use when the operator wants to analyze training stress, zone balance, VO2max context, combat-sport load, or what to optimize next.",
         inputShape: "{ userIds?: string[] }",
         requiredFields: [],
         notes: [
             "The API path is /api/v1/health/training-load and the UI route is /training-load.",
             "This is a read-model-only surface. Workout records remain ordinary workout_session entities for batch CRUD.",
-            "Forge uses HRR zone analytics and TRIMP-like internal load from stored workout evidence."
+            "Forge uses HRR zone analytics, TRIMP-like internal load, per-bucket load rate, personal-baseline comparisons, and deterministic training-intelligence modes from stored workout evidence."
         ],
         example: '{"userIds":["user_operator"]}'
     },
@@ -6262,6 +6263,23 @@ function compactTrainingLoad(trainingLoad) {
         summary: trainingLoad.summary,
         intensityDistribution: trainingLoad.recentIntensityDistribution,
         weeklyLoad: trainingLoad.weeklyLoad.slice(-8),
+        latestZoneTime: trainingLoad.zoneTimeSeries.weekly.at(-1) ??
+            trainingLoad.zoneTimeSeries.daily.at(-1) ??
+            null,
+        trainingIntelligence: {
+            defaultMode: trainingLoad.trainingIntelligence.defaultMode,
+            modes: trainingLoad.trainingIntelligence.modes.map((mode) => ({
+                key: mode.key,
+                label: mode.label,
+                score: mode.score,
+                status: mode.status,
+                confidence: mode.confidence,
+                summary: mode.summary,
+                loadBalance: mode.loadBalance,
+                nextWorkout: mode.nextWorkout,
+                nextWeekTargets: mode.nextWeekTargets
+            }))
+        },
         topActivities: trainingLoad.activityBreakdown.slice(0, 6),
         targetModel: trainingLoad.targetModel,
         detailRoute: "/api/v1/health/training-load"

package/dist/server/server/src/health.js CHANGED Viewed

@@ -2750,20 +2750,34 @@ function nestedRecord(value) {
         ? value
         : {};
 }
+const CURRENT_WORKOUT_RAW_EVIDENCE_VERSION = "healthkit-workout-raw-bulk-v4";
 function expectedWorkoutEvidenceCounts(derived) {
     const syncCursor = nestedRecord(derived.syncCursor);
     const captureQuality = nestedRecord(derived.captureQuality);
+    const captureQualityFlags = Array.isArray(captureQuality.flags)
+        ? captureQuality.flags.filter((flag) => typeof flag === "string")
+        : [];
+    const summaryOnlyExport = captureQuality.status === "summary_exported" ||
+        captureQualityFlags.includes("server_side_evidence_derivation");
     const syncTimeSeriesCount = finiteNumberFromUnknown(syncCursor.timeSeriesSampleCount);
-    const captureHeartRateCount = finiteNumberFromUnknown(captureQuality.heartRateSamples);
+    const captureHeartRateCount = summaryOnlyExport
+        ? null
+        : finiteNumberFromUnknown(captureQuality.heartRateSamples);
     const syncRoutePointCount = finiteNumberFromUnknown(syncCursor.routePointCount);
-    const captureRoutePointCount = finiteNumberFromUnknown(captureQuality.routePoints);
+    const captureRoutePointCount = summaryOnlyExport
+        ? null
+        : finiteNumberFromUnknown(captureQuality.routePoints);
     const expectedTimeSeriesSamples = Math.max(0, Math.ceil(Math.max(syncTimeSeriesCount ?? 0, captureHeartRateCount ?? 0)));
     const expectedHeartRateSamples = Math.max(0, Math.ceil(captureHeartRateCount ?? 0));
     const expectedRoutePoints = Math.max(0, Math.ceil(Math.max(syncRoutePointCount ?? 0, captureRoutePointCount ?? 0)));
+    const rawEvidenceVersion = typeof syncCursor.rawEvidenceVersion === "string"
+        ? syncCursor.rawEvidenceVersion
+        : "";
     return {
         expectedTimeSeriesSamples,
         expectedHeartRateSamples,
         expectedRoutePoints,
+        hasCurrentRawEvidenceVersion: rawEvidenceVersion === CURRENT_WORKOUT_RAW_EVIDENCE_VERSION,
         hasEvidenceMetadata: syncTimeSeriesCount !== null ||
             captureHeartRateCount !== null ||
             syncRoutePointCount !== null ||
@@ -2816,7 +2830,8 @@ function mobileHealthWorkoutImportState(userId) {
         const actualHeartRateCount = Math.max(0, row.heart_rate_count ?? 0);
         const actualRoutePointCount = Math.max(0, row.route_point_count ?? 0);
         const evidenceComplete = evidenceCounts.hasEvidenceMetadata
-            ? actualTimeSeriesCount >= evidenceCounts.expectedTimeSeriesSamples &&
+            ? evidenceCounts.hasCurrentRawEvidenceVersion &&
+                actualTimeSeriesCount >= evidenceCounts.expectedTimeSeriesSamples &&
                 actualHeartRateCount >= evidenceCounts.expectedHeartRateSamples &&
                 actualRoutePointCount >= evidenceCounts.expectedRoutePoints
             : false;
@@ -4108,6 +4123,176 @@ function zoneSeconds(session, keys) {
         .filter((zone) => keys.includes(zone.key))
         .reduce((sum, zone) => sum + zone.seconds, 0);
 }
+const TRAINING_DOMAIN_KEYS = ["low", "moderate", "high"];
+function clampNumber(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function createZoneRecord() {
+    return Object.fromEntries(WORKOUT_ZONE_ORDER.map((key) => [key, 0]));
+}
+function createDomainRecord() {
+    return { low: 0, moderate: 0, high: 0 };
+}
+function addSessionZones(target, session) {
+    const zones = session.analytics
+        ?.zoneDurations ?? [];
+    for (const zone of zones) {
+        if (WORKOUT_ZONE_ORDER.includes(zone.key)) {
+            target[zone.key] += zone.seconds;
+        }
+    }
+}
+function zoneRecordTotal(record) {
+    return WORKOUT_ZONE_ORDER.reduce((sum, key) => sum + record[key], 0);
+}
+function domainSecondsFromZones(zones) {
+    return {
+        low: zones.below_z1 + zones.zone_1,
+        moderate: zones.zone_2 + zones.zone_3,
+        high: zones.zone_4 + zones.zone_5
+    };
+}
+function percentageRecord(record, total) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [
+        key,
+        total > 0 ? round(value / total, 4) : 0
+    ]));
+}
+function minuteRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, round(value / 60, 1)]));
+}
+function bucketConfidence(input) {
+    if (input.sessionCount <= 0 || input.heartRateSampleCount <= 0) {
+        return "unavailable";
+    }
+    if (input.averageHrCoverage >= 0.8 &&
+        input.heartRateSampleCount >= input.sessionCount * 100) {
+        return "high";
+    }
+    if (input.averageHrCoverage >= 0.45) {
+        return "medium";
+    }
+    return "low";
+}
+function monthKey(value) {
+    return value.slice(0, 7);
+}
+function monthEndDateKey(key) {
+    const [year, month] = key.split("-").map((part) => Number(part));
+    return dateKeyFromDate(new Date(Date.UTC(year, month, 0)));
+}
+function bucketDates(interval, session) {
+    if (interval === "daily") {
+        const key = dayKey(session.startedAt);
+        return { bucketKey: key, startDate: key, endDate: key };
+    }
+    if (interval === "weekly") {
+        const weekKey = isoWeekKey(session.startedAt);
+        const date = new Date(session.startedAt);
+        const day = date.getUTCDay() || 7;
+        const start = addDays(date, 1 - day);
+        const end = addDays(start, 6);
+        return {
+            bucketKey: weekKey,
+            startDate: dateKeyFromDate(start),
+            endDate: dateKeyFromDate(end)
+        };
+    }
+    const key = monthKey(session.startedAt);
+    return {
+        bucketKey: key,
+        startDate: `${key}-01`,
+        endDate: monthEndDateKey(key)
+    };
+}
+function buildZoneTimeBuckets(sessions, interval, limit) {
+    const buckets = new Map();
+    for (const session of sessions) {
+        const dates = bucketDates(interval, session);
+        const current = buckets.get(dates.bucketKey) ?? {
+            ...dates,
+            sessionCount: 0,
+            durationSeconds: 0,
+            trainingLoad: 0,
+            zoneSeconds: createZoneRecord(),
+            dayHighSeconds: new Map(),
+            heartRateCoverageValues: [],
+            heartRateSampleCount: 0
+        };
+        current.sessionCount += 1;
+        current.durationSeconds += session.durationSeconds;
+        current.trainingLoad += workoutLoad(session);
+        addSessionZones(current.zoneSeconds, session);
+        const sessionDayKey = dayKey(session.startedAt);
+        current.dayHighSeconds.set(sessionDayKey, (current.dayHighSeconds.get(sessionDayKey) ?? 0) +
+            zoneSeconds(session, ["zone_4", "zone_5"]));
+        current.heartRateCoverageValues.push(workoutHrCoverage(session));
+        current.heartRateSampleCount += workoutHrSampleCount(session);
+        buckets.set(dates.bucketKey, current);
+    }
+    const rows = [...buckets.values()]
+        .sort((left, right) => left.bucketKey.localeCompare(right.bucketKey))
+        .slice(-limit)
+        .map((bucket) => {
+        const hrCoveredSeconds = zoneRecordTotal(bucket.zoneSeconds);
+        const domains = domainSecondsFromZones(bucket.zoneSeconds);
+        const durationMinutes = bucket.durationSeconds / 60;
+        const loadPerMinute = durationMinutes > 0 ? round(bucket.trainingLoad / durationMinutes, 2) : 0;
+        const loadPerHour = bucket.durationSeconds > 0
+            ? round(bucket.trainingLoad / (bucket.durationSeconds / 3600), 1)
+            : 0;
+        const averageHrCoverage = round(average(bucket.heartRateCoverageValues), 3);
+        return {
+            bucketKey: bucket.bucketKey,
+            startDate: bucket.startDate,
+            endDate: bucket.endDate,
+            sessionCount: bucket.sessionCount,
+            durationSeconds: Math.round(bucket.durationSeconds),
+            durationMinutes: round(bucket.durationSeconds / 60, 1),
+            hrCoveredSeconds: Math.round(hrCoveredSeconds),
+            trainingLoad: round(bucket.trainingLoad, 1),
+            loadPerHour,
+            loadPerMinute,
+            baselineLoadRatio: null,
+            baselineIntensityRatio: null,
+            zoneSeconds: Object.fromEntries(WORKOUT_ZONE_ORDER.map((key) => [key, Math.round(bucket.zoneSeconds[key])])),
+            zoneMinutes: minuteRecord(bucket.zoneSeconds),
+            zonePercentages: percentageRecord(bucket.zoneSeconds, hrCoveredSeconds),
+            domainSeconds: Object.fromEntries(TRAINING_DOMAIN_KEYS.map((key) => [key, Math.round(domains[key])])),
+            domainMinutes: minuteRecord(domains),
+            domainPercentages: percentageRecord(domains, hrCoveredSeconds),
+            hardDayCount: [...bucket.dayHighSeconds.values()].filter((seconds) => seconds >= 10 * 60).length,
+            averageHrCoverage,
+            heartRateSampleCount: bucket.heartRateSampleCount,
+            confidence: bucketConfidence({
+                sessionCount: bucket.sessionCount,
+                averageHrCoverage,
+                heartRateSampleCount: bucket.heartRateSampleCount
+            })
+        };
+    });
+    return rows.map((row, index) => {
+        const baselineWindow = interval === "daily"
+            ? rows.slice(Math.max(0, index - 28), index)
+            : interval === "weekly"
+                ? rows.slice(Math.max(0, index - 4), index)
+                : rows.slice(Math.max(0, index - 3), index);
+        const baselineLoad = average(baselineWindow.map((bucket) => bucket.trainingLoad).filter((value) => value > 0));
+        const baselineIntensity = average(baselineWindow.map((bucket) => bucket.loadPerMinute).filter((value) => value > 0));
+        return {
+            ...row,
+            baselineLoadRatio: baselineLoad > 0 ? round(row.trainingLoad / baselineLoad, 2) : null,
+            baselineIntensityRatio: baselineIntensity > 0 ? round(row.loadPerMinute / baselineIntensity, 2) : null
+        };
+    });
+}
+function buildZoneTimeSeries(sessions) {
+    return {
+        daily: buildZoneTimeBuckets(sessions, "daily", 90),
+        weekly: buildZoneTimeBuckets(sessions, "weekly", 26),
+        monthly: buildZoneTimeBuckets(sessions, "monthly", 12)
+    };
+}
 function workoutLoad(session) {
     return (session.analytics?.load
         ?.trimp ?? 0);
@@ -4186,6 +4371,251 @@ function summarizeIntensityDistribution(sessions) {
 function latestVitalValue(vitalsTrend, key) {
     return [...vitalsTrend].reverse().find((entry) => entry[key] != null)?.[key] ?? null;
 }
+const MODE_DOMAIN_TARGETS = {
+    combat_readiness: {
+        label: "Combat readiness",
+        statusLabel: "fight-ready balance",
+        low: [0.62, 0.78],
+        moderate: [0.1, 0.22],
+        high: [0.06, 0.16],
+        maxHardSessions: 2
+    },
+    aerobic_base: {
+        label: "Aerobic base",
+        statusLabel: "base-building balance",
+        low: [0.72, 0.9],
+        moderate: [0.05, 0.18],
+        high: [0.02, 0.1],
+        maxHardSessions: 1
+    },
+    endurance_pro: {
+        label: "Endurance pro",
+        statusLabel: "pyramidal/polarized balance",
+        low: [0.7, 0.88],
+        moderate: [0.04, 0.2],
+        high: [0.06, 0.18],
+        maxHardSessions: 2
+    }
+};
+function targetMidpoint(range) {
+    return (range[0] + range[1]) / 2;
+}
+function rangeScore(value, range) {
+    if (value >= range[0] && value <= range[1]) {
+        return 100;
+    }
+    const distance = value < range[0] ? range[0] - value : value - range[1];
+    return clampNumber(100 - distance * 350, 0, 100);
+}
+function loadBalanceStatus(summary) {
+    if (summary.readiness === "overload_watch" ||
+        (summary.acuteChronicRatio ?? 0) > 1.35 ||
+        (summary.strain7d ?? 0) > 450) {
+        return "recover";
+    }
+    if ((summary.acuteChronicRatio ?? 1) < 0.8) {
+        return "build";
+    }
+    if (summary.highIntensityMinutes7d >= 45) {
+        return "maintain";
+    }
+    return "sharpen";
+}
+function scoreStatus(score, balance) {
+    if (balance === "recover") {
+        return "recovery_priority";
+    }
+    if (score >= 82) {
+        return "on_target";
+    }
+    if (score >= 65) {
+        return "watch";
+    }
+    return "needs_adjustment";
+}
+function scoreConfidence(summary, latestBucket) {
+    const coverage = latestBucket?.averageHrCoverage ?? summary.averageHeartRateCoverage;
+    if (coverage >= 0.85 && (latestBucket?.heartRateSampleCount ?? 0) >= 300) {
+        return "high";
+    }
+    if (coverage >= 0.5) {
+        return "medium";
+    }
+    if (coverage > 0) {
+        return "low";
+    }
+    return "unavailable";
+}
+function targetMinutes(totalMinutes, range) {
+    return [Math.round(totalMinutes * range[0]), Math.round(totalMinutes * range[1])];
+}
+function buildZoneMinuteTargets(totalMinutes, target) {
+    const low = totalMinutes * targetMidpoint(target.low);
+    const moderate = totalMinutes * targetMidpoint(target.moderate);
+    const high = totalMinutes * targetMidpoint(target.high);
+    return {
+        below_z1: Math.round(low * 0.35),
+        zone_1: Math.round(low * 0.65),
+        zone_2: Math.round(moderate * 0.65),
+        zone_3: Math.round(moderate * 0.35),
+        zone_4: Math.round(high * 0.75),
+        zone_5: Math.round(high * 0.25)
+    };
+}
+function buildTrainingIntelligence(input) {
+    const latestWeek = input.zoneTimeSeries.weekly.at(-1);
+    const priorWeeks = input.zoneTimeSeries.weekly.slice(-5, -1);
+    const baselineMinutes = average(priorWeeks.map((week) => week.durationMinutes).filter((value) => value > 0)) ||
+        latestWeek?.durationMinutes ||
+        180;
+    const balance = loadBalanceStatus(input.summary);
+    const lowPct = input.recentIntensityDistribution.find((entry) => entry.key === "low")
+        ?.percentage ?? 0;
+    const moderatePct = input.recentIntensityDistribution.find((entry) => entry.key === "moderate")
+        ?.percentage ?? 0;
+    const highPct = input.recentIntensityDistribution.find((entry) => entry.key === "high")
+        ?.percentage ?? 0;
+    const currentLoadRatio = input.summary.acuteChronicRatio ?? 1;
+    const loadBalance = {
+        status: balance,
+        acuteLoad7d: input.summary.acuteLoad7d,
+        chronicWeeklyLoad28d: input.summary.chronicWeeklyLoad28d,
+        acuteChronicRatio: input.summary.acuteChronicRatio,
+        monotony7d: input.summary.monotony7d,
+        strain7d: input.summary.strain7d,
+        latestWeekLoad: latestWeek?.trainingLoad ?? 0,
+        latestWeekLoadPerMinute: latestWeek?.loadPerMinute ?? 0,
+        latestWeekBaselineLoadRatio: latestWeek?.baselineLoadRatio ?? null,
+        latestWeekBaselineIntensityRatio: latestWeek?.baselineIntensityRatio ?? null
+    };
+    return {
+        defaultMode: "combat_readiness",
+        modes: Object.keys(MODE_DOMAIN_TARGETS).map((mode) => {
+            const target = MODE_DOMAIN_TARGETS[mode];
+            const lowScore = rangeScore(lowPct, target.low);
+            const moderateScore = rangeScore(moderatePct, target.moderate);
+            const highScore = rangeScore(highPct, target.high);
+            const loadScore = balance === "recover"
+                ? 45
+                : clampNumber(100 - Math.abs(currentLoadRatio - 1) * 90, 0, 100);
+            const hardDayScore = clampNumber(100 - Math.max(0, input.summary.hardDayCount7d - target.maxHardSessions) * 28, 0, 100);
+            const qualityScore = clampNumber(input.summary.averageHeartRateCoverage * 100, 0, 100);
+            const score = Math.round(lowScore * 0.22 +
+                moderateScore * 0.14 +
+                highScore * 0.2 +
+                loadScore * 0.24 +
+                hardDayScore * 0.12 +
+                qualityScore * 0.08);
+            const nextWeekScale = balance === "recover" ? 0.75 : balance === "build" ? 1.12 : 1;
+            const nextWeekMinutes = Math.round(baselineMinutes * nextWeekScale);
+            const shouldAllowFourByFour = balance !== "recover" &&
+                highPct <= target.high[1] &&
+                input.summary.hardDayCount7d < target.maxHardSessions &&
+                scoreConfidence(input.summary, latestWeek) !== "low" &&
+                scoreConfidence(input.summary, latestWeek) !== "unavailable";
+            const drivers = [
+                lowPct >= target.low[0]
+                    ? `Low/base work is ${Math.round(lowPct * 100)}% of recent HR-zone time.`
+                    : null,
+                highPct <= target.high[1]
+                    ? `High-domain exposure is controlled at ${Math.round(highPct * 100)}%.`
+                    : null,
+                currentLoadRatio >= 0.8 && currentLoadRatio <= 1.25
+                    ? `Acute load is close to chronic base at ${round(currentLoadRatio, 2)}x.`
+                    : null,
+                latestWeek?.baselineLoadRatio != null
+                    ? `Latest week is ${latestWeek.baselineLoadRatio}x your recent weekly load baseline.`
+                    : null
+            ].filter((entry) => Boolean(entry));
+            const limitingFactors = [
+                lowPct < target.low[0]
+                    ? `Low/base work is below the ${Math.round(target.low[0] * 100)}-${Math.round(target.low[1] * 100)}% target band.`
+                    : null,
+                highPct > target.high[1]
+                    ? `High-domain work is above the ${Math.round(target.high[1] * 100)}% ceiling for this mode.`
+                    : null,
+                balance === "recover"
+                    ? "Recent load balance points to recovery before another hard stimulus."
+                    : null,
+                input.summary.hardDayCount7d > target.maxHardSessions
+                    ? `${input.summary.hardDayCount7d} hard days in 7 days exceeds this mode's target.`
+                    : null,
+                input.summary.averageHeartRateCoverage < 0.5
+                    ? "Heart-rate evidence is thin, so zone decisions need caution."
+                    : null
+            ].filter((entry) => Boolean(entry));
+            return {
+                key: mode,
+                label: target.label,
+                score,
+                status: scoreStatus(score, balance),
+                confidence: scoreConfidence(input.summary, latestWeek),
+                summary: balance === "recover"
+                    ? `${target.label}: recover first, then rebuild the next hard stimulus.`
+                    : `${target.label}: ${target.statusLabel} is ${score >= 75 ? "mostly aligned" : "not yet aligned"}.`,
+                drivers,
+                limitingFactors,
+                loadBalance,
+                nextWeekTargets: {
+                    totalMinutesRange: balance === "recover"
+                        ? targetMinutes(baselineMinutes, [0.65, 0.85])
+                        : targetMinutes(nextWeekMinutes, [0.95, 1.08]),
+                    zoneMinuteTargets: buildZoneMinuteTargets(nextWeekMinutes, target),
+                    domainMinuteTargets: {
+                        low: targetMinutes(nextWeekMinutes, target.low),
+                        moderate: targetMinutes(nextWeekMinutes, target.moderate),
+                        high: targetMinutes(nextWeekMinutes, target.high)
+                    },
+                    maxHardSessions: balance === "recover" ? Math.max(0, target.maxHardSessions - 1) : target.maxHardSessions,
+                    minimumEasyMinutes: Math.round(nextWeekMinutes * target.low[0]),
+                    warning: balance === "recover"
+                        ? "Keep next week below baseline and avoid stacking hard sessions until load balance normalizes."
+                        : highPct > target.high[1]
+                            ? "Do not add another high-intensity session until the high-domain share drops."
+                            : null
+                },
+                nextWorkout: {
+                    recommendedType: balance === "recover"
+                        ? "recovery"
+                        : lowPct < target.low[0]
+                            ? "zone_2_base"
+                            : shouldAllowFourByFour
+                                ? "vo2max_4x4"
+                                : mode === "combat_readiness"
+                                    ? "technical_kickboxing"
+                                    : "easy_aerobic",
+                    intensityCeiling: balance === "recover"
+                        ? "Z1"
+                        : shouldAllowFourByFour
+                            ? "Z5 intervals with full recovery"
+                            : highPct > target.high[1]
+                                ? "Z2"
+                                : "Z3",
+                    durationMinutesRange: balance === "recover"
+                        ? [20, 40]
+                        : lowPct < target.low[0]
+                            ? [45, 75]
+                            : shouldAllowFourByFour
+                                ? [32, 48]
+                                : [35, 60],
+                    fourByFourAppropriate: shouldAllowFourByFour,
+                    reason: shouldAllowFourByFour
+                        ? "Load balance, hard-day count, high-domain share, and HR confidence can support one controlled VO2max stimulus."
+                        : balance === "recover"
+                            ? "Current load balance makes recovery more useful than another hard interval day."
+                            : highPct > target.high[1]
+                                ? "Recent high-domain exposure is already above this mode's target."
+                                : "A base or technical session fits the current distribution better than 4x4 work."
+                },
+                methodologyNotes: [
+                    "Scores are deterministic summaries of Forge HRR zones, TRIMP load, hard-day spacing, and evidence quality.",
+                    "ACWR, monotony, and strain are monitoring flags, not injury predictions.",
+                    "4x4 guidance is gated by freshness, recent high-intensity share, hard-day count, and HR confidence."
+                ]
+            };
+        })
+    };
+}
 export function getTrainingLoadViewData(userIds) {
     const workoutRows = listWorkoutRows(userIds);
     const sessions = workoutRows
@@ -4328,33 +4758,42 @@ export function getTrainingLoadViewData(userIds) {
             : acwr < 0.75
                 ? "underloaded"
                 : "productive";
+    const summary = {
+        sessionCount: sessions.length,
+        reliableSessionCount: reliableSessions.length,
+        totalHours: round(sessions.reduce((sum, session) => sum + session.durationSeconds, 0) / 3600, 1),
+        totalTrainingLoad: round(sessions.reduce((sum, session) => sum + workoutLoad(session), 0), 1),
+        acuteLoad7d: round(acuteLoad7d, 1),
+        chronicWeeklyLoad28d: round(chronicWeeklyLoad28d, 1),
+        acuteChronicRatio: acwr,
+        monotony7d: monotony7d != null ? round(monotony7d, 2) : null,
+        strain7d: strain7d != null ? round(strain7d, 1) : null,
+        highIntensityMinutes7d: round(highSeconds7d / 60, 1),
+        thresholdMinutes7d: round(moderateSeconds7d / 60, 1),
+        easyMinutes7d: round(lowSeconds7d / 60, 1),
+        hardDayCount7d: last7Keys.filter((key) => (dailyMap.get(key)?.highIntensitySeconds ?? 0) >= 10 * 60).length,
+        averageHeartRateCoverage: round(average(sessions.map((session) => workoutHrCoverage(session))), 3),
+        vo2MaxLatest,
+        vo2MaxDelta,
+        latestRestingHeartRate: latestVitalValue(vitalsTrend, "restingHeartRate"),
+        readiness
+    };
+    const recentIntensityDistribution = summarizeIntensityDistribution(recent28);
+    const zoneTimeSeries = buildZoneTimeSeries(sessions);
     return {
-        summary: {
-            sessionCount: sessions.length,
-            reliableSessionCount: reliableSessions.length,
-            totalHours: round(sessions.reduce((sum, session) => sum + session.durationSeconds, 0) / 3600, 1),
-            totalTrainingLoad: round(sessions.reduce((sum, session) => sum + workoutLoad(session), 0), 1),
-            acuteLoad7d: round(acuteLoad7d, 1),
-            chronicWeeklyLoad28d: round(chronicWeeklyLoad28d, 1),
-            acuteChronicRatio: acwr,
-            monotony7d: monotony7d != null ? round(monotony7d, 2) : null,
-            strain7d: strain7d != null ? round(strain7d, 1) : null,
-            highIntensityMinutes7d: round(highSeconds7d / 60, 1),
-            thresholdMinutes7d: round(moderateSeconds7d / 60, 1),
-            easyMinutes7d: round(lowSeconds7d / 60, 1),
-            hardDayCount7d: last7Keys.filter((key) => (dailyMap.get(key)?.highIntensitySeconds ?? 0) >= 10 * 60).length,
-            averageHeartRateCoverage: round(average(sessions.map((session) => workoutHrCoverage(session))), 3),
-            vo2MaxLatest,
-            vo2MaxDelta,
-            latestRestingHeartRate: latestVitalValue(vitalsTrend, "restingHeartRate"),
-            readiness
-        },
+        summary,
         zoneTotals: summarizeZoneDistribution(sessions),
         recentZoneTotals: summarizeZoneDistribution(recent28),
         intensityDistribution: summarizeIntensityDistribution(sessions),
-        recentIntensityDistribution: summarizeIntensityDistribution(recent28),
+        recentIntensityDistribution,
         dailyLoad: dailyLoad.slice(-90),
         weeklyLoad,
+        zoneTimeSeries,
+        trainingIntelligence: buildTrainingIntelligence({
+            summary,
+            recentIntensityDistribution,
+            zoneTimeSeries
+        }),
         activityBreakdown,
         vitalsTrend,
         sessionSignals: sessions