feat(storage): add decision points types and SQLite implementation

Add foundation types and storage support for decision points - human-in-the-loop
gates that enable structured input during agent workflows.

Types:
- DecisionPoint: human-in-the-loop decision gate with iteration support
- DecisionOption: structured option with ID, short label, and description

Storage interface:
- CreateDecisionPoint, GetDecisionPoint, UpdateDecisionPoint, ListPendingDecisions
- Added to both Storage and Transaction interfaces

SQLite implementation:
- decision_points table with FK to issues, iteration chain via prior_id
- Migration 041 creates table, 046 adds requested_by column
- Full CRUD support in both storage.go and transaction.go

Dolt/Memory stubs:
- Added placeholder implementations returning "not implemented" errors
- Full Dolt support planned for separate PR

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: upstream_merger

internal/storage/dolt/store.go

@@ -32,6 +32,7 @@ import (
 	_ "github.com/go-sql-driver/mysql"
 
 	"github.com/steveyegge/beads/internal/storage"
+	"github.com/steveyegge/beads/internal/types"
 )
 
 // DoltStore implements the Storage interface using Dolt
@@ -755,3 +756,27 @@ func cleanupSingleLock(lockPath string) error {
 	// Non-empty or recent lock file - don't touch it
 	return nil
 }
+
+// CreateDecisionPoint creates a new decision point for an issue.
+// TODO(dolt-parity): Implement decision point support for Dolt backend.
+func (s *DoltStore) CreateDecisionPoint(ctx context.Context, dp *types.DecisionPoint) error {
+	return fmt.Errorf("decision points not yet implemented for Dolt backend")
+}
+
+// GetDecisionPoint retrieves the decision point for an issue.
+// TODO(dolt-parity): Implement decision point support for Dolt backend.
+func (s *DoltStore) GetDecisionPoint(ctx context.Context, issueID string) (*types.DecisionPoint, error) {
+	return nil, fmt.Errorf("decision points not yet implemented for Dolt backend")
+}
+
+// UpdateDecisionPoint updates an existing decision point.
+// TODO(dolt-parity): Implement decision point support for Dolt backend.
+func (s *DoltStore) UpdateDecisionPoint(ctx context.Context, dp *types.DecisionPoint) error {
+	return fmt.Errorf("decision points not yet implemented for Dolt backend")
+}
+
+// ListPendingDecisions returns all decision points that haven't been responded to.
+// TODO(dolt-parity): Implement decision point support for Dolt backend.
+func (s *DoltStore) ListPendingDecisions(ctx context.Context) ([]*types.DecisionPoint, error) {
+	return nil, fmt.Errorf("decision points not yet implemented for Dolt backend")
+}

internal/storage/dolt/transaction.go

@@ -470,3 +470,27 @@ func scanIssueTx(ctx context.Context, tx *sql.Tx, id string) (*types.Issue, erro
 
 	return &issue, nil
 }
+
+// CreateDecisionPoint creates a new decision point within the transaction.
+// TODO(dolt-parity): Implement decision point support for Dolt backend.
+func (t *doltTransaction) CreateDecisionPoint(ctx context.Context, dp *types.DecisionPoint) error {
+	return fmt.Errorf("decision points not yet implemented for Dolt backend")
+}
+
+// GetDecisionPoint retrieves the decision point for an issue within the transaction.
+// TODO(dolt-parity): Implement decision point support for Dolt backend.
+func (t *doltTransaction) GetDecisionPoint(ctx context.Context, issueID string) (*types.DecisionPoint, error) {
+	return nil, fmt.Errorf("decision points not yet implemented for Dolt backend")
+}
+
+// UpdateDecisionPoint updates an existing decision point within the transaction.
+// TODO(dolt-parity): Implement decision point support for Dolt backend.
+func (t *doltTransaction) UpdateDecisionPoint(ctx context.Context, dp *types.DecisionPoint) error {
+	return fmt.Errorf("decision points not yet implemented for Dolt backend")
+}
+
+// ListPendingDecisions returns all decision points that haven't been responded to.
+// TODO(dolt-parity): Implement decision point support for Dolt backend.
+func (t *doltTransaction) ListPendingDecisions(ctx context.Context) ([]*types.DecisionPoint, error) {
+	return nil, fmt.Errorf("decision points not yet implemented for Dolt backend")
+}

internal/storage/memory/memory.go

@@ -1863,3 +1863,27 @@ func (m *MemoryStorage) MarkIssueDirty(ctx context.Context, issueID string) erro
 	m.dirty[issueID] = true
 	return nil
 }
+
+// CreateDecisionPoint creates a new decision point for an issue.
+// Decision points are not supported in memory storage.
+func (m *MemoryStorage) CreateDecisionPoint(ctx context.Context, dp *types.DecisionPoint) error {
+	return fmt.Errorf("decision points not supported in --no-db mode: use SQLite storage")
+}
+
+// GetDecisionPoint retrieves the decision point for an issue.
+// Decision points are not supported in memory storage.
+func (m *MemoryStorage) GetDecisionPoint(ctx context.Context, issueID string) (*types.DecisionPoint, error) {
+	return nil, fmt.Errorf("decision points not supported in --no-db mode: use SQLite storage")
+}
+
+// UpdateDecisionPoint updates an existing decision point.
+// Decision points are not supported in memory storage.
+func (m *MemoryStorage) UpdateDecisionPoint(ctx context.Context, dp *types.DecisionPoint) error {
+	return fmt.Errorf("decision points not supported in --no-db mode: use SQLite storage")
+}
+
+// ListPendingDecisions returns all decision points that haven't been responded to.
+// Decision points are not supported in memory storage.
+func (m *MemoryStorage) ListPendingDecisions(ctx context.Context) ([]*types.DecisionPoint, error) {
+	return nil, fmt.Errorf("decision points not supported in --no-db mode: use SQLite storage")
+}

internal/storage/sqlite/decision_points.go

@@ -0,0 +1,166 @@
+package sqlite
+
+// TODO(dolt-parity): These DecisionPoint methods need corresponding implementations
+// in the dolt storage backend when it's added. The interface is defined in
+// storage/storage.go and must be implemented for all backends.
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	"github.com/steveyegge/beads/internal/types"
+)
+
+// CreateDecisionPoint creates a new decision point for an issue.
+func (s *SQLiteStorage) CreateDecisionPoint(ctx context.Context, dp *types.DecisionPoint) error {
+	// Verify issue exists
+	var exists bool
+	err := s.db.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM issues WHERE id = ?)`, dp.IssueID).Scan(&exists)
+	if err != nil {
+		return fmt.Errorf("failed to check issue existence: %w", err)
+	}
+	if !exists {
+		return fmt.Errorf("issue %s not found", dp.IssueID)
+	}
+
+	// Convert empty strings to NULL for optional FK fields
+	var priorID interface{}
+	if dp.PriorID != "" {
+		priorID = dp.PriorID
+	}
+
+	// Insert decision point
+	_, err = s.db.ExecContext(ctx, `
+		INSERT INTO decision_points (
+			issue_id, prompt, options, default_option, selected_option,
+			response_text, responded_at, responded_by, iteration, max_iterations,
+			prior_id, guidance, requested_by, created_at
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+	`, dp.IssueID, dp.Prompt, dp.Options, dp.DefaultOption, dp.SelectedOption,
+		dp.ResponseText, dp.RespondedAt, dp.RespondedBy, dp.Iteration, dp.MaxIterations,
+		priorID, dp.Guidance, dp.RequestedBy)
+	if err != nil {
+		return fmt.Errorf("failed to insert decision point: %w", err)
+	}
+
+	return nil
+}
+
+// GetDecisionPoint retrieves the decision point for an issue.
+func (s *SQLiteStorage) GetDecisionPoint(ctx context.Context, issueID string) (*types.DecisionPoint, error) {
+	// Hold read lock during database operations to prevent reconnect() from
+	// closing the connection mid-query (GH#607 race condition fix)
+	s.reconnectMu.RLock()
+	defer s.reconnectMu.RUnlock()
+
+	dp := &types.DecisionPoint{}
+	err := s.db.QueryRowContext(ctx, `
+		SELECT issue_id, prompt, options,
+			COALESCE(default_option, ''), COALESCE(selected_option, ''),
+			COALESCE(response_text, ''), responded_at, COALESCE(responded_by, ''),
+			iteration, max_iterations,
+			COALESCE(prior_id, ''), COALESCE(guidance, ''), COALESCE(requested_by, ''), created_at
+		FROM decision_points
+		WHERE issue_id = ?
+	`, issueID).Scan(
+		&dp.IssueID, &dp.Prompt, &dp.Options,
+		&dp.DefaultOption, &dp.SelectedOption,
+		&dp.ResponseText, &dp.RespondedAt, &dp.RespondedBy,
+		&dp.Iteration, &dp.MaxIterations,
+		&dp.PriorID, &dp.Guidance, &dp.RequestedBy, &dp.CreatedAt,
+	)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("failed to query decision point: %w", err)
+	}
+
+	return dp, nil
+}
+
+// UpdateDecisionPoint updates an existing decision point.
+func (s *SQLiteStorage) UpdateDecisionPoint(ctx context.Context, dp *types.DecisionPoint) error {
+	// Convert empty strings to NULL for optional FK fields
+	var priorID interface{}
+	if dp.PriorID != "" {
+		priorID = dp.PriorID
+	}
+
+	result, err := s.db.ExecContext(ctx, `
+		UPDATE decision_points SET
+			prompt = ?,
+			options = ?,
+			default_option = ?,
+			selected_option = ?,
+			response_text = ?,
+			responded_at = ?,
+			responded_by = ?,
+			iteration = ?,
+			max_iterations = ?,
+			prior_id = ?,
+			guidance = ?
+		WHERE issue_id = ?
+	`, dp.Prompt, dp.Options, dp.DefaultOption, dp.SelectedOption,
+		dp.ResponseText, dp.RespondedAt, dp.RespondedBy,
+		dp.Iteration, dp.MaxIterations, priorID, dp.Guidance, dp.IssueID)
+	if err != nil {
+		return fmt.Errorf("failed to update decision point: %w", err)
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("failed to get rows affected: %w", err)
+	}
+	if rowsAffected == 0 {
+		return fmt.Errorf("decision point not found for issue %s", dp.IssueID)
+	}
+
+	return nil
+}
+
+// ListPendingDecisions returns all decision points that haven't been responded to.
+func (s *SQLiteStorage) ListPendingDecisions(ctx context.Context) ([]*types.DecisionPoint, error) {
+	// Hold read lock during database operations to prevent reconnect() from
+	// closing the connection mid-query (GH#607 race condition fix)
+	s.reconnectMu.RLock()
+	defer s.reconnectMu.RUnlock()
+
+	rows, err := s.db.QueryContext(ctx, `
+		SELECT issue_id, prompt, options,
+			COALESCE(default_option, ''), COALESCE(selected_option, ''),
+			COALESCE(response_text, ''), responded_at, COALESCE(responded_by, ''),
+			iteration, max_iterations,
+			COALESCE(prior_id, ''), COALESCE(guidance, ''), COALESCE(requested_by, ''), created_at
+		FROM decision_points
+		WHERE responded_at IS NULL
+		ORDER BY created_at ASC
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query pending decisions: %w", err)
+	}
+	defer func() { _ = rows.Close() }()
+
+	var results []*types.DecisionPoint
+	for rows.Next() {
+		dp := &types.DecisionPoint{}
+		err := rows.Scan(
+			&dp.IssueID, &dp.Prompt, &dp.Options,
+			&dp.DefaultOption, &dp.SelectedOption,
+			&dp.ResponseText, &dp.RespondedAt, &dp.RespondedBy,
+			&dp.Iteration, &dp.MaxIterations,
+			&dp.PriorID, &dp.Guidance, &dp.RequestedBy, &dp.CreatedAt,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan decision point: %w", err)
+		}
+		results = append(results, dp)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating decision points: %w", err)
+	}
+
+	return results, nil
+}

internal/storage/sqlite/migrations.go

@@ -57,6 +57,8 @@ var migrationsList = []Migration{
 	{"work_type_column", migrations.MigrateWorkTypeColumn},
 	{"source_system_column", migrations.MigrateSourceSystemColumn},
 	{"quality_score_column", migrations.MigrateQualityScoreColumn},
+	{"decision_points_table", migrations.MigrateDecisionPointColumns},
+	{"decision_requested_by_column", migrations.MigrateDecisionRequestedBy},
 }
 
 // MigrationInfo contains metadata about a migration for inspection
@@ -120,7 +122,9 @@ func getMigrationDescription(name string) string {
 		"crystallizes_column":          "Adds crystallizes column for work economics (compounds vs evaporates) per Decision 006",
 		"work_type_column":             "Adds work_type column for work assignment model (mutex vs open_competition per Decision 006)",
 		"source_system_column":         "Adds source_system column for federation adapter tracking",
-		"quality_score_column":         "Adds quality_score column for aggregate quality (0.0-1.0) set by Refineries",
+		"quality_score_column":           "Adds quality_score column for aggregate quality (0.0-1.0) set by Refineries",
+		"decision_points_table":          "Adds decision_points table for human-in-the-loop choices",
+		"decision_requested_by_column":   "Adds requested_by column to decision_points for agent wake notifications",
 	}
 
 	if desc, ok := descriptions[name]; ok {

internal/storage/sqlite/migrations/041_decision_points_table.go

@@ -0,0 +1,53 @@
+package migrations
+
+import (
+	"database/sql"
+	"fmt"
+)
+
+// MigrateDecisionPointColumns creates the decision_points table for human-in-the-loop choices.
+// This is a separate table with FK to issues rather than columns on issues, because:
+// 1. Decision points have their own lifecycle (can be iterated multiple times)
+// 2. Many issues won't have decision points, avoiding sparse columns
+// 3. prior_id creates a chain of iterations requiring self-referential structure
+func MigrateDecisionPointColumns(db *sql.DB) error {
+	var tableExists bool
+	err := db.QueryRow(`
+		SELECT COUNT(*) > 0
+		FROM sqlite_master
+		WHERE type='table' AND name='decision_points'
+	`).Scan(&tableExists)
+	if err != nil {
+		return fmt.Errorf("failed to check decision_points table: %w", err)
+	}
+
+	if tableExists {
+		return nil
+	}
+
+	_, err = db.Exec(`
+		CREATE TABLE decision_points (
+			issue_id TEXT PRIMARY KEY,
+			prompt TEXT NOT NULL,
+			options TEXT NOT NULL,
+			default_option TEXT,
+			selected_option TEXT,
+			response_text TEXT,
+			responded_at DATETIME,
+			responded_by TEXT,
+			iteration INTEGER DEFAULT 1,
+			max_iterations INTEGER DEFAULT 3,
+			prior_id TEXT,
+			guidance TEXT,
+			created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+			FOREIGN KEY (issue_id) REFERENCES issues(id) ON DELETE CASCADE,
+			FOREIGN KEY (prior_id) REFERENCES issues(id) ON DELETE SET NULL
+		);
+		CREATE INDEX idx_decision_points_prior ON decision_points(prior_id);
+	`)
+	if err != nil {
+		return fmt.Errorf("failed to create decision_points table: %w", err)
+	}
+
+	return nil
+}

internal/storage/sqlite/migrations/046_decision_requested_by_column.go

@@ -0,0 +1,33 @@
+package migrations
+
+import (
+	"database/sql"
+	"fmt"
+)
+
+// MigrateDecisionRequestedBy adds requested_by column to decision_points table.
+// This column stores the agent/session that created the decision, enabling
+// wake notifications when the decision is resolved.
+func MigrateDecisionRequestedBy(db *sql.DB) error {
+	// Check if column already exists
+	var colCount int
+	err := db.QueryRow(`
+		SELECT COUNT(*)
+		FROM pragma_table_info('decision_points')
+		WHERE name = 'requested_by'
+	`).Scan(&colCount)
+	if err != nil {
+		return fmt.Errorf("failed to check for requested_by column: %w", err)
+	}
+
+	if colCount > 0 {
+		return nil // Column already exists
+	}
+
+	_, err = db.Exec(`ALTER TABLE decision_points ADD COLUMN requested_by TEXT`)
+	if err != nil {
+		return fmt.Errorf("failed to add requested_by column: %w", err)
+	}
+
+	return nil
+}