relay-flow 0.2.4-alpha → 0.2.5-alpha

package/internal/execution/goworkflows/engine.go

@@ -23,6 +23,7 @@ import (
 	goworkflow "github.com/cschleiden/go-workflows/workflow"
 	"github.com/google/uuid"
 
+	"github.com/rajpopat27/relay-flow/internal/execution/projection"
 	"github.com/rajpopat27/relay-flow/internal/harness"
 	"github.com/rajpopat27/relay-flow/internal/identity"
 	"github.com/rajpopat27/relay-flow/internal/repo"
@@ -68,46 +69,13 @@ type Engine struct {
 	workerName   string
 }
 
-// InitDatabase creates the SQLite database at path (mode 0600) with the
-// relay_runs projection schema and closes it. Used by `relay-flow init`;
-// serve uses New to open the full engine.
-func InitDatabase(path string) error {
-	db, err := sql.Open("sqlite", fmt.Sprintf("file:%s?_txlock=immediate", path))
-	if err != nil {
-		return fmt.Errorf("open %s: %w", path, err)
-	}
-	defer db.Close()
-	if _, err := db.Exec(`PRAGMA schema_version`); err != nil {
-		return fmt.Errorf("open %s: %w", path, err)
-	}
-	if _, err := db.Exec("PRAGMA journal_mode=WAL;"); err != nil {
-		return fmt.Errorf("open %s: %w", path, err)
-	}
-	if err := os.Chmod(path, 0o600); err != nil && !os.IsNotExist(err) {
-		return fmt.Errorf("chmod %s: %w", path, err)
-	}
-	proj := &RunProjection{DB: db}
-	if err := proj.migrate(); err != nil {
-		return fmt.Errorf("migrate relay_runs: %w", err)
-	}
-	return nil
-}
+// InitDatabase preserves the embedded-engine public helper while delegating
+// relay-owned schema lifecycle to the shared projection package.
+func InitDatabase(path string) error { return projection.InitDatabase(path) }
 
-// HasNonterminalRuns inspects an existing database without migrating or
-// otherwise modifying it. It is used by init --force before config changes.
+// HasNonterminalRuns inspects the shared projection without migrating it.
 func HasNonterminalRuns(path string) (bool, error) {
-	db, err := sql.Open("sqlite", fmt.Sprintf("file:%s?mode=ro", path))
-	if err != nil {
-		return false, fmt.Errorf("open %s: %w", path, err)
-	}
-	defer db.Close()
-	var active bool
-	if err := db.QueryRow(`SELECT EXISTS(
-		SELECT 1 FROM relay_runs WHERE state NOT IN ('completed', 'canceled')
-	)`).Scan(&active); err != nil {
-		return false, fmt.Errorf("inspect %s: %w", path, err)
-	}
-	return active, nil
+	return projection.HasNonterminalRuns(path)
 }
 
 // New opens the SQLite database at path (created with mode 0600 when
@@ -148,6 +116,13 @@ func New(path string, deps Dependencies) (*Engine, error) {
 		db.Close()
 		return nil, fmt.Errorf("migrate relay_runs: %w", err)
 	}
+	// A marker-less legacy database is adopted only by the embedded executor;
+	// a persisted Temporal identity fails closed rather than being combined
+	// with go-workflows state.
+	if err := (&projection.RunProjection{DB: db}).VerifyIdentity(context.Background(), projection.ExecutorIdentity{ExecutorPlugin: "goworkflows"}); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("verify executor identity: %w", err)
+	}
 	activities := &Activities{
 		Repos:      deps.Repos,
 		Runner:     deps.Runner,

package/internal/execution/goworkflows/projection.go

@@ -3,543 +3,126 @@ package goworkflows
 import (
 	"context"
 	"database/sql"
-	"errors"
-	"fmt"
 	"sync"
 	"time"
 
+	"github.com/rajpopat27/relay-flow/internal/execution/projection"
 	"github.com/rajpopat27/relay-flow/internal/run"
 )
 
-// RunProjection is the derived relay_runs read model in the same SQLite
-// database as the engine backend. Durable workflow history is authoritative;
-// this table serves application-level queries only. Updates are idempotent
-// durable activities, so replay repairs interrupted updates.
+// RunProjection is retained as the embedded-engine facade for compatibility
+// with the existing go-workflows activities and tests. The relay schema and
+// SQL implementation live in internal/execution/projection so Temporal and
+// goworkflows share exactly one projection implementation.
 type RunProjection struct {
 	DB        *sql.DB
+	inner     *projection.RunProjection
 	runtimeMu sync.Mutex
 }
 
-// NodeRuntime is the durable runtime identity for one node in a run. Unlike
-// relay_runs' current-node fields, one row is retained for every visited node.
-type NodeRuntime struct {
-	RunID       run.ID
-	Node        string
-	TerminalID  string
-	SessionID   string
-	NodeVisitID run.NodeVisitID
-	UpdatedAt   time.Time
-}
+// NodeRuntime is the durable runtime identity for one node in a run.
+type NodeRuntime = projection.NodeRuntime
 
-const relayRunsSchema = `
-CREATE TABLE IF NOT EXISTS relay_runs (
-    id TEXT PRIMARY KEY,
-    logical_run_id TEXT,
-    attempt_id INTEGER,
-    repo TEXT NOT NULL,
-    workflow TEXT NOT NULL,
-    ticket_id TEXT NOT NULL,
-    ticket_key TEXT NOT NULL,
-    state TEXT NOT NULL,
-    current_node TEXT,
-    current_node_visit_id TEXT,
-    last_error TEXT,
-	retry_error TEXT,
-	retry_attempt INTEGER,
-	next_retry_at DATETIME,
-    started_at DATETIME NOT NULL,
-    updated_at DATETIME NOT NULL,
-    finished_at DATETIME
-);
-CREATE INDEX IF NOT EXISTS relay_runs_ticket_key ON relay_runs (ticket_key);
-CREATE INDEX IF NOT EXISTS relay_runs_workflow_state ON relay_runs (workflow, state);
-CREATE INDEX IF NOT EXISTS relay_runs_repo_state ON relay_runs (repo, state);
-CREATE TABLE IF NOT EXISTS relay_node_runtime (
-    run_id TEXT NOT NULL,
-    node TEXT NOT NULL,
-    terminal_id TEXT,
-    session_id TEXT,
-    node_visit_id TEXT NOT NULL,
-    updated_at DATETIME NOT NULL,
-    PRIMARY KEY (run_id, node),
-    FOREIGN KEY (run_id) REFERENCES relay_runs(id) ON DELETE CASCADE
-);
-CREATE TABLE IF NOT EXISTS relay_processed_reports (
-    run_id TEXT NOT NULL,
-    report_id TEXT NOT NULL,
-    node_visit_id TEXT NOT NULL,
-    created_at DATETIME NOT NULL,
-    PRIMARY KEY (run_id, report_id),
-    FOREIGN KEY (run_id) REFERENCES relay_runs(id) ON DELETE CASCADE
-);
-CREATE TABLE IF NOT EXISTS relay_node_sessions (
-    run_id TEXT NOT NULL,
-    node TEXT NOT NULL,
-    session_id TEXT NOT NULL,
-    node_visit_id TEXT NOT NULL,
-    created_at DATETIME NOT NULL,
-    PRIMARY KEY (run_id, node, session_id),
-    FOREIGN KEY (run_id) REFERENCES relay_runs(id) ON DELETE CASCADE
-);
-`
+var errRunNotFound = projection.ErrRunNotFound
+var errNodeRuntimeNotFound = projection.ErrNodeRuntimeNotFound
 
-func (p *RunProjection) migrate() error {
-	if _, err := p.DB.Exec(relayRunsSchema); err != nil {
-		return err
-	}
-	for name, definition := range map[string]string{
-		"logical_run_id": "TEXT",
-		"attempt_id":     "INTEGER",
-		"retry_error":    "TEXT",
-		"retry_attempt":  "INTEGER",
-		"next_retry_at":  "DATETIME",
-	} {
-		var count int
-		if err := p.DB.QueryRow(`SELECT COUNT(1) FROM pragma_table_info('relay_runs') WHERE name = ?`, name).Scan(&count); err != nil {
-			return err
-		}
-		if count == 0 {
-			if _, err := p.DB.Exec(`ALTER TABLE relay_runs ADD COLUMN ` + name + ` ` + definition); err != nil {
-				return err
-			}
-		}
-	}
-	// Rows created before attempt identities were introduced represent the
-	// original attempt. Backfill the stable logical ID and attempt number so
-	// restart allocation remains numeric and never reuses attempt 1.
-	if _, err := p.DB.Exec(`UPDATE relay_runs SET logical_run_id = id WHERE COALESCE(logical_run_id, '') = ''`); err != nil {
-		return err
-	}
-	if _, err := p.DB.Exec(`UPDATE relay_runs SET attempt_id = 1 WHERE attempt_id IS NULL OR attempt_id = 0`); err != nil {
-		return err
+// IsNotFound reports a missing projection row.
+func IsNotFound(err error) bool { return projection.IsNotFound(err) }
+
+func (p *RunProjection) shared() *projection.RunProjection {
+	if p.inner == nil {
+		p.inner = &projection.RunProjection{DB: p.DB}
 	}
-	return nil
+	return p.inner
 }
 
-var errRunNotFound = errors.New("run not found")
-var errNodeRuntimeNotFound = errors.New("node runtime not found")
+func (p *RunProjection) migrate() error { return p.shared().Migrate() }
 
-// IsNotFound reports a missing projection row.
-func IsNotFound(err error) bool { return errors.Is(err, errRunNotFound) }
-
-func (p *RunProjection) insertStart(ctx context.Context, s run.Start, now time.Time) error {
-	logicalID := s.LogicalID
-	if logicalID == "" {
-		logicalID = s.ID
-	}
-	attemptID := s.AttemptID
-	if attemptID == 0 {
-		attemptID = 1
-	}
-	_, err := p.DB.ExecContext(ctx, `
-		INSERT INTO relay_runs (id, logical_run_id, attempt_id, repo, workflow, ticket_id, ticket_key, state, started_at, updated_at)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-		ON CONFLICT(id) DO NOTHING`,
-		string(s.ID), string(logicalID), int64(attemptID), s.Repo, s.Workflow.Name, s.Ticket.ID, s.Ticket.Key,
-		string(run.StateStarting), now, now)
-	return err
+func (p *RunProjection) insertStart(ctx context.Context, start run.Start, now time.Time) error {
+	return p.shared().InsertStart(ctx, start, now)
 }
 
 func (p *RunProjection) updateState(ctx context.Context, id run.ID, state run.State, lastErr string, finished *time.Time) error {
-	terminal := state == run.StateCompleted || state == run.StateCanceled
-	_, err := p.DB.ExecContext(ctx, `
-		UPDATE relay_runs SET state = ?, last_error = ?, updated_at = ?, finished_at = COALESCE(?, finished_at),
-			retry_error = CASE WHEN ? THEN NULL ELSE retry_error END,
-			retry_attempt = CASE WHEN ? THEN NULL ELSE retry_attempt END,
-			next_retry_at = CASE WHEN ? THEN NULL ELSE next_retry_at END
-		WHERE id = ?`,
-		string(state), lastErr, time.Now().UTC(), finished, terminal, terminal, terminal, string(id))
-	return err
+	return p.shared().UpdateState(ctx, id, state, lastErr, finished)
 }
 
 func (p *RunProjection) updateRetry(ctx context.Context, id run.ID, status *run.RetryStatus) error {
-	if status == nil {
-		_, err := p.DB.ExecContext(ctx, `
-			UPDATE relay_runs SET retry_error = NULL, retry_attempt = NULL, next_retry_at = NULL, updated_at = ?
-			WHERE id = ?`, time.Now().UTC(), string(id))
-		return err
-	}
-	_, err := p.DB.ExecContext(ctx, `
-		UPDATE relay_runs SET retry_error = ?, retry_attempt = ?, next_retry_at = ?, updated_at = ?
-		WHERE id = ?`, status.LastError, status.Attempt, status.NextRetryAt, time.Now().UTC(), string(id))
-	return err
+	return p.shared().UpdateRetry(ctx, id, status)
 }
 
 func (p *RunProjection) updateNode(ctx context.Context, id run.ID, state run.State, node string, visit run.NodeVisitID) error {
-	p.runtimeMu.Lock()
-	defer p.runtimeMu.Unlock()
-	tx, err := p.DB.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer tx.Rollback()
-	now := time.Now().UTC()
-	if _, err := tx.ExecContext(ctx, `
-		UPDATE relay_runs SET state = ?, current_node = ?, current_node_visit_id = ?, updated_at = ?
-		WHERE id = ?`,
-		string(state), node, string(visit), now, string(id)); err != nil {
-		return err
-	}
-	// A revisit changes only the latest visit ID. Reusable terminal/session
-	// identities remain attached to this run/node row.
-	if _, err := tx.ExecContext(ctx, `
-		INSERT INTO relay_node_runtime (run_id, node, node_visit_id, updated_at)
-		VALUES (?, ?, ?, ?)
-		ON CONFLICT(run_id, node) DO UPDATE SET
-			node_visit_id = excluded.node_visit_id,
-			updated_at = excluded.updated_at`,
-		string(id), node, string(visit), now); err != nil {
-		return err
-	}
-	return tx.Commit()
+	return p.shared().UpdateNode(ctx, id, state, node, visit)
 }
 
 func (p *RunProjection) getNodeRuntime(ctx context.Context, id run.ID, node string) (NodeRuntime, error) {
-	var rt NodeRuntime
-	var terminalID, sessionID sql.NullString
-	err := p.DB.QueryRowContext(ctx, `
-		SELECT run_id, node, terminal_id, session_id, node_visit_id, updated_at
-		FROM relay_node_runtime WHERE run_id = ? AND node = ?`, string(id), node).
-		Scan(&rt.RunID, &rt.Node, &terminalID, &sessionID, &rt.NodeVisitID, &rt.UpdatedAt)
-	if errors.Is(err, sql.ErrNoRows) {
-		return NodeRuntime{}, errNodeRuntimeNotFound
-	}
-	if err != nil {
-		return NodeRuntime{}, err
-	}
-	rt.TerminalID = terminalID.String
-	rt.SessionID = sessionID.String
-	return rt, nil
+	return p.shared().GetNodeRuntime(ctx, id, node)
 }
 
-func (p *RunProjection) updateNodeRuntime(ctx context.Context, rt NodeRuntime) error {
-	_, err := p.DB.ExecContext(ctx, `
-		INSERT INTO relay_node_runtime (run_id, node, terminal_id, session_id, node_visit_id, updated_at)
-		VALUES (?, ?, ?, ?, ?, ?)
-		ON CONFLICT(run_id, node) DO UPDATE SET
-			terminal_id = excluded.terminal_id,
-			session_id = excluded.session_id,
-			node_visit_id = excluded.node_visit_id,
-			updated_at = excluded.updated_at`,
-		string(rt.RunID), rt.Node, nullableString(rt.TerminalID), nullableString(rt.SessionID),
-		string(rt.NodeVisitID), time.Now().UTC())
-	return err
+func (p *RunProjection) updateNodeRuntime(ctx context.Context, runtime NodeRuntime) error {
+	return p.shared().UpdateNodeRuntime(ctx, runtime)
 }
 
 func (p *RunProjection) loadNodeRuntime(ctx context.Context, id run.ID, node string) (NodeRuntime, error) {
-	rt, err := p.getNodeRuntime(ctx, id, node)
-	if errors.Is(err, errNodeRuntimeNotFound) {
-		return NodeRuntime{RunID: id, Node: node}, nil
-	}
-	return rt, err
+	return p.shared().LoadNodeRuntime(ctx, id, node)
 }
 
 func (p *RunProjection) nodeRuntimeVisitIsCurrent(ctx context.Context, id run.ID, node string, visit run.NodeVisitID) (bool, error) {
-	var count int
-	err := p.DB.QueryRowContext(ctx, `
-		SELECT COUNT(1) FROM relay_node_runtime
-		WHERE run_id = ? AND node = ? AND node_visit_id = ?`,
-		string(id), node, string(visit)).Scan(&count)
-	return count == 1, err
+	return p.shared().NodeRuntimeVisitIsCurrent(ctx, id, node, visit)
 }
 
 func (p *RunProjection) replaceNodeRuntime(ctx context.Context, id run.ID, node string, visit run.NodeVisitID, terminalID, previousSessionID, sessionID string) error {
-	result, err := p.DB.ExecContext(ctx, `
-		UPDATE relay_node_runtime SET terminal_id = ?,
-			session_id = CASE WHEN COALESCE(session_id, '') = ? THEN ? ELSE session_id END,
-			updated_at = ?
-		WHERE run_id = ? AND node = ? AND node_visit_id = ?`,
-		nullableString(terminalID), previousSessionID, nullableString(sessionID), time.Now().UTC(),
-		string(id), node, string(visit))
-	if err != nil {
-		return err
-	}
-	updated, err := result.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if updated != 1 {
-		return fmt.Errorf("node runtime %s/%s visit %s is not current", id, node, visit)
-	}
-	return nil
+	return p.shared().ReplaceNodeRuntime(ctx, id, node, visit, terminalID, previousSessionID, sessionID)
 }
 
 func (p *RunProjection) updateNodeRuntimeVisit(ctx context.Context, id run.ID, node string, visit run.NodeVisitID) error {
-	p.runtimeMu.Lock()
-	defer p.runtimeMu.Unlock()
-	_, err := p.DB.ExecContext(ctx, `
-		INSERT INTO relay_node_runtime (run_id, node, node_visit_id, updated_at)
-		VALUES (?, ?, ?, ?)
-		ON CONFLICT(run_id, node) DO UPDATE SET
-			node_visit_id = excluded.node_visit_id,
-			updated_at = excluded.updated_at`,
-		string(id), node, string(visit), time.Now().UTC())
-	return err
+	return p.shared().UpdateNodeRuntimeVisit(ctx, id, node, visit)
 }
 
 func (p *RunProjection) registerNodeSession(ctx context.Context, registration run.NodeRuntimeRegistration) (bool, error) {
-	p.runtimeMu.Lock()
-	defer p.runtimeMu.Unlock()
-	tx, err := p.DB.BeginTx(ctx, nil)
-	if err != nil {
-		return false, err
-	}
-	defer tx.Rollback()
-	var current run.NodeVisitID
-	if err := tx.QueryRowContext(ctx, `
-		SELECT node_visit_id FROM relay_node_runtime WHERE run_id = ? AND node = ?`,
-		string(registration.RunID), registration.Node).Scan(&current); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return false, nil
-		}
-		return false, err
-	}
-	if _, err := tx.ExecContext(ctx, `
-		INSERT INTO relay_node_sessions (run_id, node, session_id, node_visit_id, created_at)
-		VALUES (?, ?, ?, ?, ?) ON CONFLICT(run_id, node, session_id) DO NOTHING`,
-		string(registration.RunID), registration.Node, registration.SessionID, string(current), time.Now().UTC()); err != nil {
-		return false, err
-	}
-	var bound run.NodeVisitID
-	if err := tx.QueryRowContext(ctx, `
-		SELECT node_visit_id FROM relay_node_sessions
-		WHERE run_id = ? AND node = ? AND session_id = ?`,
-		string(registration.RunID), registration.Node, registration.SessionID).Scan(&bound); err != nil {
-		return false, err
-	}
-	if bound != current {
-		return false, tx.Commit()
-	}
-	result, err := tx.ExecContext(ctx, `
-		UPDATE relay_node_runtime SET session_id = ?, updated_at = ?
-		WHERE run_id = ? AND node = ? AND node_visit_id = ?`,
-		registration.SessionID, time.Now().UTC(), string(registration.RunID), registration.Node, string(bound))
-	if err != nil {
-		return false, err
-	}
-	updated, err := result.RowsAffected()
-	if err != nil {
-		return false, err
-	}
-	return updated == 1, tx.Commit()
+	return p.shared().RegisterNodeSession(ctx, registration)
 }
 
 func (p *RunProjection) hasProcessedReport(ctx context.Context, id run.ID, reportID string) (bool, error) {
-	var count int
-	err := p.DB.QueryRowContext(ctx, `
-		SELECT COUNT(1) FROM relay_processed_reports WHERE run_id = ? AND report_id = ?`,
-		string(id), reportID).Scan(&count)
-	return count == 1, err
+	return p.shared().HasProcessedReport(ctx, id, reportID)
 }
 
 func (p *RunProjection) recordProcessedReport(ctx context.Context, id run.ID, visit run.NodeVisitID, reportID string) error {
-	_, err := p.DB.ExecContext(ctx, `
-		INSERT INTO relay_processed_reports (run_id, report_id, node_visit_id, created_at)
-		VALUES (?, ?, ?, ?) ON CONFLICT(run_id, report_id) DO NOTHING`,
-		string(id), reportID, string(visit), time.Now().UTC())
-	return err
+	return p.shared().RecordProcessedReport(ctx, id, visit, reportID)
 }
 
 func (p *RunProjection) clearNodeRuntime(ctx context.Context, id run.ID, node string, clearTerminal, clearSession bool) error {
-	_, err := p.DB.ExecContext(ctx, `
-		UPDATE relay_node_runtime SET
-			terminal_id = CASE WHEN ? THEN NULL ELSE terminal_id END,
-			session_id = CASE WHEN ? THEN NULL ELSE session_id END,
-			updated_at = ?
-		WHERE run_id = ? AND node = ?`, clearTerminal, clearSession,
-		time.Now().UTC(), string(id), node)
-	return err
+	return p.shared().ClearNodeRuntime(ctx, id, node, clearTerminal, clearSession)
 }
 
 func (p *RunProjection) listNodeRuntimes(ctx context.Context, id run.ID) ([]NodeRuntime, error) {
-	rows, err := p.DB.QueryContext(ctx, `
-		SELECT run_id, node, terminal_id, session_id, node_visit_id, updated_at
-		FROM relay_node_runtime WHERE run_id = ?`, string(id))
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var out []NodeRuntime
-	for rows.Next() {
-		var rt NodeRuntime
-		var terminalID, sessionID sql.NullString
-		if err := rows.Scan(&rt.RunID, &rt.Node, &terminalID, &sessionID, &rt.NodeVisitID, &rt.UpdatedAt); err != nil {
-			return nil, err
-		}
-		rt.TerminalID, rt.SessionID = terminalID.String, sessionID.String
-		out = append(out, rt)
-	}
-	return out, rows.Err()
-}
-
-func nullableString(value string) any {
-	if value == "" {
-		return nil
-	}
-	return value
+	return p.shared().ListNodeRuntimes(ctx, id)
 }
 
 func (p *RunProjection) get(ctx context.Context, id run.ID) (run.Run, error) {
-	row := p.DB.QueryRowContext(ctx, `
-		SELECT id, logical_run_id, attempt_id, repo, workflow, ticket_id, ticket_key, state, current_node, current_node_visit_id, last_error,
-			retry_error, retry_attempt, next_retry_at, started_at, updated_at, finished_at
-		FROM relay_runs WHERE id = ?`, string(id))
-	return scanRun(row)
+	return p.shared().Get(ctx, id)
 }
 
 func (p *RunProjection) findByTicket(ctx context.Context, ticket string) (run.Run, error) {
-	row := p.DB.QueryRowContext(ctx, `
-		SELECT id, logical_run_id, attempt_id, repo, workflow, ticket_id, ticket_key, state, current_node, current_node_visit_id, last_error,
-			retry_error, retry_attempt, next_retry_at, started_at, updated_at, finished_at
-		FROM relay_runs WHERE ticket_key = ? ORDER BY started_at DESC, attempt_id DESC LIMIT 1`, ticket)
-	return scanRun(row)
+	return p.shared().FindByTicket(ctx, ticket)
 }
 
 func (p *RunProjection) findByLogicalID(ctx context.Context, logicalID run.ID) (run.Run, error) {
-	row := p.DB.QueryRowContext(ctx, `
-		SELECT id, logical_run_id, attempt_id, repo, workflow, ticket_id, ticket_key, state, current_node, current_node_visit_id, last_error,
-			retry_error, retry_attempt, next_retry_at, started_at, updated_at, finished_at
-		FROM relay_runs WHERE logical_run_id = ? ORDER BY started_at DESC, attempt_id DESC LIMIT 1`, string(logicalID))
-	return scanRun(row)
-}
-
-type rowScanner interface {
-	Scan(dest ...any) error
-}
-
-func scanRun(row rowScanner) (run.Run, error) {
-	var r run.Run
-	var logicalID sql.NullString
-	var attemptNumber sql.NullInt64
-	var node, visit, lastErr, retryErr sql.NullString
-	var retryAttempt sql.NullInt64
-	var nextRetry, finished sql.NullTime
-	var started, updated time.Time
-	err := row.Scan(&r.ID, &logicalID, &attemptNumber, &r.Repo, &r.Workflow, &r.Ticket.ID, &r.Ticket.Key, &r.State,
-		&node, &visit, &lastErr, &retryErr, &retryAttempt, &nextRetry, &started, &updated, &finished)
-	if errors.Is(err, sql.ErrNoRows) {
-		return run.Run{}, errRunNotFound
-	}
-	if err != nil {
-		return run.Run{}, err
-	}
-	if logicalID.Valid && logicalID.String != "" {
-		r.LogicalID = run.ID(logicalID.String)
-	} else {
-		r.LogicalID = r.ID
-	}
-	if attemptNumber.Valid && attemptNumber.Int64 > 0 {
-		r.AttemptID = run.AttemptID(attemptNumber.Int64)
-	} else {
-		r.AttemptID = 1
-	}
-	r.CurrentNode = node.String
-	r.CurrentNodeVisitID = run.NodeVisitID(visit.String)
-	r.LastError = lastErr.String
-	if retryErr.Valid && retryAttempt.Valid && nextRetry.Valid {
-		r.Retry = &run.RetryStatus{
-			Attempt: int(retryAttempt.Int64), LastError: retryErr.String, NextRetryAt: nextRetry.Time,
-		}
-	}
-	r.StartedAt = started
-	r.UpdatedAt = updated
-	if finished.Valid {
-		t := finished.Time
-		r.FinishedAt = &t
-	}
-	return r, nil
+	return p.shared().FindByLogicalID(ctx, logicalID)
 }
 
-func (p *RunProjection) list(ctx context.Context, f run.Filter) ([]run.Run, error) {
-	q := `SELECT id, logical_run_id, attempt_id, repo, workflow, ticket_id, ticket_key, state, current_node, current_node_visit_id, last_error, retry_error, retry_attempt, next_retry_at, started_at, updated_at, finished_at FROM relay_runs WHERE 1=1`
-	var args []any
-	if f.Repo != "" {
-		q += ` AND repo = ?`
-		args = append(args, f.Repo)
-	}
-	if f.Workflow != "" {
-		q += ` AND workflow = ?`
-		args = append(args, f.Workflow)
-	}
-	if f.Ticket != "" {
-		q += ` AND ticket_key = ?`
-		args = append(args, f.Ticket)
-	}
-	if f.Active != nil {
-		if *f.Active {
-			q += ` AND state NOT IN ('completed', 'canceled')`
-		} else {
-			q += ` AND state IN ('completed', 'canceled')`
-		}
-	}
-	q += ` ORDER BY started_at`
-	rows, err := p.DB.QueryContext(ctx, q, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var out []run.Run
-	for rows.Next() {
-		r, err := scanRun(rows)
-		if err != nil {
-			return nil, err
-		}
-		out = append(out, r)
-	}
-	return out, rows.Err()
+func (p *RunProjection) list(ctx context.Context, filter run.Filter) ([]run.Run, error) {
+	return p.shared().List(ctx, filter)
 }
 
 func (p *RunProjection) hasActive(ctx context.Context, column, value string) (bool, error) {
-	var n int
-	err := p.DB.QueryRowContext(ctx,
-		fmt.Sprintf(`SELECT COUNT(1) FROM relay_runs WHERE %s = ? AND state NOT IN ('completed', 'canceled')`, column),
-		value).Scan(&n)
-	return n > 0, err
+	// Keep this narrow compatibility method for the existing engine; the
+	// shared implementation exposes typed workflow/repo query methods.
+	if column == "workflow" {
+		return p.shared().HasActiveWorkflow(ctx, value)
+	}
+	return p.shared().HasActiveRepo(ctx, value)
 }
 
-// sweepRetention removes terminal projection rows whose finished_at is older
-// than the retention window. Nonterminal runs are never removed.
 func (p *RunProjection) sweepRetention(ctx context.Context, olderThan time.Time) ([]string, error) {
-	rows, err := p.DB.QueryContext(ctx, `
-		SELECT id FROM relay_runs
-		WHERE state IN ('completed', 'canceled') AND finished_at IS NOT NULL AND finished_at < ?`, olderThan)
-	if err != nil {
-		return nil, err
-	}
-	var ids []string
-	for rows.Next() {
-		var id string
-		if err := rows.Scan(&id); err != nil {
-			rows.Close()
-			return nil, err
-		}
-		ids = append(ids, id)
-	}
-	rows.Close()
-	for _, id := range ids {
-		tx, err := p.DB.BeginTx(ctx, nil)
-		if err != nil {
-			return ids, err
-		}
-		if _, err := tx.ExecContext(ctx, `DELETE FROM relay_processed_reports WHERE run_id = ?`, id); err != nil {
-			tx.Rollback()
-			return ids, err
-		}
-		if _, err := tx.ExecContext(ctx, `DELETE FROM relay_node_sessions WHERE run_id = ?`, id); err != nil {
-			tx.Rollback()
-			return ids, err
-		}
-		if _, err := tx.ExecContext(ctx, `DELETE FROM relay_node_runtime WHERE run_id = ?`, id); err != nil {
-			tx.Rollback()
-			return ids, err
-		}
-		if _, err := tx.ExecContext(ctx, `DELETE FROM relay_runs WHERE id = ?`, id); err != nil {
-			tx.Rollback()
-			return ids, err
-		}
-		if err := tx.Commit(); err != nil {
-			return ids, err
-		}
-	}
-	return ids, nil
+	return p.shared().SweepRetention(ctx, olderThan)
 }