Fix bd-dvd and bd-ymj: Parent resurrection and export metadata

Bug 1 (bd-dvd): GetNextChildID now attempts parent resurrection from JSONL
before failing. Added TryResurrectParent call to match CreateIssue behavior.

Bug 2 (bd-ymj): Export now updates last_import_hash metadata to prevent
'JSONL content has changed' errors on subsequent exports.

Files changed:
- internal/storage/sqlite/hash_ids.go: Add resurrection attempt
- cmd/bd/daemon_sync.go: Add metadata updates after export
- Tests added for both fixes
- Fixed pre-existing bug in integrity_content_test.go

Follow-up work tracked in epic bd-ar2 (9 issues for improvements).

Fixes GH #334

cmd/bd/daemon_sync.go

@@ -306,6 +306,27 @@ func createExportFunc(ctx context.Context, store storage.Storage, autoCommit, au
 		}
 		log.log("Exported to JSONL")
 
+		// Update last_import_hash metadata to prevent "content has changed" errors (bd-ymj fix)
+		// This keeps metadata in sync after export so next export doesn't fail
+		if currentHash, err := computeJSONLHash(jsonlPath); err == nil {
+			if err := store.SetMetadata(exportCtx, "last_import_hash", currentHash); err != nil {
+				log.log("Warning: failed to update last_import_hash: %v", err)
+			}
+			exportTime := time.Now().Format(time.RFC3339)
+			if err := store.SetMetadata(exportCtx, "last_import_time", exportTime); err != nil {
+				log.log("Warning: failed to update last_import_time: %v", err)
+			}
+			// Store mtime for fast-path optimization
+			if jsonlInfo, statErr := os.Stat(jsonlPath); statErr == nil {
+				mtimeStr := fmt.Sprintf("%d", jsonlInfo.ModTime().Unix())
+				if err := store.SetMetadata(exportCtx, "last_import_mtime", mtimeStr); err != nil {
+					log.log("Warning: failed to update last_import_mtime: %v", err)
+				}
+			}
+		} else {
+			log.log("Warning: failed to compute JSONL hash for metadata update: %v", err)
+		}
+
 		// Update database mtime to be >= JSONL mtime (fixes #278, #301, #321)
 		// This prevents validatePreExport from incorrectly blocking on next export
 		// with "JSONL is newer than database" after daemon auto-export
@@ -496,6 +517,27 @@ func createSyncFunc(ctx context.Context, store storage.Storage, autoCommit, auto
 		}
 		log.log("Exported to JSONL")
 
+		// Update last_import_hash metadata to prevent "content has changed" errors (bd-ymj fix)
+		// This keeps metadata in sync after export so next export doesn't fail
+		if currentHash, err := computeJSONLHash(jsonlPath); err == nil {
+			if err := store.SetMetadata(syncCtx, "last_import_hash", currentHash); err != nil {
+				log.log("Warning: failed to update last_import_hash: %v", err)
+			}
+			exportTime := time.Now().Format(time.RFC3339)
+			if err := store.SetMetadata(syncCtx, "last_import_time", exportTime); err != nil {
+				log.log("Warning: failed to update last_import_time: %v", err)
+			}
+			// Store mtime for fast-path optimization
+			if jsonlInfo, statErr := os.Stat(jsonlPath); statErr == nil {
+				mtimeStr := fmt.Sprintf("%d", jsonlInfo.ModTime().Unix())
+				if err := store.SetMetadata(syncCtx, "last_import_mtime", mtimeStr); err != nil {
+					log.log("Warning: failed to update last_import_mtime: %v", err)
+				}
+			}
+		} else {
+			log.log("Warning: failed to compute JSONL hash for metadata update: %v", err)
+		}
+
 		// Update database mtime to be >= JSONL mtime (fixes #278, #301, #321)
 		// This prevents validatePreExport from incorrectly blocking on next export
 		dbPath := filepath.Join(beadsDir, "beads.db")

cmd/bd/daemon_sync_test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@@ -291,3 +292,92 @@ func TestExportImportRoundTrip(t *testing.T) {
 		t.Errorf("expected label 'bug', got %v", labels)
 	}
 }
+
+// TestExportUpdatesMetadata verifies that export updates last_import_hash metadata (bd-ymj fix)
+func TestExportUpdatesMetadata(t *testing.T) {
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, ".beads", "beads.db")
+	jsonlPath := filepath.Join(tmpDir, ".beads", "issues.jsonl")
+
+	// Create storage
+	store, err := sqlite.New(context.Background(), dbPath)
+	if err != nil {
+		t.Fatalf("failed to create store: %v", err)
+	}
+	defer store.Close()
+
+	ctx := context.Background()
+
+	// Set issue_prefix
+	if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
+		t.Fatalf("failed to set issue_prefix: %v", err)
+	}
+
+	// Create test issue
+	issue := &types.Issue{
+		ID:          "test-1",
+		Title:       "Test Issue",
+		Description: "Test description",
+		IssueType:   types.TypeBug,
+		Priority:    1,
+		Status:      types.StatusOpen,
+		CreatedAt:   time.Now(),
+		UpdatedAt:   time.Now(),
+	}
+
+	if err := store.CreateIssue(ctx, issue, "test"); err != nil {
+		t.Fatalf("failed to create issue: %v", err)
+	}
+
+	// First export
+	if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil {
+		t.Fatalf("first export failed: %v", err)
+	}
+
+	// Manually update metadata as daemon would (this is what we're testing)
+	// Note: In production, createExportFunc and createSyncFunc do this
+	currentHash, err := computeJSONLHash(jsonlPath)
+	if err != nil {
+		t.Fatalf("failed to compute JSONL hash: %v", err)
+	}
+	if err := store.SetMetadata(ctx, "last_import_hash", currentHash); err != nil {
+		t.Fatalf("failed to set last_import_hash: %v", err)
+	}
+	exportTime := time.Now().Format(time.RFC3339)
+	if err := store.SetMetadata(ctx, "last_import_time", exportTime); err != nil {
+		t.Fatalf("failed to set last_import_time: %v", err)
+	}
+	if jsonlInfo, statErr := os.Stat(jsonlPath); statErr == nil {
+		mtimeStr := jsonlInfo.ModTime().Unix()
+		if err := store.SetMetadata(ctx, "last_import_mtime", fmt.Sprintf("%d", mtimeStr)); err != nil {
+			t.Fatalf("failed to set last_import_mtime: %v", err)
+		}
+	}
+
+	// Verify metadata was set
+	lastHash, err := store.GetMetadata(ctx, "last_import_hash")
+	if err != nil {
+		t.Fatalf("failed to get last_import_hash: %v", err)
+	}
+	if lastHash == "" {
+		t.Error("expected last_import_hash to be set after export")
+	}
+
+	lastTime, err := store.GetMetadata(ctx, "last_import_time")
+	if err != nil {
+		t.Fatalf("failed to get last_import_time: %v", err)
+	}
+	if lastTime == "" {
+		t.Error("expected last_import_time to be set after export")
+	}
+
+	// Second export should succeed without "content has changed" error
+	if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil {
+		t.Fatalf("second export failed (metadata not updated properly): %v", err)
+	}
+
+	// Verify validatePreExport doesn't fail with "content has changed"
+	if err := validatePreExport(ctx, store, jsonlPath); err != nil {
+		t.Fatalf("validatePreExport failed after metadata update: %v", err)
+	}
+}

cmd/bd/integrity_content_test.go

@@ -27,6 +27,8 @@ func TestContentBasedComparison(t *testing.T) {
 	dbPath := filepath.Join(beadsDir, "beads.db")
 	jsonlPath := filepath.Join(beadsDir, "issues.jsonl")
 
+	ctx := context.Background()
+
 	// Create and populate database
 	localStore, err := sqlite.New(ctx, dbPath)
 	if err != nil {
@@ -34,8 +36,6 @@ func TestContentBasedComparison(t *testing.T) {
 	}
 	defer localStore.Close()
 
-	ctx := context.Background()
-
 	// Initialize database with issue_prefix
 	if err := localStore.SetConfig(ctx, "issue_prefix", "test"); err != nil {
 		t.Fatalf("Failed to set issue_prefix: %v", err)
@@ -179,6 +179,8 @@ func TestContentHashComputation(t *testing.T) {
 	dbPath := filepath.Join(beadsDir, "beads.db")
 	jsonlPath := filepath.Join(beadsDir, "issues.jsonl")
 
+	ctx := context.Background()
+
 	// Create and populate database
 	localStore, err := sqlite.New(ctx, dbPath)
 	if err != nil {
@@ -186,8 +188,6 @@ func TestContentHashComputation(t *testing.T) {
 	}
 	defer localStore.Close()
 
-	ctx := context.Background()
-
 	if err := localStore.SetConfig(ctx, "issue_prefix", "test"); err != nil {
 		t.Fatalf("Failed to set issue_prefix: %v", err)
 	}

internal/storage/sqlite/child_id_test.go

@@ -129,8 +129,10 @@ func TestGetNextChildID_ParentNotExists(t *testing.T) {
 	if err == nil {
 		t.Errorf("expected error for non-existent parent, got nil")
 	}
-	if err != nil && err.Error() != "parent issue bd-nonexistent does not exist" {
-		t.Errorf("unexpected error message: %v", err)
+	// With resurrection feature (bd-dvd fix), error message includes JSONL history check
+	expectedErr := "parent issue bd-nonexistent does not exist and could not be resurrected from JSONL history"
+	if err != nil && err.Error() != expectedErr {
+		t.Errorf("unexpected error message: got %q, want %q", err.Error(), expectedErr)
 	}
 }
 
@@ -203,3 +205,72 @@ func TestCreateIssue_HierarchicalID_ParentNotExists(t *testing.T) {
 		t.Errorf("unexpected error message: got %q, want %q", err.Error(), expectedErr)
 	}
 }
+
+func TestGetNextChildID_ResurrectParent(t *testing.T) {
+	tmpDir := t.TempDir()
+	tmpFile := tmpDir + "/test.db"
+	defer os.Remove(tmpFile)
+	store := newTestStore(t, tmpFile)
+	defer store.Close()
+	ctx := context.Background()
+
+	// Create parent issue
+	parent := &types.Issue{
+		ID:          "bd-test123",
+		ContentHash: "abc123",
+		Title:       "Parent Issue",
+		Description: "Parent to be resurrected",
+		Status:      types.StatusOpen,
+		Priority:    1,
+		IssueType:   types.TypeEpic,
+	}
+	if err := store.CreateIssue(ctx, parent, "test"); err != nil {
+		t.Fatalf("failed to create parent: %v", err)
+	}
+
+	// Delete the parent from database (simulating deletion)
+	if err := store.DeleteIssue(ctx, parent.ID); err != nil {
+		t.Fatalf("failed to delete parent: %v", err)
+	}
+
+	// Create JSONL file with the deleted parent (simulating JSONL history)
+	// Note: This requires the JSONL to be in .beads/issues.jsonl relative to dbPath
+	// The resurrection logic looks for issues.jsonl in the same directory as the database
+	beadsDir := tmpDir
+	jsonlPath := beadsDir + "/issues.jsonl"
+
+	// Write parent to JSONL
+	jsonlFile, err := os.Create(jsonlPath)
+	if err != nil {
+		t.Fatalf("failed to create JSONL file: %v", err)
+	}
+	parentJSON := `{"id":"bd-test123","content_hash":"abc123","title":"Parent Issue","description":"Parent to be resurrected","status":"open","priority":1,"type":"epic","created_at":"2025-01-01T00:00:00Z","updated_at":"2025-01-01T00:00:00Z"}`
+	if _, err := jsonlFile.WriteString(parentJSON + "\n"); err != nil {
+		jsonlFile.Close()
+		t.Fatalf("failed to write to JSONL: %v", err)
+	}
+	jsonlFile.Close()
+
+	// Now attempt to get next child ID - should resurrect parent
+	childID, err := store.GetNextChildID(ctx, parent.ID)
+	if err != nil {
+		t.Fatalf("GetNextChildID should have resurrected parent, but got error: %v", err)
+	}
+
+	expectedID := "bd-test123.1"
+	if childID != expectedID {
+		t.Errorf("expected child ID %s, got %s", expectedID, childID)
+	}
+
+	// Verify parent was resurrected as tombstone
+	resurrectedParent, err := store.GetIssue(ctx, parent.ID)
+	if err != nil {
+		t.Fatalf("failed to get resurrected parent: %v", err)
+	}
+	if resurrectedParent.Status != types.StatusClosed {
+		t.Errorf("expected resurrected parent to be closed, got %s", resurrectedParent.Status)
+	}
+	if resurrectedParent.Title != "Parent Issue" {
+		t.Errorf("expected resurrected parent title to be preserved, got %s", resurrectedParent.Title)
+	}
+}

internal/storage/sqlite/hash_ids.go

@@ -34,7 +34,14 @@ func (s *SQLiteStorage) GetNextChildID(ctx context.Context, parentID string) (st
 		return "", fmt.Errorf("failed to check parent existence: %w", err)
 	}
 	if count == 0 {
-		return "", fmt.Errorf("parent issue %s does not exist", parentID)
+		// Try to resurrect parent from JSONL history before failing (bd-dvd fix)
+		resurrected, err := s.TryResurrectParent(ctx, parentID)
+		if err != nil {
+			return "", fmt.Errorf("failed to resurrect parent %s: %w", parentID, err)
+		}
+		if !resurrected {
+			return "", fmt.Errorf("parent issue %s does not exist and could not be resurrected from JSONL history", parentID)
+		}
 	}
 	
 	// Calculate current depth by counting dots