fix(zig): seq divergence + schema mismatch behavior (Round 76)

TASK-199: Fix seq value divergence (Zig=1 vs Rust=0)
- Root cause: crsqlAfterInsertFunc called getNextSeq() unconditionally for
  maybeMarkReinserted, wasting seq=0 even when no sentinel existed
- Fix: Modified getOrCreatePkKey() to return {key, existed} struct
- Only bump seq for reinsert when existed=true (resurrection case)
- Result: test-clock-internals.sh 27/27 pass, 0 seq divergences

TASK-186: Align schema mismatch behavior with Rust/C
- Decision: Lenient (ignore unknown columns during sync)
- Added columnExistsInTable() helper in merge_insert.zig
- Check column existence before applying changes in changes_vtab.zig
- Result: test-schema-mismatch.sh 12/12 pass

Test results:
- test-parity.sh: 367 passed, 4 failed (pre-existing)
- test-clock-internals.sh: 27/27 pass
- test-app-todo.sh: 2 parity confirmed

Author: subtleGradient

.tasks/DELEGATE_WORK_HANDOFF.md

@@ -68,6 +68,101 @@ Artifacts:
 
 ---
 
+## Round 2025-12-25 (76) — seq divergence + schema mismatch fixes (2 tasks)
+
+**Tasks executed**
+- `.tasks/done/TASK-199-seq-value-divergence.md` (bug fix)
+- `.tasks/done/TASK-186-schema-mismatch-unknown-column-behavior.md` (behavior alignment)
+
+**Commits**
+- `211de13e` — fix(zig): seq divergence + schema mismatch behavior (Round 76)
+
+**Environment**
+- OS: darwin (macOS ARM64)
+- Tooling: nix, zig (via nix), bash
+
+**Commands run (exact)**
+```bash
+make -C zig build
+bash zig/harness/test-clock-internals.sh
+bash zig/harness/test-schema-mismatch.sh
+bash zig/harness/test-app-todo.sh
+bash zig/harness/test-parity.sh
+```
+
+**Outputs (paste)**
+
+<details>
+<summary>TASK-199: seq divergence fix (27/27 PASS, 0 seq divergences)</summary>
+
+**Root cause**: In `crsqlAfterInsertFunc`, Zig called `getNextSeq()` unconditionally for `maybeMarkReinserted()`, even when no sentinel row existed to update. This consumed `seq=0` without effect, causing the first column's seq to start at 1 instead of 0.
+
+Rust/C only calls `bump_seq()` when `create_record_existed=true` (resurrection case).
+
+**Fix**: Modified `getOrCreatePkKey()` to return a `GetOrCreateKeyResult` struct with both `key` and `existed` flag. Only call `getNextSeq()` for reinsert if `existed=true`.
+
+**Test output**:
+```text
+Clock Table Internals Test Summary
+  PASSED:         27
+  FAILED:         0
+  seq divergences: 0
+
+Before fix: Zig seq=1, Rust seq=0
+After fix:  Zig seq=0, Rust seq=0
+```
+
+**Files modified**: `zig/src/local_writes/after_write.zig`
+</details>
+
+<details>
+<summary>TASK-186: schema mismatch fix (12/12 PASS)</summary>
+
+**Design decision**: Align with Rust/C (lenient behavior) — ignore unknown columns during sync.
+
+**Root cause**: When applying a change for a column that doesn't exist locally, `updateBaseTableColumn()` or `insertOrUpdateColumn()` would fail with SQLITE_ERROR because the generated SQL references a non-existent column.
+
+**Fix**: Added `columnExistsInTable()` helper in `merge_insert.zig`. Added column existence checks before applying changes in `changes_vtab.zig`. If column doesn't exist, skip gracefully.
+
+**Test output**:
+```text
+Schema Mismatch Test Summary
+  PASSED:  12
+  FAILED:  0
+```
+
+**Files modified**: 
+- `zig/src/merge_insert.zig` — added `columnExistsInTable()`
+- `zig/src/changes_vtab.zig` — added column checks
+</details>
+
+<details>
+<summary>Regression checks</summary>
+
+```text
+test-app-todo.sh:
+  Results: 2 parity confirmed, 0 failures, 0 divergences
+
+test-parity.sh:
+  PASSED:  367
+  FAILED:  4 (pre-existing edge cases)
+  SKIPPED: 22
+```
+</details>
+
+**Reproduction steps (clean checkout)**
+1. `git clone <repo> && cd cr-sqlite`
+2. `make -C zig build`
+3. `bash zig/harness/test-clock-internals.sh` — verify 27/27 pass, 0 seq divergences
+4. `bash zig/harness/test-schema-mismatch.sh` — verify 12/12 pass
+5. `bash zig/harness/test-parity.sh` — verify 367 passed
+
+**Known gaps / unverified claims**
+- Linux CI not verified (local darwin only)
+- No commits yet (pending)
+
+---
+
 ## Round 2025-12-25 (75) — Composite PK sync + Hypothesis tests (2 tasks)
 
 **Tasks executed**

.tasks/active/TASK-199-seq-value-divergence.md

@@ -0,0 +1,91 @@
+# TASK-199 — seq Value Divergence (Zig=1, Rust=0)
+
+## Goal
+Investigate and fix the `seq` column value divergence between Zig and Rust/C implementations.
+
+## Status
+- State: **DONE**
+- Priority: MEDIUM (affects sync ordering in edge cases)
+- Discovered: 2025-12-23 (TASK-192 prior DB parity testing)
+- Fixed: 2025-12-25 (Round 76)
+
+## Problem
+
+When performing single operations, the `seq` column in `crsql_changes` differs:
+- **Rust/C**: `seq=0`
+- **Zig (before fix)**: `seq=1`
+
+## Root Cause
+
+In `crsqlAfterInsertFunc`, Zig called `getNextSeq()` unconditionally for `maybeMarkReinserted()`, even when no sentinel row existed to update. This consumed `seq=0` without effect, causing the first column's seq to start at 1.
+
+**Rust/C behavior:**
+```rust
+// Only bump seq IF create_record_existed (resurrection case)
+} else if create_record_existed {
+    let seq = bump_seq(ext_data);
+    update_create_record(...);
+}
+// Then bump seq for each column
+for col in tbl_info.non_pks.iter() {
+    let seq = bump_seq(ext_data);  // First call returns 0
+    ...
+}
+```
+
+**Zig (before fix):**
+```zig
+// Always called, even for fresh inserts
+const seq_reinsert = site_identity.getNextSeq();  // Returns 0, wasted
+_ = maybeMarkReinserted(...);  // Does nothing if no sentinel
+
+// Then for each column
+const seq2 = site_identity.getNextSeq();  // Returns 1, should be 0
+```
+
+## Fix
+
+Modified `getOrCreatePkKey()` to return a struct with both `key` and `existed` flag, matching Rust/C's approach. Then only call `maybeMarkReinserted()` when `existed=true`.
+
+**Files modified:**
+- `zig/src/local_writes/after_write.zig`
+  - Added `GetOrCreateKeyResult` struct
+  - Modified `getOrCreatePkKey()` to return `{key, existed}` 
+  - Modified `crsqlAfterInsertFunc` to only bump seq for reinsert if existed
+  - Updated `crsqlAfterUpdateFunc` and `crsqlAfterDeleteFunc` callers
+
+## Verification
+
+```bash
+# Before fix:
+Zig:   t|^A	^A|x|1   # seq=1
+Rust:  t|^A	^A|x|0   # seq=0
+
+# After fix:
+Zig:   t|^A	^A|x|0   # seq=0
+Rust:  t|^A	^A|x|0   # seq=0
+```
+
+Test results:
+- `test-clock-internals.sh`: 27 PASSED, 0 seq divergences
+- `test-app-todo.sh`: 2 parity confirmed
+- `test-parity.sh`: 367 PASSED
+
+## Acceptance Criteria
+
+1. [x] Document the intended semantics of `seq`
+2. [x] Determine if divergence affects sync correctness (yes, ordering)
+3. [x] Fix Zig to match Rust (done)
+
+## Parent Docs / Cross-links
+
+- Discovery: `.tasks/done/TASK-192-prior-db-oracle-parity.md`
+- Gap backlog: `research/zig-cr/92-gap-backlog.md`
+
+## Progress Log
+- 2025-12-23: Created from TASK-192 findings.
+- 2025-12-25: Fixed in Round 76. Root cause: unconditional `getNextSeq()` for reinsert.
+
+## Completion Notes
+- Date: 2025-12-25
+- Commit: 211de13e

…hema-mismatch-unknown-column-behavior.md …hema-mismatch-unknown-column-behavior.md.tasks/active/TASK-186-schema-mismatch-unknown-column-behavior.md renamed to .tasks/done/TASK-186-schema-mismatch-unknown-column-behavior.md .tasks/active/TASK-186-schema-mismatch-unknown-column-behavior.md renamed to .tasks/done/TASK-186-schema-mismatch-unknown-column-behavior.md

@@ -1,6 +1,6 @@
 # 92-gap-backlog
 
-> Last updated: 2025-12-25 (Post-Round 75: Composite PK sync + Hypothesis tests)
+> Last updated: 2025-12-25 (Post-Round 76: seq divergence + schema mismatch fixes)
 
 ## Status
 
@@ -15,21 +15,22 @@
 - Resurrection parity: ✅ **25/25 PASSING** (Round 63)
 - Sentinel parity: ✅ **6/6 PASSING** (Round 63)
 - Multinode sync: ✅ **6/6 PASSING** (Round 63)
-- Schema mismatch: ⚠️ **11/12 PASSING** (1 divergence: unknown column behavior)
+- Schema mismatch: ✅ **12/12 PASSING** (Round 76 — unknown column now ignored)
 - Savepoint sync: ✅ **16/16 PASSING** (Round 67)
 - ATTACH CRR: ✅ **15/15 PASSING** (Round 66)
 - Site ID collision: ✅ **13/13 PASSING** (Round 66)
 - Trigger CRR: ✅ **31/31 PASSING** (Round 67)
 - VACUUM CRR: ✅ **17/17 PASSING** (Round 68)
 - Wide table: ✅ **13/13 PASSING** (Round 69)
 - PK UPDATE: ✅ **16/16 PASSING** (Round 74)
+- Clock internals: ✅ **27/27 PASSING, 0 seq divergences** (Round 76)
 - **App simulation (Todo)**: ✅ **2/2 PASSING** (Round 73)
 - **App simulation (Chat)**: ✅ **4/4 PASSING** (Round 73)
 - **App simulation (Inventory)**: ✅ **4/4 PASSING** (Round 75 — composite PK sync fixed)
 - **Stress test (60 iterations)**: ✅ **60/60 PASSING, 0 divergences** (Round 73)
 - **CL merge properties**: ✅ **18/18 PASSING** (Round 75)
 - **Sentinel properties**: ✅ **15/15 PASSING** (Round 75)
-- Parity suite: **357 passed, 13 failed (pre-existing), 22 skipped**
+- Parity suite: **367 passed, 4 failed (pre-existing edge cases), 22 skipped**
 - Test scripts: **67+ total**
 - Zig implementation: `zig/`
 - Canonical task queue: `.tasks/{backlog,active,done}/`
@@ -39,16 +40,14 @@
 ### Active (0 tasks)
 No active tasks. Core sync functionality is complete and working.
 
-### Backlog (2 tasks)
+### Backlog (1 task)
 | Task | Priority | Summary | Effort |
 |------|----------|---------|--------|
 | **TASK-207** | BLOCKED | Re-enable CI for release | Medium (blocked on release decision) |
-| **TASK-186** | MEDIUM | Schema mismatch: unknown column behavior | Design decision |
 
-### Triage Inbox (4 items)
+### Triage Inbox (3 items)
 | Task | Priority | Summary | Disposition |
 |------|----------|---------|-------------|
-| **TASK-199** | MEDIUM | seq divergence (Zig=1, Rust=0) | Needs design decision |
 | **TASK-200** | LOW | Zig validation gaps (more permissive) | Nice to have |
 | **TASK-201** | LOW | Performance regression tests | Nice to have |
 | **TASK-203** | LOW | Empty blob PK encoding divergence | Edge case |
@@ -60,7 +59,18 @@ No active tasks. Core sync functionality is complete and working.
 
 ### Known Limitations
 - **crsql_changes SELECT perf**: ~2-7x slower on wide tables vs Rust/C (COUNT is fast, SELECT * is slow)
-- **seq divergence**: Zig starts seq at 1, Rust/C at 0 (doesn't affect sync correctness)
+
+### Completed Round 76 (2025-12-25) — seq divergence + schema mismatch fixes
+- [x] **TASK-199**: Fix seq value divergence (Zig=1, Rust=0) ✓
+  - Root cause: `crsqlAfterInsertFunc` called `getNextSeq()` unconditionally for `maybeMarkReinserted`, wasting seq=0
+  - Fix: Modified `getOrCreatePkKey()` to return `{key, existed}` struct, only bump seq for reinsert if existed
+  - Files: `zig/src/local_writes/after_write.zig`
+  - Result: `test-clock-internals.sh` now 27/27 PASS with 0 seq divergences
+- [x] **TASK-186**: Fix schema mismatch unknown column behavior ✓
+  - Decision: Align with Rust/C (lenient) — ignore unknown columns during sync
+  - Fix: Added `columnExistsInTable()` helper, check before applying column changes
+  - Files: `zig/src/merge_insert.zig`, `zig/src/changes_vtab.zig`
+  - Result: `test-schema-mismatch.sh` now 12/12 PASS
 
 ### Completed Round 75 (2025-12-25) — Composite PK sync + Hypothesis tests
 - [x] **TASK-208**: Fix composite PK sync ✓

.tasks/done/TASK-199-seq-value-divergence.md

@@ -1731,6 +1731,15 @@ fn changesUpdate(
             // No local row - INSERT new row
             log.debug("changesUpdate: no local row, inserting new row", .{});
 
+            // Check if the column exists in the destination table.
+            // If not, skip this change gracefully (matches Rust/C lenient behavior).
+            // This handles staggered migrations where source has columns destination doesn't.
+            if (!merge_insert.columnExistsInTable(api_db, table_slice, cid_slice)) {
+                log.debug("changesUpdate: column '{s}' does not exist in table '{s}', skipping (lenient mode)", .{ cid_slice, table_slice });
+                pRowid.* = 0;
+                return vtab.SQLITE_OK;
+            }
+
             // Get the value from argv[5] (column 3: val)
             const insert_value = toApiValue(argv[5]);
 
@@ -1948,6 +1957,16 @@ fn changesUpdate(
         return vtab.SQLITE_OK;
     }
 
+    // Step 4a: Check if column exists in destination table.
+    // If not, skip this change gracefully (matches Rust/C lenient behavior).
+    // This handles staggered migrations where source has columns destination doesn't.
+    // Note: This check comes AFTER sentinel handling since sentinels (-1) always "exist".
+    if (!merge_insert.columnExistsInTable(api_db, table_slice, cid_slice)) {
+        log.debug("changesUpdate: column '{s}' does not exist in table '{s}', skipping (lenient mode)", .{ cid_slice, table_slice });
+        pRowid.* = 0;
+        return vtab.SQLITE_OK;
+    }
+
     // Step 4b: Check if row needs resurrection
     // A row needs resurrection if:
     //   - The incoming cl indicates live (odd) OR cl > local_cl