catence 0.2.1-beta.28 → 0.2.1-beta.29

package/README.md

@@ -10,7 +10,8 @@ As a context, I'm both an endurance athlete and a data junkie. I already got a c
 
 ## What is included
 
-- Garmin, Intervals.icu, and Strava ingestion with source-aware normalization.
+- Garmin, Intervals.icu, Strava, and read-only TrainingPeaks ingestion (planned workouts + coach-entered zones) with source-aware normalization.
+- Intervals.icu-derived fitness (daily CTL, ATL, TSB, ramp rate) is ingested and queryable through the catalog with explicit Intervals provenance; Garmin remains the source of record for activity detail and its own load numbers.
 - Read-only MCP tools, plus explicitly named, lock-guarded write tools for Strava hydration and detached syncs.
 - One Catence MCP server serves several athlete stores side by side. Every personal-data MCP call names an `athleteId`; tools act only on that store and never merge athletes implicitly. The MCP server does not authenticate callers — it trusts the `athleteId` each call names.
 - A password-protected Chainlit Console with an authenticated dashboard, a data-sync button with live progress, and in-app model management.
@@ -42,8 +43,11 @@ printf %s 'alex@example.com' | catence-data --athlete alex secret set --provider
 printf %s 'your-garmin-password' | catence-data --athlete alex secret set --provider garmin --field password --value-stdin
 printf %s 'intervals-api-key' | catence-data --athlete alex secret set --provider intervals --field apiKey --value-stdin
 printf %s '12345' | catence-data --athlete alex secret set --provider intervals --field athleteId --value-stdin
+printf %s '<production-tpauth-cookie-value>' | catence-data --athlete alex secret set --provider trainingpeaks --field authCookie --value-stdin
 ```
 
+TrainingPeaks is a read-only companion provider for planned workouts (next 14 days) and coach-entered zones/thresholds; the `Production_tpAuth` browser cookie expires every few weeks and needs a re-paste. See [docs/providers-trainingpeaks.md](docs/providers-trainingpeaks.md).
+
 Sync and create retrieval context:
 
 ```sh

package/dist/contracts/progress.d.ts

@@ -1,5 +1,5 @@
 export declare const STALE_RUN_TIMEOUT_MS: number;
-export declare const SYNC_STAGES: readonly ["starting", "login", "singletons", "daily", "range", "ftp_history", "max_metrics", "hrv_history", "scores", "activities", "collections", "intervals", "importing", "completed", "interrupted", "failed", "timed_out"];
+export declare const SYNC_STAGES: readonly ["starting", "login", "singletons", "daily", "range", "ftp_history", "max_metrics", "hrv_history", "scores", "activities", "collections", "intervals", "trainingpeaks", "planned_workouts", "zones", "athlete_settings", "importing", "completed", "interrupted", "failed", "timed_out"];
 export type SyncStage = (typeof SYNC_STAGES)[number];
 export interface SyncProgressState {
     runId: string;

package/dist/contracts/progress.js

@@ -12,6 +12,10 @@ export const SYNC_STAGES = [
     'activities',
     'collections',
     'intervals',
+    'trainingpeaks',
+    'planned_workouts',
+    'zones',
+    'athlete_settings',
     'importing',
     'completed',
     'interrupted',

package/dist/contracts/release.d.ts

@@ -3,7 +3,7 @@
  * Keep these values synchronized with release/manifest.json; release checks
  * deliberately reject drift before a package can be published.
  */
-export declare const CATENCE_RUNTIME_VERSION = "0.2.1-beta.28";
+export declare const CATENCE_RUNTIME_VERSION = "0.2.1-beta.29";
 export declare const CATENCE_PROTOCOL_VERSION = 1;
 export type CatenceRuntimeCapabilities = {
     mcp: true;

package/dist/contracts/release.js

@@ -3,7 +3,7 @@
  * Keep these values synchronized with release/manifest.json; release checks
  * deliberately reject drift before a package can be published.
  */
-export const CATENCE_RUNTIME_VERSION = '0.2.1-beta.28';
+export const CATENCE_RUNTIME_VERSION = '0.2.1-beta.29';
 export const CATENCE_PROTOCOL_VERSION = 1;
 export function catenceRuntimeHealth() {
     return {

package/dist/contracts/staging.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const PROVIDERS: readonly ["intervals", "garmin", "strava"];
+export declare const PROVIDERS: readonly ["intervals", "garmin", "strava", "trainingpeaks"];
 export type Provider = (typeof PROVIDERS)[number];
 export declare const STAGING_SCHEMA_VERSION = 1;
 export declare const rawObjectSchema: z.ZodObject<{
@@ -7,6 +7,7 @@ export declare const rawObjectSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -23,6 +24,7 @@ export declare const runManifestSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -35,6 +37,7 @@ export declare const sourceEntitySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -52,6 +55,7 @@ export declare const streamManifestSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -69,6 +73,7 @@ export declare const activitySyncStateSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -81,6 +86,7 @@ export declare const extractionErrorSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -94,6 +100,7 @@ export declare const stagingRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -105,6 +112,7 @@ export declare const stagingRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -120,6 +128,7 @@ export declare const stagingRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -136,6 +145,7 @@ export declare const stagingRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -152,6 +162,7 @@ export declare const stagingRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;
@@ -163,6 +174,7 @@ export declare const stagingRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         intervals: "intervals";
+        trainingpeaks: "trainingpeaks";
         garmin: "garmin";
         strava: "strava";
     }>;

package/dist/contracts/staging.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export const PROVIDERS = ['intervals', 'garmin', 'strava'];
+export const PROVIDERS = ['intervals', 'garmin', 'strava', 'trainingpeaks'];
 export const STAGING_SCHEMA_VERSION = 1;
 export const rawObjectSchema = z.object({
     kind: z.literal('raw_object'), schemaVersion: z.literal(STAGING_SCHEMA_VERSION), provider: z.enum(PROVIDERS),

package/dist/core/query/catalog.d.ts

@@ -1,4 +1,4 @@
-export type DatasetName = 'activities' | 'canonical_activities' | 'canonical_activity_facts' | 'activity_sources' | 'activity_summaries' | 'activity_intervals' | 'swim_lengths' | 'swim_sets' | 'activity_quality_flags' | 'daily_metrics' | 'daily_health' | 'training_metrics' | 'training_metric_observations' | 'wellness_samples' | 'health_sessions' | 'power_bests' | 'activity_decoupling' | 'run_dynamics' | 'nutrition_days' | 'nutrition_items' | 'events' | 'workouts' | 'workout_documents' | 'training_plans' | 'routes' | 'gear' | 'devices' | 'goals' | 'achievements' | 'messages' | 'source_entities' | 'activity_samples' | 'activity_links' | 'activity_segments' | 'segments' | 'segment_effort_history' | 'strava_gear' | 'course_geometry';
+export type DatasetName = 'activities' | 'canonical_activities' | 'canonical_activity_facts' | 'activity_sources' | 'activity_summaries' | 'activity_intervals' | 'swim_lengths' | 'swim_sets' | 'activity_quality_flags' | 'daily_metrics' | 'daily_health' | 'fitness_trend' | 'training_metrics' | 'training_metric_observations' | 'wellness_samples' | 'health_sessions' | 'power_bests' | 'activity_decoupling' | 'run_dynamics' | 'nutrition_days' | 'nutrition_items' | 'events' | 'workouts' | 'workout_documents' | 'training_plans' | 'routes' | 'gear' | 'devices' | 'goals' | 'achievements' | 'messages' | 'source_entities' | 'activity_samples' | 'activity_links' | 'activity_segments' | 'segments' | 'segment_effort_history' | 'strava_gear' | 'course_geometry';
 export type CatalogColumn = {
     name: string;
     type: string;

package/dist/core/query/catalog.js

@@ -42,6 +42,10 @@ export const DATASET_CATALOG = {
         name: 'daily_metrics', relation: 'daily_metrics', description: 'Long-form provider daily facts. Metric names and units are explicit.', dateColumn: 'metric_date', provenanceColumns: ['provider', 'raw_object_hash'], permittedGroupings: ['provider', 'metric_name'],
         columns: [column('provider', 'VARCHAR', { filterable: true, groupable: true }), column('metric_date', 'DATE', { filterable: true, groupable: true }), column('metric_name', 'VARCHAR', { filterable: true, groupable: true }), column('value_number', 'DOUBLE', { metric: true }), column('value_text', 'VARCHAR'), column('unit', 'VARCHAR', { filterable: true, groupable: true }), column('raw_object_hash', 'VARCHAR')],
     },
+    fitness_trend: {
+        name: 'fitness_trend', relation: 'fitness_trend', description: 'One canonical daily fitness/fatigue/form row per date (CTL, ATL, TSB) plus ramp rate and daily training load. Garmin wins whenever it has the values for that date; TrainingPeaks or Intervals.icu is a whole-day fallback, and the provider column names the winner. Source values are stored verbatim, never recomputed by Catence — query daily_metrics (metric names ctl/atl/tsb/ramp_rate/fitness_load) to compare provider observations. Missing dates mean no provider value exists, not a zero.', dateColumn: 'metric_date', provenanceColumns: ['provider'], permittedGroupings: ['provider'],
+        columns: [column('provider', 'VARCHAR', { filterable: true, groupable: true }), column('metric_date', 'DATE', { filterable: true, groupable: true }), column('ctl', 'DOUBLE', { unit: 'tss/d', metric: true, description: 'Chronic training load (fitness), Intervals-derived rolling daily average.' }), column('atl', 'DOUBLE', { unit: 'tss/d', metric: true, description: 'Acute training load (fatigue), Intervals-derived rolling daily average.' }), column('tsb', 'DOUBLE', { unit: 'tss', metric: true, description: 'Training stress balance (form) = CTL - ATL as reported by Intervals.' }), column('ramp_rate', 'DOUBLE', { unit: 'tss/d/week', metric: true, description: 'CTL ramp rate as reported by Intervals.' }), column('fitness_load', 'DOUBLE', { unit: 'tss', metric: true, description: 'Daily training load (TSS/TRIMP) used for the PMC series, as reported by Intervals.' })],
+    },
     daily_health: {
         name: 'daily_health', relation: 'daily_health', description: 'One canonical daily-health record per date. Garmin wins whenever it has facts for that date; Intervals or another provider is a whole-day fallback. Use daily_metrics to compare source observations.', dateColumn: 'metric_date', provenanceColumns: ['provider'], permittedGroupings: ['provider'],
         columns: [column('provider', 'VARCHAR', { filterable: true, groupable: true }), column('metric_date', 'DATE', { filterable: true, groupable: true }), column('resting_hr_bpm', 'DOUBLE', { unit: 'bpm', metric: true }), column('hrv_ms', 'DOUBLE', { unit: 'ms', metric: true }), column('sleep_seconds', 'DOUBLE', { unit: 's', metric: true }), column('sleep_score', 'DOUBLE', { metric: true }), column('stress', 'DOUBLE', { metric: true }), column('body_battery', 'DOUBLE', { metric: true }), column('readiness', 'DOUBLE', { metric: true }), column('spo2_pct', 'DOUBLE', { unit: '%', metric: true }), column('weight_kg', 'DOUBLE', { unit: 'kg', metric: true }), column('steps', 'DOUBLE', { unit: 'count', metric: true })],

package/dist/core/retrieval/index.js

@@ -88,7 +88,7 @@ export async function buildRetrievalIndex(database) {
     const domain = await database.rows(`
     SELECT provider, entity_type, remote_id, cast(occurred_on AS VARCHAR) AS occurred_on, payload_json
     FROM domain_entities
-    WHERE entity_type IN ('event', 'workout', 'scheduled_workout', 'training_plan', 'route', 'message')
+    WHERE entity_type IN ('event', 'workout', 'scheduled_workout', 'planned_workout', 'training_plan', 'route', 'message')
   `);
     for (const entity of domain) {
         const fields = selectedPayloadText(payloadObject(entity.payload_json));

package/dist/core/runtime/secrets.d.ts

@@ -13,6 +13,9 @@ declare const secretSchema: z.ZodObject<{
         clientId: z.ZodOptional<z.ZodString>;
         clientSecret: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    trainingpeaks: z.ZodOptional<z.ZodObject<{
+        authCookie: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type AthleteSecrets = z.infer<typeof secretSchema>;
 export type SecretProvider = keyof AthleteSecrets;

package/dist/core/runtime/secrets.js

@@ -6,18 +6,21 @@ const secretSchema = z.object({
     garmin: z.object({ email: z.string().min(1).optional(), password: z.string().min(1).optional() }).strict().optional(),
     intervals: z.object({ apiKey: z.string().min(1).optional(), athleteId: z.string().min(1).optional() }).strict().optional(),
     strava: z.object({ clientId: z.string().min(1).optional(), clientSecret: z.string().min(1).optional() }).strict().optional(),
+    trainingpeaks: z.object({ authCookie: z.string().min(1).optional() }).strict().optional(),
 }).strict();
 const secretFields = {
     garmin: ['email', 'password'],
     intervals: ['apiKey', 'athleteId'],
     strava: ['clientId', 'clientSecret'],
+    trainingpeaks: ['authCookie'],
 };
-const secretProviderOrder = ['garmin', 'intervals', 'strava'];
+const secretProviderOrder = ['garmin', 'intervals', 'strava', 'trainingpeaks'];
 /** Display labels for the Console credentials editor. */
 export const secretProviderLabels = {
     garmin: 'Garmin',
     intervals: 'Intervals.icu',
     strava: 'Strava',
+    trainingpeaks: 'TrainingPeaks',
 };
 export function providerSecretPath(paths) {
     return path.join(paths.secrets, 'providers.json');
@@ -121,7 +124,7 @@ export async function athleteProviderEnvironment(paths, base = process.env) {
     // athlete store that has not explicitly configured that provider, unless
     // the operator has opted in via CATENCE_ALLOW_ENV_SECRETS or is using a
     // per-athlete scoped variable (CATENCE_ATHLETE_<ID>_GARMIN_EMAIL etc.).
-    for (const name of ['GARMIN_EMAIL', 'GARMIN_PASSWORD', 'INTERVALS_API_KEY', 'INTERVALS_ATHLETE_ID', 'STRAVA_CLIENT_ID', 'STRAVA_CLIENT_SECRET']) {
+    for (const name of ['GARMIN_EMAIL', 'GARMIN_PASSWORD', 'INTERVALS_API_KEY', 'INTERVALS_ATHLETE_ID', 'STRAVA_CLIENT_ID', 'STRAVA_CLIENT_SECRET', 'TP_AUTH_COOKIE']) {
         delete environment[name];
     }
     const garminEmail = resolveWithEnvFallback(secrets.garmin?.email, 'GARMIN_EMAIL', perAthletePrefix, base, allowGenericEnv);
@@ -130,6 +133,7 @@ export async function athleteProviderEnvironment(paths, base = process.env) {
     const intervalsAthleteId = resolveWithEnvFallback(secrets.intervals?.athleteId, 'INTERVALS_ATHLETE_ID', perAthletePrefix, base, allowGenericEnv);
     const stravaClientId = resolveWithEnvFallback(secrets.strava?.clientId, 'STRAVA_CLIENT_ID', perAthletePrefix, base, allowGenericEnv);
     const stravaClientSecret = resolveWithEnvFallback(secrets.strava?.clientSecret, 'STRAVA_CLIENT_SECRET', perAthletePrefix, base, allowGenericEnv);
+    const trainingpeaksAuthCookie = resolveWithEnvFallback(secrets.trainingpeaks?.authCookie, 'TP_AUTH_COOKIE', perAthletePrefix, base, allowGenericEnv);
     if (garminEmail)
         environment.GARMIN_EMAIL = garminEmail;
     if (garminPassword)
@@ -142,6 +146,8 @@ export async function athleteProviderEnvironment(paths, base = process.env) {
         environment.STRAVA_CLIENT_ID = stravaClientId;
     if (stravaClientSecret)
         environment.STRAVA_CLIENT_SECRET = stravaClientSecret;
+    if (trainingpeaksAuthCookie)
+        environment.TP_AUTH_COOKIE = trainingpeaksAuthCookie;
     return environment;
 }
 //# sourceMappingURL=secrets.js.map

package/dist/elt/application/detached-sync.d.ts

@@ -1,6 +1,6 @@
 import { type SpawnOptions } from 'node:child_process';
 import type { CatencePaths } from '../../contracts/runtime.js';
-export declare const DETACHED_SYNC_PROVIDERS: readonly ["intervals", "garmin", "strava", "all"];
+export declare const DETACHED_SYNC_PROVIDERS: readonly ["intervals", "garmin", "strava", "trainingpeaks", "all"];
 export type DetachedSyncProvider = (typeof DETACHED_SYNC_PROVIDERS)[number];
 export type DetachedSyncRequest = {
     paths: CatencePaths;

package/dist/elt/application/detached-sync.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { STALE_RUN_TIMEOUT_MS } from '../../contracts/progress.js';
 import { syncProgress } from './management.js';
-export const DETACHED_SYNC_PROVIDERS = ['intervals', 'garmin', 'strava', 'all'];
+export const DETACHED_SYNC_PROVIDERS = ['intervals', 'garmin', 'strava', 'trainingpeaks', 'all'];
 /** Raised when another sync run is already active for this store. */
 export class DetachedSyncBusyError extends Error {
     runId;
@@ -41,7 +41,7 @@ function assertValidRequest(request) {
         throw new Error('athleteId is required and must be a lowercase athlete identifier.');
     }
     if (request.provider !== undefined && !DETACHED_SYNC_PROVIDERS.includes(request.provider)) {
-        throw new Error('provider must be intervals, garmin, strava, or all.');
+        throw new Error('provider must be intervals, garmin, strava, trainingpeaks, or all.');
     }
     if (request.from !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(request.from)) {
         throw new Error('from must use YYYY-MM-DD.');

package/dist/elt/application/management.d.ts

@@ -1,6 +1,6 @@
 import type { CatencePaths } from '../../contracts/runtime.js';
 import { type SyncProgressSnapshot } from '../../contracts/progress.js';
-type SyncProviderChoice = 'intervals' | 'garmin';
+type SyncProviderChoice = 'intervals' | 'garmin' | 'trainingpeaks';
 export type ProviderChoice = SyncProviderChoice | 'strava' | 'all';
 export declare function initializeDataStore(paths: CatencePaths): Promise<Record<string, unknown>>;
 export declare function syncData(paths: CatencePaths, provider: ProviderChoice, explicitFrom?: string, advanceCursor?: boolean, refreshActivities?: boolean, backfill?: boolean): Promise<Record<string, unknown>>;

package/dist/elt/application/management.js

@@ -4,7 +4,7 @@ import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { createReadStream } from 'node:fs';
 import { createInterface } from 'node:readline';
-import { EVENT_WINDOW_PAST_DAYS } from '../ingestion/providers/registry.js';
+import { EVENT_WINDOW_PAST_DAYS, TRAININGPEAKS_PLANNED_DAYS_AHEAD } from '../ingestion/providers/registry.js';
 import { createServer } from 'node:http';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -164,7 +164,7 @@ async function backfillGarminSwimLengths(database, paths, parentRunId, log) {
  * Progress NDJSON lines (kind 'progress') are normalized and persisted as
  * throttled heartbeats; other output is forwarded to the sync logger.
  */
-function runGarminWorker(runId, arguments_, environment, pump, log, onInterruptReady) {
+function runStagingWorker(runId, provider, arguments_, environment, pump, log, onInterruptReady) {
     return new Promise((resolve) => {
         const child = spawn('uv', arguments_, { ...environment, stdio: ['ignore', 'pipe', 'pipe'] });
         let killTimer;
@@ -203,7 +203,7 @@ function runGarminWorker(runId, arguments_, environment, pump, log, onInterruptR
                 parsed = JSON.parse(line);
             }
             catch {
-                log.info(`[garmin] ${line}`);
+                log.info(`[${provider}] ${line}`);
                 return;
             }
             if (typeof parsed === 'object' && parsed !== null && parsed.kind === 'progress') {
@@ -212,7 +212,7 @@ function runGarminWorker(runId, arguments_, environment, pump, log, onInterruptR
                     pump.publish(state);
                 return;
             }
-            log.info(`[garmin] ${line}`);
+            log.info(`[${provider}] ${line}`);
         });
         buffer(child.stderr, (line) => {
             let parsed;
@@ -220,14 +220,14 @@ function runGarminWorker(runId, arguments_, environment, pump, log, onInterruptR
                 parsed = JSON.parse(line);
             }
             catch {
-                log.error(`[garmin] ${line}`);
+                log.error(`[${provider}] ${line}`);
                 return;
             }
             if (typeof parsed === 'object' && parsed !== null && parsed.kind === 'stage_timings') {
-                log.info('Garmin staging worker stage timings', parsed);
+                log.info('Staging worker stage timings', parsed);
                 return;
             }
-            log.error(`[garmin] ${line}`);
+            log.error(`[${provider}] ${line}`);
         });
         child.on('error', (error) => {
             if (killTimer)
@@ -289,7 +289,7 @@ async function syncProvider(database, paths, provider, options, log) {
     };
     const dailyWindow = explicitWindow ? await uncoveredExplicitWindow('daily') : await database.resolveIncrementalWindow(provider, 'daily', options.toDate, defaultFromDate(), 3);
     const activityWindow = explicitWindow ? await uncoveredExplicitWindow('activities') : await database.resolveIncrementalWindow(provider, 'activities', options.toDate, defaultFromDate(), 14);
-    const hasProviderWork = provider === 'intervals' ? activityWindow !== null : dailyWindow !== null || activityWindow !== null;
+    const hasProviderWork = provider === 'intervals' ? activityWindow !== null : provider === 'trainingpeaks' ? true : dailyWindow !== null || activityWindow !== null;
     if (!hasProviderWork) {
         log.debug('No uncovered work; skipping provider', { provider, daily: dailyWindow ?? null, activities: activityWindow ?? null });
         return {
@@ -300,7 +300,8 @@ async function syncProvider(database, paths, provider, options, log) {
             refreshedActivities: provider === 'garmin' && options.refreshActivities, skipped: true,
         };
     }
-    const fromDate = [dailyWindow?.fromDate, activityWindow?.fromDate].filter((date) => Boolean(date)).sort()[0];
+    const fromDate = [dailyWindow?.fromDate, activityWindow?.fromDate].filter((date) => Boolean(date)).sort()[0]
+        ?? (provider === 'trainingpeaks' ? new Date().toISOString().slice(0, 10) : '');
     const runId = await database.beginRun(provider, fromDate);
     log.info('Starting sync run', {
         runId, provider, fromDate, toDate: options.toDate,
@@ -322,6 +323,32 @@ async function syncProvider(database, paths, provider, options, log) {
                 await new IntervalsExtractor(database, paths, config.apiKey, config.athleteId, log).sync(runId, activityWindow, !options.backfill || options.refreshActivities);
             });
         }
+        else if (provider === 'trainingpeaks') {
+            const output = path.join(paths.staging, 'trainingpeaks', `${runId}.jsonl`);
+            await mkdir(path.dirname(output), { recursive: true });
+            const fromDate = new Date().toISOString().slice(0, 10);
+            const toDate = new Date(Date.now() + TRAININGPEAKS_PLANNED_DAYS_AHEAD * 86_400_000).toISOString().slice(0, 10);
+            const arguments_ = ['run', 'python', '-m', 'python.catence.providers.trainingpeaks.cli', '--from', fromDate, '--to', toDate, '--data-dir', paths.root, '--output', output, '--run-id', runId];
+            let interruptChild = null;
+            await runWithInterruptGuard(runId, database, () => interruptChild?.(), guard, async () => {
+                const environment = await athleteProviderEnvironment(paths);
+                if (!environment.TP_AUTH_COOKIE) {
+                    throw new Error('TrainingPeaks auth cookie is not configured. Set it with: catence-data --athlete <id> secret set --provider trainingpeaks --field authCookie --value-stdin');
+                }
+                extractionStarted = true;
+                pump.setStage('trainingpeaks');
+                const outcome = await runStagingWorker(runId, 'trainingpeaks', arguments_, {
+                    cwd: packageRoot(),
+                    env: { ...environment, UV_PROJECT_ENVIRONMENT: process.env.UV_PROJECT_ENVIRONMENT ?? path.join(paths.root, 'python-venv') },
+                }, pump, log, (kill) => { interruptChild = kill; });
+                if (!guard.interrupted && outcome.code !== 0) {
+                    throw new Error(`TrainingPeaks staging worker exited with code ${outcome.code}${outcome.signal ? ` (${outcome.signal})` : ''}.`);
+                }
+            });
+            if (!guard.interrupted && existsSync(output)) {
+                await importJsonl(database, runId, output, log);
+            }
+        }
         else {
             const output = path.join(paths.staging, 'garmin', `${runId}.jsonl`);
             const knownActivities = path.join(paths.staging, 'garmin', `${runId}.known-activities.json`);
@@ -366,7 +393,7 @@ async function syncProvider(database, paths, provider, options, log) {
             const workerStartedAt = Date.now();
             let interruptChild = null;
             await runWithInterruptGuard(runId, database, () => interruptChild?.(), guard, async () => {
-                const outcome = await runGarminWorker(runId, arguments_, {
+                const outcome = await runStagingWorker(runId, 'garmin', arguments_, {
                     cwd: packageRoot(),
                     env: { ...(await athleteProviderEnvironment(paths)), UV_PROJECT_ENVIRONMENT: process.env.UV_PROJECT_ENVIRONMENT ?? path.join(paths.root, 'python-venv') },
                 }, pump, log, (kill) => { interruptChild = kill; });
@@ -422,7 +449,7 @@ async function syncProvider(database, paths, provider, options, log) {
         const [run] = await database.rows('SELECT status, error_count FROM sync_runs WHERE run_id = $runId', { runId });
         log.info('Sync run finished', { runId, provider, status: run?.status ?? 'unknown', errorCount: run?.error_count ?? 0 });
     }
-    if (!guard.interrupted && options.advanceCursor && !options.explicitFrom && extractionStarted) {
+    if (!guard.interrupted && options.advanceCursor && !options.explicitFrom && extractionStarted && provider !== 'trainingpeaks') {
         await database.advanceIncrementalCursor(provider, 'daily', runId, options.toDate, 3);
         await database.advanceIncrementalCursor(provider, 'activities', runId, options.toDate, 14);
     }
@@ -454,7 +481,7 @@ export async function syncData(paths, provider, explicitFrom, advanceCursor = tr
         for (const runId of timedOutRuns.runIds) {
             await removeProgressSidecar(paths, runId).catch(() => undefined);
         }
-        const providers = provider === 'all' ? ['intervals', 'garmin'] : [provider];
+        const providers = provider === 'all' ? ['intervals', 'garmin', 'trainingpeaks'] : [provider];
         const toDate = new Date().toISOString().slice(0, 10);
         const runs = [];
         for (const source of providers)

package/dist/elt/ingestion/providers/intervals.js

@@ -98,6 +98,11 @@ export class IntervalsExtractor {
                     // detail, files, streams, and structured activity data.
                     await this.database.recordActivitySyncState('intervals', activityId, summaryHash, runId, false);
                 }
+                // The same payload also carries the rolling daily PMC numbers
+                // (icu_ctl/icu_atl/...) embedded per activity; there is no separate
+                // fitness endpoint. Fan them out as fitness_summary entities so the
+                // normalizer can store the day's provider-reported CTL/ATL/load.
+                await this.importEntities('fitness_summary', 'activities', payload, null, runId);
             }
         }
     }

package/dist/elt/ingestion/providers/registry.d.ts

@@ -8,7 +8,10 @@ export declare const intervalsReadRegistry: readonly EndpointSpec[];
 /**
  * Intervals is an analysis companion to Garmin: its activity-list payload
  * supplies the separately named training calculations without duplicating
- * Garmin's activity detail, files, streams, or account data.
+ * Garmin's activity detail, files, streams, or account data. There is no
+ * /fitness endpoint — the daily PMC numbers (icu_ctl/icu_atl/...) ride
+ * embedded on each activity, and the extractor fans them out into
+ * fitness_summary entities so they reach the fitness_trend dataset.
  */
 export declare const intervalsSecondaryReadRegistry: EndpointSpec[];
 /** How far back and ahead of today the planned-events fetch reaches. */
@@ -28,5 +31,13 @@ export declare const intervalsActivityReadEndpoints: readonly ["activity", "stre
 /** Read-only methods exposed by python-garminconnect, grouped for manifest tests and worker dispatch. */
 export declare const garminReadRegistry: readonly EndpointSpec[];
 export declare const stravaReadRegistry: readonly EndpointSpec[];
+/**
+ * TrainingPeaks is a companion provider in the Intervals role: planned-workout
+ * and coach-entered zone/threshold provenance. Completed activities stay with
+ * Garmin; TP zone rows are never merged with Garmin's device-detected values.
+ */
+export declare const trainingpeaksReadRegistry: readonly EndpointSpec[];
+/** How far ahead of today the planned-workout window reaches. */
+export declare const TRAININGPEAKS_PLANNED_DAYS_AHEAD = 14;
 export declare const allReadOnlyEndpoints: readonly EndpointSpec[];
 export declare function assertReadOnlyRegistry(): void;

package/dist/elt/ingestion/providers/registry.js

@@ -19,7 +19,10 @@ export const intervalsReadRegistry = registry('intervals', [
 /**
  * Intervals is an analysis companion to Garmin: its activity-list payload
  * supplies the separately named training calculations without duplicating
- * Garmin's activity detail, files, streams, or account data.
+ * Garmin's activity detail, files, streams, or account data. There is no
+ * /fitness endpoint — the daily PMC numbers (icu_ctl/icu_atl/...) ride
+ * embedded on each activity, and the extractor fans them out into
+ * fitness_summary entities so they reach the fitness_trend dataset.
  */
 export const intervalsSecondaryReadRegistry = intervalsReadRegistry.filter((endpoint) => endpoint.name === 'athlete' || endpoint.name === 'activities' || endpoint.name === 'events');
 /** How far back and ahead of today the planned-events fetch reaches. */
@@ -70,7 +73,19 @@ export const stravaReadRegistry = registry('strava', [
     ['activity_candidates', 'date_range', 'activity'], ['activity_detail', 'activity', 'activity'],
     ['segment', 'child', 'segment'], ['segment_efforts', 'child', 'segment_effort'],
 ]);
-export const allReadOnlyEndpoints = [...intervalsReadRegistry, ...garminReadRegistry, ...stravaReadRegistry];
+/**
+ * TrainingPeaks is a companion provider in the Intervals role: planned-workout
+ * and coach-entered zone/threshold provenance. Completed activities stay with
+ * Garmin; TP zone rows are never merged with Garmin's device-detected values.
+ */
+export const trainingpeaksReadRegistry = registry('trainingpeaks', [
+    ['planned_workouts', 'date_range', 'planned_workout'],
+    ['zones', 'collection', 'zone_setting'],
+    ['athlete_settings', 'singleton', 'profile'],
+]);
+/** How far ahead of today the planned-workout window reaches. */
+export const TRAININGPEAKS_PLANNED_DAYS_AHEAD = 14;
+export const allReadOnlyEndpoints = [...intervalsReadRegistry, ...garminReadRegistry, ...stravaReadRegistry, ...trainingpeaksReadRegistry];
 export function assertReadOnlyRegistry() {
     for (const endpoint of allReadOnlyEndpoints) {
         if (endpoint.readOnly !== true)

package/dist/elt/normalization/normalizers.js

@@ -274,6 +274,8 @@ export async function importSourceEntity(database, entity) {
         await importDailyMetrics(database, entity.provider, entity.remoteId, entity.occurredOn, payload, rawHash);
     if (entity.provider === 'garmin' && entity.entityType === 'body_composition')
         await importGarminWeight(database, entity.occurredOn, payload, rawHash);
+    if (entity.provider === 'intervals' && entity.entityType === 'fitness_summary')
+        await importIntervalsFitnessSummary(database, entity.remoteId, entity.occurredOn, payload, rawHash);
     if (entity.entityType === 'nutrition_day' || entity.entityType === 'nutrition_log')
         await importNutrition(database, entity.provider, entity.occurredOn, entity.remoteId, payload, rawHash);
     if (entity.provider === 'garmin' && entity.entityType === 'training_metric')
@@ -296,6 +298,58 @@ export async function importSourceEntity(database, entity) {
         await importActivityPowerBest(database, entity.parentRemoteId, payload, rawHash);
     if (entity.provider === 'garmin' && entity.entityType === 'course')
         await importGarminCourse(database, entity.remoteId, payload, rawHash);
+    if (entity.provider === 'trainingpeaks' && entity.entityType === 'zone_setting')
+        await importTrainingPeaksZoneSetting(database, entity.remoteId, entity.occurredOn, payload, rawHash);
+    if (entity.provider === 'trainingpeaks' && entity.entityType === 'planned_workout')
+        await importTrainingPeaksPlannedWorkout(database, entity.remoteId, entity.occurredOn, payload, rawHash);
+}
+// TrainingPeaks zone settings are coach-manual-data provenance. Each metric
+// group (power/HR/pace per workout type) becomes training_metric_observations
+// rows with an explicit trainingpeaks source_type. They are NEVER merged with
+// or preferred over Garmin's device-detected values: the query layer presents
+// both with provenance (neither is preferred), exactly like the daily_health
+// fallback rule except that here both sources stay visible.
+async function importTrainingPeaksZoneSetting(database, remoteId, occurredOn, payload, rawHash) {
+    const [workoutTypeId, metricKey] = remoteId.split(':');
+    const threshold = firstNumber(payload, ['threshold']);
+    const observedAt = `${datePart(occurredOn) ?? new Date().toISOString().slice(0, 10)}T00:00:00Z`;
+    if (threshold === null)
+        return;
+    const metric = metricForZoneMetric(metricKey, Number(workoutTypeId));
+    if (!metric)
+        return;
+    await upsertTrainingMetricObservation(database, {
+        provider: 'trainingpeaks',
+        observationId: `trainingpeaks:zone:${remoteId}`,
+        metricName: metric.metric,
+        sport: metric.sport,
+        observedAt,
+        value: threshold,
+        unit: metric.unit,
+        dimensions: { workoutTypeId: Number(workoutTypeId), calculationMethod: firstString(payload, ['calculationMethod']), zoneCalculatorId: firstNumber(payload, ['zoneCalculatorId']), zones: payload.zones ?? null },
+        sourceType: 'trainingpeaks_zone_setting',
+        sourceRemoteId: remoteId,
+        activitySourceId: null,
+        rawHash,
+    });
+}
+function metricForZoneMetric(metricKey, workoutTypeId) {
+    if (metricKey === 'power' && workoutTypeId === 2)
+        return { metric: 'cycling_ftp_w', unit: 'W', sport: 'cycling' };
+    if (metricKey === 'heartrate' && workoutTypeId === 2)
+        return { metric: 'cycling_lthr_bpm', unit: 'bpm', sport: 'cycling' };
+    if (metricKey === 'heartrate' && workoutTypeId === 3)
+        return { metric: 'running_lthr_bpm', unit: 'bpm', sport: 'running' };
+    if (metricKey === 'speed' && workoutTypeId === 3)
+        return { metric: 'running_threshold_pace_s_per_km', unit: 's_per_km', sport: 'running' };
+    return null;
+}
+// Planned workouts join the same domain family Garmin scheduled_workouts
+// populate, tagged by provider. The domain upsert above already stored the
+// raw entity; this hook only needs to exist for future field-level mapping,
+// so it intentionally records nothing extra today.
+async function importTrainingPeaksPlannedWorkout(_database, _remoteId, _occurredOn, _payload, _rawHash) {
+    return;
 }
 async function importActivity(database, provider, remoteId, payload, rawHash) {
     const fields = activityFields(provider, payload);
@@ -323,12 +377,12 @@ function isCyclingSport(sport) {
 async function upsertTrainingMetricObservation(database, values) {
     await database.run(`INSERT INTO training_metric_observations
       (observation_id, provider, metric_name, sport, observed_at, value_number, value_text, unit, device_id, dimensions_json, source_type, source_remote_id, activity_source_id, raw_object_hash)
-     VALUES ($observationId, 'garmin', $metricName, $sport, $observedAt, $value, $valueText, $unit, $deviceId, $dimensions, $sourceType, $sourceRemoteId, $activitySourceId, $rawHash)
+     VALUES ($observationId, $provider, $metricName, $sport, $observedAt, $value, $valueText, $unit, $deviceId, $dimensions, $sourceType, $sourceRemoteId, $activitySourceId, $rawHash)
      ON CONFLICT (observation_id) DO UPDATE SET
        sport = excluded.sport, observed_at = excluded.observed_at, value_number = excluded.value_number, value_text = excluded.value_text,
        unit = excluded.unit, device_id = excluded.device_id, dimensions_json = excluded.dimensions_json,
        source_type = excluded.source_type, source_remote_id = excluded.source_remote_id,
-       activity_source_id = excluded.activity_source_id, raw_object_hash = excluded.raw_object_hash`, { ...values, value: values.value ?? null, valueText: values.valueText ?? null, unit: values.unit ?? null, deviceId: values.deviceId ?? null, dimensions: json(values.dimensions ?? {}) });
+       activity_source_id = excluded.activity_source_id, raw_object_hash = excluded.raw_object_hash`, { ...values, provider: values.provider ?? 'garmin', value: values.value ?? null, valueText: values.valueText ?? null, unit: values.unit ?? null, deviceId: values.deviceId ?? null, dimensions: json(values.dimensions ?? {}) });
 }
 async function importGarminCyclingFtpFromActivity(database, remoteId, payload, rawHash) {
     const fields = activityFields('garmin', payload);
@@ -1090,6 +1144,29 @@ async function importGarminWeight(database, date, payload, rawHash) {
         await upsertDailyMetric(database, 'garmin', metricDate, 'weight_kg', kg, null, 'kg', rawHash);
     }
 }
+// Intervals-derived PMC values. The provider computes these (post-activity
+// snapshots in activity_summary and rolling daily values in fitness); Catence
+// stores them verbatim as provider observations, never recomputed, and keeps
+// the Intervals provenance explicit so a coach-entered or Garmin value is
+// never conflated with them.
+const intervalsFitnessMetricMap = [
+    { name: 'ctl', unit: 'tss/d', keys: ['icu_ctl', 'ctl'] },
+    { name: 'atl', unit: 'tss/d', keys: ['icu_atl', 'atl'] },
+    { name: 'tsb', unit: 'tss', keys: ['icu_tsb', 'tsb'] },
+    { name: 'ramp_rate', unit: 'tss/d/week', keys: ['icu_ramp_rate', 'ramp_rate', 'rampRate'] },
+    { name: 'fitness_load', unit: 'tss', keys: ['icu_training_load', 'training_load'] },
+];
+async function importIntervalsFitnessSummary(database, remoteId, date, payload, rawHash) {
+    const metricDate = datePart(date) ?? datePart(firstString(payload, ['id', 'date', 'start_date_local', 'start_date'])) ?? null;
+    if (!metricDate)
+        return;
+    for (const metric of intervalsFitnessMetricMap) {
+        const value = firstNumber(payload, metric.keys);
+        if (value === null)
+            continue;
+        await upsertDailyMetric(database, 'intervals', metricDate, metric.name, value, null, metric.unit, rawHash);
+    }
+}
 async function importNutrition(database, provider, date, remoteId, payload, rawHash) {
     const nutritionDate = datePart(date) ?? datePart(firstString(payload, ['id', 'date', 'calendarDate'])) ?? null;
     if (!nutritionDate)

package/dist/elt/storage/migrations.d.ts

@@ -1,3 +1,3 @@
 import { type Migration } from './migrations.legacy.js';
-export declare const migrations: Migration[];
 export type { Migration };
+export declare const migrations: Migration[];

package/dist/elt/storage/migrations.js

@@ -1016,5 +1016,65 @@ const runDynamicsFactsMigration = {
     UPDATE retrieval_index_state SET status = 'stale' WHERE index_name = 'context';
   `,
 };
-export const migrations = [...baseMigrations, stravaAndIdentityMigration, garminPrimaryAndTrainingMetricsMigration, garminActivitySportAndFtpBackfillMigration, garminPrimaryDailyHealthMigration, garminHistoricalMetricsAndStreamsMigration, garminUtcActivityTimestampMigration, garminLactateThresholdMetricsMigration, swimFactsAndQualityMigration, syncRunProgressMigration, canonicalTrainingDerivedAvgPowerMigration, courseGeometryMigration, activityDecouplingFactsMigration, runDynamicsFactsMigration];
+const intervalsFitnessTrendMigration = {
+    version: 19,
+    name: 'intervals_fitness_trend',
+    sql: `
+    -- Catalog exposure for Intervals-derived daily CTL/ATL/TSB (plus ramp
+    -- rate and daily load). The values are stored verbatim in daily_metrics
+    -- as provider observations; this view pivots them into one row per
+    -- provider/date so the catalog can serve them with explicit Intervals
+    -- provenance. Catence never recomputes these numbers.
+    CREATE TABLE IF NOT EXISTS daily_metrics (
+      provider VARCHAR NOT NULL,
+      metric_date DATE NOT NULL,
+      metric_name VARCHAR NOT NULL,
+      value_number DOUBLE,
+      value_text VARCHAR,
+      unit VARCHAR,
+      raw_object_hash VARCHAR,
+      PRIMARY KEY (provider, metric_date, metric_name)
+    );
+    CREATE OR REPLACE VIEW fitness_trend AS
+    SELECT provider, metric_date,
+      max(value_number) FILTER (WHERE metric_name = 'ctl') AS ctl,
+      max(value_number) FILTER (WHERE metric_name = 'atl') AS atl,
+      max(value_number) FILTER (WHERE metric_name = 'tsb') AS tsb,
+      max(value_number) FILTER (WHERE metric_name = 'ramp_rate') AS ramp_rate,
+      max(value_number) FILTER (WHERE metric_name = 'fitness_load') AS fitness_load
+    FROM daily_metrics
+    WHERE metric_name IN ('ctl', 'atl', 'tsb', 'ramp_rate', 'fitness_load')
+    GROUP BY provider, metric_date;
+  `,
+};
+const unifiedFitnessTrendMigration = {
+    version: 20,
+    name: 'unified_fitness_trend',
+    sql: `
+    -- One canonical fitness/fatigue/form row per date: Garmin wins whenever
+    -- it has the values for that date, TrainingPeaks or Intervals.icu is a
+    -- whole-day fallback (the daily_health rule), and the provider column
+    -- names the winner. Source values stay verbatim in daily_metrics as
+    -- per-provider observations — this view only picks, it never recomputes.
+    CREATE OR REPLACE VIEW fitness_trend AS
+    WITH provider_day AS (
+      SELECT provider, metric_date,
+        max(value_number) FILTER (WHERE metric_name = 'ctl') AS ctl,
+        max(value_number) FILTER (WHERE metric_name = 'atl') AS atl,
+        max(value_number) FILTER (WHERE metric_name = 'tsb') AS tsb,
+        max(value_number) FILTER (WHERE metric_name = 'ramp_rate') AS ramp_rate,
+        max(value_number) FILTER (WHERE metric_name = 'fitness_load') AS fitness_load
+      FROM daily_metrics
+      WHERE metric_name IN ('ctl', 'atl', 'tsb', 'ramp_rate', 'fitness_load')
+      GROUP BY provider, metric_date
+    )
+    SELECT provider, metric_date, ctl, atl, tsb, ramp_rate, fitness_load
+    FROM provider_day
+    QUALIFY row_number() OVER (
+      PARTITION BY metric_date
+      ORDER BY CASE provider WHEN 'garmin' THEN 1 WHEN 'trainingpeaks' THEN 2 ELSE 3 END
+    ) = 1;
+  `,
+};
+export const migrations = [...baseMigrations, stravaAndIdentityMigration, garminPrimaryAndTrainingMetricsMigration, garminActivitySportAndFtpBackfillMigration, garminPrimaryDailyHealthMigration, garminHistoricalMetricsAndStreamsMigration, garminUtcActivityTimestampMigration, garminLactateThresholdMetricsMigration, swimFactsAndQualityMigration, syncRunProgressMigration, canonicalTrainingDerivedAvgPowerMigration, courseGeometryMigration, activityDecouplingFactsMigration, runDynamicsFactsMigration, intervalsFitnessTrendMigration, unifiedFitnessTrendMigration];
 //# sourceMappingURL=migrations.js.map

package/dist/interfaces/cli/commands.js

@@ -143,12 +143,12 @@ athleteCommand.command('add')
 });
 const secretCommand = program.command('secret').description('Write or remove a provider value in one athlete’s owner-only secret store.');
 secretCommand.command('set')
-    .requiredOption('--provider <provider>', 'garmin, intervals, or strava')
+    .requiredOption('--provider <provider>', 'garmin, intervals, strava, or trainingpeaks')
     .requiredOption('--field <field>', 'provider secret field')
     .requiredOption('--value-stdin', 'read the secret from stdin without putting it in shell history')
     .action(async (options) => {
-    if (!['garmin', 'intervals', 'strava'].includes(options.provider))
-        throw new Error('--provider must be garmin, intervals, or strava.');
+    if (!['garmin', 'intervals', 'strava', 'trainingpeaks'].includes(options.provider))
+        throw new Error('--provider must be garmin, intervals, strava, or trainingpeaks.');
     const { paths } = await currentAthlete();
     await setAthleteSecret(paths, options.provider, options.field, await stdinSecret());
     process.stdout.write(`${JSON.stringify({ athleteId: program.opts().athlete, provider: options.provider, field: options.field, stored: true }, null, 2)}\n`);
@@ -185,22 +185,22 @@ program.command('demo')
     process.stdout.write(`${JSON.stringify({ ...result, home: demoCatalog.root, athleteId: 'demo' }, null, 2)}\n`);
 });
 program.command('sync')
-    .requiredOption('--provider <provider>', 'intervals, garmin, strava, or all')
+    .requiredOption('--provider <provider>', 'intervals, garmin, strava, trainingpeaks, or all')
     .option('--from <date>', 'explicit ISO date range; otherwise use incremental cursors')
     .option('--refresh', 're-fetch Garmin activity details, files, and streams even when summaries are unchanged')
     .action(async (options) => {
-    if (!['intervals', 'garmin', 'strava', 'all'].includes(options.provider))
-        throw new Error('--provider must be intervals, garmin, strava, or all.');
+    if (!['intervals', 'garmin', 'strava', 'trainingpeaks', 'all'].includes(options.provider))
+        throw new Error('--provider must be intervals, garmin, strava, trainingpeaks, or all.');
     const { paths } = await currentAthlete();
     process.stdout.write(`${JSON.stringify(await syncData(paths, options.provider, options.from, true, options.refresh ?? false), null, 2)}\n`);
 });
 program.command('backfill')
     .requiredOption('--from <date>', 'ISO date at which to begin backfill')
-    .option('--provider <provider>', 'intervals, garmin, strava, or all', 'all')
+    .option('--provider <provider>', 'intervals, garmin, strava, trainingpeaks, or all', 'all')
     .option('--refresh', 're-fetch and upsert data already covered by the requested range')
     .action(async (options) => {
-    if (!['intervals', 'garmin', 'strava', 'all'].includes(options.provider))
-        throw new Error('--provider must be intervals, garmin, strava, or all.');
+    if (!['intervals', 'garmin', 'strava', 'trainingpeaks', 'all'].includes(options.provider))
+        throw new Error('--provider must be intervals, garmin, strava, trainingpeaks, or all.');
     const { paths } = await currentAthlete();
     process.stdout.write(`${JSON.stringify(await syncData(paths, options.provider, options.from, false, options.refresh ?? false, true), null, 2)}\n`);
 });

package/dist/interfaces/http/server.js

@@ -388,7 +388,7 @@ function parseSyncBody(body) {
     if (raw.athleteId !== undefined && typeof raw.athleteId !== 'string')
         throw new Error('athleteId must be a string.');
     if (raw.provider !== undefined && (typeof raw.provider !== 'string' || !DETACHED_SYNC_PROVIDERS.includes(raw.provider))) {
-        throw new Error('provider must be intervals, garmin, strava, or all.');
+        throw new Error('provider must be intervals, garmin, strava, trainingpeaks, or all.');
     }
     if (raw.from !== undefined && (typeof raw.from !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(raw.from))) {
         throw new Error('from must use YYYY-MM-DD.');

package/dist/interfaces/mcp/server.js

@@ -322,7 +322,7 @@ export function createCatenceMcpServer(paths = resolveCatalogPaths(), dependenci
         title: 'Start a detached data sync',
         description: 'Write-only sync trigger, named like the other explicit lock-guarded write tools. Spawns one detached catence-data sync process for this athlete and returns immediately with the run handle and log file; it refuses while another sync run is active. Track the run with catence_sync_progress; this tool never waits for completion. Pass backfill with a from date to extend history backwards without advancing the incremental cursors (from is required when backfill is set).',
         inputSchema: {
-            provider: z.enum(['intervals', 'garmin', 'strava', 'all']).optional(),
+            provider: z.enum(['intervals', 'garmin', 'strava', 'trainingpeaks', 'all']).optional(),
             from: z.string().date().optional(),
             refresh: z.boolean().optional(),
             backfill: z.boolean().optional(),

package/docs/architecture.md

@@ -34,7 +34,7 @@ src/interfaces/  CLI and MCP transport adapters and executable entry points
 
 ### 1. Data fetching
 
-Garmin Connect provides the complete local record. Intervals.icu contributes only its separately named activity-analysis values (for example training load, RPE, feel, and weighted power). Strava is a deliberately sparse, targeted source for current gear and selected activity segment enrichment.
+Garmin Connect provides the complete local record. Intervals.icu contributes only its separately named activity-analysis values (for example training load, RPE, feel, weighted power, and its derived daily CTL/ATL/TSB fitness trend). TrainingPeaks is a read-only companion in the same role: planned workouts for the next 14 days and coach-entered zone/threshold settings, consumed from the trainingpeaks-mcp-core fork via cookie auth; its zone values carry explicit coach-manual provenance and are never merged with Garmin's device-detected ones. Strava is a deliberately sparse, targeted source for current gear and selected activity segment enrichment.
 
 For Garmin, we will use [python-garminconnect](https://github.com/cyberjunky/python-garminconnect) as it is the most mature and widely used library for this purpose. On the Intervals.icu side, the best option available right now is [node-intervals-icue](https://github.com/paladini/node-intervals-icu).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catence",
-  "version": "0.2.1-beta.28",
+  "version": "0.2.1-beta.29",
   "description": "Local MCP access to normalized Garmin, Intervals.icu, and targeted Strava fitness data.",
   "license": "AGPL-3.0-or-later",
   "repository": {
@@ -89,9 +89,9 @@
     "vitest": "^5.0.0"
   },
   "overrides": {
-    "fast-uri": "3.1.8",
-    "hono": "4.13.7",
+    "fast-uri": "3.1.9",
+    "hono": "4.13.14",
     "nanoid": "3.3.18",
-    "qs": "6.16.0"
+    "qs": "6.17.1"
   }
 }

package/pyproject.toml

@@ -11,11 +11,14 @@ dependencies = [
   "pyarrow>=18.0.0",
   "pydantic>=2.0.0",
   "stravalib>=2.5.0",
+  "tp-mcp>=3.2.0",
 ]
 
 [tool.uv.sources]
 # fork commit
 garminconnect = { git = "https://github.com/rifusaki/python-garminconnect.git", rev = "38b3d5003ae348de384f679976d0527316775f94" }
+# fork commit (trainingpeaks-mcp-core): client/auth core only, consumed like python-garminconnect
+tp-mcp = { git = "https://github.com/rifusaki/trainingpeaks-mcp-core.git", rev = "ec883a697c77f6864a4849539729eff2daac646e" }
 
 [tool.uv]
 package = false

package/uv.lock

@@ -11,6 +11,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" },
 ]
 
+[[package]]
+name = "anyio"
+version = "4.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.15'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" },
+]
+
 [[package]]
 name = "arrow"
 version = "1.4.0"
@@ -36,6 +49,7 @@ dependencies = [
     { name = "pyarrow" },
     { name = "pydantic" },
     { name = "stravalib" },
+    { name = "tp-mcp" },
 ]
 
 [package.dev-dependencies]
@@ -52,6 +66,7 @@ requires-dist = [
     { name = "pyarrow", specifier = ">=18.0.0" },
     { name = "pydantic", specifier = ">=2.0.0" },
     { name = "stravalib", specifier = ">=2.5.0" },
+    { name = "tp-mcp", git = "https://github.com/rifusaki/trainingpeaks-mcp-core.git?rev=ec883a697c77f6864a4849539729eff2daac646e" },
 ]
 
 [package.metadata.requires-dev]
@@ -326,6 +341,43 @@ dependencies = [
     { name = "ua-generator" },
 ]
 
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
 [[package]]
 name = "idna"
 version = "3.18"
@@ -659,6 +711,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f4/0a/9c510377cca40b6bebe915d451126db413391664db88ff50fe02a7be7709/stravalib-2.5.0-py3-none-any.whl", hash = "sha256:723422a3f06fd7f213b9b4b813f730a481fd0869b5b5e6a350f4823a1063d092", size = 128193, upload-time = "2026-06-01T13:24:24.697Z" },
 ]
 
+[[package]]
+name = "tp-mcp"
+version = "3.2.0"
+source = { git = "https://github.com/rifusaki/trainingpeaks-mcp-core.git?rev=ec883a697c77f6864a4849539729eff2daac646e#ec883a697c77f6864a4849539729eff2daac646e" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic" },
+]
+
 [[package]]
 name = "typing-extensions"
 version = "4.16.0"