catence 0.2.0-beta.1 → 0.2.0-beta.10

package/README.md

@@ -22,7 +22,7 @@ Catence helps explore recovery, training load, trends, activity detail, swimming
 
 ## Quick start
 
-Install Catence and create the first athlete. The default catalog home is `~/.catence`; set `CATENCE_HOME` or pass `--home` to use a different location.
+Install Catence and create the first athlete. The default catalog home is `~/.catence`; set `CATENCE_HOME` or pass `--home` to use a different location. For the full local or Docker deployment walkthrough, see [deployment notes](docs/deployment.md).
 
 ```sh
 npm install --global catence@0.2.0
@@ -88,18 +88,77 @@ catence-data --athlete alex sync --provider intervals
 catence-data --athlete alex sync --provider garmin --from 2025-07-29
 catence-data --athlete alex backfill --provider garmin --from 2020-01-01 --refresh
 catence-data --athlete alex retry --run <run-id>
+catence-data --athlete alex progress --watch    # follow an active sync run live
 
 # Strava OAuth uses clientId and clientSecret previously stored for this athlete
 catence-data --athlete alex auth strava --callback
 catence-data --athlete alex disconnect strava
 
+# Update the runtime and Console together on the tracked release channel
+catence-data update --check
+catence-data update
+
 # Choose a non-default catalog location
 catence-data --home /srv/catence setup --athlete alex --label "Alex"
 catence --home /srv/catence
 ```
 
+`catence-data update` follows the channel of the installed runtime: a beta
+install tracks the npm `beta` tag and the matching PyPI prereleases, a stable
+install tracks `latest`. Pass `--channel stable` to move off a beta. The command
+replaces the global `catence` package and installs or upgrades
+`catence-console` with `uv tool` when `uv` is available; `--check` only reports.
+
 Register `http://127.0.0.1:8765/strava/callback` with the Strava application for the callback flow. The manual `auth strava --code <authorization-code>` flow remains available for headless environments.
 
+## Background sync and live progress
+
+Long Garmin backfills fetch hundreds of days of data and can take 20-30+ minutes. Sync runs stream worker output to the console in real time, tolerate Ctrl+C and SSH/terminal deaths cleanly, and expose a live progress heartbeat you can follow from the CLI, the MCP server, or a Docker helper.
+
+### What happens during a run
+
+When a sync starts, Catence creates a row in `sync_runs` with status `running` and begins persisting heartbeats to the `sync_run_progress` table (schema migration 14). The Garmin staging worker emits one compact JSON progress record every few seconds on stdout; the runtime parses it, normalizes it, and upserts it. Even if the worker cannot emit — for example while stuck in login — the runtime persists a 30-second fallback heartbeat so a run is always observable and never falsely looks stale.
+
+Each progress record follows the same contract:
+
+- `runId`, `provider` — which run the record belongs to
+- `stage` — `starting`, `login`, `singletons`, `daily`, `range`, `ftp_history`, `max_metrics`, `hrv_history`, `scores`, `activities`, `collections` while extracting; `completed` on success; `failed`, `interrupted`, or `timed_out` as terminal states written by the runtime
+- `currentStep` — the endpoint, date, or activity being fetched right now
+- `completedUnits` / `totalUnits` — for example days fetched out of the total days in the window
+- `percentComplete` — 0 to 100
+- `elapsedSeconds` / `estimatedRemainingSeconds` — the ETA is computed once the run has a known total and has completed at least one unit
+- `heartbeatAt` — UTC ISO timestamp of the record
+
+### Interruption and stale-run recovery
+
+- SIGINT, SIGTERM, and SIGHUP (Ctrl+C, terminal close, `kill`) are trapped on both the Node runtime and the Python worker. The child stops between days and the run is marked `interrupted` in `sync_runs` — never a zombie `running` row — and the process exits with 130/143/129.
+- Before every sync or retry, runs still stuck in `running` for more than 15 minutes are marked `timed_out` (with `completed_at` set), so a dead SSH session cannot block later syncs.
+- Resume a failed or interrupted run without re-reading history with `retry --run <run-id>`.
+
+### Watching progress
+
+```sh
+catence-data --athlete alex progress          # one-shot JSON snapshot
+catence-data --athlete alex progress --watch  # live view; exits when no run is active
+```
+
+`--watch` renders a compact progress table on a TTY and exits when the last active run finishes; piped output stays JSON.
+
+The read-only MCP tool `catence_sync_progress` returns the same snapshot — active runs with their latest heartbeat plus the most recent runs — and takes `athleteId` like every other personal-data tool.
+
+### Docker deployments
+
+`scripts/deploy-console.sh` generates a `sync.sh` helper that gained a `progress` command and a `--detach` flag:
+
+```sh
+cd catence-deploy
+./sync.sh --athlete alex sync --detach     # start the run in the background and return
+./sync.sh --athlete alex progress --watch  # follow it live
+./sync.sh --athlete alex progress          # one-shot snapshot
+```
+
+`--detach` works with `backfill` too. A detached run keeps streaming into the container logs (`docker compose -f catence-deploy/docker-compose.yml logs -f console`) and keeps writing heartbeats, so it survives the shell that started it and is recoverable by the next sync.
+
 ## Safe demo and Glama
 
 Run a clearly marked generated dataset without provider accounts:
@@ -153,7 +212,7 @@ export OPENAI_API_KEY='…'
 uvx catence-console@0.2.0 serve
 ```
 
-On the first authenticated visit, the Console wizard asks for an Azure, OpenAI, or Anthropic model and writes only the non-secret model configuration to `~/.catence/config.json`. Model-provider keys remain process environment variables. The Console settings include an athlete selector; the server overwrites model-supplied athlete scope with that selected value on every personal-data call.
+On the first authenticated visit, the Console wizard asks for an OpenAI-compatible, OpenAI, or Anthropic model and writes only the non-secret model configuration to `~/.catence/config.json`. The `openai-compatible` option covers Azure and Opencode; see [`docs/llm-providers.md`](docs/llm-providers.md). Model-provider keys remain process environment variables. The Console settings include an athlete selector; the server overwrites model-supplied athlete scope with that selected value on every personal-data call.
 
 To preflight the Console and a running runtime:
 
@@ -186,10 +245,77 @@ docker run --rm -it -v catence-data:/data --entrypoint catence-data catence-cons
 
 Use the same `--entrypoint catence-data` pattern for `secret set` and `sync`. Route a Cloudflare Tunnel to `http://127.0.0.1:8000`; do not run a tunnel client in this image. Use HTTPS at the tunnel and retain the Console login—the dashboard is fetched through the authenticated Console origin rather than directly from port 8787.
 
+[`scripts/deploy-console.sh`](scripts/deploy-console.sh) deploys this stack from
+the public registries and seeds a starter `config.json` (the Console model
+profiles from [`config.example.json`](config.example.json)) into the data
+volume, so the settings panel works before the first chat. Edit
+`/data/config.json` in the volume (or the bind-mounted `--home` directory) to
+change models and defaults, or discover OpenCode Go profiles from the image:
+
+```sh
+docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm \
+  --entrypoint node console \
+  /usr/local/lib/node_modules/catence/scripts/discover-opencode-go.mjs --write /data/config.json
+```
+
 ## Configuration
 
 [`config.example.json`](config.example.json) documents rate limits, Strava budgets, and Console model profiles. It intentionally contains environment-variable names rather than credential values. Keep per-athlete provider values in `catence-data secret set`, not in `.env` or `config.json`.
 
+### Per-model reasoning effort
+
+Models that support reasoning effort can set a fixed level per model in `config.json`, or expose a per-chat **Thinking effort** dropdown with custom levels via `variants`.
+
+**Fixed level** (all requests for the model use it):
+
+```json
+{
+  "console": {
+    "profiles": {
+      "opencode-zen": {
+        "label": "OpenCode Zen",
+        "defaultModel": "deepseek-v4-flash-free",
+        "models": {
+          "deepseek-v4-flash-free": {
+            "label": "DeepSeek V4 Flash Free",
+            "model": "openai/deepseek-v4-flash-free",
+            "reasoningEffort": "high"
+          }
+        },
+        "apiKeyEnv": "OPENCODE_API_KEY",
+        "apiBaseEnv": "OPENCODE_ZEN_API_BASE"
+      }
+    }
+  }
+}
+```
+
+**Custom variants** (per-chat dropdown): `variants` maps each dropdown label to the value sent to the provider. This is how non-OpenAI models (for example DeepSeek V4 Flash, which uses its own Default/High/Max scheme rather than the OpenAI-standard list) expose their native levels:
+
+```json
+"deepseek-v4-flash-free": {
+  "label": "DeepSeek V4 Flash Free",
+  "model": "openai/deepseek-v4-flash-free",
+  "variants": { "High": "high", "Max": "max" }
+}
+```
+
+With `variants`, the chat **Thinking effort** dropdown shows `Provider default` plus each label; selecting one sends that exact value (e.g. `reasoning_effort: "high"`). Without `variants`, the dropdown falls back to the OpenAI-standard set (`minimal`, `low`, `medium`, `high`, `xhigh`).
+
+**Disabling reasoning effort**: an explicitly empty `variants` map (`"variants": {}`) disables the feature for that model — no `reasoning_effort` is ever sent and the **Thinking effort** dropdown is greyed out. This is how models that reject the parameter (for example MiMo, which expects its own `thinking` toggle) are configured:
+
+```json
+"mimo-v2.5": {
+  "label": "MiMo V2.5",
+  "model": "openai/mimo-v2.5",
+  "variants": {}
+}
+```
+
+A model cannot combine `variants: {}` with a fixed `reasoningEffort`.
+
+A fixed `reasoningEffort` overrides any profile-level `defaultReasoningEffort`; the per-chat dropdown selection (a variant value) overrides both. If nothing is set, the provider default is used. The dropdown options always follow the model currently selected in the **Model** dropdown.
+
 For source development:
 
 ```sh
@@ -215,3 +341,19 @@ data.
 Garmin is the primary source for activity and wellness data; Intervals.icu supplements training analysis; Strava is used for targeted segments, efforts, and gear. Missing fields mean a provider did not supply a value. The source credentials and source APIs determine the data available. Catence does not use the official Garmin API; Garmin sync relies on the selected athlete’s email/password credentials.
 
 See [distribution notes](docs/distribution.md) for release artifacts, including APM and MCPB demo bundles.
+
+##
+
+```bash
+cd catence-deploy
+docker compose -f docker-compose.yml --env-file .env exec console \
+  catence-data sync --athlete martina --provider all --home /data        # incremental sync, all providers
+docker compose -f docker-compose.yml --env-file .env exec console \
+  catence-data backfill --athlete martina --from 2026-01-01 --home /data # full backfill from a date
+docker compose -f docker-compose.yml --env-file .env exec console \
+  catence-data status --athlete martina --home /data                     # coverage/errors
+docker compose -f docker-compose.yml --env-file .env exec console \
+  catence-data progress --athlete martina --home /data --watch           # live sync progress
+docker compose -f docker-compose.yml --env-file .env exec console \
+  catence-data athlete list --home /data                                 # list athlete IDs
+```

package/config.example.json

@@ -23,40 +23,52 @@
     }
   },
   "console": {
-    "defaultProfile": "azure-foundry",
+    "defaultProfile": "openai",
     "limits": {
       "toolRounds": 8,
       "toolResultCharacters": 24000
     },
     "profiles": {
-      "azure-foundry": {
-        "label": "Azure Foundry",
-        "defaultModel": "terra",
-        "defaultReasoningEffort": "medium",
-        "models": {
-          "terra": { "label": "GPT-5.6 Terra", "model": "azure_ai/gpt-5.6-terra" },
-          "luna": { "label": "GPT-5.6 Luna", "model": "azure_ai/gpt-5.6-luna" },
-          "sol": { "label": "GPT-5.6 Sol", "model": "azure_ai/gpt-5.6-sol" }
-        },
-        "apiKeyEnv": "AZURE_API_KEY",
-        "apiBaseEnv": "AZURE_API_BASE",
-        "apiVersionEnv": "AZURE_API_VERSION"
-      },
-      "opencode": {
-        "label": "OpenCode-compatible",
-        "model": "openai/your-model-name",
-        "apiKeyEnv": "OPENCODE_API_KEY",
-        "apiBaseEnv": "OPENCODE_API_BASE"
-      },
       "openai": {
         "label": "OpenAI",
         "model": "openai/gpt-5-mini",
         "apiKeyEnv": "OPENAI_API_KEY"
       },
+      "openai-compatible": {
+        "label": "OpenAI-compatible",
+        "model": "openai/your-model-name",
+        "apiKeyEnv": "OPENAI_API_KEY",
+        "apiBaseEnv": "OPENAI_API_BASE"
+      },
       "anthropic": {
         "label": "Anthropic",
         "model": "anthropic/claude-sonnet-4-5",
         "apiKeyEnv": "ANTHROPIC_API_KEY"
+      },
+      "opencode-zen": {
+        "label": "OpenCode Zen",
+        "defaultModel": "deepseek-v4-flash-free",
+        "models": {
+          "deepseek-v4-flash-free": {
+            "label": "DeepSeek V4 Flash Free",
+            "model": "openai/deepseek-v4-flash-free",
+            "variants": { "High": "high", "Max": "max" }
+          },
+          "nemotron-3-ultra-free": { "label": "Nemotron 3 Ultra Free", "model": "openai/nemotron-3-ultra-free" },
+          "big-pickle": { "label": "Big Pickle", "model": "openai/big-pickle" }
+        },
+        "apiKeyEnv": "OPENCODE_API_KEY",
+        "apiBaseEnv": "OPENCODE_ZEN_API_BASE"
+      },
+      "opencode-zen-responses": {
+        "label": "OpenCode Zen (Responses)",
+        "defaultModel": "gpt-5.6-luna",
+        "models": {
+          "gpt-5.6-luna": { "label": "GPT 5.6 Luna", "model": "openai/responses/gpt-5.6-luna" },
+          "gpt-5.6-terra": { "label": "GPT 5.6 Terra", "model": "openai/responses/gpt-5.6-terra" }
+        },
+        "apiKeyEnv": "OPENCODE_API_KEY",
+        "apiBaseEnv": "OPENCODE_ZEN_RESPONSES_API_BASE"
       }
     }
   }

package/dist/contracts/index.d.ts

@@ -1,3 +1,4 @@
+export * from './progress.js';
 export * from './runtime.js';
 export * from './release.js';
 export * from './staging.js';

package/dist/contracts/index.js

@@ -1,3 +1,4 @@
+export * from './progress.js';
 export * from './runtime.js';
 export * from './release.js';
 export * from './staging.js';

package/dist/contracts/progress.d.ts

@@ -0,0 +1,23 @@
+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", "importing", "completed", "interrupted", "failed", "timed_out"];
+export type SyncStage = (typeof SYNC_STAGES)[number];
+export interface SyncProgressState {
+    runId: string;
+    provider: string;
+    stage: SyncStage;
+    currentStep: string | null;
+    completedUnits: number;
+    totalUnits: number | null;
+    percentComplete: number;
+    elapsedSeconds: number;
+    estimatedRemainingSeconds: number | null;
+    heartbeatAt: string;
+}
+export interface SyncProgressSnapshot {
+    running: SyncProgressState[];
+    recent: SyncProgressState[];
+}
+export interface InterruptedRuns {
+    runIds: string[];
+}
+export declare function normalizeProgress(value: unknown): SyncProgressState | null;

package/dist/contracts/progress.js

@@ -0,0 +1,48 @@
+export const STALE_RUN_TIMEOUT_MS = 15 * 60 * 1000;
+export const SYNC_STAGES = [
+    'starting',
+    'login',
+    'singletons',
+    'daily',
+    'range',
+    'ftp_history',
+    'max_metrics',
+    'hrv_history',
+    'scores',
+    'activities',
+    'collections',
+    'importing',
+    'completed',
+    'interrupted',
+    'failed',
+    'timed_out',
+];
+export function normalizeProgress(value) {
+    if (typeof value !== 'object' || value === null) {
+        return null;
+    }
+    const record = value;
+    const runId = typeof record.runId === 'string' ? record.runId : '';
+    const provider = typeof record.provider === 'string' ? record.provider : '';
+    if (!runId || !provider) {
+        return null;
+    }
+    const stage = SYNC_STAGES.includes(record.stage)
+        ? record.stage
+        : 'starting';
+    const numberOr = (value, fallback) => typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+    const roundOrNull = (value) => typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.round(value)) : null;
+    return {
+        runId,
+        provider,
+        stage,
+        currentStep: typeof record.currentStep === 'string' ? record.currentStep : null,
+        completedUnits: Math.max(0, Math.round(numberOr(record.completedUnits, 0))),
+        totalUnits: roundOrNull(record.totalUnits),
+        percentComplete: Math.min(100, Math.max(0, numberOr(record.percentComplete, 0))),
+        elapsedSeconds: Math.max(0, numberOr(record.elapsedSeconds, 0)),
+        estimatedRemainingSeconds: roundOrNull(record.estimatedRemainingSeconds),
+        heartbeatAt: typeof record.heartbeatAt === 'string' ? record.heartbeatAt : new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=progress.js.map

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.0-beta.1";
+export declare const CATENCE_RUNTIME_VERSION = "0.2.0-beta.10";
 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.0-beta.1';
+export const CATENCE_RUNTIME_VERSION = '0.2.0-beta.10';
 export const CATENCE_PROTOCOL_VERSION = 1;
 export function catenceRuntimeHealth() {
     return {

package/dist/core/logging.d.ts

@@ -0,0 +1,16 @@
+import type { CatencePaths } from '../contracts/runtime.js';
+export type SyncLogger = {
+    info: (message: string, context?: Record<string, unknown>) => void;
+    warn: (message: string, context?: Record<string, unknown>) => void;
+    error: (message: string, context?: Record<string, unknown>) => void;
+    debug: (message: string, context?: Record<string, unknown>) => void;
+};
+/**
+ * Resolve the sync log file path.
+ *
+ * `CATENCE_LOG` may be an absolute path or a path relative to the catalog home.
+ * When unset (the default), logs go to stderr only so the console stays clean
+ * and stdout remains machine-readable for callers like sync.sh.
+ */
+export declare function resolveLogFile(paths: CatencePaths, environment?: NodeJS.ProcessEnv): string | null;
+export declare function createSyncLogger(paths: CatencePaths, environment?: NodeJS.ProcessEnv): SyncLogger;

package/dist/core/logging.js

@@ -0,0 +1,68 @@
+import { appendFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+const LEVEL_WEIGHT = { debug: 10, info: 20, warn: 30, error: 40 };
+function configuredLevel(environment = process.env) {
+    const raw = (environment.CATENCE_LOG_LEVEL ?? 'info').toLowerCase();
+    if (raw === 'debug')
+        return LEVEL_WEIGHT.debug;
+    if (raw === 'warn')
+        return LEVEL_WEIGHT.warn;
+    if (raw === 'error')
+        return LEVEL_WEIGHT.error;
+    return LEVEL_WEIGHT.info;
+}
+/**
+ * Resolve the sync log file path.
+ *
+ * `CATENCE_LOG` may be an absolute path or a path relative to the catalog home.
+ * When unset (the default), logs go to stderr only so the console stays clean
+ * and stdout remains machine-readable for callers like sync.sh.
+ */
+export function resolveLogFile(paths, environment = process.env) {
+    const configured = environment.CATENCE_LOG;
+    if (!configured)
+        return null;
+    return path.isAbsolute(configured) ? configured : path.join(paths.root, configured);
+}
+export function createSyncLogger(paths, environment = process.env) {
+    const threshold = configuredLevel(environment);
+    const logFile = resolveLogFile(paths, environment);
+    const write = (level, message, context) => {
+        if (LEVEL_WEIGHT[level] < threshold)
+            return;
+        const line = formatLogLine(level, message, context);
+        process.stderr.write(`${line}\n`);
+        if (logFile) {
+            // Fire-and-forget: never block a sync run on log persistence.
+            appendLogLine(logFile, `${line}\n`).catch(() => { });
+        }
+    };
+    return {
+        info: (message, context) => write('info', message, context),
+        warn: (message, context) => write('warn', message, context),
+        error: (message, context) => write('error', message, context),
+        debug: (message, context) => write('debug', message, context),
+    };
+}
+function formatLogLine(level, message, context) {
+    const timestamp = new Date().toISOString();
+    const tag = level.toUpperCase().padEnd(5);
+    let line = `[${timestamp}] [${tag}] ${message}`;
+    if (context && Object.keys(context).length > 0) {
+        line += ` ${serializeContext(context)}`;
+    }
+    return line;
+}
+function serializeContext(context) {
+    try {
+        return JSON.stringify(context);
+    }
+    catch {
+        return '';
+    }
+}
+let appendLogLine = async (file, line) => {
+    await mkdir(path.dirname(file), { recursive: true });
+    await appendFile(file, line, 'utf8');
+};
+//# sourceMappingURL=logging.js.map

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

@@ -1,4 +1,5 @@
 import type { CatencePaths } from '../../contracts/runtime.js';
+import { type SyncProgressSnapshot } from '../../contracts/progress.js';
 import type { QueryValues, ReadDataStore } from '../../contracts/storage.js';
 import { type DatasetDefinition } from './catalog.js';
 export declare class ReadOnlyRepository {
@@ -10,6 +11,7 @@ export declare class ReadOnlyRepository {
     datasetRelation(datasetName: string): Promise<string>;
     activitySampleRelation(): Promise<string>;
     status(): Promise<Record<string, unknown>>;
+    progress(): Promise<SyncProgressSnapshot>;
     coverage(): Promise<Record<string, unknown>>;
     activity(activityId: string): Promise<Record<string, unknown> | null>;
     summary(startDate: string, endDate: string): Promise<Record<string, unknown>>;

package/dist/core/query/repository.js

@@ -1,5 +1,6 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { SYNC_STAGES } from '../../contracts/progress.js';
 import { sqlString } from './sql.js';
 import { DATASET_CATALOG, getDataset } from './catalog.js';
 export class ReadOnlyRepository {
@@ -137,6 +138,33 @@ export class ReadOnlyRepository {
             incrementalCursors: cursors,
         };
     }
+    async progress() {
+        // Same sequential-read discipline as status(): the shared native
+        // connection must not run these small reads concurrently.
+        const running = await this.rows(`
+      SELECT runs.run_id, runs.provider, coalesce(progress.stage, 'starting') AS stage,
+        progress.current_step,
+        coalesce(progress.completed_units, 0) AS completed_units,
+        progress.total_units,
+        coalesce(progress.percent, 0) AS percent,
+        coalesce(progress.elapsed_seconds, 0) AS elapsed_seconds,
+        progress.estimated_remaining_seconds,
+        cast(coalesce(progress.heartbeat_at, runs.started_at) AS VARCHAR) AS heartbeat_at
+      FROM sync_runs AS runs
+      LEFT JOIN sync_run_progress AS progress USING (run_id)
+      WHERE runs.status = 'running'
+      ORDER BY runs.started_at DESC
+    `);
+        const recent = await this.rows(`
+      SELECT run_id, provider, stage, current_step, completed_units, total_units, percent,
+        elapsed_seconds, estimated_remaining_seconds,
+        cast(heartbeat_at AS VARCHAR) AS heartbeat_at
+      FROM sync_run_progress
+      ORDER BY heartbeat_at DESC
+      LIMIT 10
+    `);
+        return { running: running.map(toSyncProgressState), recent: recent.map(toSyncProgressState) };
+    }
     async coverage() {
         const rows = await this.rows(`
       SELECT 'activities' AS dataset, min(cast(started_at_utc AS DATE)) AS start_date, max(cast(started_at_utc AS DATE)) AS end_date, count(*)::INTEGER AS row_count FROM activities
@@ -166,6 +194,20 @@ export class ReadOnlyRepository {
         return Object.values(DATASET_CATALOG);
     }
 }
+function toSyncProgressState(row) {
+    return {
+        runId: row.run_id,
+        provider: row.provider,
+        stage: SYNC_STAGES.includes(row.stage) ? row.stage : 'starting',
+        currentStep: row.current_step,
+        completedUnits: Math.max(0, Number(row.completed_units) || 0),
+        totalUnits: row.total_units === null || row.total_units === undefined ? null : Math.max(0, Number(row.total_units) || 0),
+        percentComplete: Math.min(100, Math.max(0, Number(row.percent) || 0)),
+        elapsedSeconds: Math.max(0, Number(row.elapsed_seconds) || 0),
+        estimatedRemainingSeconds: row.estimated_remaining_seconds === null || row.estimated_remaining_seconds === undefined ? null : Math.max(0, Number(row.estimated_remaining_seconds) || 0),
+        heartbeatAt: row.heartbeat_at,
+    };
+}
 /** Converts DuckDB's Date/BigInt values into MCP-safe JSON values. */
 export function jsonSafe(value) {
     if (typeof value === 'bigint')

package/dist/core/runtime/catalog.js

@@ -40,9 +40,8 @@ export function athleteStorePaths(catalogPaths, athleteId) {
 function legacyStoreMessage(paths) {
     return `Catence 0.2 uses a catalog at ${paths.root}. The existing directory looks like a 0.1 data store and cannot be migrated automatically. Create a fresh catalog and re-sync each athlete.`;
 }
-async function hasEntries(directory) {
-    return (await readdir(directory).catch((error) => error.code === 'ENOENT' ? [] : Promise.reject(error))).length > 0;
-}
+/** Home-directory entries the Console creates on its own and must not block catalog initialization. */
+const CONSOLE_ARTIFACTS = new Set(['config.json', 'console', '.files', '.chainlit', 'public']);
 export async function loadCatalog(paths = resolveCatalogPaths()) {
     const contents = await readFile(paths.catalog, 'utf8').catch((error) => {
         if (error.code !== 'ENOENT')
@@ -68,10 +67,21 @@ async function writeCatalog(paths, catalog) {
 export async function initializeCatalog(paths = resolveCatalogPaths(), athlete) {
     if (existsSync(paths.catalog))
         return loadCatalog(paths);
-    if (await hasEntries(paths.root)) {
-        if (existsSync(path.join(paths.root, 'catence.duckdb')))
-            throw new Error(legacyStoreMessage(paths));
-        throw new Error(`Refusing to initialize ${paths.root}: choose an empty --home directory or remove its unrelated contents.`);
+    let entries;
+    try {
+        entries = await readdir(paths.root);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            entries = [];
+        else
+            throw error;
+    }
+    if (entries.includes('catence.duckdb'))
+        throw new Error(legacyStoreMessage(paths));
+    const unrelated = entries.filter((entry) => !CONSOLE_ARTIFACTS.has(entry));
+    if (unrelated.length > 0) {
+        throw new Error(`Refusing to initialize ${paths.root}: found ${unrelated.join(', ')}. Remove these or choose an empty --home directory.`);
     }
     const id = athleteIdSchema.parse(athlete.id);
     const record = { id, label: athlete.label.trim(), createdAt: new Date().toISOString() };

package/dist/core/runtime/self-update.d.ts

@@ -0,0 +1,44 @@
+export type UpdateChannel = 'stable' | 'beta';
+export type ParsedRelease = {
+    major: number;
+    minor: number;
+    patch: number;
+    /** Present only for prerelease builds; a stable release beats every beta of the same tuple. */
+    beta?: number;
+};
+export type SelfUpdatePlan = {
+    channel: UpdateChannel;
+    runtime: {
+        current: string;
+        target?: string;
+        updateAvailable: boolean;
+    };
+    console: {
+        installed?: string;
+        target?: string;
+        updateAvailable: boolean;
+    };
+    /** True when neither component has anything to apply. */
+    ok: boolean;
+};
+export declare function parseReleaseVersion(version: string): ParsedRelease | null;
+export declare function compareReleaseVersions(left: ParsedRelease, right: ParsedRelease): -1 | 0 | 1;
+export declare function channelForVersion(version: string): UpdateChannel;
+export declare function latestRelease(versions: string[], channel: UpdateChannel): string | undefined;
+export declare function planSelfUpdate(options: {
+    runtimeVersion: string;
+    channel: UpdateChannel;
+    npmDistTags: Record<string, string>;
+    pypiReleases: string[];
+    consoleInstalled?: string;
+}): SelfUpdatePlan;
+export declare function fetchNpmDistTags(packageName: string, fetchImpl?: typeof fetch): Promise<Record<string, string>>;
+export declare function fetchPypiReleases(packageName: string, fetchImpl?: typeof fetch): Promise<string[]>;
+/** Run an update command (npm or uv) with the user's terminal attached. */
+export declare function runSelfUpdateCommand(command: string, args: string[]): Promise<number>;
+export declare function hasCommand(command: string): Promise<boolean>;
+/** Read `catence-console --version` from PATH; undefined when the Console is not installed. */
+export declare function readInstalledConsoleVersion(): Promise<string | undefined>;
+/** Global npm package root, used to decide whether `catence` can update itself in place. */
+export declare function npmGlobalPrefix(): Promise<string | undefined>;
+export declare function isGlobalNpmInstall(moduleUrl: string, npmPrefix: string | undefined): boolean;