catence 0.2.0-beta.8 → 0.2.0

package/dist/interfaces/cli/commands.js

@@ -2,7 +2,7 @@
 import { createInterface } from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { Command } from 'commander';
-import { addAthlete, athleteStorePaths, CATENCE_RUNTIME_VERSION, channelForVersion, createDemoStore, dataStatus, defaultCatalogHome, disconnectStravaAccount, fetchNpmDistTags, fetchPypiReleases, hasCommand, initializeCatalog, isGlobalNpmInstall, linkActivity, loadCatalog, npmGlobalPrefix, planSelfUpdate, readInstalledConsoleVersion, rebuildRetrievalIndex, resolveAthlete, resolveCatalogPaths, retryDataSync, runSelfUpdateCommand, setAthleteSecret, syncData, connectStrava, connectStravaWithCallback, unlinkActivity, } from '../../runtime/index.js';
+import { addAthlete, athleteStorePaths, CATENCE_RUNTIME_VERSION, CatenceDatabase, channelForVersion, createDemoStore, dataStatus, defaultCatalogHome, disconnectStravaAccount, fetchNpmDistTags, fetchPypiReleases, hasCommand, importStagedFile, initializeCatalog, isGlobalNpmInstall, linkActivity, loadCatalog, npmGlobalPrefix, planSelfUpdate, readInstalledConsoleVersion, rebuildRetrievalIndex, reimportNutrition, resolveExtractionErrors, resolveAthlete, resolveCatalogPaths, retryDataSync, runSelfUpdateCommand, setAthleteSecret, syncData, syncProgress, connectStrava, connectStravaWithCallback, unlinkActivity, } from '../../runtime/index.js';
 const program = new Command()
     .name('catence-data')
     .description('Athlete-scoped Catence data setup, extraction, and normalization.')
@@ -158,6 +158,38 @@ program.command('status').action(async () => {
     const { paths } = await currentAthlete();
     process.stdout.write(`${JSON.stringify(await dataStatus(paths), null, 2)}\n`);
 });
+function renderProgress(snapshot) {
+    const lines = snapshot.running.map((run) => {
+        const pct = run.percentComplete.toFixed(1).padStart(5);
+        const units = run.totalUnits !== null ? `${run.completedUnits}/${run.totalUnits}` : String(run.completedUnits);
+        const eta = run.estimatedRemainingSeconds !== null ? `${Math.round(run.estimatedRemainingSeconds)}s` : '?';
+        const step = run.currentStep ?? '';
+        return `${pct}%  ${run.stage.padEnd(12)} ${units.padEnd(11)} ${eta.padEnd(6)} ${step}`;
+    });
+    return lines.length === 0 ? 'no active sync runs' : lines.join('\n');
+}
+program.command('progress')
+    .description('Show live progress for active sync runs.')
+    .option('--watch', 'refresh every few seconds until no sync runs are active')
+    .action(async (options) => {
+    const { paths } = await currentAthlete();
+    if (!options.watch) {
+        process.stdout.write(`${JSON.stringify(await syncProgress(paths), null, 2)}\n`);
+        return;
+    }
+    while (true) {
+        const snapshot = await syncProgress(paths);
+        if (output.isTTY) {
+            output.write(`\x1b[2J\x1b[H${renderProgress(snapshot)}\n`);
+        }
+        else {
+            process.stdout.write(`${JSON.stringify(snapshot, null, 2)}\n`);
+        }
+        if (snapshot.running.length === 0)
+            break;
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+    }
+});
 program.command('update')
     .description('Check for and apply the newest Catence release on the tracked channel (runtime and Console).')
     .option('--check', 'report available releases without changing anything')
@@ -220,5 +252,66 @@ program.command('build-retrieval-index').description('Build derived local retrie
     const { paths } = await currentAthlete();
     process.stdout.write(`${JSON.stringify(await rebuildRetrievalIndex(paths), null, 2)}\n`);
 });
+program.command('reimport-nutrition').description('Re-run normalization over captured nutrition entities without contacting providers.').action(async () => {
+    const { paths } = await currentAthlete();
+    process.stdout.write(`${JSON.stringify(await reimportNutrition(paths), null, 2)}\n`);
+});
+program
+    .command('import')
+    .description('Import a staged JSONL file (for example a swim-length backfill) into one athlete’s data store.')
+    .requiredOption('--provider <provider>', 'garmin, intervals, or strava')
+    .argument('<file>', 'path to the staged JSONL file')
+    .action(async (file, options) => {
+    const { paths } = await currentAthlete();
+    process.stdout.write(`${JSON.stringify(await importStagedFile(paths, options.provider, file), null, 2)}\n`);
+});
+program
+    .command('resolve-errors')
+    .description('Mark unresolved extraction errors as resolved (for example stale bootstrap failures from an environment that has since recovered).')
+    .option('--run <run-id>', 'resolve errors from a specific run only (repeatable)')
+    .option('--provider <provider>', 'resolve errors for garmin, intervals, or strava only')
+    .option('--before <timestamp>', 'resolve errors created before this ISO timestamp')
+    .option('--all', 'resolve every unresolved error')
+    .action(async (options) => {
+    const { paths } = await currentAthlete();
+    const runIds = Array.isArray(options.run) ? options.run : options.run ? [options.run] : undefined;
+    process.stdout.write(`${JSON.stringify(await resolveExtractionErrors(paths, { runIds, provider: options.provider, before: options.before, all: options.all }), null, 2)}\n`);
+});
+program
+    .command('migrate')
+    .description('Apply pending DuckDB schema migrations. Without --all it migrates the selected --athlete store; with --all it migrates every athlete in the catalog.')
+    .option('--all', 'migrate every athlete in the catalog')
+    .option('--home <directory>', 'Catence catalog home directory (also accepts global --home)')
+    .action(async (options) => {
+    const effectiveHome = options.home ?? program.opts().home;
+    const effectiveCatalog = effectiveHome ? resolveCatalogPaths(effectiveHome) : currentCatalog();
+    const migratePaths = async (paths) => {
+        const database = await CatenceDatabase.open(paths);
+        const applied = await database.rows('SELECT version FROM schema_migrations ORDER BY version');
+        await database.close();
+        return { migrated: true, appliedVersions: applied.map((row) => row.version) };
+    };
+    if (options.all) {
+        const catalog = await loadCatalog(effectiveCatalog);
+        const results = {};
+        for (const athlete of catalog.athletes) {
+            const paths = athleteStorePaths(effectiveCatalog, athlete.id);
+            try {
+                results[athlete.id] = await migratePaths(paths);
+            }
+            catch (error) {
+                results[athlete.id] = { migrated: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        process.stdout.write(`${JSON.stringify({ catalog: effectiveCatalog.root, results }, null, 2)}\n`);
+        return;
+    }
+    const athleteId = program.opts().athlete;
+    if (!athleteId)
+        throw new Error('--athlete is required for this command. Run catence-data athlete list to inspect the catalog or use --all.');
+    const { athlete, paths } = await resolveAthlete(effectiveCatalog, athleteId);
+    const result = await migratePaths(paths);
+    process.stdout.write(`${JSON.stringify({ athleteId: athlete.id, ...result }, null, 2)}\n`);
+});
 await program.parseAsync();
 //# sourceMappingURL=commands.js.map

package/dist/interfaces/http/generation-status.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Read + classify the generation progress sidecar written by the Catence
+ * Console agent turn (see `catence_console/generation_sidecar.py`). Mirrors the
+ * detached-sync sidecar logic: a run is "running" until it reaches a terminal
+ * stage, and "stale" (i.e. likely stuck) when its heartbeat is older than the
+ * threshold. This powers the chat UI's "still thinking vs stalled" signal.
+ */
+export interface GenerationStatus {
+    threadId: string;
+    stage?: string;
+    running: boolean;
+    stale: boolean;
+    heartbeatAt?: string;
+    startedAt?: string;
+    updatedAt?: string;
+    toolCallCount: number;
+    lastTool?: string | null;
+}
+export declare function generationStatus(homeRoot: string, threadId: string): Promise<GenerationStatus>;

package/dist/interfaces/http/generation-status.js

@@ -0,0 +1,55 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+const TERMINAL_STAGES = new Set([
+    'completed',
+    'failed',
+    'interrupted',
+    'timed_out'
+]);
+const STALE_MS = 5 * 60 * 1000; // 5 minutes
+function emptyStatus(threadId) {
+    return {
+        threadId,
+        running: false,
+        stale: false,
+        toolCallCount: 0
+    };
+}
+export async function generationStatus(homeRoot, threadId) {
+    const safe = threadId.replace(/[^a-zA-Z0-9_-]/g, '');
+    if (!safe)
+        return emptyStatus(threadId);
+    const file = path.join(homeRoot, 'generation', `${safe}.generation.json`);
+    let raw;
+    try {
+        raw = await readFile(file, 'utf8');
+    }
+    catch {
+        return emptyStatus(threadId);
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return emptyStatus(threadId);
+    }
+    const base = {
+        threadId,
+        stage: typeof data.stage === 'string' ? data.stage : undefined,
+        heartbeatAt: typeof data.heartbeatAt === 'string' ? data.heartbeatAt : undefined,
+        startedAt: typeof data.startedAt === 'string' ? data.startedAt : undefined,
+        updatedAt: typeof data.updatedAt === 'string' ? data.updatedAt : undefined,
+        toolCallCount: typeof data.toolCallCount === 'number' ? data.toolCallCount : 0,
+        lastTool: data.lastTool === null || typeof data.lastTool === 'string'
+            ? data.lastTool
+            : undefined
+    };
+    if (base.stage && TERMINAL_STAGES.has(base.stage)) {
+        return { ...base, running: false, stale: false };
+    }
+    const hb = base.heartbeatAt ? Date.parse(base.heartbeatAt) : NaN;
+    const stale = !Number.isFinite(hb) || Date.now() - hb > STALE_MS;
+    return { ...base, running: true, stale };
+}
+//# sourceMappingURL=generation-status.js.map

package/dist/interfaces/http/server.d.ts

@@ -1,11 +1,17 @@
 import { type Server } from 'node:http';
-import { type CatalogPaths, type CatencePaths } from '../../runtime/index.js';
+import { type DetachedSyncSpawner, mergeOpenCodeGoConsoleProfiles, startDetachedSync, type CatalogPaths, type CatencePaths } from '../../runtime/index.js';
 export type CatenceHttpServerOptions = {
     /** A shared catalog for public servers. All data APIs then require athleteId. */
     catalogPaths?: CatalogPaths;
     /** Internal compatibility hook for tests and embedded single-store callers. */
     paths?: CatencePaths;
     allowedOrigins?: readonly string[];
+    /** Internal compatibility hook for tests: override the detached sync spawner. */
+    startSync?: typeof startDetachedSync;
+    /** Internal compatibility hook for tests: passed into the default startDetachedSync. */
+    syncSpawnProcess?: DetachedSyncSpawner;
+    /** Internal compatibility hook for tests: override OpenCode Go model discovery. */
+    mergeModels?: typeof mergeOpenCodeGoConsoleProfiles;
 };
 /**
  * Create Catence's local Streamable HTTP server.

package/dist/interfaces/http/server.js

@@ -1,7 +1,9 @@
 import { createServer } from 'node:http';
+import path from 'node:path';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { catenceRuntimeHealth, DashboardSnapshotService, jsonSafe, loadCatalog, openReadOnlyRepository, resolveAthlete, resolveCatalogPaths } from '../../runtime/index.js';
+import { catenceRuntimeHealth, DashboardSnapshotService, DetachedSyncBusyError, DETACHED_SYNC_PROVIDERS, jsonSafe, loadCatalog, mergeOpenCodeGoConsoleProfiles, openReadOnlyRepository, resolveAthlete, resolveCatalogPaths, startDetachedSync, syncProgress, } from '../../runtime/index.js';
 import { createCatenceMcpServer } from '../mcp/server.js';
+import { generationStatus } from './generation-status.js';
 const MAX_REQUEST_BYTES = 1_000_000;
 function json(response, statusCode, value) {
     const body = JSON.stringify(jsonSafe(value));
@@ -85,6 +87,84 @@ async function dashboardPaths(catalogPaths, staticPaths, url) {
         return staticPaths;
     throw new Error('No Catence data store is configured.');
 }
+function parseSyncBody(body) {
+    if (body === undefined)
+        return {};
+    if (typeof body !== 'object' || body === null || Array.isArray(body))
+        throw new Error('Request body must be a JSON object.');
+    const raw = body;
+    for (const key of Object.keys(raw)) {
+        if (!['athleteId', 'provider', 'from', 'refresh', 'refreshModels'].includes(key)) {
+            throw new Error(`Unknown sync field: ${key}.`);
+        }
+    }
+    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.');
+    }
+    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.');
+    }
+    for (const flag of ['refresh', 'refreshModels']) {
+        if (raw[flag] !== undefined && typeof raw[flag] !== 'boolean')
+            throw new Error(`${flag} must be a boolean.`);
+    }
+    return raw;
+}
+async function resolveSyncPaths(catalogPaths, staticPaths, body) {
+    if (catalogPaths) {
+        if (!body.athleteId)
+            throw new Error('athleteId is required. Call /api/v1/athletes to inspect the configured catalog.');
+        return (await resolveAthlete(catalogPaths, body.athleteId)).paths;
+    }
+    if (staticPaths)
+        return staticPaths;
+    throw new Error('No Catence data store is configured.');
+}
+/** Best-effort last-success timestamps; null while a run holds the write lock. */
+async function lastSyncSummary(paths) {
+    const completedAtIso = (value) => {
+        if (value instanceof Date)
+            return Number.isNaN(value.getTime()) ? null : value.toISOString();
+        if (typeof value === 'string' && value.trim())
+            return value;
+        return null;
+    };
+    try {
+        // Read-only repository on purpose: it exposes per-run history (`syncRuns`)
+        // and degrades through the typed lock-conflict error while a detached
+        // sync holds DuckDB's single-writer lock. The write-capable dataStatus()
+        // would both block here and has no run history at all.
+        const repository = await openReadOnlyRepository(paths);
+        try {
+            const status = await repository.status();
+            const runs = Array.isArray(status.syncRuns) ? status.syncRuns : [];
+            const completed = runs.filter((run) => String(run.status ?? '').startsWith('completed') && completedAtIso(run.completed_at));
+            const providers = {};
+            let lastCompletedAt = null;
+            for (const run of completed) {
+                const completedAt = completedAtIso(run.completed_at);
+                const provider = String(run.provider ?? 'unknown');
+                if (!providers[provider] || providers[provider] < completedAt)
+                    providers[provider] = completedAt;
+                if (!lastCompletedAt || lastCompletedAt < completedAt)
+                    lastCompletedAt = completedAt;
+            }
+            return { lastCompletedAt, providers, recentRuns: runs.slice(0, 5) };
+        }
+        finally {
+            await repository.close();
+        }
+    }
+    catch {
+        // Best-effort by contract: while a detached sync holds the single-writer
+        // DuckDB lock, even opening a snapshot fails cross-process. Progress (from
+        // sidecar heartbeats) must still reach the dashboard, so any failure here
+        // degrades to "no last-sync summary" instead of failing /sync/status.
+        return null;
+    }
+}
 async function handleMcpRequest(request, response, paths) {
     if (request.method !== 'POST') {
         methodNotAllowed(response);
@@ -143,6 +223,8 @@ export function createCatenceHttpServer(options = {}) {
     const catalogPaths = options.catalogPaths ?? (options.paths ? null : resolveCatalogPaths());
     const staticPaths = options.paths ?? null;
     const allowedOrigins = options.allowedOrigins ?? [];
+    const startSync = options.startSync ?? startDetachedSync;
+    const mergeModels = options.mergeModels ?? mergeOpenCodeGoConsoleProfiles;
     return createServer((request, response) => {
         void (async () => {
             if (!addCorsHeaders(request, response, allowedOrigins)) {
@@ -158,6 +240,10 @@ export function createCatenceHttpServer(options = {}) {
                 json(response, 200, catenceRuntimeHealth());
                 return;
             }
+            if (pathname === '/api/v1/health' && request.method === 'GET') {
+                json(response, 200, catenceRuntimeHealth());
+                return;
+            }
             if (pathname === '/api/v1/athletes' && request.method === 'GET') {
                 if (!catalogPaths) {
                     json(response, 200, { defaultAthleteId: 'local', athletes: [{ id: 'local', label: 'Local athlete' }] });
@@ -182,6 +268,103 @@ export function createCatenceHttpServer(options = {}) {
                 }
                 return;
             }
+            if (pathname === '/api/v1/sync' && request.method === 'POST') {
+                let body;
+                try {
+                    body = parseSyncBody(await readJsonBody(request));
+                    const paths = await resolveSyncPaths(catalogPaths, staticPaths, body);
+                    // Optional model self-discovery runs before the data sync so new
+                    // OpenCode Go models appear without a manual script run. Failure is
+                    // non-fatal: it must never block or fail a data sync. The Console
+                    // reads <CATENCE_HOME>/config.json, so catalog deployments merge
+                    // into the catalog root's config instead of the athlete store.
+                    const discoveryConfigPath = catalogPaths ? path.join(catalogPaths.root, 'config.json') : paths.config;
+                    let discoveryWarning = null;
+                    if (body.refreshModels) {
+                        try {
+                            await mergeModels({ configPath: discoveryConfigPath, setDefault: false });
+                        }
+                        catch (error) {
+                            discoveryWarning = `OpenCode Go model discovery failed; profiles were left unchanged (${error instanceof Error ? error.message : String(error)}).`;
+                        }
+                    }
+                    const handle = await startSync({
+                        paths,
+                        athleteId: body.athleteId ?? 'local',
+                        provider: body.provider,
+                        from: body.from,
+                        refresh: body.refresh,
+                        // The child resolves the athlete within the catalog, not within
+                        // the athlete store this route resolved for locks and logs.
+                        cliHome: catalogPaths ? catalogPaths.root : undefined,
+                    }, { spawnProcess: options.syncSpawnProcess });
+                    json(response, 202, { ...handle, ...(discoveryWarning ? { warning: discoveryWarning } : {}), progressEndpoint: '/api/v1/sync/status' });
+                }
+                catch (error) {
+                    json(response, error instanceof DetachedSyncBusyError ? 409 : 400, {
+                        error: {
+                            code: error instanceof DetachedSyncBusyError ? 'sync_in_progress' : 'sync_start_failed',
+                            message: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                }
+                return;
+            }
+            if (pathname === '/api/v1/models/discover' && request.method === 'POST') {
+                // Refresh the OpenCode Go profiles without starting a data sync. The
+                // Console's Models page calls this behind its authenticated proxy.
+                try {
+                    const body = await readJsonBody(request).catch(() => ({}));
+                    const raw = (body ?? {});
+                    if (raw.setDefault !== undefined && typeof raw.setDefault !== 'boolean')
+                        throw new Error('setDefault must be a boolean.');
+                    const configPath = catalogPaths ? path.join(catalogPaths.root, 'config.json') : staticPaths?.config;
+                    if (!configPath)
+                        throw new Error('No Catence data store is configured.');
+                    json(response, 200, jsonSafe(await mergeModels({ configPath, setDefault: raw.setDefault === true })));
+                }
+                catch (error) {
+                    json(response, 400, { error: { code: 'model_discovery_failed', message: error instanceof Error ? error.message : String(error) } });
+                }
+                return;
+            }
+            if (pathname === '/api/v1/sync/status' && request.method === 'GET') {
+                try {
+                    const url = new URL(request.url ?? '/', 'http://localhost');
+                    const paths = await dashboardPaths(catalogPaths, staticPaths, url);
+                    const athleteId = catalogPaths ? (await resolveAthlete(catalogPaths, url.searchParams.get('athleteId') ?? '')).athlete.id : 'local';
+                    json(response, 200, { athleteId, progress: await syncProgress(paths), lastSync: await lastSyncSummary(paths) });
+                }
+                catch (error) {
+                    json(response, 400, { error: { code: 'sync_status_unavailable', message: error instanceof Error ? error.message : String(error) } });
+                }
+                return;
+            }
+            if (pathname.startsWith('/api/v1/threads/') &&
+                pathname.endsWith('/generation') &&
+                request.method === 'GET') {
+                try {
+                    const segments = pathname.split('/').filter(Boolean);
+                    const threadId = segments[segments.length - 2];
+                    if (!threadId)
+                        throw new Error('Missing threadId in request path.');
+                    const base = (catalogPaths ?? staticPaths ?? resolveCatalogPaths());
+                    const root = base?.root;
+                    if (!root || typeof root !== 'string') {
+                        throw new Error('No Catence data store is configured.');
+                    }
+                    json(response, 200, await generationStatus(root, threadId));
+                }
+                catch (error) {
+                    json(response, 400, {
+                        error: {
+                            code: 'generation_status_unavailable',
+                            message: error instanceof Error ? error.message : String(error)
+                        }
+                    });
+                }
+                return;
+            }
             if (pathname === '/mcp') {
                 await handleMcpRequest(request, response, catalogPaths ?? staticPaths ?? resolveCatalogPaths());
                 return;

package/dist/interfaces/mcp/main.js

@@ -1,11 +1,42 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { existsSync } from 'node:fs';
-import { addAthlete, athleteStorePaths, createDemoStore, defaultCatalogHome, initializeCatalog, loadCatalog, resolveCatalogPaths } from '../../runtime/index.js';
+import { addAthlete, athleteStorePaths, CatenceDatabase, createDemoStore, defaultCatalogHome, initializeCatalog, loadCatalog, resolveCatalogPaths } from '../../runtime/index.js';
 import { parseServeCliOptions, SERVE_USAGE } from '../http/cli-options.js';
 import { createCatenceHttpServer } from '../http/server.js';
 import { MCP_USAGE, parseMcpCliOptions } from './cli-options.js';
 import { createCatenceMcpServer } from './server.js';
+async function migrateCatalogStores(home) {
+    // On Docker image bumps the DuckDB schema version increases. The
+    // read-only MCP health probe would otherwise report "version X required"
+    // until the next manual sync. Proactively opening each athlete store in
+    // writable mode runs the idempotent migrations (database.ts:migrate)
+    // before the HTTP server starts listening, so a plain `docker compose up`
+    // after `deploy-console.sh beta` heals existing installs without an extra
+    // manual `catence-data migrate --all` step. Failures are best-effort:
+    // a missing catalog or a store still locked by another process is retried
+    // on the next sync or health check.
+    try {
+        const catalogPaths = resolveCatalogPaths(home);
+        const catalog = await loadCatalog(catalogPaths).catch(() => null);
+        if (!catalog || catalog.athletes.length === 0)
+            return;
+        for (const athlete of catalog.athletes) {
+            const paths = athleteStorePaths(catalogPaths, athlete.id);
+            try {
+                const database = await CatenceDatabase.open(paths);
+                await database.close();
+            }
+            catch {
+                // Best-effort: a lock or a corrupted store must not prevent the
+                // server from starting; the next sync will retry the migration.
+            }
+        }
+    }
+    catch {
+        // Catalog read failures are non-fatal for startup.
+    }
+}
 async function run() {
     const arguments_ = process.argv.slice(2);
     if (arguments_[0] === 'serve') {
@@ -14,6 +45,7 @@ async function run() {
             process.stderr.write(`${SERVE_USAGE}\n`);
             return;
         }
+        await migrateCatalogStores(options.home);
         const httpServer = createCatenceHttpServer({
             catalogPaths: resolveCatalogPaths(options.home),
             allowedOrigins: options.allowedOrigins,

package/dist/interfaces/mcp/server.d.ts

@@ -1,8 +1,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { type CatalogPaths, hydrateStravaActivity, type CatencePaths } from '../../runtime/index.js';
+import { type CatalogPaths, hydrateStravaActivity, startDetachedSync, type CatencePaths } from '../../runtime/index.js';
 type StravaActivityHydrator = typeof hydrateStravaActivity;
 type McpDependencies = {
     hydrateStravaActivity?: StravaActivityHydrator;
+    startDetachedSync?: typeof startDetachedSync;
 };
 export declare function createCatenceMcpServer(paths?: CatencePaths | CatalogPaths, dependencies?: McpDependencies): McpServer;
 export {};