capture more tasks

Author: subtleGradient

.tasks/backlog/TASK-161-resurrection-parity-suite.md

@@ -0,0 +1,75 @@
+# TASK-161 — Resurrection parity test suite (consolidated)
+
+## Goal
+Create comprehensive resurrection tests verifying Zig matches Rust/C oracle for all CL (causal length) scenarios.
+
+## Status
+- State: backlog
+- Priority: high (cross-impl parity, CL semantics)
+- Parallelizable: YES (no file conflicts with other backlog tasks)
+
+## Context
+Consolidates TASK-161 through TASK-165 into a single test file. These scenarios from Python `test_cl_merging.py` are not covered in Zig harness:
+
+1. **Live row via sentinel**: Sentinel arrives for already-live row
+2. **Dead row via sentinel**: Sentinel resurrects tombstoned row
+3. **Live row via column**: Column update on live row (normal case with CL verification)
+4. **Dead row via column**: Column update resurrects tombstoned row
+5. **Out-of-order sync**: Changes arrive in wrong order (delete after resurrect)
+
+## Files to Modify
+- `zig/harness/test-resurrection-parity.sh` (new, ~400 lines)
+- `zig/harness/test-parity.sh` (wire in new test)
+
+## Acceptance Criteria
+1. Each of 5 scenarios implemented as separate test function
+2. Each test runs against both Zig and Rust/C oracle
+3. Each test compares final state (data, clock entries, CL values)
+4. All tests PASS with identical behavior
+5. Test output clearly documents any divergences found
+
+## Test Skeleton
+```bash
+#!/usr/bin/env bash
+# test-resurrection-parity.sh - CL resurrection scenarios
+
+test_live_via_sentinel() {
+    # Site A: INSERT row (CL=1)
+    # Site A: DELETE row (CL=2) 
+    # Site A: INSERT row (CL=3) - resurrection
+    # Site B: has live row (CL=1)
+    # Site B: receives resurrection sentinel (CL=3)
+    # Verify: both live, CL=3
+}
+
+test_dead_via_sentinel() {
+    # Create, delete (tombstone CL=2)
+    # Send resurrection sentinel (CL=3)
+    # Verify: resurrected, CL=3
+}
+
+test_live_via_column() {
+    # Normal UPDATE case but verify CL advances
+}
+
+test_dead_via_column() {
+    # Tombstoned row receives column update with higher CL
+    # Should resurrect with that column value
+}
+
+test_out_of_order() {
+    # Send changes in order: INSERT(CL=1), RESURRECT(CL=3), DELETE(CL=2)
+    # Verify: row is live (CL=3 wins)
+}
+```
+
+## Parent Docs / Cross-links
+- Python tests: `py/correctness/tests/test_cl_merging.py`
+- Supersedes: TASK-162, TASK-163, TASK-164, TASK-165
+- Gap backlog: `research/zig-cr/92-gap-backlog.md`
+
+## Progress Log
+- 2025-12-22: Consolidated from 5 individual tasks for efficient parallel execution.
+
+## Completion Notes
+(Empty until done.)

.tasks/backlog/TASK-166-sentinel-parity-suite.md

@@ -0,0 +1,71 @@
+# TASK-166 — Sentinel emission parity test suite (consolidated)
+
+## Goal
+Create comprehensive sentinel tests verifying Zig matches Rust/C oracle for sentinel (cid='-1') emission rules.
+
+## Status
+- State: backlog
+- Priority: high (wire format parity)
+- Parallelizable: YES (no file conflicts with other backlog tasks)
+
+## Context
+Consolidates TASK-166 through TASK-169 into a single test file. These scenarios from Python `test_sentinel_omission.py` are not covered in Zig harness:
+
+1. **No sentinel on INSERT**: Normal INSERT should NOT create cid='-1'
+2. **Sentinel on DELETE**: DELETE MUST create cid='-1' with CL
+3. **No sentinel on REPLACE**: INSERT OR REPLACE should NOT create sentinel
+4. **No sentinel on merge**: Applying remote changes should NOT create new sentinels
+
+## Files to Modify
+- `zig/harness/test-sentinel-parity.sh` (new, ~300 lines)
+- `zig/harness/test-parity.sh` (wire in new test)
+
+## Acceptance Criteria
+1. Each of 4 scenarios implemented as separate test function
+2. Each test runs against both Zig and Rust/C oracle
+3. Each test queries clock table for cid='-1' presence
+4. All tests PASS with identical behavior
+5. Sentinel propagation during sync verified (not created, just passed through)
+
+## Test Skeleton
+```bash
+#!/usr/bin/env bash
+# test-sentinel-parity.sh - Sentinel emission rules
+
+test_no_sentinel_on_insert() {
+    # INSERT row
+    # Query: SELECT * FROM t__crsql_clock WHERE cid = '-1'
+    # Verify: no rows (sentinel not created)
+}
+
+test_sentinel_on_delete() {
+    # INSERT then DELETE
+    # Query: SELECT * FROM t__crsql_clock WHERE cid = '-1'
+    # Verify: 1 row with correct CL
+}
+
+test_no_sentinel_on_replace() {
+    # INSERT then INSERT OR REPLACE
+    # Verify: no sentinel created
+}
+
+test_no_sentinel_on_merge() {
+    # Site A: INSERT
+    # Sync to Site B
+    # Verify: Site B has data but NO sentinel in clock
+    # Site A: DELETE (creates sentinel)
+    # Sync to Site B
+    # Verify: Site B has sentinel (propagated, not new)
+}
+```
+
+## Parent Docs / Cross-links
+- Python tests: `py/correctness/tests/test_sentinel_omission.py`
+- Supersedes: TASK-167, TASK-168, TASK-169
+- Gap backlog: `research/zig-cr/92-gap-backlog.md`
+
+## Progress Log
+- 2025-12-22: Consolidated from 4 individual tasks for efficient parallel execution.
+
+## Completion Notes
+(Empty until done.)

.tasks/backlog/TASK-170-fk-cascade-suite.md

@@ -0,0 +1,83 @@
+# TASK-170 — Foreign key and cascade test suite (consolidated)
+
+## Goal
+Create tests verifying Zig handles foreign keys and cascading operations between CRR tables.
+
+## Status
+- State: backlog
+- Priority: high (real-world apps have FKs)
+- Parallelizable: YES (no file conflicts with other backlog tasks)
+
+## Context
+Consolidates TASK-170 and TASK-171. No existing tests verify FK behavior between CRR tables.
+
+Key questions to answer:
+1. Can CRR tables have FK constraints to each other?
+2. What happens when child row syncs before parent?
+3. Do cascaded deletes get proper clock entries?
+4. Is the cascade CL correct for sync convergence?
+
+## Files to Modify
+- `zig/harness/test-fk-crr.sh` (new, ~350 lines)
+- `zig/harness/test-parity.sh` (wire in new test)
+
+## Acceptance Criteria
+1. Test FK between two CRR tables (parent/child)
+2. Test child arriving before parent during sync
+3. Test ON DELETE CASCADE behavior
+4. Verify cascade creates proper clock entries
+5. Verify cascade clock entries have correct CL
+6. Verify sync convergence after cascade
+7. Document any Zig vs Rust/C differences
+
+## Test Skeleton
+```bash
+#!/usr/bin/env bash
+# test-fk-crr.sh - Foreign keys between CRR tables
+
+setup_fk_tables() {
+    # CREATE TABLE parent (id INTEGER PRIMARY KEY NOT NULL);
+    # CREATE TABLE child (id INTEGER PRIMARY KEY NOT NULL, 
+    #                     parent_id INTEGER REFERENCES parent(id) ON DELETE CASCADE);
+    # SELECT crsql_as_crr('parent');
+    # SELECT crsql_as_crr('child');
+}
+
+test_fk_basic() {
+    # INSERT parent, INSERT child
+    # Verify: both have clock entries
+}
+
+test_child_before_parent_sync() {
+    # Site A: INSERT parent, INSERT child
+    # Site B: receive child first (via crsql_changes)
+    # Document: does it fail? defer? succeed with dangling FK?
+    # Site B: receive parent
+    # Verify: FK now satisfied
+}
+
+test_cascade_delete() {
+    # INSERT parent + 3 children
+    # DELETE parent (cascades to children)
+    # Verify: all 4 rows have tombstones
+    # Verify: child tombstones have clock entries
+    # Verify: child tombstone CL values
+}
+
+test_cascade_sync_convergence() {
+    # Site A: cascade delete
+    # Site B: has parent + children
+    # Sync A to B
+    # Verify: B has all tombstones
+}
+```
+
+## Parent Docs / Cross-links
+- Supersedes: TASK-171
+- Gap backlog: `research/zig-cr/92-gap-backlog.md`
+
+## Progress Log
+- 2025-12-22: Consolidated FK and cascade tasks.
+
+## Completion Notes
+(Empty until done.)

.tasks/backlog/TASK-172-error-handling.md

@@ -0,0 +1,63 @@
+# TASK-172 — Malformed input error handling tests
+
+## Goal
+Verify Zig handles malformed inputs gracefully (error, not crash).
+
+## Status
+- State: backlog
+- Priority: high (security/robustness)
+- Parallelizable: YES (no file conflicts with other backlog tasks)
+
+## Context
+The `pk` column in crsql_changes contains packed binary data. Malformed data could crash or corrupt. We need to verify graceful error handling.
+
+## Files to Modify
+- `zig/harness/test-error-handling.sh` (new, ~250 lines)
+- `zig/harness/test-parity.sh` (wire in new test)
+
+## Acceptance Criteria
+1. Test truncated PK blob → error, not crash
+2. Test wrong column count header → error
+3. Test invalid type markers → error
+4. Test corrupted length prefixes → error
+5. Error messages are actionable (not just "error")
+6. Database remains uncorrupted after each error
+7. Zig and Rust/C produce same error behavior
+
+## Test Skeleton
+```bash
+#!/usr/bin/env bash
+# test-error-handling.sh - Malformed input handling
+
+test_truncated_pk() {
+    # Valid PK would be X'010901' (1 col, int8, value 1)
+    # Send X'0109' (truncated)
+    # Expect: error, no crash
+}
+
+test_wrong_column_count() {
+    # Header says 3 columns but only 1 value
+    # Expect: error
+}
+
+test_invalid_type_marker() {
+    # Use type marker 0xFF (invalid)
+    # Expect: error
+}
+
+test_db_uncorrupted_after_error() {
+    # Insert valid row
+    # Attempt malformed insert (fails)
+    # Verify: valid row still intact
+    # Verify: can still INSERT/UPDATE/DELETE
+}
+```
+
+## Parent Docs / Cross-links
+- Gap backlog: `research/zig-cr/92-gap-backlog.md`
+
+## Progress Log
+- 2025-12-22: Created from gap analysis.
+
+## Completion Notes
+(Empty until done.)

.tasks/backlog/TASK-173-schema-mismatch.md

@@ -0,0 +1,62 @@
+# TASK-173 — Schema mismatch during sync tests
+
+## Goal
+Verify Zig handles schema mismatches gracefully during sync.
+
+## Status
+- State: backlog
+- Priority: medium (production scenario)
+- Parallelizable: YES (no file conflicts with other backlog tasks)
+
+## Context
+Different sites may have different schemas due to staggered migrations. Need to document and test behavior.
+
+## Files to Modify
+- `zig/harness/test-schema-mismatch.sh` (new, ~200 lines)
+- `zig/harness/test-parity.sh` (wire in new test)
+
+## Acceptance Criteria
+1. Test: source has column destination doesn't
+2. Test: destination has column source doesn't
+3. Document behavior for each case (error? ignored? partial?)
+4. Zig and Rust/C produce identical behavior
+5. No data corruption in any case
+
+## Test Skeleton
+```bash
+#!/usr/bin/env bash
+# test-schema-mismatch.sh - Schema mismatch handling
+
+test_source_has_extra_column() {
+    # Site A: table with columns (id, name, extra)
+    # Site B: table with columns (id, name) - no 'extra'
+    # Site A: INSERT with extra='value'
+    # Sync A changes to B
+    # Document: what happens to 'extra' column data?
+}
+
+test_dest_has_extra_column() {
+    # Site A: table with columns (id, name)
+    # Site B: table with columns (id, name, extra)
+    # Site A: INSERT
+    # Sync A changes to B
+    # Verify: row created, extra column is NULL/default
+}
+
+test_type_mismatch() {
+    # Site A: column 'val' is INTEGER
+    # Site B: column 'val' is TEXT
+    # Site A: INSERT val=42
+    # Sync A to B
+    # Document: type coercion or error?
+}
+```
+
+## Parent Docs / Cross-links
+- Gap backlog: `research/zig-cr/92-gap-backlog.md`
+
+## Progress Log
+- 2025-12-22: Created from gap analysis.
+
+## Completion Notes
+(Empty until done.)