trekoon 0.3.0 → 0.3.1

package/src/storage/migrations.ts

@@ -177,9 +177,64 @@ const MIGRATIONS: readonly Migration[] = [
     up(db: Database): void {
       migrateWorktreeScopedSyncMetadata(db);
     },
-    down(db: Database): void {
-      db.exec("DROP INDEX IF EXISTS idx_sync_cursors_owner;");
-      db.exec("DROP INDEX IF EXISTS idx_git_context_scope_path;");
+    down(_db: Database): void {
+      throw new Error(
+        "Migration 0004 (worktree_scoped_sync_metadata) is irreversible. " +
+        "It adds columns via ALTER TABLE that cannot be removed without " +
+        "reconstructing tables and risking data loss. " +
+        "Rollback below version 4 is not supported.",
+      );
+    },
+  },
+  {
+    version: 5,
+    name: "0005_dependency_edge_integrity",
+    up(db: Database): void {
+      // Clean up orphaned dependency rows where source or target no longer exists.
+      db.exec(`
+        DELETE FROM dependencies
+        WHERE source_id NOT IN (SELECT id FROM tasks UNION ALL SELECT id FROM subtasks)
+           OR depends_on_id NOT IN (SELECT id FROM tasks UNION ALL SELECT id FROM subtasks);
+      `);
+
+      // Deduplicate any existing duplicate edges before creating the unique index.
+      // Keep one arbitrary row per logical edge (MIN(id) is lexicographic, not chronological, but any survivor is equivalent).
+      db.exec(`
+        DELETE FROM dependencies
+        WHERE id NOT IN (
+          SELECT MIN(id) FROM dependencies
+          GROUP BY source_id, depends_on_id
+        );
+      `);
+
+      db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_dependencies_edge ON dependencies (source_id, depends_on_id);");
+    },
+    down(_db: Database): void {
+      throw new Error(
+        "Migration 0005 (dependency_edge_integrity) is irreversible. " +
+        "It removes orphaned rows and deduplicates dependency edges. " +
+        "Rollback below version 5 is not supported.",
+      );
+    },
+  },
+  {
+    version: 6,
+    name: "0006_add_owner_column",
+    up(db: Database): void {
+      if (!tableHasColumn(db, "tasks", "owner")) {
+        db.exec("ALTER TABLE tasks ADD COLUMN owner TEXT;");
+      }
+      if (!tableHasColumn(db, "subtasks", "owner")) {
+        db.exec("ALTER TABLE subtasks ADD COLUMN owner TEXT;");
+      }
+    },
+    down(_db: Database): void {
+      throw new Error(
+        "Migration 0006 (add_owner_column) is irreversible. " +
+        "It adds columns via ALTER TABLE that cannot be removed without " +
+        "reconstructing tables and risking data loss. " +
+        "Rollback below version 6 is not supported.",
+      );
     },
   },
 ];

package/src/sync/service.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 
 import { type Database } from "bun:sqlite";
 
-import { openTrekoonDatabase } from "../storage/database";
+import { openTrekoonDatabase, writeTransaction } from "../storage/database";
 import { countBranchEventsSince, queryBranchEventsSince } from "./branch-db";
 import { persistGitContext, resolveGitContext } from "./git-context";
 import {
@@ -15,6 +15,49 @@ import {
   type SyncStatusSummary,
 } from "./types";
 
+function isCursorStale(db: Database, cursorToken: string, sourceBranch: string): boolean {
+  if (cursorToken === "0:") {
+    return false;
+  }
+
+  const [createdAtRaw, idRaw] = cursorToken.split(":");
+  const createdAt: number = Number.parseInt(createdAtRaw ?? "0", 10);
+  const id: string = idRaw ?? "";
+
+  if (!Number.isFinite(createdAt) || createdAt === 0) {
+    return false;
+  }
+
+  // Check if the event referenced by the cursor still exists.
+  // If the cursor references a specific event id, check for it.
+  // Otherwise, check if any event at or after the cursor timestamp exists
+  // on the source branch.
+  if (id.length > 0) {
+    const row = db
+      .query("SELECT id FROM events WHERE id = ? LIMIT 1;")
+      .get(id) as { id: string } | null;
+    if (row) {
+      return false;
+    }
+  }
+
+  // The referenced event is gone. Check if there are any events on the
+  // source branch at or after the cursor timestamp — if not, the cursor
+  // may simply be at the end of the stream.
+  const newerRow = db
+    .query(
+      `SELECT id FROM events
+       WHERE git_branch = ? AND created_at >= ?
+       ORDER BY created_at ASC, id ASC
+       LIMIT 1;`,
+    )
+    .get(sourceBranch, createdAt) as { id: string } | null;
+
+  // If there are newer events but our referenced event is gone,
+  // events between the cursor and the oldest remaining event were pruned.
+  return newerRow !== null;
+}
+
 interface StoredEvent {
   readonly id: string;
   readonly entity_kind: string;
@@ -289,23 +332,22 @@ function entityFieldConflict(
     return null;
   }
 
+  // Note: loads all matching events into memory. For entities with very large
+  // event histories, consider a cursor-based scan. The idx_events_entity index
+  // keeps the scan narrow by (entity_kind, entity_id).
   const rows = localDb
     .query(
       `
       SELECT payload, git_branch
       FROM events
-      WHERE entity_kind = ? AND entity_id = ?
+      WHERE entity_kind = ? AND entity_id = ? AND git_branch != ?
       ORDER BY created_at DESC, id DESC
-      LIMIT 50;
-      `,
+      LIMIT 500;
+`,
     )
-    .all(event.entity_kind, event.entity_id) as Array<{ payload: string; git_branch: string | null }>;
+    .all(event.entity_kind, event.entity_id, sourceBranch) as Array<{ payload: string; git_branch: string | null }>;
 
   for (const row of rows) {
-    if (row.git_branch === sourceBranch) {
-      continue;
-    }
-
     const payloadValidation = parsePayload(row.payload);
     if (!payloadValidation.ok) {
       continue;
@@ -360,6 +402,15 @@ function createConflict(
   ).run(randomUUID(), event.id, event.entity_kind, event.entity_id, fieldName, oursValue, theirsValue, resolution, now, now);
 }
 
+function hasLocalEntityEdits(db: Database, entityKind: string, entityId: string, sourceBranch: string): boolean {
+  const row = db
+    .query(
+      `SELECT 1 FROM events WHERE entity_kind = ? AND entity_id = ? AND git_branch != ? LIMIT 1;`,
+    )
+    .get(entityKind, entityId, sourceBranch);
+  return row !== null;
+}
+
 function rowExists(db: Database, tableName: string, id: string): boolean {
   const row = db.query(`SELECT id FROM ${tableName} WHERE id = ? LIMIT 1;`).get(id) as { id: string } | null;
   return row !== null;
@@ -495,10 +546,9 @@ function applyCreate(db: Database, event: StoredEvent, fields: Record<string, un
       updated_at,
       version
     ) VALUES (?, ?, ?, ?, ?, ?, ?, 1)
-    ON CONFLICT(id) DO UPDATE SET
-      source_id = excluded.source_id,
+    ON CONFLICT(source_id, depends_on_id) DO UPDATE SET
+      id = excluded.id,
       source_kind = excluded.source_kind,
-      depends_on_id = excluded.depends_on_id,
       depends_on_kind = excluded.depends_on_kind,
       updated_at = excluded.updated_at,
       version = dependencies.version + 1;
@@ -689,6 +739,7 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
     persistGitContext(storage.db, git);
     const cursor = loadCursor(storage.db, git.worktreePath, sourceBranch);
     const cursorToken = cursor?.cursor_token ?? "0:";
+    const staleCursor: boolean = cursor !== null && isCursorStale(storage.db, cursorToken, sourceBranch);
     const incomingEvents: StoredEvent[] = queryBranchEventsSince(storage.db, sourceBranch, cursorToken) as StoredEvent[];
 
     // Same-branch fast path: skip conflict detection when already on sourceBranch.
@@ -697,7 +748,7 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
       let lastToken: string | null = null;
       let lastEventAt: number | null = cursor?.last_event_at ?? null;
 
-      storage.db.transaction((): void => {
+      writeTransaction(storage.db, (): void => {
         for (const incoming of incomingEvents) {
           storeEvent(storage.db, incoming);
           lastToken = cursorTokenFromEvent(incoming);
@@ -707,7 +758,7 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
         if (lastToken) {
           saveCursor(storage.db, git.worktreePath, sourceBranch, lastToken, lastEventAt);
         }
-      })();
+      });
 
       return {
         sourceBranch,
@@ -721,7 +772,10 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
           applyRejectedEvents: 0,
           quarantinedEvents: 0,
           conflictEvents: 0,
-          errorHints: [],
+          staleCursor,
+          errorHints: staleCursor
+            ? ["Stale cursor detected; some events may have been pruned. Consider a full rebuild."]
+            : [],
         },
       };
     }
@@ -735,7 +789,7 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
     let lastToken: string | null = null;
     let lastEventAt: number | null = cursor?.last_event_at ?? null;
 
-    storage.db.transaction((): void => {
+    writeTransaction(storage.db, (): void => {
       for (const incoming of incomingEvents) {
         const payloadValidation = parsePayload(incoming.payload);
 
@@ -758,6 +812,23 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
         }
 
         const payload: EventPayload = { fields: payloadValidation.fields };
+
+        const isDeleteWithLocalEdits =
+          incoming.operation.endsWith(".deleted") &&
+          hasLocalEntityEdits(storage.db, incoming.entity_kind, incoming.entity_id, sourceBranch);
+        if (isDeleteWithLocalEdits) {
+          // Note: dependency.removed is intentionally excluded — dependencies are
+          // edges (not entities with local edit history), so conflict detection
+          // does not apply to them.
+          createConflict(storage.db, incoming, "__delete__", null, "Entity deleted on source branch");
+          createdConflicts += 1;
+          conflictEvents += 1;
+          storeEvent(storage.db, incoming);
+          lastToken = cursorTokenFromEvent(incoming);
+          lastEventAt = incoming.created_at;
+          continue;
+        }
+
         const fieldsToApply: Record<string, unknown> = {};
         let withheldConflictCount = 0;
 
@@ -801,7 +872,16 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
       if (lastToken) {
         saveCursor(storage.db, git.worktreePath, sourceBranch, lastToken, lastEventAt);
       }
-    })();
+    });
+
+    const errorHints: string[] = buildSyncErrorHints({
+      malformedPayloadEvents,
+      applyRejectedEvents,
+      conflictEvents,
+    });
+    if (staleCursor) {
+      errorHints.push("Stale cursor detected; some events may have been pruned. Consider a full rebuild.");
+    }
 
     return {
       sourceBranch,
@@ -815,11 +895,8 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
         applyRejectedEvents,
         quarantinedEvents,
         conflictEvents,
-        errorHints: buildSyncErrorHints({
-          malformedPayloadEvents,
-          applyRejectedEvents,
-          conflictEvents,
-        }),
+        staleCursor,
+        errorHints,
       },
     };
   } finally {
@@ -1010,7 +1087,7 @@ export function syncResolve(cwd: string, conflictId: string, resolution: SyncRes
       throw new Error(`Conflict '${conflictId}' already resolved.`);
     }
 
-    storage.db.transaction((): void => {
+    writeTransaction(storage.db, (): void => {
       if (resolution === "theirs") {
         updateSingleField(
           storage.db,
@@ -1027,7 +1104,7 @@ export function syncResolve(cwd: string, conflictId: string, resolution: SyncRes
         .run(resolution, now, conflict.id);
 
       appendResolutionEvent(storage.db, git.branchName, git.headSha, conflict, resolution);
-    })();
+    });
 
     return {
       conflictId,

package/src/sync/types.ts

@@ -31,6 +31,7 @@ export interface SyncPullDiagnostics {
   readonly applyRejectedEvents: number;
   readonly quarantinedEvents: number;
   readonly conflictEvents: number;
+  readonly staleCursor: boolean;
   readonly errorHints: readonly string[];
 }