catence 0.2.0-beta.18 → 0.2.0-beta.19

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

package/dist/core/query/repository.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { SYNC_STAGES } from '../../contracts/progress.js';
-import { mergeProgress, readProgressSidecars } from '../../elt/storage/progress-sidecar.js';
+import { mergeProgress, readRunningProgress } from '../../elt/storage/progress-sidecar.js';
 import { sqlString } from './sql.js';
 import { DATASET_CATALOG, getDataset } from './catalog.js';
 export class ReadOnlyRepository {
@@ -165,9 +165,11 @@ export class ReadOnlyRepository {
       LIMIT 10
     `);
         // Merge with sidecar heartbeat files so an active Garmin run stays visible
-        // even while the same process holds the single-writer database lock.
-        const sidecars = await readProgressSidecars(this.paths);
-        return mergeProgress(running.map(toSyncProgressState), recent.map(toSyncProgressState), sidecars);
+        // even while the same process holds the single-writer database lock. The
+        // filtered reader guarantees a terminal or stale heartbeat can never read
+        // as an active run again, so a finished sync cannot block new ones.
+        const runningSidecars = await readRunningProgress(this.paths);
+        return mergeProgress(running.map(toSyncProgressState), recent.map(toSyncProgressState), runningSidecars);
     }
     async coverage() {
         const rows = await this.rows(`

package/dist/core/runtime/opencode-go.d.ts

@@ -42,8 +42,11 @@ export type OpenCodeGoMergeResult = {
  * Fetch the live OpenCode Go catalog and merge the two Console profiles into
  * `configPath`, preserving every other section plus existing console fields
  * (`limits`, other profiles) and the existing `defaultProfile` unless
- * `setDefault` is passed. The written file is re-validated with the same
- * strict schema the runtime applies on load, then replaced atomically.
+ * `setDefault` is passed. Model routing (`model`) is refreshed from the live
+ * catalog, while per-model customizations (custom label, `reasoningEffort`,
+ * `variants`) and models that disappeared upstream are kept. The written file
+ * is re-validated with the same strict schema the runtime applies on load,
+ * then replaced atomically.
  */
 export declare function mergeOpenCodeGoConsoleProfiles(options: {
     configPath: string;

package/dist/core/runtime/opencode-go.js

@@ -144,12 +144,29 @@ async function readConfigRoot(configPath) {
         throw error;
     }
 }
+/** Per-model fields a human may have customized after the initial discovery. */
+function preservedModelFields(previous) {
+    if (typeof previous !== 'object' || previous === null || Array.isArray(previous))
+        return {};
+    const raw = previous;
+    const preserved = {};
+    if (typeof raw.label === 'string' && raw.label.trim())
+        preserved.label = raw.label;
+    if (typeof raw.reasoningEffort === 'string')
+        preserved.reasoningEffort = raw.reasoningEffort;
+    if (raw.variants !== undefined)
+        preserved.variants = raw.variants;
+    return preserved;
+}
 /**
  * Fetch the live OpenCode Go catalog and merge the two Console profiles into
  * `configPath`, preserving every other section plus existing console fields
  * (`limits`, other profiles) and the existing `defaultProfile` unless
- * `setDefault` is passed. The written file is re-validated with the same
- * strict schema the runtime applies on load, then replaced atomically.
+ * `setDefault` is passed. Model routing (`model`) is refreshed from the live
+ * catalog, while per-model customizations (custom label, `reasoningEffort`,
+ * `variants`) and models that disappeared upstream are kept. The written file
+ * is re-validated with the same strict schema the runtime applies on load,
+ * then replaced atomically.
  */
 export async function mergeOpenCodeGoConsoleProfiles(options) {
     const baseUrl = options.baseUrl ?? OPENCODE_GO_DEFAULT_BASE_URL;
@@ -165,10 +182,41 @@ export async function mergeOpenCodeGoConsoleProfiles(options) {
     const defaultProfile = typeof existingConsole.defaultProfile === 'string' && existingConsole.defaultProfile && !options.setDefault
         ? existingConsole.defaultProfile
         : built.defaultProfile;
+    // Merge per model, not per profile: discovery owns routing and the id list,
+    // but a human's label, reasoningEffort, and variants must survive every
+    // re-discovery. Models that vanished upstream stay configured.
+    const mergedProfiles = {};
+    for (const [profileId, builtProfile] of Object.entries(built.profiles)) {
+        const previousProfile = existingProfiles[profileId];
+        const rawModels = typeof previousProfile === 'object' && previousProfile !== null
+            ? previousProfile.models
+            : undefined;
+        const previousModels = typeof rawModels === 'object' && rawModels !== null && !Array.isArray(rawModels)
+            ? rawModels
+            : {};
+        const models = { ...previousModels };
+        for (const [modelId, entry] of Object.entries(builtProfile.models)) {
+            models[modelId] = {
+                ...preservedModelFields(previousModels[modelId]),
+                label: entry.label,
+                model: entry.model,
+            };
+        }
+        const previousDefaultModel = typeof previousProfile === 'object' && previousProfile !== null
+            ? previousProfile.defaultModel
+            : undefined;
+        mergedProfiles[profileId] = {
+            ...builtProfile,
+            ...(typeof previousDefaultModel === 'string' && previousDefaultModel in models
+                ? { defaultModel: previousDefaultModel }
+                : {}),
+            models,
+        };
+    }
     const updatedConsole = {
         ...existingConsole,
         defaultProfile,
-        profiles: { ...existingProfiles, ...built.profiles },
+        profiles: { ...existingProfiles, ...mergedProfiles },
     };
     // Validate before writing anything: the runtime rejects invalid configs at
     // load time, so a bad merge must never reach disk.

package/dist/elt/application/management.js

@@ -332,7 +332,7 @@ async function syncProvider(database, paths, provider, options, log) {
         }
         else {
             await database.finishRun(runId);
-            pump.publishFinal(baseProgress(runId, provider, 'completed'));
+            await pump.publishFinal(baseProgress(runId, provider, 'completed'));
         }
         await removeProgressSidecar(paths, runId).catch(() => undefined);
         const [run] = await database.rows('SELECT status, error_count FROM sync_runs WHERE run_id = $runId', { runId });

package/dist/elt/storage/progress-sidecar.d.ts

@@ -56,6 +56,6 @@ export declare class ProgressPump {
     /** Transition the run to the JSONL import stage; keep-alives persist it. */
     setStageImporting(): void;
     /** Write a terminal heartbeat immediately, bypassing the publish throttle. */
-    publishFinal(state: SyncProgressState): void;
+    publishFinal(state: SyncProgressState): Promise<void>;
     stop(): void;
 }

package/dist/elt/storage/progress-sidecar.js

@@ -50,15 +50,33 @@ export async function readProgressSidecars(paths) {
 /** Active runs from sidecars: non-terminal stage and a fresh heartbeat. */
 export async function readRunningProgress(paths, staleAfterMs = PROGRESS_SIDECAR_STALE_MS) {
     const now = Date.now();
+    const directory = path.join(paths.staging, 'garmin');
+    if (!existsSync(directory))
+        return [];
+    const files = (await readdir(directory)).filter((file) => file.endsWith(PROGRESS_SIDECAR_SUFFIX));
     const running = [];
-    for (const state of await readProgressSidecars(paths)) {
-        if (TERMINAL_STAGES.has(state.stage))
+    const prunable = [];
+    for (const file of files) {
+        let state = null;
+        try {
+            state = normalizeProgress(JSON.parse(await readFile(path.join(directory, file), 'utf8')));
+        }
+        catch {
+            // Torn or partial sidecar write; it is not authoritative.
+        }
+        if (!state)
             continue;
         const ageMs = now - Date.parse(state.heartbeatAt);
-        if (!Number.isFinite(ageMs) || ageMs > staleAfterMs)
+        if (TERMINAL_STAGES.has(state.stage) || !Number.isFinite(ageMs) || ageMs > staleAfterMs) {
+            // A terminal heartbeat that survived its own cleanup (a crash between
+            // the final publish and the sidecar removal) must never read as an
+            // active run again, so sweep it instead of leaving it behind forever.
+            prunable.push(file);
             continue;
+        }
         running.push(state);
     }
+    await Promise.all(prunable.map((file) => rm(path.join(directory, file), { force: true }).catch(() => undefined)));
     return running;
 }
 /**
@@ -159,14 +177,16 @@ export class ProgressPump {
         this.setStage('importing');
     }
     /** Write a terminal heartbeat immediately, bypassing the publish throttle. */
-    publishFinal(state) {
+    async publishFinal(state) {
         this.lastHeartbeatAt = Date.now();
         this.lastProgress = state;
         const { database, paths, log } = this.options;
-        void database.heartbeatRun(this.runId, state).catch((error) => {
+        // Both terminal writes complete before the caller removes the sidecar, so
+        // a finished run can never resurrect its own progress file after cleanup.
+        await database.heartbeatRun(this.runId, state).catch((error) => {
             log.debug('Progress heartbeat failed', { runId: this.runId, error: error instanceof Error ? error.message : String(error) });
         });
-        void writeProgressSidecar(paths, this.runId, state).catch((error) => {
+        await writeProgressSidecar(paths, this.runId, state).catch((error) => {
             log.debug('Progress sidecar write failed', { runId: this.runId, error: error instanceof Error ? error.message : String(error) });
         });
     }

package/dist/interfaces/http/server.js

@@ -1,4 +1,5 @@
 import { createServer } from 'node:http';
+import path from 'node:path';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { catenceRuntimeHealth, DashboardSnapshotService, dataStatus, DetachedSyncBusyError, DETACHED_SYNC_PROVIDERS, jsonSafe, loadCatalog, mergeOpenCodeGoConsoleProfiles, openReadOnlyRepository, ReadOnlyDatabaseError, resolveAthlete, resolveCatalogPaths, startDetachedSync, syncProgress, } from '../../runtime/index.js';
 import { createCatenceMcpServer } from '../mcp/server.js';
@@ -122,14 +123,21 @@ async function resolveSyncPaths(catalogPaths, staticPaths, body) {
 }
 /** 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 {
         const status = await dataStatus(paths);
         const runs = Array.isArray(status.syncRuns) ? status.syncRuns : [];
-        const completed = runs.filter((run) => typeof run.completed_at === 'string' && String(run.status).startsWith('completed'));
+        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 = String(run.completed_at);
+            const completedAt = completedAtIso(run.completed_at);
             const provider = String(run.provider ?? 'unknown');
             if (!providers[provider] || providers[provider] < completedAt)
                 providers[provider] = completedAt;
@@ -250,11 +258,14 @@ export function createCatenceHttpServer(options = {}) {
                     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.
+                    // 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: paths.config, setDefault: false });
+                            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)}).`;
@@ -273,6 +284,24 @@ export function createCatenceHttpServer(options = {}) {
                 }
                 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');

package/docs/deployment/local-console.md

@@ -196,12 +196,21 @@ script fetches it and merges two ready-made profiles into `config.json`:
 `opencode-go` (chat + responses models, base `…/zen/go/v1`) and
 `opencode-go-messages` (messages models, base `…/zen/go`). Existing profiles,
 limits, and `defaultProfile` are preserved unless `--set-default` is passed.
+Re-discovery refreshes each known model's routing reference but keeps your
+custom label, `reasoningEffort`, and `variants`, and keeps models that have
+disappeared from the live catalog.
 
 ```sh
 # Local (from a checkout)
 npm run discover:opencode-go -- --write ~/.catence/config.json
 ```
 
+Inside the Console's Models page, **Discover OpenCode Go models** runs the
+same merge for the current home without touching athlete data (runtime route
+`POST /api/v1/models/discover`, proxied behind the Console login). Models can
+also be edited in place there — the update action rewrites the `console`
+section atomically and never stores secret values.
+
 Then set the credentials and verify:
 
 ```sh

package/docs/deployment/local-mcp.md

@@ -313,7 +313,12 @@ override the host and port when the flags are omitted.
 - `GET /api/v1/sync/status?athleteId=alex` reports live progress heartbeats,
   recent runs, and best-effort last-completion timestamps per provider. It
   keeps working while a sync holds the write lock (`lastSync` becomes `null`
-  then).
+  then). Finished runs are never reported as active, so a completed or
+  crashed run can never wedge the busy guard.
+- `POST /api/v1/models/discover` refreshes the OpenCode Go profiles in
+  `<home>/config.json` without starting a data sync:
+  `{"setDefault": false}` (both fields optional). Returns the merged profile
+  ids, per-route counts, and any prefix-guessed routes.
 - Browser origins must be listed with `--allow-origin` (repeatable). The
   packaged Console instead proxies the dashboard through its authenticated
   same-origin route.

package/docs/llm-providers.md

@@ -196,13 +196,18 @@ different API shapes:
 
 The script warns on stderr and skips any model that does not fit one of these
 families. Rerun it to refresh the model lists; existing profiles, limits, and
-`defaultProfile` are preserved unless `--set-default` is passed.
+`defaultProfile` are preserved unless `--set-default` is passed. Re-running
+never discards your own tweaks: per-model custom labels, `reasoningEffort`
+pins, and `variants` maps survive every refresh, and models that have dropped
+out of the live catalog stay configured.
 
 You do not have to run the script manually: the Console dashboard's **Sync
 data** button (and `POST /api/v1/sync` with `"refreshModels": true`) refreshes
-these profiles from the live catalog before starting a data sync. Discovery
-failures — offline machine, catalog unreachable — are reported as a warning and
-never block or fail the sync itself.
+these profiles from the live catalog before starting a data sync, and the
+Models page's **Discover OpenCode Go models** button (or
+`POST /api/v1/models/discover`) refreshes them without syncing anything.
+Discovery failures — offline machine, catalog unreachable — are reported as a
+warning and never block or fail the sync itself.
 
 ```sh
 export OPENCODE_GO_API_KEY='…'                      # any non-empty value satisfies the key check

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catence",
-  "version": "0.2.0-beta.18",
+  "version": "0.2.0-beta.19",
   "description": "Local MCP access to normalized Garmin, Intervals.icu, and targeted Strava fitness data.",
   "license": "AGPL-3.0-or-later",
   "repository": {