fix(git-sync): unwedge per-page conflicts, preserve callout types, flush collab on disconnect

Addresses QA findings on PR #119 (issues #235/#236).

SYNC-WEDGE (HIGH): one same-line conflict on one page froze sync for the
WHOLE space in both directions forever. The pull's docmost->main merge left
the vault mid-merge, so every later cycle's isMergeInProgress() check returned
skipped:"merge-in-progress" and skipped the entire space with no recovery.
- pull.ts now COMMITS a conflicting merge with markers in place (commitMerge):
  cleanly-merged pages land, the conflicted page carries its markers on main and
  is isolated by the existing push-side conflict-marker skip (markers never reach
  Docmost), and the next cycle is no longer wedged. conflictedPaths is surfaced.
- cycle.ts now RECOVERS a vault left mid-merge by a prior/pre-fix cycle: it
  aborts the stale merge (merge --abort, hard-reset fallback) and continues,
  instead of skipping the space forever.
- git.ts: listUnmergedPaths / commitMerge / abortMerge / resetHardToHead.

CALLOUT TYPE FIDELITY: git-sync's CALLOUT_TYPES was missing "note" and "default"
(editor-canonical types), so [!note]/[!default] callouts flattened to [!info] on
every round-trip. Aligned the list with @docmost/editor-ext getValidCalloutType.

LOSS-ON-FAST-CLOSE: editing a page then closing the tab inside the collab
debounce window (~3-18s) lost the edit, because with unloadImmediately:false
Hocuspocus does not flush the debounced onStoreDocument on the last-client
disconnect. PersistenceExtension.onDisconnect now flushes the pending store
(debouncer.executeNow) on the last disconnect only, with no redundant write.

DUPLICATION re-verify (#1): the schema-default merge-key normalization is intact;
faithful toYdoc-based reproduction shows callout + rich content resync with 0 ops
and no growth/strip across cycles -> the re-report was leftover vault data, not a
live regression. Locked with a callout regression spec.

Tests: git-sync 688 pass (incl. real-VaultGit wedge-recovery integration); server
git-sync+collaboration 285 pass; new callout merge/fidelity + onDisconnect-flush
specs. tsc --noEmit clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

packages/git-sync/test/cycle.test.ts

@@ -24,6 +24,10 @@ function fakeVault(overrides: Record<string, any> = {}) {
     stageAll: rec("stageAll"),
     commit: rec("commit", { committed: false }),
     merge: rec("merge", { ok: true, conflict: false, output: "" }),
+    listUnmergedPaths: vi.fn(async () => [] as string[]),
+    commitMerge: rec("commitMerge"),
+    abortMerge: rec("abortMerge"),
+    resetHardToHead: rec("resetHardToHead"),
     readRef: vi.fn(async () => null),
     revParse: vi.fn(async () => "0000000000000000000000000000000000000000"),
     diffNameStatus: vi.fn(async () => [] as any[]),
@@ -64,16 +68,47 @@ function baseDeps(vault: any, over: Partial<RunCycleDeps> = {}): RunCycleDeps {
 }
 
 describe("runCycle (composition)", () => {
-  it("short-circuits with skipped:'merge-in-progress' and runs no pull/push", async () => {
-    const vault = fakeVault({ isMergeInProgress: vi.fn(async () => true) });
+  it("RECOVERS from a vault left mid-merge: aborts the stale merge and continues (no wedge)", async () => {
+    // Regression for the WEDGE bug (QA #119): a vault left mid-merge by a prior
+    // cycle used to skip the WHOLE space forever. Now the cycle aborts the stale
+    // merge and proceeds so the space self-heals.
+    let midMerge = true;
+    const vault = fakeVault({
+      // mid-merge until `abortMerge` clears it (then the cycle continues).
+      isMergeInProgress: vi.fn(async () => midMerge),
+      abortMerge: vi.fn(async () => {
+        midMerge = false;
+      }),
+    });
     const deps = baseDeps(vault);
 
     const res = await runCycle(deps);
 
-    expect(res).toEqual({ ran: false, skipped: "merge-in-progress" });
-    // Never advanced to the pull (listSpaceTree) or push.
-    expect(deps.client.listSpaceTree).not.toHaveBeenCalled();
-    expect(vault.order).not.toContain("checkout:docmost");
+    // The stale merge was aborted and the cycle RAN (no permanent wedge).
+    expect(vault.abortMerge).toHaveBeenCalledTimes(1);
+    expect(res.ran).toBe(true);
+    expect(deps.client.listSpaceTree).toHaveBeenCalledTimes(1);
+    expect(vault.order).toContain("checkout:docmost");
+  });
+
+  it("hard-resets when 'merge --abort' cannot clear a stray unmerged index", async () => {
+    // abortMerge does NOT clear it (no MERGE_HEAD but stray unmerged entries);
+    // the cycle falls back to a hard reset, then proceeds.
+    let midMerge = true;
+    const vault = fakeVault({
+      isMergeInProgress: vi.fn(async () => midMerge),
+      abortMerge: vi.fn(async () => undefined), // leaves it mid-merge
+      resetHardToHead: vi.fn(async () => {
+        midMerge = false;
+      }),
+    });
+    const deps = baseDeps(vault);
+
+    const res = await runCycle(deps);
+
+    expect(vault.abortMerge).toHaveBeenCalledTimes(1);
+    expect(vault.resetHardToHead).toHaveBeenCalledTimes(1);
+    expect(res.ran).toBe(true);
   });
 
   it("stages ensureRepo -> ensureBranch(docmost,main) -> checkout(docmost) BEFORE pulling", async () => {