trekoon 0.2.9 → 0.3.1

package/src/index.ts

@@ -5,7 +5,7 @@ import { executeShell, parseInvocation, renderShellResult } from "./runtime/cli-
 export async function run(argv: readonly string[] = process.argv.slice(2)): Promise<void> {
   const parsed = parseInvocation(argv);
   const result = await executeShell(parsed);
-  const rendered: string = renderShellResult(result, parsed.mode, parsed.compatibilityMode);
+  const rendered: string = renderShellResult(result, parsed.mode, parsed.compatibilityMode, { compact: parsed.compact });
 
   if (result.ok) {
     process.stdout.write(`${rendered}\n`);

package/src/io/output.ts

@@ -13,8 +13,9 @@ const CONTRACT_VERSION = "1.0.0";
 const COMPATIBILITY_DEPRECATED_SINCE = "0.1.8";
 const COMPATIBILITY_REMOVAL_AFTER = "2026-09-30";
 
-interface RenderOptions {
+export interface RenderOptions {
   readonly compatibilityMode?: CompatibilityMode | null;
+  readonly compact?: boolean;
 }
 
 function toLegacySyncCommandId(command: string): string {
@@ -136,13 +137,14 @@ export function failResult(input: ResultInput & { readonly error: ToonError }):
 
 export function toToonEnvelope(result: CliResult, options: RenderOptions = {}): ToonEnvelope {
   const compatibilityMode: CompatibilityMode | null = options.compatibilityMode ?? null;
+  const compact: boolean = options.compact ?? false;
   const command: string = resolveCompatibilityCommand(result.command, compatibilityMode);
 
   return {
     ok: result.ok,
     command,
     data: result.data,
-    metadata: createContractMetadata(result, compatibilityMode),
+    ...(compact ? {} : { metadata: createContractMetadata(result, compatibilityMode) }),
     ...(result.error ? { error: result.error } : {}),
     ...(result.meta ? { meta: result.meta } : {}),
   };

package/src/runtime/cli-shell.ts

@@ -8,11 +8,12 @@ import { runMigrate } from "../commands/migrate";
 import { runQuickstart } from "../commands/quickstart";
 import { runSession } from "../commands/session";
 import { runSkills } from "../commands/skills";
+import { runSuggest } from "../commands/suggest";
 import { runSubtask } from "../commands/subtask";
 import { runSync } from "../commands/sync";
 import { runTask } from "../commands/task";
 import { runWipe } from "../commands/wipe";
-import { failResult, okResult, renderResult } from "../io/output";
+import { failResult, okResult, renderResult, type RenderOptions } from "../io/output";
 import { resolveStorageResolutionDiagnostics } from "../storage/database";
 import { type CliContext, type CliResult, type CompatibilityMode, type OutputMode } from "./command-types";
 import { CLI_VERSION } from "./version";
@@ -32,11 +33,13 @@ const SUPPORTED_ROOT_COMMANDS: readonly string[] = [
   "migrate",
   "sync",
   "skills",
+  "suggest",
   "wipe",
 ];
 
 export interface ParsedInvocation {
   readonly mode: OutputMode;
+  readonly compact: boolean;
   readonly compatibilityMode: CompatibilityMode | null;
   readonly compatibilityModeRaw: string | null;
   readonly compatibilityModeMissingValue: boolean;
@@ -53,6 +56,7 @@ export interface ParseInvocationOptions {
 export function parseInvocation(argv: readonly string[], options: ParseInvocationOptions = {}): ParsedInvocation {
   const stdoutIsTTY: boolean = options.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
   let explicitMode: OutputMode | null = null;
+  let compact = false;
   let compatibilityModeRaw: string | null = null;
   let compatibilityModeMissingValue = false;
   let wantsHelp = false;
@@ -75,6 +79,11 @@ export function parseInvocation(argv: readonly string[], options: ParseInvocatio
       continue;
     }
 
+    if (token === "--compact") {
+      compact = true;
+      continue;
+    }
+
     if (token === "--help" || token === "-h") {
       wantsHelp = true;
       continue;
@@ -105,6 +114,7 @@ export function parseInvocation(argv: readonly string[], options: ParseInvocatio
 
   return {
     mode: explicitMode ?? (stdoutIsTTY ? "human" : "json"),
+    compact,
     compatibilityMode,
     compatibilityModeRaw,
     compatibilityModeMissingValue,
@@ -115,13 +125,23 @@ export function parseInvocation(argv: readonly string[], options: ParseInvocatio
   };
 }
 
-export function renderShellResult(result: CliResult, mode: OutputMode, compatibilityMode: CompatibilityMode | null = null): string {
+export function renderShellResult(
+  result: CliResult,
+  mode: OutputMode,
+  compatibilityMode: CompatibilityMode | null = null,
+  options: { compact?: boolean } = {},
+): string {
   const effectiveCompatibilityMode: CompatibilityMode | null =
     compatibilityMode === "legacy-sync-command-ids" && result.command.startsWith("sync.")
       ? compatibilityMode
       : null;
 
-  return renderResult(result, mode, { compatibilityMode: effectiveCompatibilityMode });
+  const renderOptions: RenderOptions = {
+    compatibilityMode: effectiveCompatibilityMode,
+    compact: options.compact ?? false,
+  };
+
+  return renderResult(result, mode, renderOptions);
 }
 
 function isStringArray(value: unknown): value is string[] {
@@ -375,6 +395,9 @@ export async function executeShell(parsed: ParsedInvocation, cwd: string = proce
     case "skills":
       result = await runSkills(context);
       break;
+    case "suggest":
+      result = await runSuggest(context);
+      break;
     default:
       result = failResult({
         command: "shell",

package/src/runtime/command-types.ts

@@ -32,7 +32,7 @@ export interface ToonEnvelope {
   readonly ok: boolean;
   readonly command: string;
   readonly data: unknown;
-  readonly metadata: ContractMetadata;
+  readonly metadata?: ContractMetadata;
   readonly error?: ToonError;
   readonly meta?: Record<string, unknown>;
 }

package/src/storage/database.ts

@@ -98,6 +98,48 @@ export function resolveStorageResolutionDiagnostics(
   }
 }
 
+/** Default connection-level busy_timeout applied at open time. */
+const DEFAULT_BUSY_TIMEOUT_MS = 15000;
+
+/**
+ * Maximum time (ms) to wait when acquiring the write lock via BEGIN IMMEDIATE.
+ * Kept below the default bun test timeout so that lock-contention surfaces as
+ * a SQLITE_BUSY error rather than a test-level timeout.
+ */
+const WRITE_LOCK_BUSY_TIMEOUT_MS = 3000;
+
+/**
+ * Execute a write transaction using BEGIN IMMEDIATE to acquire a reserved lock
+ * up-front, avoiding SQLITE_BUSY errors that occur when a deferred transaction
+ * is promoted to a write lock after readers have already started.
+ *
+ * A shorter busy_timeout is applied while acquiring the lock so callers receive
+ * a prompt SQLITE_BUSY error instead of blocking for the full connection-level
+ * timeout.  The connection-level timeout is restored before returning.
+ */
+export function writeTransaction<T>(db: Database, fn: (db: Database) => T): T {
+  db.exec(`PRAGMA busy_timeout = ${WRITE_LOCK_BUSY_TIMEOUT_MS};`);
+  try {
+    db.exec("BEGIN IMMEDIATE;");
+  } catch (error) {
+    db.exec(`PRAGMA busy_timeout = ${DEFAULT_BUSY_TIMEOUT_MS};`);
+    throw error;
+  }
+  db.exec(`PRAGMA busy_timeout = ${DEFAULT_BUSY_TIMEOUT_MS};`);
+  try {
+    const result: T = fn(db);
+    db.exec("COMMIT;");
+    return result;
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK;");
+    } catch {
+      /* best-effort rollback — propagate the original error */
+    }
+    throw error;
+  }
+}
+
 export function openTrekoonDatabase(
   workingDirectory: string = process.cwd(),
   options: OpenTrekoonDatabaseOptions = {},
@@ -110,7 +152,7 @@ export function openTrekoonDatabase(
 
   const db: Database = new Database(paths.databaseFile, { create: true });
 
-  db.exec("PRAGMA busy_timeout = 5000;");
+  db.exec(`PRAGMA busy_timeout = ${DEFAULT_BUSY_TIMEOUT_MS};`);
   db.exec("PRAGMA journal_mode = WAL;");
   db.exec("PRAGMA foreign_keys = ON;");
 

package/src/storage/events-retention.ts

@@ -1,5 +1,7 @@
 import { type Database } from "bun:sqlite";
 
+import { writeTransaction } from "./database";
+
 export const DEFAULT_EVENT_RETENTION_DAYS = 90;
 const DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1000;
 
@@ -18,6 +20,7 @@ export interface EventPruneSummary {
   readonly candidateCount: number;
   readonly archivedCount: number;
   readonly deletedCount: number;
+  readonly staleCursorCount: number;
 }
 
 function ensureArchiveTable(db: Database): void {
@@ -53,27 +56,72 @@ function countCandidates(db: Database, cutoffTimestamp: number): number {
   return row?.count ?? 0;
 }
 
+function oldestCursorTimestamp(db: Database): number | null {
+  const row = db
+    .query("SELECT MIN(last_event_at) AS oldest FROM sync_cursors WHERE last_event_at IS NOT NULL;")
+    .get() as { oldest: number | null } | null;
+
+  return row?.oldest ?? null;
+}
+
+function countStaleCursors(db: Database): number {
+  // A cursor is stale when its last_event_at references a timestamp
+  // that has no corresponding event remaining in the events table.
+  // We detect this by checking if the oldest event in the table is
+  // newer than the cursor's last_event_at.
+  const oldestEventRow = db
+    .query("SELECT MIN(created_at) AS oldest FROM events;")
+    .get() as { oldest: number | null } | null;
+
+  const oldestEventAt: number | null = oldestEventRow?.oldest ?? null;
+
+  if (oldestEventAt === null) {
+    // No events at all — any cursor with a last_event_at is stale.
+    const row = db
+      .query("SELECT COUNT(*) AS count FROM sync_cursors WHERE last_event_at IS NOT NULL;")
+      .get() as { count: number } | null;
+    return row?.count ?? 0;
+  }
+
+  const row = db
+    .query(
+      "SELECT COUNT(*) AS count FROM sync_cursors WHERE last_event_at IS NOT NULL AND last_event_at < ?;",
+    )
+    .get(oldestEventAt) as { count: number } | null;
+
+  return row?.count ?? 0;
+}
+
 export function pruneEvents(db: Database, options: EventPruneOptions = {}): EventPruneSummary {
   const retentionDays: number = assertRetentionDays(options.retentionDays ?? DEFAULT_EVENT_RETENTION_DAYS);
   const dryRun: boolean = options.dryRun ?? false;
   const archive: boolean = options.archive ?? false;
   const now: number = options.now ?? Date.now();
-  const cutoffTimestamp: number = now - retentionDays * DAY_IN_MILLISECONDS;
-  const candidateCount: number = countCandidates(db, cutoffTimestamp);
+  const retentionCutoff: number = now - retentionDays * DAY_IN_MILLISECONDS;
+
+  // Guard: never prune events that a sync cursor still references.
+  // The effective cutoff is the earlier of the retention cutoff and
+  // the oldest cursor timestamp — so cursors always have replayable history.
+  const oldest: number | null = oldestCursorTimestamp(db);
+  const effectiveCutoff: number = oldest !== null ? Math.min(retentionCutoff, oldest) : retentionCutoff;
+
+  const candidateCount: number = countCandidates(db, effectiveCutoff);
+  const staleCursors: number = countStaleCursors(db);
 
   if (dryRun || candidateCount === 0) {
     return {
       retentionDays,
-      cutoffTimestamp,
+      cutoffTimestamp: effectiveCutoff,
       dryRun,
       archive,
       candidateCount,
       archivedCount: 0,
       deletedCount: 0,
+      staleCursorCount: staleCursors,
     };
   }
 
-  return db.transaction((): EventPruneSummary => {
+  return writeTransaction(db, (): EventPruneSummary => {
     let archivedCount = 0;
 
     if (archive) {
@@ -118,21 +166,22 @@ export function pruneEvents(db: Database, options: EventPruneOptions = {}): Even
             version = excluded.version;
           `,
         )
-        .run(cutoffTimestamp);
+        .run(effectiveCutoff);
 
       archivedCount = archived.changes;
     }
 
-    const deleted = db.query("DELETE FROM events WHERE created_at < ?;").run(cutoffTimestamp);
+    const deleted = db.query("DELETE FROM events WHERE created_at < ?;").run(effectiveCutoff);
 
     return {
       retentionDays,
-      cutoffTimestamp,
+      cutoffTimestamp: effectiveCutoff,
       dryRun,
       archive,
       candidateCount,
       archivedCount,
       deletedCount: deleted.changes,
+      staleCursorCount: staleCursors,
     };
-  })();
+  });
 }

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[];
 }