trekoon 0.1.6 → 0.1.8

package/src/storage/migrations.ts

@@ -278,11 +278,58 @@ function recordMigration(db: Database, migration: Migration): void {
   );
 }
 
+function isSchemaCurrentFastPath(db: Database, latestVersion: number): boolean {
+  if (latestVersion === 0 || !migrationTableExists(db) || !hasMigrationVersionColumn(db)) {
+    return false;
+  }
+
+  const row = db
+    .query(
+      `
+      SELECT
+        COALESCE(MIN(version), 0) AS min_version,
+        COALESCE(MAX(version), 0) AS max_version,
+        COUNT(DISTINCT version) AS distinct_versions,
+        SUM(CASE WHEN version IS NULL THEN 1 ELSE 0 END) AS null_versions
+      FROM schema_migrations;
+      `,
+    )
+    .get() as
+    | {
+        min_version: number;
+        max_version: number;
+        distinct_versions: number;
+        null_versions: number;
+      }
+    | null;
+
+  if (!row) {
+    return false;
+  }
+
+  return (
+    row.null_versions === 0 &&
+    row.min_version === 1 &&
+    row.max_version === latestVersion &&
+    row.distinct_versions === latestVersion
+  );
+}
+
 export function migrateDatabase(db: Database): void {
+  validateMigrationPlan();
+
+  const latestVersion: number = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
+
+  // Fast path: avoid BEGIN EXCLUSIVE when schema is already current.
+  // This reduces startup lock contention while keeping the explicit
+  // transactional migration path for non-current/legacy schemas.
+  if (isSchemaCurrentFastPath(db, latestVersion)) {
+    return;
+  }
+
   runExclusive(db, (): void => {
     ensureMigrationTable(db);
     ensureMigrationVersionColumn(db);
-    validateMigrationPlan();
 
     const version: number = currentVersion(db);
 

package/src/sync/service.ts

@@ -225,17 +225,55 @@ function countBehind(remoteDb: Database, cursorToken: string): number {
   return row?.count ?? 0;
 }
 
-function listRemoteEventIds(remoteDb: Database): Set<string> {
-  const rows = remoteDb.query("SELECT id FROM events;").all() as Array<{ id: string }>;
-  return new Set(rows.map((row) => row.id));
+function countAhead(localDb: Database, currentBranch: string | null, remoteDbPath: string): number {
+  if (!currentBranch) {
+    return 0;
+  }
+
+  localDb.query("ATTACH DATABASE ? AS sync_remote;").run(remoteDbPath);
+
+  try {
+    const row = localDb
+      .query(
+        `
+        SELECT COUNT(*) AS count
+        FROM events AS local_events
+        WHERE local_events.git_branch = @branch
+          AND NOT EXISTS (
+            SELECT 1
+            FROM sync_remote.events AS remote_events
+            WHERE remote_events.id = local_events.id
+          );
+        `,
+      )
+      .get({ "@branch": currentBranch }) as { count: number } | null;
+
+    return row?.count ?? 0;
+  } finally {
+    localDb.query("DETACH DATABASE sync_remote;").run();
+  }
 }
 
-function countAhead(localDb: Database, currentBranch: string | null, remoteEventIds: Set<string>): number {
-  const rows = localDb
-    .query("SELECT id, git_branch FROM events WHERE git_branch = ?;")
-    .all(currentBranch) as Array<{ id: string; git_branch: string | null }>;
+function buildSyncErrorHints(diagnostics: {
+  malformedPayloadEvents: number;
+  applyRejectedEvents: number;
+  conflictEvents: number;
+}): string[] {
+  const hints: string[] = [];
+
+  if (diagnostics.malformedPayloadEvents > 0) {
+    hints.push("Malformed event payloads were quarantined; inspect sync conflicts with field '__payload__'.");
+  }
+
+  if (diagnostics.applyRejectedEvents > 0) {
+    hints.push("Some events were quarantined as invalid; inspect sync conflicts with field '__apply__'.");
+  }
+
+  if (diagnostics.conflictEvents > 0) {
+    hints.push("Field-level conflicts detected; run 'trekoon sync conflicts list' and resolve pending entries.");
+  }
 
-  return rows.filter((row) => !remoteEventIds.has(row.id)).length;
+  return hints;
 }
 
 function readFieldValue(payload: EventPayload, field: string): unknown {
@@ -631,7 +669,7 @@ export function syncStatus(cwd: string, sourceBranch: string): SyncStatusSummary
     try {
       return {
         sourceBranch,
-        ahead: countAhead(storage.db, git.branchName, listRemoteEventIds(remote.db)),
+        ahead: countAhead(storage.db, git.branchName, remote.path),
         behind: countBehind(remote.db, cursorToken),
         pendingConflicts: countPendingConflicts(storage.db),
         git,
@@ -658,6 +696,10 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
 
     let appliedEvents = 0;
     let createdConflicts = 0;
+    let malformedPayloadEvents = 0;
+    let applyRejectedEvents = 0;
+    let quarantinedEvents = 0;
+    let conflictEvents = 0;
     let lastToken: string | null = null;
     let lastEventAt: number | null = cursor?.last_event_at ?? null;
 
@@ -666,6 +708,8 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
         const payloadValidation = parsePayload(incoming.payload);
 
         if (!payloadValidation.ok) {
+          malformedPayloadEvents += 1;
+          quarantinedEvents += 1;
           createConflict(
             storage.db,
             incoming,
@@ -688,6 +732,7 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
           const conflict = entityFieldConflict(storage.db, sourceBranch, incoming, fieldName, value);
 
           if (conflict) {
+            conflictEvents += 1;
             createConflict(storage.db, incoming, fieldName, conflict.oursValue, conflict.theirsValue);
             createdConflicts += 1;
             continue;
@@ -699,6 +744,8 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
         if (applyEntityFields(storage.db, incoming, fieldsToApply)) {
           appliedEvents += 1;
         } else if (incoming.operation !== "resolve_conflict") {
+          applyRejectedEvents += 1;
+          quarantinedEvents += 1;
           createConflict(
             storage.db,
             incoming,
@@ -726,6 +773,17 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
       appliedEvents,
       createdConflicts,
       cursorToken: lastToken,
+      diagnostics: {
+        malformedPayloadEvents,
+        applyRejectedEvents,
+        quarantinedEvents,
+        conflictEvents,
+        errorHints: buildSyncErrorHints({
+          malformedPayloadEvents,
+          applyRejectedEvents,
+          conflictEvents,
+        }),
+      },
     };
   } finally {
     remote.close();

package/src/sync/types.ts

@@ -21,6 +21,15 @@ export interface PullSummary {
   readonly appliedEvents: number;
   readonly createdConflicts: number;
   readonly cursorToken: string | null;
+  readonly diagnostics: SyncPullDiagnostics;
+}
+
+export interface SyncPullDiagnostics {
+  readonly malformedPayloadEvents: number;
+  readonly applyRejectedEvents: number;
+  readonly quarantinedEvents: number;
+  readonly conflictEvents: number;
+  readonly errorHints: readonly string[];
 }
 
 export interface ResolveSummary {