Remove snapshot/restore functionality from compaction

Snapshots defeated the entire purpose of compaction - if we're keeping
the original content, we're not actually saving any space. Compaction
is about graceful memory decay for agentic databases, not reversible
compression.

Removed:
- CreateSnapshot/GetSnapshots/RestoreFromSnapshot from storage
- --restore flag and functionality from bd compact command
- All snapshot-related tests
- Snapshot struct and related code

The database is ephemeral and meant to decay over time. Compaction
actually reduces database size now.

Closes bd-260 (won't fix - conceptually wrong)
Closes bd-261 (already done in bd-259)

cmd/bd/compact.go

@@ -12,15 +12,14 @@ import (
 )
 
 var (
-	compactDryRun   bool
+	compactDryRun  bool
-	compactTier     int
+	compactTier    int
-	compactAll      bool
+	compactAll     bool
-	compactID       string
+	compactID      string
-	compactForce    bool
+	compactForce   bool
-	compactBatch    int
+	compactBatch   int
-	compactWorkers  int
+	compactWorkers int
-	compactStats    bool
+	compactStats   bool
-	compactRestore  string
 )
 
 var compactCmd = &cobra.Command{
@@ -41,7 +40,6 @@ Examples:
   bd compact --id bd-42                 # Compact specific issue
   bd compact --id bd-42 --force         # Force compact (bypass checks)
   bd compact --stats                    # Show statistics
-  bd compact --restore bd-42            # Restore from snapshot
 `,
 	Run: func(cmd *cobra.Command, args []string) {
 		ctx := context.Background()
@@ -57,11 +55,6 @@ Examples:
 			return
 		}
 
-		if compactRestore != "" {
-			runCompactRestore(ctx, sqliteStore, compactRestore)
-			return
-		}
-
 		if compactID != "" && compactAll {
 			fmt.Fprintf(os.Stderr, "Error: cannot use --id and --all together\n")
 			os.Exit(1)
@@ -367,11 +360,6 @@ func runCompactStats(ctx context.Context, store *sqlite.SQLiteStorage) {
 	}
 }
 
-func runCompactRestore(ctx context.Context, store *sqlite.SQLiteStorage, issueID string) {
-	fmt.Fprintf(os.Stderr, "Error: --restore not yet implemented\n")
-	os.Exit(1)
-}
-
 func progressBar(current, total int) string {
 	const width = 40
 	if total == 0 {
@@ -398,7 +386,6 @@ func init() {
 	compactCmd.Flags().IntVar(&compactBatch, "batch-size", 10, "Issues per batch")
 	compactCmd.Flags().IntVar(&compactWorkers, "workers", 5, "Parallel workers")
 	compactCmd.Flags().BoolVar(&compactStats, "stats", false, "Show compaction statistics")
-	compactCmd.Flags().StringVar(&compactRestore, "restore", "", "Restore issue from snapshot")
 
 	rootCmd.AddCommand(compactCmd)
 }

internal/compact/compactor.go

@@ -88,10 +88,6 @@ func (c *Compactor) CompactTier1(ctx context.Context, issueID string) error {
 		return fmt.Errorf("dry-run: would compact %s (original size: %d bytes)", issueID, originalSize)
 	}
 
-	if err := c.store.CreateSnapshot(ctx, issue, 1); err != nil {
-		return fmt.Errorf("failed to create snapshot: %w", err)
-	}
-
 	summary, err := c.haiku.SummarizeTier1(ctx, issue)
 	if err != nil {
 		return fmt.Errorf("failed to summarize with Haiku: %w", err)
@@ -235,10 +231,6 @@ func (c *Compactor) compactSingleWithResult(ctx context.Context, issueID string,
 
 	result.OriginalSize = len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria)
 
-	if err := c.store.CreateSnapshot(ctx, issue, 1); err != nil {
-		return fmt.Errorf("failed to create snapshot: %w", err)
-	}
-
 	summary, err := c.haiku.SummarizeTier1(ctx, issue)
 	if err != nil {
 		return fmt.Errorf("failed to summarize with Haiku: %w", err)

internal/compact/compactor_test.go

@@ -224,18 +224,6 @@ func TestCompactTier1_WithAPI(t *testing.T) {
 	if afterIssue.AcceptanceCriteria != "" {
 		t.Error("acceptance criteria should be cleared")
 	}
-
-	snapshots, err := store.GetSnapshots(ctx, issue.ID)
-	if err != nil {
-		t.Fatalf("failed to get snapshots: %v", err)
-	}
-	if len(snapshots) == 0 {
-		t.Fatal("snapshot should exist")
-	}
-	snapshot := snapshots[0]
-	if snapshot.Description != issue.Description {
-		t.Error("snapshot should preserve original description")
-	}
 }
 
 func TestCompactTier1Batch_DryRun(t *testing.T) {

internal/storage/sqlite/compact.go

@@ -3,11 +3,8 @@ package sqlite
 import (
 	"context"
 	"database/sql"
-	"encoding/json"
 	"fmt"
 	"time"
-
-	"github.com/steveyegge/beads/internal/types"
 )
 
 // CompactionCandidate represents an issue eligible for compaction
@@ -19,18 +16,6 @@ type CompactionCandidate struct {
 	DependentCount int
 }
 
-// Snapshot represents a saved version of issue content before compaction
-type Snapshot struct {
-	IssueID            string    `json:"issue_id"`
-	CompactionLevel    int       `json:"compaction_level"`
-	Description        string    `json:"description"`
-	Design             string    `json:"design"`
-	Notes              string    `json:"notes"`
-	AcceptanceCriteria string    `json:"acceptance_criteria"`
-	Title              string    `json:"title"`
-	CreatedAt          time.Time `json:"created_at"`
-}
-
 // GetTier1Candidates returns issues eligible for Tier 1 compaction.
 // Criteria:
 // - Status = closed
@@ -291,166 +276,6 @@ func (s *SQLiteStorage) CheckEligibility(ctx context.Context, issueID string, ti
 	return false, fmt.Sprintf("invalid tier: %d", tier), nil
 }
 
-// CreateSnapshot creates a snapshot of the issue's content before compaction.
-// The snapshot includes all text fields and is stored as JSON.
-// Multiple snapshots can exist per issue (one per compaction level).
-// NOTE: This should be called within the same transaction as the compaction operation.
-func (s *SQLiteStorage) CreateSnapshot(ctx context.Context, issue *types.Issue, level int) error {
-	if level <= 0 {
-		return fmt.Errorf("invalid compaction level %d; must be >= 1", level)
-	}
-
-	snapshot := Snapshot{
-		IssueID:            issue.ID,
-		CompactionLevel:    level,
-		Description:        issue.Description,
-		Design:             issue.Design,
-		Notes:              issue.Notes,
-		AcceptanceCriteria: issue.AcceptanceCriteria,
-		Title:              issue.Title,
-		CreatedAt:          time.Now().UTC(),
-	}
-
-	snapshotJSON, err := json.Marshal(snapshot)
-	if err != nil {
-		return fmt.Errorf("failed to marshal snapshot: %w", err)
-	}
-
-	query := `
-		INSERT INTO compaction_snapshots (issue_id, compaction_level, snapshot_json, created_at)
-		VALUES (?, ?, ?, ?)
-	`
-
-	_, err = s.db.ExecContext(ctx, query, issue.ID, level, snapshotJSON, snapshot.CreatedAt)
-	if err != nil {
-		return fmt.Errorf("failed to insert snapshot: %w", err)
-	}
-
-	return nil
-}
-
-// RestoreFromSnapshot restores an issue's content from a snapshot.
-// Returns the exact original content from the snapshot at the specified level.
-// Uses a transaction with optimistic concurrency control to prevent race conditions.
-func (s *SQLiteStorage) RestoreFromSnapshot(ctx context.Context, issueID string, level int) error {
-	if level <= 0 {
-		return fmt.Errorf("invalid level %d; must be >= 1", level)
-	}
-
-	tx, err := s.db.BeginTx(ctx, nil)
-	if err != nil {
-		return fmt.Errorf("begin tx: %w", err)
-	}
-	defer func() {
-		if err != nil {
-			_ = tx.Rollback()
-		}
-	}()
-
-	var snapshotJSON []byte
-	err = tx.QueryRowContext(ctx, `
-		SELECT snapshot_json
-		FROM compaction_snapshots
-		WHERE issue_id = ? AND compaction_level = ?
-		ORDER BY created_at DESC
-		LIMIT 1
-	`, issueID, level).Scan(&snapshotJSON)
-	if err == sql.ErrNoRows {
-		return fmt.Errorf("no snapshot found for issue %s at level %d", issueID, level)
-	}
-	if err != nil {
-		return fmt.Errorf("failed to query snapshot: %w", err)
-	}
-
-	var snapshot Snapshot
-	if err = json.Unmarshal(snapshotJSON, &snapshot); err != nil {
-		return fmt.Errorf("failed to unmarshal snapshot: %w", err)
-	}
-
-	if snapshot.IssueID != issueID {
-		return fmt.Errorf("snapshot issue_id mismatch: got %s, want %s", snapshot.IssueID, issueID)
-	}
-
-	restoreLevel := snapshot.CompactionLevel - 1
-	if restoreLevel < 0 {
-		return fmt.Errorf("invalid restore level computed: %d", restoreLevel)
-	}
-
-	res, err := tx.ExecContext(ctx, `
-		UPDATE issues
-		SET description = ?,
-		    design = ?,
-		    notes = ?,
-		    acceptance_criteria = ?,
-		    title = ?,
-		    compaction_level = ?,
-		    updated_at = ?
-		WHERE id = ? AND COALESCE(compaction_level, 0) = ?
-	`,
-		snapshot.Description,
-		snapshot.Design,
-		snapshot.Notes,
-		snapshot.AcceptanceCriteria,
-		snapshot.Title,
-		restoreLevel,
-		time.Now().UTC(),
-		issueID,
-		snapshot.CompactionLevel,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to restore issue content: %w", err)
-	}
-
-	rows, _ := res.RowsAffected()
-	if rows == 0 {
-		return fmt.Errorf("restore conflict: current compaction_level changed or issue not found")
-	}
-
-	if err = tx.Commit(); err != nil {
-		return fmt.Errorf("commit restore tx: %w", err)
-	}
-
-	return nil
-}
-
-// GetSnapshots returns all snapshots for an issue, ordered by compaction level and creation time.
-// Returns the latest snapshot for each level.
-func (s *SQLiteStorage) GetSnapshots(ctx context.Context, issueID string) ([]*Snapshot, error) {
-	query := `
-		SELECT snapshot_json
-		FROM compaction_snapshots
-		WHERE issue_id = ?
-		ORDER BY compaction_level ASC, created_at DESC
-	`
-
-	rows, err := s.db.QueryContext(ctx, query, issueID)
-	if err != nil {
-		return nil, fmt.Errorf("failed to query snapshots: %w", err)
-	}
-	defer rows.Close()
-
-	var snapshots []*Snapshot
-	for rows.Next() {
-		var snapshotJSON []byte
-		if err := rows.Scan(&snapshotJSON); err != nil {
-			return nil, fmt.Errorf("failed to scan snapshot: %w", err)
-		}
-
-		var snapshot Snapshot
-		if err := json.Unmarshal(snapshotJSON, &snapshot); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal snapshot: %w", err)
-		}
-
-		snapshots = append(snapshots, &snapshot)
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("rows iteration error: %w", err)
-	}
-
-	return snapshots, nil
-}
-
 // ApplyCompaction updates the compaction metadata for an issue after successfully compacting it.
 // This sets compaction_level, compacted_at, and original_size fields.
 func (s *SQLiteStorage) ApplyCompaction(ctx context.Context, issueID string, level int, originalSize int) error {

internal/storage/sqlite/compact_bench_test.go

@@ -110,69 +110,7 @@ func BenchmarkCheckEligibility(b *testing.B) {
 	}
 }
 
-func BenchmarkCreateSnapshot(b *testing.B) {
+func generateID(b testing.TB, prefix string, n int) string{
-	store, cleanup := setupBenchDB(b)
-	defer cleanup()
-	ctx := context.Background()
-
-	issue := &types.Issue{
-		ID:                 "bd-1",
-		Title:              "Test Issue",
-		Description:        "Original description with substantial content",
-		Design:             "Design notes with additional context",
-		Notes:              "Additional notes for the issue",
-		AcceptanceCriteria: "Must meet all requirements",
-		Status:             "closed",
-		Priority:           2,
-		IssueType:          "task",
-		ClosedAt:           timePtr(time.Now()),
-	}
-	if err := store.CreateIssue(ctx, issue, "test"); err != nil {
-		b.Fatalf("Failed to create issue: %v", err)
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		if err := store.CreateSnapshot(ctx, issue, i%5+1); err != nil {
-			b.Fatalf("CreateSnapshot failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkGetSnapshots(b *testing.B) {
-	store, cleanup := setupBenchDB(b)
-	defer cleanup()
-	ctx := context.Background()
-
-	issue := &types.Issue{
-		ID:          "bd-1",
-		Title:       "Test",
-		Description: "Test description",
-		Status:      "closed",
-		Priority:    2,
-		IssueType:   "task",
-		ClosedAt:    timePtr(time.Now()),
-	}
-	if err := store.CreateIssue(ctx, issue, "test"); err != nil {
-		b.Fatalf("Failed to create issue: %v", err)
-	}
-
-	for i := 1; i <= 5; i++ {
-		if err := store.CreateSnapshot(ctx, issue, i); err != nil {
-			b.Fatalf("CreateSnapshot failed: %v", err)
-		}
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, err := store.GetSnapshots(ctx, issue.ID)
-		if err != nil {
-			b.Fatalf("GetSnapshots failed: %v", err)
-		}
-	}
-}
-
-func generateID(b testing.TB, prefix string, n int) string {
 	b.Helper()
 	return prefix + string(rune('0'+n/10)) + string(rune('0'+n%10))
 }

internal/storage/sqlite/compact_test.go

@@ -3,7 +3,6 @@ package sqlite
 import (
 	"context"
 	"database/sql"
-	"strings"
 	"testing"
 	"time"
 
@@ -315,236 +314,6 @@ func TestTier1NoCircularDeps(t *testing.T) {
 	}
 }
 
-func TestCreateSnapshot(t *testing.T) {
-	store, cleanup := setupTestDB(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	issue := &types.Issue{
-		ID:                 "bd-1",
-		Title:              "Test Issue",
-		Description:        "Original description",
-		Design:             "Design notes",
-		Notes:              "Additional notes",
-		AcceptanceCriteria: "Must work",
-		Status:             "closed",
-		Priority:           2,
-		IssueType:          "task",
-		ClosedAt:           timePtr(time.Now()),
-	}
-	if err := store.CreateIssue(ctx, issue, "test"); err != nil {
-		t.Fatalf("Failed to create issue: %v", err)
-	}
-
-	err := store.CreateSnapshot(ctx, issue, 1)
-	if err != nil {
-		t.Fatalf("CreateSnapshot failed: %v", err)
-	}
-
-	snapshots, err := store.GetSnapshots(ctx, issue.ID)
-	if err != nil {
-		t.Fatalf("GetSnapshots failed: %v", err)
-	}
-
-	if len(snapshots) != 1 {
-		t.Fatalf("Expected 1 snapshot, got %d", len(snapshots))
-	}
-
-	snapshot := snapshots[0]
-	if snapshot.Description != issue.Description {
-		t.Errorf("Expected description %q, got %q", issue.Description, snapshot.Description)
-	}
-	if snapshot.Design != issue.Design {
-		t.Errorf("Expected design %q, got %q", issue.Design, snapshot.Design)
-	}
-	if snapshot.Notes != issue.Notes {
-		t.Errorf("Expected notes %q, got %q", issue.Notes, snapshot.Notes)
-	}
-	if snapshot.AcceptanceCriteria != issue.AcceptanceCriteria {
-		t.Errorf("Expected criteria %q, got %q", issue.AcceptanceCriteria, snapshot.AcceptanceCriteria)
-	}
-}
-
-func TestCreateSnapshotUTF8(t *testing.T) {
-	store, cleanup := setupTestDB(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	issue := &types.Issue{
-		ID:                 "bd-1",
-		Title:              "UTF-8 Test 🎉",
-		Description:        "Café, résumé, 日本語, emoji 🚀",
-		Design:             "Design with 中文 and émojis 🔥",
-		Notes:              "Notes: ñ, ü, é, à",
-		AcceptanceCriteria: "Must handle UTF-8 correctly ✅",
-		Status:             "closed",
-		Priority:           2,
-		IssueType:          "task",
-		ClosedAt:           timePtr(time.Now()),
-	}
-	if err := store.CreateIssue(ctx, issue, "test"); err != nil {
-		t.Fatalf("Failed to create issue: %v", err)
-	}
-
-	err := store.CreateSnapshot(ctx, issue, 1)
-	if err != nil {
-		t.Fatalf("CreateSnapshot failed: %v", err)
-	}
-
-	snapshots, err := store.GetSnapshots(ctx, issue.ID)
-	if err != nil {
-		t.Fatalf("GetSnapshots failed: %v", err)
-	}
-
-	if len(snapshots) != 1 {
-		t.Fatalf("Expected 1 snapshot, got %d", len(snapshots))
-	}
-
-	snapshot := snapshots[0]
-	if snapshot.Title != issue.Title {
-		t.Errorf("UTF-8 title not preserved: expected %q, got %q", issue.Title, snapshot.Title)
-	}
-	if snapshot.Description != issue.Description {
-		t.Errorf("UTF-8 description not preserved: expected %q, got %q", issue.Description, snapshot.Description)
-	}
-	if snapshot.Design != issue.Design {
-		t.Errorf("UTF-8 design not preserved: expected %q, got %q", issue.Design, snapshot.Design)
-	}
-}
-
-func TestCreateMultipleSnapshots(t *testing.T) {
-	store, cleanup := setupTestDB(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	issue := &types.Issue{
-		ID:          "bd-1",
-		Title:       "Test Issue",
-		Description: "Original",
-		Status:      "closed",
-		Priority:    2,
-		IssueType:   "task",
-		ClosedAt:    timePtr(time.Now()),
-	}
-	if err := store.CreateIssue(ctx, issue, "test"); err != nil {
-		t.Fatalf("Failed to create issue: %v", err)
-	}
-
-	if err := store.CreateSnapshot(ctx, issue, 1); err != nil {
-		t.Fatalf("CreateSnapshot level 1 failed: %v", err)
-	}
-
-	issue.Description = "Compacted once"
-	if err := store.CreateSnapshot(ctx, issue, 2); err != nil {
-		t.Fatalf("CreateSnapshot level 2 failed: %v", err)
-	}
-
-	snapshots, err := store.GetSnapshots(ctx, issue.ID)
-	if err != nil {
-		t.Fatalf("GetSnapshots failed: %v", err)
-	}
-
-	if len(snapshots) != 2 {
-		t.Fatalf("Expected 2 snapshots, got %d", len(snapshots))
-	}
-
-	if snapshots[0].CompactionLevel != 1 {
-		t.Errorf("Expected first snapshot level 1, got %d", snapshots[0].CompactionLevel)
-	}
-	if snapshots[1].CompactionLevel != 2 {
-		t.Errorf("Expected second snapshot level 2, got %d", snapshots[1].CompactionLevel)
-	}
-}
-
-func TestRestoreFromSnapshot(t *testing.T) {
-	store, cleanup := setupTestDB(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	issue := &types.Issue{
-		ID:                 "bd-1",
-		Title:              "Original Title",
-		Description:        "Original description",
-		Design:             "Original design",
-		Notes:              "Original notes",
-		AcceptanceCriteria: "Original criteria",
-		Status:             "closed",
-		Priority:           2,
-		IssueType:          "task",
-		ClosedAt:           timePtr(time.Now()),
-	}
-	if err := store.CreateIssue(ctx, issue, "test"); err != nil {
-		t.Fatalf("Failed to create issue: %v", err)
-	}
-
-	if err := store.CreateSnapshot(ctx, issue, 1); err != nil {
-		t.Fatalf("CreateSnapshot failed: %v", err)
-	}
-
-	_, err := store.db.ExecContext(ctx, `
-		UPDATE issues 
-		SET description = 'Compacted', 
-		    design = '', 
-		    notes = '', 
-		    acceptance_criteria = '',
-		    compaction_level = 1
-		WHERE id = ?
-	`, issue.ID)
-	if err != nil {
-		t.Fatalf("Failed to update issue: %v", err)
-	}
-
-	err = store.RestoreFromSnapshot(ctx, issue.ID, 1)
-	if err != nil {
-		t.Fatalf("RestoreFromSnapshot failed: %v", err)
-	}
-
-	restored, err := store.GetIssue(ctx, issue.ID)
-	if err != nil {
-		t.Fatalf("GetIssue failed: %v", err)
-	}
-
-	if restored.Description != issue.Description {
-		t.Errorf("Description not restored: expected %q, got %q", issue.Description, restored.Description)
-	}
-	if restored.Design != issue.Design {
-		t.Errorf("Design not restored: expected %q, got %q", issue.Design, restored.Design)
-	}
-	if restored.Notes != issue.Notes {
-		t.Errorf("Notes not restored: expected %q, got %q", issue.Notes, restored.Notes)
-	}
-	if restored.AcceptanceCriteria != issue.AcceptanceCriteria {
-		t.Errorf("Criteria not restored: expected %q, got %q", issue.AcceptanceCriteria, restored.AcceptanceCriteria)
-	}
-}
-
-func TestRestoreSnapshotNoSnapshot(t *testing.T) {
-	store, cleanup := setupTestDB(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	issue := &types.Issue{
-		ID:          "bd-1",
-		Title:       "Test",
-		Description: "Test",
-		Status:      "closed",
-		Priority:    2,
-		IssueType:   "task",
-		ClosedAt:    timePtr(time.Now()),
-	}
-	if err := store.CreateIssue(ctx, issue, "test"); err != nil {
-		t.Fatalf("Failed to create issue: %v", err)
-	}
-
-	err := store.RestoreFromSnapshot(ctx, issue.ID, 1)
-	if err == nil {
-		t.Fatal("Expected error when no snapshot exists")
-	}
-	if !strings.Contains(err.Error(), "no snapshot found") {
-		t.Errorf("Expected 'no snapshot found' error, got: %v", err)
-	}
-}
-
 func TestApplyCompaction(t *testing.T) {
 	store, cleanup := setupTestDB(t)
 	defer cleanup()