feat: complete bd-kwro messaging & knowledge graph epic

- Add bd cleanup --ephemeral flag for transient message cleanup (bd-kwro.9) - Add Ephemeral filter to IssueFilter type - Add ephemeral filtering to SQLite storage queries Tests (bd-kwro.10): - Add internal/hooks/hooks_test.go for hook system - Add cmd/bd/mail_test.go for mail commands - Add internal/storage/sqlite/graph_links_test.go for graph links Documentation (bd-kwro.11): - Add docs/messaging.md for full messaging reference - Add docs/graph-links.md for graph link types - Update AGENTS.md with inter-agent messaging section - Update CHANGELOG.md with all bd-kwro features 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2025-12-16 20:36:47 -08:00
parent 46bfb43b8d
commit 8d73a86f7a
11 changed files with 1874 additions and 5 deletions
--- a/internal/hooks/hooks_test.go
+++ b/internal/hooks/hooks_test.go
@@ -0,0 +1,334 @@
+package hooks
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/steveyegge/beads/internal/types"
+)
+
+func TestNewRunner(t *testing.T) {
+	runner := NewRunner("/tmp/hooks")
+	if runner == nil {
+		t.Fatal("NewRunner returned nil")
+	}
+	if runner.hooksDir != "/tmp/hooks" {
+		t.Errorf("hooksDir = %q, want %q", runner.hooksDir, "/tmp/hooks")
+	}
+	if runner.timeout != 10*time.Second {
+		t.Errorf("timeout = %v, want %v", runner.timeout, 10*time.Second)
+	}
+}
+
+func TestNewRunnerFromWorkspace(t *testing.T) {
+	runner := NewRunnerFromWorkspace("/workspace")
+	if runner == nil {
+		t.Fatal("NewRunnerFromWorkspace returned nil")
+	}
+	expected := filepath.Join("/workspace", ".beads", "hooks")
+	if runner.hooksDir != expected {
+		t.Errorf("hooksDir = %q, want %q", runner.hooksDir, expected)
+	}
+}
+
+func TestEventToHook(t *testing.T) {
+	tests := []struct {
+		event    string
+		expected string
+	}{
+		{EventCreate, HookOnCreate},
+		{EventUpdate, HookOnUpdate},
+		{EventClose, HookOnClose},
+		{EventMessage, HookOnMessage},
+		{"unknown", ""},
+		{"", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.event, func(t *testing.T) {
+			result := eventToHook(tt.event)
+			if result != tt.expected {
+				t.Errorf("eventToHook(%q) = %q, want %q", tt.event, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestHookExists_NoHook(t *testing.T) {
+	tmpDir := t.TempDir()
+	runner := NewRunner(tmpDir)
+
+	if runner.HookExists(EventCreate) {
+		t.Error("HookExists returned true for non-existent hook")
+	}
+}
+
+func TestHookExists_NotExecutable(t *testing.T) {
+	tmpDir := t.TempDir()
+	hookPath := filepath.Join(tmpDir, HookOnCreate)
+
+	// Create a non-executable file
+	if err := os.WriteFile(hookPath, []byte("#!/bin/sh\necho test"), 0644); err != nil {
+		t.Fatalf("Failed to create hook file: %v", err)
+	}
+
+	runner := NewRunner(tmpDir)
+
+	if runner.HookExists(EventCreate) {
+		t.Error("HookExists returned true for non-executable hook")
+	}
+}
+
+func TestHookExists_Executable(t *testing.T) {
+	tmpDir := t.TempDir()
+	hookPath := filepath.Join(tmpDir, HookOnCreate)
+
+	// Create an executable file
+	if err := os.WriteFile(hookPath, []byte("#!/bin/sh\necho test"), 0755); err != nil {
+		t.Fatalf("Failed to create hook file: %v", err)
+	}
+
+	runner := NewRunner(tmpDir)
+
+	if !runner.HookExists(EventCreate) {
+		t.Error("HookExists returned false for executable hook")
+	}
+}
+
+func TestHookExists_Directory(t *testing.T) {
+	tmpDir := t.TempDir()
+	hookPath := filepath.Join(tmpDir, HookOnCreate)
+
+	// Create a directory instead of a file
+	if err := os.MkdirAll(hookPath, 0755); err != nil {
+		t.Fatalf("Failed to create directory: %v", err)
+	}
+
+	runner := NewRunner(tmpDir)
+
+	if runner.HookExists(EventCreate) {
+		t.Error("HookExists returned true for directory")
+	}
+}
+
+func TestRunSync_NoHook(t *testing.T) {
+	tmpDir := t.TempDir()
+	runner := NewRunner(tmpDir)
+
+	issue := &types.Issue{ID: "bd-test", Title: "Test"}
+
+	// Should not error when hook doesn't exist
+	err := runner.RunSync(EventCreate, issue)
+	if err != nil {
+		t.Errorf("RunSync returned error for non-existent hook: %v", err)
+	}
+}
+
+func TestRunSync_NotExecutable(t *testing.T) {
+	tmpDir := t.TempDir()
+	hookPath := filepath.Join(tmpDir, HookOnCreate)
+
+	// Create a non-executable file
+	if err := os.WriteFile(hookPath, []byte("#!/bin/sh\necho test"), 0644); err != nil {
+		t.Fatalf("Failed to create hook file: %v", err)
+	}
+
+	runner := NewRunner(tmpDir)
+	issue := &types.Issue{ID: "bd-test", Title: "Test"}
+
+	// Should not error when hook is not executable
+	err := runner.RunSync(EventCreate, issue)
+	if err != nil {
+		t.Errorf("RunSync returned error for non-executable hook: %v", err)
+	}
+}
+
+func TestRunSync_Success(t *testing.T) {
+	tmpDir := t.TempDir()
+	hookPath := filepath.Join(tmpDir, HookOnCreate)
+	outputFile := filepath.Join(tmpDir, "output.txt")
+
+	// Create a hook that writes to a file
+	hookScript := `#!/bin/sh
+echo "$1 $2" > ` + outputFile
+	if err := os.WriteFile(hookPath, []byte(hookScript), 0755); err != nil {
+		t.Fatalf("Failed to create hook file: %v", err)
+	}
+
+	runner := NewRunner(tmpDir)
+	issue := &types.Issue{ID: "bd-test", Title: "Test Issue"}
+
+	err := runner.RunSync(EventCreate, issue)
+	if err != nil {
+		t.Errorf("RunSync returned error: %v", err)
+	}
+
+	// Verify the hook ran and received correct arguments
+	output, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatalf("Failed to read output file: %v", err)
+	}
+
+	expected := "bd-test create\n"
+	if string(output) != expected {
+		t.Errorf("Hook output = %q, want %q", string(output), expected)
+	}
+}
+
+func TestRunSync_ReceivesJSON(t *testing.T) {
+	tmpDir := t.TempDir()
+	hookPath := filepath.Join(tmpDir, HookOnMessage)
+	outputFile := filepath.Join(tmpDir, "stdin.txt")
+
+	// Create a hook that captures stdin
+	hookScript := `#!/bin/sh
+cat > ` + outputFile
+	if err := os.WriteFile(hookPath, []byte(hookScript), 0755); err != nil {
+		t.Fatalf("Failed to create hook file: %v", err)
+	}
+
+	runner := NewRunner(tmpDir)
+	issue := &types.Issue{
+		ID:       "bd-msg",
+		Title:    "Test Message",
+		Sender:   "alice",
+		Assignee: "bob",
+	}
+
+	err := runner.RunSync(EventMessage, issue)
+	if err != nil {
+		t.Errorf("RunSync returned error: %v", err)
+	}
+
+	// Verify JSON was passed to stdin
+	output, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatalf("Failed to read output file: %v", err)
+	}
+
+	// Just check that it contains expected fields
+	if len(output) == 0 {
+		t.Error("Hook did not receive JSON input")
+	}
+	if string(output) == "" || output[0] != '{' {
+		t.Errorf("Hook input doesn't look like JSON: %s", string(output))
+	}
+}
+
+func TestRunSync_Timeout(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping timeout test in short mode")
+	}
+
+	tmpDir := t.TempDir()
+	hookPath := filepath.Join(tmpDir, HookOnCreate)
+
+	// Create a hook that sleeps for longer than timeout
+	hookScript := `#!/bin/sh
+sleep 60`
+	if err := os.WriteFile(hookPath, []byte(hookScript), 0755); err != nil {
+		t.Fatalf("Failed to create hook file: %v", err)
+	}
+
+	runner := &Runner{
+		hooksDir: tmpDir,
+		timeout:  500 * time.Millisecond, // Short timeout
+	}
+	issue := &types.Issue{ID: "bd-test", Title: "Test"}
+
+	start := time.Now()
+	err := runner.RunSync(EventCreate, issue)
+	elapsed := time.Since(start)
+
+	if err == nil {
+		t.Error("RunSync should have returned error for timeout")
+	}
+
+	// Should have returned within timeout + some buffer
+	if elapsed > 5*time.Second {
+		t.Errorf("RunSync took too long: %v", elapsed)
+	}
+}
+
+func TestRunSync_HookFailure(t *testing.T) {
+	tmpDir := t.TempDir()
+	hookPath := filepath.Join(tmpDir, HookOnUpdate)
+
+	// Create a hook that exits with error
+	hookScript := `#!/bin/sh
+exit 1`
+	if err := os.WriteFile(hookPath, []byte(hookScript), 0755); err != nil {
+		t.Fatalf("Failed to create hook file: %v", err)
+	}
+
+	runner := NewRunner(tmpDir)
+	issue := &types.Issue{ID: "bd-test", Title: "Test"}
+
+	err := runner.RunSync(EventUpdate, issue)
+	if err == nil {
+		t.Error("RunSync should have returned error for failed hook")
+	}
+}
+
+func TestRun_Async(t *testing.T) {
+	tmpDir := t.TempDir()
+	hookPath := filepath.Join(tmpDir, HookOnClose)
+	outputFile := filepath.Join(tmpDir, "async_output.txt")
+
+	// Create a hook that writes to a file
+	hookScript := `#!/bin/sh
+echo "async" > ` + outputFile
+	if err := os.WriteFile(hookPath, []byte(hookScript), 0755); err != nil {
+		t.Fatalf("Failed to create hook file: %v", err)
+	}
+
+	runner := NewRunner(tmpDir)
+	issue := &types.Issue{ID: "bd-test", Title: "Test"}
+
+	// Run should return immediately
+	runner.Run(EventClose, issue)
+
+	// Wait for the async hook to complete with retries
+	var output []byte
+	var err error
+	for i := 0; i < 10; i++ {
+		time.Sleep(100 * time.Millisecond)
+		output, err = os.ReadFile(outputFile)
+		if err == nil {
+			break
+		}
+	}
+
+	if err != nil {
+		t.Fatalf("Failed to read output file after retries: %v", err)
+	}
+
+	expected := "async\n"
+	if string(output) != expected {
+		t.Errorf("Hook output = %q, want %q", string(output), expected)
+	}
+}
+
+func TestAllHookEvents(t *testing.T) {
+	// Verify all event constants have corresponding hook names
+	events := []struct {
+		event string
+		hook  string
+	}{
+		{EventCreate, HookOnCreate},
+		{EventUpdate, HookOnUpdate},
+		{EventClose, HookOnClose},
+		{EventMessage, HookOnMessage},
+	}
+
+	for _, e := range events {
+		t.Run(e.event, func(t *testing.T) {
+			result := eventToHook(e.event)
+			if result != e.hook {
+				t.Errorf("eventToHook(%q) = %q, want %q", e.event, result, e.hook)
+			}
+		})
+	}
+}
--- a/internal/storage/sqlite/graph_links_test.go
+++ b/internal/storage/sqlite/graph_links_test.go
@@ -0,0 +1,499 @@
+package sqlite
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/steveyegge/beads/internal/types"
+)
+
+func TestRelatesTo(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create two issues
+	issue1 := &types.Issue{
+		Title:     "Issue 1",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeTask,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+	issue2 := &types.Issue{
+		Title:     "Issue 2",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeTask,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	if err := store.CreateIssue(ctx, issue1, "test"); err != nil {
+		t.Fatalf("Failed to create issue1: %v", err)
+	}
+	if err := store.CreateIssue(ctx, issue2, "test"); err != nil {
+		t.Fatalf("Failed to create issue2: %v", err)
+	}
+
+	// Add relates_to link (bidirectional)
+	relatesTo1, _ := json.Marshal([]string{issue2.ID})
+	if err := store.UpdateIssue(ctx, issue1.ID, map[string]interface{}{
+		"relates_to": string(relatesTo1),
+	}, "test"); err != nil {
+		t.Fatalf("Failed to update issue1 relates_to: %v", err)
+	}
+
+	relatesTo2, _ := json.Marshal([]string{issue1.ID})
+	if err := store.UpdateIssue(ctx, issue2.ID, map[string]interface{}{
+		"relates_to": string(relatesTo2),
+	}, "test"); err != nil {
+		t.Fatalf("Failed to update issue2 relates_to: %v", err)
+	}
+
+	// Verify links
+	updated1, err := store.GetIssue(ctx, issue1.ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if len(updated1.RelatesTo) != 1 || updated1.RelatesTo[0] != issue2.ID {
+		t.Errorf("issue1.RelatesTo = %v, want [%s]", updated1.RelatesTo, issue2.ID)
+	}
+
+	updated2, err := store.GetIssue(ctx, issue2.ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if len(updated2.RelatesTo) != 1 || updated2.RelatesTo[0] != issue1.ID {
+		t.Errorf("issue2.RelatesTo = %v, want [%s]", updated2.RelatesTo, issue1.ID)
+	}
+}
+
+func TestRelatesTo_MultipleLinks(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create three issues
+	issues := make([]*types.Issue, 3)
+	for i := range issues {
+		issues[i] = &types.Issue{
+			Title:     "Issue",
+			Status:    types.StatusOpen,
+			Priority:  2,
+			IssueType: types.TypeTask,
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		}
+		if err := store.CreateIssue(ctx, issues[i], "test"); err != nil {
+			t.Fatalf("Failed to create issue %d: %v", i, err)
+		}
+	}
+
+	// Link issue0 to both issue1 and issue2
+	relatesTo, _ := json.Marshal([]string{issues[1].ID, issues[2].ID})
+	if err := store.UpdateIssue(ctx, issues[0].ID, map[string]interface{}{
+		"relates_to": string(relatesTo),
+	}, "test"); err != nil {
+		t.Fatalf("Failed to update relates_to: %v", err)
+	}
+
+	// Verify
+	updated, err := store.GetIssue(ctx, issues[0].ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if len(updated.RelatesTo) != 2 {
+		t.Errorf("RelatesTo has %d links, want 2", len(updated.RelatesTo))
+	}
+}
+
+func TestDuplicateOf(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create canonical and duplicate issues
+	canonical := &types.Issue{
+		Title:     "Canonical Issue",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeBug,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+	duplicate := &types.Issue{
+		Title:     "Duplicate Issue",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeBug,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	if err := store.CreateIssue(ctx, canonical, "test"); err != nil {
+		t.Fatalf("Failed to create canonical: %v", err)
+	}
+	if err := store.CreateIssue(ctx, duplicate, "test"); err != nil {
+		t.Fatalf("Failed to create duplicate: %v", err)
+	}
+
+	// Mark as duplicate and close
+	if err := store.UpdateIssue(ctx, duplicate.ID, map[string]interface{}{
+		"duplicate_of": canonical.ID,
+		"status":       string(types.StatusClosed),
+	}, "test"); err != nil {
+		t.Fatalf("Failed to mark as duplicate: %v", err)
+	}
+
+	// Verify
+	updated, err := store.GetIssue(ctx, duplicate.ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if updated.DuplicateOf != canonical.ID {
+		t.Errorf("DuplicateOf = %q, want %q", updated.DuplicateOf, canonical.ID)
+	}
+	if updated.Status != types.StatusClosed {
+		t.Errorf("Status = %q, want %q", updated.Status, types.StatusClosed)
+	}
+}
+
+func TestSupersededBy(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create old and new versions
+	oldVersion := &types.Issue{
+		Title:     "Design Doc v1",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeTask,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+	newVersion := &types.Issue{
+		Title:     "Design Doc v2",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeTask,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	if err := store.CreateIssue(ctx, oldVersion, "test"); err != nil {
+		t.Fatalf("Failed to create old version: %v", err)
+	}
+	if err := store.CreateIssue(ctx, newVersion, "test"); err != nil {
+		t.Fatalf("Failed to create new version: %v", err)
+	}
+
+	// Mark old as superseded
+	if err := store.UpdateIssue(ctx, oldVersion.ID, map[string]interface{}{
+		"superseded_by": newVersion.ID,
+		"status":        string(types.StatusClosed),
+	}, "test"); err != nil {
+		t.Fatalf("Failed to mark as superseded: %v", err)
+	}
+
+	// Verify
+	updated, err := store.GetIssue(ctx, oldVersion.ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if updated.SupersededBy != newVersion.ID {
+		t.Errorf("SupersededBy = %q, want %q", updated.SupersededBy, newVersion.ID)
+	}
+	if updated.Status != types.StatusClosed {
+		t.Errorf("Status = %q, want %q", updated.Status, types.StatusClosed)
+	}
+}
+
+func TestRepliesTo(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create original message and reply
+	original := &types.Issue{
+		Title:       "Original Message",
+		Description: "Original content",
+		Status:      types.StatusOpen,
+		Priority:    2,
+		IssueType:   types.TypeMessage,
+		Sender:      "alice",
+		Assignee:    "bob",
+		Ephemeral:   true,
+		CreatedAt:   time.Now(),
+		UpdatedAt:   time.Now(),
+	}
+	reply := &types.Issue{
+		Title:       "Re: Original Message",
+		Description: "Reply content",
+		Status:      types.StatusOpen,
+		Priority:    2,
+		IssueType:   types.TypeMessage,
+		Sender:      "bob",
+		Assignee:    "alice",
+		Ephemeral:   true,
+		CreatedAt:   time.Now(),
+		UpdatedAt:   time.Now(),
+	}
+
+	if err := store.CreateIssue(ctx, original, "test"); err != nil {
+		t.Fatalf("Failed to create original: %v", err)
+	}
+
+	// Set replies_to before creation
+	reply.RepliesTo = original.ID
+	if err := store.CreateIssue(ctx, reply, "test"); err != nil {
+		t.Fatalf("Failed to create reply: %v", err)
+	}
+
+	// Verify thread link
+	savedReply, err := store.GetIssue(ctx, reply.ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if savedReply.RepliesTo != original.ID {
+		t.Errorf("RepliesTo = %q, want %q", savedReply.RepliesTo, original.ID)
+	}
+}
+
+func TestRepliesTo_Chain(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create a chain of replies
+	messages := make([]*types.Issue, 3)
+	var prevID string
+
+	for i := range messages {
+		messages[i] = &types.Issue{
+			Title:     "Message",
+			Status:    types.StatusOpen,
+			Priority:  2,
+			IssueType: types.TypeMessage,
+			Sender:    "user",
+			Assignee:  "inbox",
+			Ephemeral: true,
+			RepliesTo: prevID,
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		}
+		if err := store.CreateIssue(ctx, messages[i], "test"); err != nil {
+			t.Fatalf("Failed to create message %d: %v", i, err)
+		}
+		prevID = messages[i].ID
+	}
+
+	// Verify chain
+	for i := 1; i < len(messages); i++ {
+		saved, err := store.GetIssue(ctx, messages[i].ID)
+		if err != nil {
+			t.Fatalf("GetIssue failed for message %d: %v", i, err)
+		}
+		if saved.RepliesTo != messages[i-1].ID {
+			t.Errorf("Message %d: RepliesTo = %q, want %q", i, saved.RepliesTo, messages[i-1].ID)
+		}
+	}
+}
+
+func TestEphemeralField(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create ephemeral issue
+	ephemeral := &types.Issue{
+		Title:     "Ephemeral Issue",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeMessage,
+		Ephemeral: true,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	// Create non-ephemeral issue
+	permanent := &types.Issue{
+		Title:     "Permanent Issue",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeTask,
+		Ephemeral: false,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	if err := store.CreateIssue(ctx, ephemeral, "test"); err != nil {
+		t.Fatalf("Failed to create ephemeral: %v", err)
+	}
+	if err := store.CreateIssue(ctx, permanent, "test"); err != nil {
+		t.Fatalf("Failed to create permanent: %v", err)
+	}
+
+	// Verify ephemeral flag
+	savedEphemeral, err := store.GetIssue(ctx, ephemeral.ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if !savedEphemeral.Ephemeral {
+		t.Error("Ephemeral issue should have Ephemeral=true")
+	}
+
+	savedPermanent, err := store.GetIssue(ctx, permanent.ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if savedPermanent.Ephemeral {
+		t.Error("Permanent issue should have Ephemeral=false")
+	}
+}
+
+func TestEphemeralFilter(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create mix of ephemeral and non-ephemeral issues
+	for i := 0; i < 3; i++ {
+		ephemeral := &types.Issue{
+			Title:     "Ephemeral",
+			Status:    types.StatusClosed, // Closed for cleanup test
+			Priority:  2,
+			IssueType: types.TypeMessage,
+			Ephemeral: true,
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		}
+		if err := store.CreateIssue(ctx, ephemeral, "test"); err != nil {
+			t.Fatalf("Failed to create ephemeral %d: %v", i, err)
+		}
+	}
+
+	for i := 0; i < 2; i++ {
+		permanent := &types.Issue{
+			Title:     "Permanent",
+			Status:    types.StatusClosed,
+			Priority:  2,
+			IssueType: types.TypeTask,
+			Ephemeral: false,
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		}
+		if err := store.CreateIssue(ctx, permanent, "test"); err != nil {
+			t.Fatalf("Failed to create permanent %d: %v", i, err)
+		}
+	}
+
+	// Filter for ephemeral only
+	ephemeralTrue := true
+	closedStatus := types.StatusClosed
+	ephemeralFilter := types.IssueFilter{
+		Status:    &closedStatus,
+		Ephemeral: &ephemeralTrue,
+	}
+
+	ephemeralIssues, err := store.SearchIssues(ctx, "", ephemeralFilter)
+	if err != nil {
+		t.Fatalf("SearchIssues failed: %v", err)
+	}
+	if len(ephemeralIssues) != 3 {
+		t.Errorf("Expected 3 ephemeral issues, got %d", len(ephemeralIssues))
+	}
+
+	// Filter for non-ephemeral only
+	ephemeralFalse := false
+	nonEphemeralFilter := types.IssueFilter{
+		Status:    &closedStatus,
+		Ephemeral: &ephemeralFalse,
+	}
+
+	permanentIssues, err := store.SearchIssues(ctx, "", nonEphemeralFilter)
+	if err != nil {
+		t.Fatalf("SearchIssues failed: %v", err)
+	}
+	if len(permanentIssues) != 2 {
+		t.Errorf("Expected 2 non-ephemeral issues, got %d", len(permanentIssues))
+	}
+}
+
+func TestSenderField(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create issue with sender
+	msg := &types.Issue{
+		Title:     "Message",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeMessage,
+		Sender:    "alice@example.com",
+		Assignee:  "bob@example.com",
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	if err := store.CreateIssue(ctx, msg, "test"); err != nil {
+		t.Fatalf("Failed to create message: %v", err)
+	}
+
+	// Verify sender is preserved
+	saved, err := store.GetIssue(ctx, msg.ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if saved.Sender != "alice@example.com" {
+		t.Errorf("Sender = %q, want %q", saved.Sender, "alice@example.com")
+	}
+}
+
+func TestMessageType(t *testing.T) {
+	store, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Create a message type issue
+	msg := &types.Issue{
+		Title:     "Test Message",
+		Status:    types.StatusOpen,
+		Priority:  2,
+		IssueType: types.TypeMessage,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	if err := store.CreateIssue(ctx, msg, "test"); err != nil {
+		t.Fatalf("Failed to create message: %v", err)
+	}
+
+	// Verify type is preserved
+	saved, err := store.GetIssue(ctx, msg.ID)
+	if err != nil {
+		t.Fatalf("GetIssue failed: %v", err)
+	}
+	if saved.IssueType != types.TypeMessage {
+		t.Errorf("IssueType = %q, want %q", saved.IssueType, types.TypeMessage)
+	}
+
+	// Filter by message type
+	messageType := types.TypeMessage
+	filter := types.IssueFilter{
+		IssueType: &messageType,
+	}
+
+	messages, err := store.SearchIssues(ctx, "", filter)
+	if err != nil {
+		t.Fatalf("SearchIssues failed: %v", err)
+	}
+	if len(messages) != 1 {
+		t.Errorf("Expected 1 message, got %d", len(messages))
+	}
+}
--- a/internal/storage/sqlite/queries.go
+++ b/internal/storage/sqlite/queries.go
@@ -1552,6 +1552,15 @@ func (s *SQLiteStorage) SearchIssues(ctx context.Context, query string, filter t
 		whereClauses = append(whereClauses, fmt.Sprintf("id IN (%s)", strings.Join(placeholders, ", ")))
 	}

+	// Ephemeral filtering (bd-kwro.9)
+	if filter.Ephemeral != nil {
+		if *filter.Ephemeral {
+			whereClauses = append(whereClauses, "ephemeral = 1")
+		} else {
+			whereClauses = append(whereClauses, "(ephemeral = 0 OR ephemeral IS NULL)")
+		}
+	}
+
 	whereSQL := ""
 	if len(whereClauses) > 0 {
 		whereSQL = "WHERE " + strings.Join(whereClauses, " AND ")
--- a/internal/storage/sqlite/transaction.go
+++ b/internal/storage/sqlite/transaction.go
@@ -1068,6 +1068,15 @@ func (t *sqliteTxStorage) SearchIssues(ctx context.Context, query string, filter
 		whereClauses = append(whereClauses, fmt.Sprintf("id IN (%s)", strings.Join(placeholders, ", ")))
 	}

+	// Ephemeral filtering (bd-kwro.9)
+	if filter.Ephemeral != nil {
+		if *filter.Ephemeral {
+			whereClauses = append(whereClauses, "ephemeral = 1")
+		} else {
+			whereClauses = append(whereClauses, "(ephemeral = 0 OR ephemeral IS NULL)")
+		}
+	}
+
 	whereSQL := ""
 	if len(whereClauses) > 0 {
 		whereSQL = "WHERE " + strings.Join(whereClauses, " AND ")
--- a/internal/types/types.go
+++ b/internal/types/types.go
@@ -389,6 +389,9 @@ type IssueFilter struct {

 	// Tombstone filtering (bd-1bu)
 	IncludeTombstones bool // If false (default), exclude tombstones from results
+
+	// Ephemeral filtering (bd-kwro.9)
+	Ephemeral *bool // Filter by ephemeral flag (nil = any, true = only ephemeral, false = only non-ephemeral)
 }

 // SortPolicy determines how ready work is ordered