catence 0.2.1-beta.2 → 0.2.1-beta.3

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

package/dist/elt/application/management.js

@@ -19,7 +19,7 @@ import { completeStravaAuthorization, disconnectStrava, getStravaAuthorizationUr
 import { setManualActivityLink, unlinkActivitySource } from '../normalization/activities/linking.js';
 import { importSourceEntity } from '../normalization/normalizers.js';
 import { CatenceDatabase, openReadOnlyRepository, ReadOnlyDatabaseError } from '../storage/database.js';
-import { mergeProgress, ProgressPump, readRunningProgress, removeProgressSidecar } from '../storage/progress-sidecar.js';
+import { mergeProgress, ProgressPump, readRunningProgress, removeProgressSidecar, writeProgressSidecar, PROGRESS_KEEPALIVE_MS } from '../storage/progress-sidecar.js';
 import { withDataWriteLock } from '../storage/write-lock.js';
 function packageRoot() {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
@@ -430,8 +430,42 @@ export async function syncData(paths, provider, explicitFrom, advanceCursor = tr
             runs.push(await syncProvider(database, paths, source, { explicitFrom, toDate, advanceCursor, refreshActivities, backfill }, log));
         const executedRuns = runs.filter((run) => !run.skipped);
         if (executedRuns.length > 0) {
-            const index = await buildRetrievalIndex(database);
-            log.info('Rebuilt retrieval index after sync', { documents: index.documents, mode: index.mode, watermark: index.watermark });
+            // The per-provider pumps already stopped (sidecars removed, runs marked
+            // completed), but buildRetrievalIndex still holds the single-writer DB
+            // lock, so /dashboard reads as unavailable. Hold a non-terminal sidecar
+            // for the last executed run so /sync/status keeps reporting running and
+            // the Status Sync button stays disabled through local post-processing.
+            const last = [...executedRuns].reverse().find((run) => run.runId);
+            let indexingKeepalive = null;
+            const holdIndexingProgress = () => last?.runId
+                ? writeProgressSidecar(paths, last.runId, {
+                    ...baseProgress(last.runId, last.provider, 'importing'),
+                    currentStep: 'building retrieval index',
+                    percentComplete: 99,
+                }).catch((error) => {
+                    log.debug('Indexing progress sidecar write failed', {
+                        runId: last.runId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                })
+                : Promise.resolve();
+            if (last?.runId) {
+                await holdIndexingProgress();
+                indexingKeepalive = setInterval(() => {
+                    void holdIndexingProgress();
+                }, PROGRESS_KEEPALIVE_MS);
+                indexingKeepalive.unref?.();
+            }
+            try {
+                const index = await buildRetrievalIndex(database);
+                log.info('Rebuilt retrieval index after sync', { documents: index.documents, mode: index.mode, watermark: index.watermark });
+            }
+            finally {
+                if (indexingKeepalive)
+                    clearInterval(indexingKeepalive);
+                if (last?.runId)
+                    await removeProgressSidecar(paths, last.runId).catch(() => undefined);
+            }
         }
         return { runIds: runs.flatMap((run) => run.runId ? [run.runId] : []), runs, timedOutRuns: timedOutRuns.runIds };
     }

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

@@ -48,7 +48,16 @@ export declare class ProgressPump {
     private lastHeartbeatAt;
     private interval;
     private stageOverride;
+    /**
+     * Serializes heartbeat writes in call order. publish() used to fire its
+     * database and sidecar writes without awaiting them, so a throttled write
+     * could win the sidecar rename race against a later publishFinal() and
+     * leave a stale non-terminal stage behind.
+     */
+    private writeTail;
     constructor(runId: string, provider: string, options: ProgressPumpOptions);
+    private enqueueHeartbeat;
+    private writeHeartbeat;
     start(): void;
     publish(state: SyncProgressState): void;
     /** Force subsequent keep-alive heartbeats to report the given stage. */

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

@@ -133,11 +133,36 @@ export class ProgressPump {
     lastHeartbeatAt = 0;
     interval = null;
     stageOverride = null;
+    /**
+     * Serializes heartbeat writes in call order. publish() used to fire its
+     * database and sidecar writes without awaiting them, so a throttled write
+     * could win the sidecar rename race against a later publishFinal() and
+     * leave a stale non-terminal stage behind.
+     */
+    writeTail = Promise.resolve();
     constructor(runId, provider, options) {
         this.runId = runId;
         this.provider = provider;
         this.options = options;
     }
+    enqueueHeartbeat(state) {
+        const run = this.writeTail.then(() => this.writeHeartbeat(state));
+        // A write failure is already logged inside writeHeartbeat; never let it
+        // break the chain (or surface as an unhandled rejection) for later beats.
+        this.writeTail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async writeHeartbeat(state) {
+        const { database, paths, log } = this.options;
+        await Promise.all([
+            database.heartbeatRun(this.runId, state).catch((error) => {
+                log.debug('Progress heartbeat failed', { runId: this.runId, error: error instanceof Error ? error.message : String(error) });
+            }),
+            writeProgressSidecar(paths, this.runId, state).catch((error) => {
+                log.debug('Progress sidecar write failed', { runId: this.runId, error: error instanceof Error ? error.message : String(error) });
+            }),
+        ]);
+    }
     start() {
         if (this.interval)
             return;
@@ -156,13 +181,7 @@ export class ProgressPump {
         }
         this.lastHeartbeatAt = now;
         this.lastProgress = state;
-        const { database, paths, log } = this.options;
-        void 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) => {
-            log.debug('Progress sidecar write failed', { runId: this.runId, error: error instanceof Error ? error.message : String(error) });
-        });
+        void this.enqueueHeartbeat(state).catch(() => undefined);
     }
     /** Force subsequent keep-alive heartbeats to report the given stage. */
     setStage(stage) {
@@ -180,15 +199,11 @@ export class ProgressPump {
     async publishFinal(state) {
         this.lastHeartbeatAt = Date.now();
         this.lastProgress = state;
-        const { database, paths, log } = this.options;
-        // 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) });
-        });
-        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) });
-        });
+        // Awaiting the chained write guarantees every earlier heartbeat (in
+        // particular a throttled publish still in flight) lands first, so the
+        // terminal stage is always the last one persisted before the caller
+        // removes the sidecar.
+        await this.enqueueHeartbeat(state);
     }
     stop() {
         if (this.interval) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catence",
-  "version": "0.2.1-beta.2",
+  "version": "0.2.1-beta.3",
   "description": "Local MCP access to normalized Garmin, Intervals.icu, and targeted Strava fitness data.",
   "license": "AGPL-3.0-or-later",
   "repository": {
@@ -55,6 +55,7 @@
     "test:watch": "vitest",
     "catence-data": "tsx src/interfaces/cli/main.ts",
     "mcp": "tsx src/interfaces/mcp/main.ts",
+    "dev": "node scripts/dev.mjs",
     "console": "uv run --project console catence-console serve",
     "console:doctor": "uv run --project console catence-console doctor",
     "discover:opencode-go": "node scripts/discover-opencode-go.mjs",
@@ -79,11 +80,11 @@
     "@types/node": "^24.3.0",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2",
-    "vitest": "^3.2.4"
+    "vitest": "^5.0.0"
   },
   "overrides": {
     "fast-uri": "3.1.7",
-    "hono": "4.12.34",
+    "hono": "4.13.7",
     "nanoid": "3.3.18",
     "qs": "6.16.0"
   }