diff --git a/adapters/postgres/work_repository.go b/adapters/postgres/work_repository.go index 05c6fb0..38e39ce 100644 --- a/adapters/postgres/work_repository.go +++ b/adapters/postgres/work_repository.go @@ -121,6 +121,71 @@ func (r *WorkRepository) CompleteDispatch(ctx context.Context, dispatchID, worke return nil } +func (r *WorkRepository) SaveWorkGraph(ctx context.Context, graph work.WorkGraph) error { + tx, err := r.pool.Begin(ctx) + if err != nil { + return err + } + defer tx.Rollback(ctx) + if _, err := tx.Exec(ctx, `INSERT INTO work.graphs(graph_id,revision,state,max_parallel,max_attempts) VALUES($1,$2,$3,$4,$5) ON CONFLICT(graph_id,revision) DO NOTHING`, graph.ID, graph.Revision, graph.State, graph.Budget.MaxParallel, graph.Budget.MaxAttempts); err != nil { + return err + } + for _, node := range graph.Nodes { + if _, err := tx.Exec(ctx, `INSERT INTO work.graph_nodes(graph_id,revision,node_id,idempotency_key,state,attempts) VALUES($1,$2,$3,$4,$5,$6) ON CONFLICT(graph_id,revision,node_id) DO NOTHING`, graph.ID, graph.Revision, node.ID, node.IdempotencyKey, node.State, node.Attempts); err != nil { + return err + } + } + for _, edge := range graph.Edges { + if _, err := tx.Exec(ctx, `INSERT INTO work.graph_edges(graph_id,revision,from_node_id,to_node_id) VALUES($1,$2,$3,$4) ON CONFLICT(graph_id,revision,from_node_id,to_node_id) DO NOTHING`, graph.ID, graph.Revision, edge.From, edge.To); err != nil { + return err + } + } + return tx.Commit(ctx) +} + +func (r *WorkRepository) LoadWorkGraph(ctx context.Context, graphID string, revision int64) (work.WorkGraph, error) { + var graph work.WorkGraph + err := r.pool.QueryRow(ctx, `SELECT graph_id,revision,state,max_parallel,max_attempts FROM work.graphs WHERE graph_id=$1 AND revision=$2`, graphID, revision).Scan(&graph.ID, &graph.Revision, &graph.State, &graph.Budget.MaxParallel, &graph.Budget.MaxAttempts) + if err != nil { + return work.WorkGraph{}, fmt.Errorf("load graph: %w", err) + } + rows, err := r.pool.Query(ctx, `SELECT node_id,idempotency_key,state,attempts FROM work.graph_nodes WHERE graph_id=$1 AND revision=$2 ORDER BY node_id`, graphID, revision) + if err != nil { + return work.WorkGraph{}, err + } + for rows.Next() { + var node work.GraphNode + if err := rows.Scan(&node.ID, &node.IdempotencyKey, &node.State, &node.Attempts); err != nil { + rows.Close() + return work.WorkGraph{}, err + } + graph.Nodes = append(graph.Nodes, node) + } + if err := rows.Err(); err != nil { + rows.Close() + return work.WorkGraph{}, err + } + rows.Close() + edges, err := r.pool.Query(ctx, `SELECT from_node_id,to_node_id FROM work.graph_edges WHERE graph_id=$1 AND revision=$2 ORDER BY from_node_id,to_node_id`, graphID, revision) + if err != nil { + return work.WorkGraph{}, err + } + for edges.Next() { + var edge work.GraphEdge + if err := edges.Scan(&edge.From, &edge.To); err != nil { + edges.Close() + return work.WorkGraph{}, err + } + graph.Edges = append(graph.Edges, edge) + } + if err := edges.Err(); err != nil { + edges.Close() + return work.WorkGraph{}, err + } + edges.Close() + return graph, nil +} + func (r *WorkRepository) RecoverStaleClaims(ctx context.Context, nowUnixMillis, staleAfterMillis int64) (int64, error) { command, err := r.pool.Exec(ctx, `UPDATE work.agent_dispatch_queue SET state='QUEUED',claimed_by='',updated_at_unix_millis=$1 WHERE state='CLAIMED' AND updated_at_unix_millis <= $2`, nowUnixMillis, nowUnixMillis-staleAfterMillis) if err != nil { diff --git a/database/migrations/031_work_graph_persistence.sql b/database/migrations/031_work_graph_persistence.sql new file mode 100644 index 0000000..4bd7501 --- /dev/null +++ b/database/migrations/031_work_graph_persistence.sql @@ -0,0 +1,41 @@ +BEGIN; + +SET ROLE work_role; + +CREATE TABLE IF NOT EXISTS work.graphs ( + graph_id TEXT NOT NULL, + revision BIGINT NOT NULL, + state TEXT NOT NULL, + max_parallel INTEGER NOT NULL, + max_attempts INTEGER NOT NULL, + PRIMARY KEY (graph_id, revision), + CHECK (graph_id <> ''), CHECK (revision > 0), + CHECK (state IN ('DRAFT','ADMITTED','RUNNING','PAUSED','CANCELLING','PARTIAL','VERIFYING','COMPLETED','FAILED','UNKNOWN','RECOVERING')), + CHECK (max_parallel > 0), CHECK (max_attempts > 0) +); + +CREATE TABLE IF NOT EXISTS work.graph_nodes ( + graph_id TEXT NOT NULL, + revision BIGINT NOT NULL, + node_id TEXT NOT NULL, + idempotency_key TEXT NOT NULL, + state TEXT NOT NULL, + attempts INTEGER NOT NULL, + PRIMARY KEY (graph_id, revision, node_id), + FOREIGN KEY (graph_id, revision) REFERENCES work.graphs(graph_id, revision), + CHECK (node_id <> ''), CHECK (idempotency_key <> ''), CHECK (attempts >= 0), + CHECK (state IN ('BLOCKED_PREREQUISITE','READY','LEASED','RUNNING','SUCCEEDED','FAILED','CANCELLED','UNKNOWN','RECOVERING')) +); + +CREATE TABLE IF NOT EXISTS work.graph_edges ( + graph_id TEXT NOT NULL, + revision BIGINT NOT NULL, + from_node_id TEXT NOT NULL, + to_node_id TEXT NOT NULL, + PRIMARY KEY (graph_id, revision, from_node_id, to_node_id), + FOREIGN KEY (graph_id, revision) REFERENCES work.graphs(graph_id, revision), + CHECK (from_node_id <> ''), CHECK (to_node_id <> ''), CHECK (from_node_id <> to_node_id) +); + +RESET ROLE; +COMMIT; diff --git a/dev/ACTIVE_TASK.json b/dev/ACTIVE_TASK.json index 30b185c..1d21d87 100644 --- a/dev/ACTIVE_TASK.json +++ b/dev/ACTIVE_TASK.json @@ -1,5 +1,5 @@ { - "task_file": "dev/tasks/DEV-000132-work-graph-admission-scheduler.json", - "task_id": "DEV-000132", + "task_file": "dev/tasks/DEV-000133-work-graph-persistence.json", + "task_id": "DEV-000133", "task_revision": 1 } diff --git a/dev/tasks/DEV-000133-work-graph-persistence.json b/dev/tasks/DEV-000133-work-graph-persistence.json new file mode 100644 index 0000000..1c9a83d --- /dev/null +++ b/dev/tasks/DEV-000133-work-graph-persistence.json @@ -0,0 +1,23 @@ +{ + "task_id": "DEV-000133", + "task_revision": 1, + "architecture_revision": "ADR-0018", + "base_repo_revision": "4a800df", + "risk_tier": "E", + "intent": "Persist immutable Work Graph revisions with typed nodes and dependency edges for durable scheduler integration.", + "requirement_ids": ["WP-401", "Durable graph revision", "Graph node dependencies"], + "allowed_change_scope": {"modules": ["work-agent-execution", "work-storage"], "paths": ["database/migrations/031_work_graph_persistence.sql", "adapters/postgres/work_repository.go", "tests/agent_execution/graph_persistence_sql_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000133-work-graph-persistence.json"]}, + "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/**", "runtime/**", ".gitea/**"]}, + "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 1}, + "contracts": {"consume": ["DEV-000131/132 graph contracts and scheduler"], "may_change": ["Work graph persistence schema and repository methods"]}, + "semantic_owner": "work-agent-execution", + "canonical_state": ["work.graphs", "work.graph_nodes", "work.graph_edges"], + "state_transitions": ["graph revision persisted once; nodes and edges immutable within revision"], + "side_effects_and_privileges": ["Work schema only; no cross-owner SQL"], + "persistence_and_migrations": ["Append-only migration 031; production apply is later canary"], + "failure_retry_restart": ["Idempotent inserts; load reconstructs deterministic node/edge order"], + "assumptions": ["Durable scheduler and result/conflict persistence follow"], + "acceptance_scenarios": ["Graph revision cannot collide into mutation", "Nodes/edges remain tied to revision", "Load reconstructs graph"], + "required_tests": ["go test ./...", "go vet ./...", "preflight", "check-diff", "check-architecture", "independent", "git diff --check"], + "terminal_gap_states": ["BLOCKED_BY_MIGRATION_DECISION", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"] +} diff --git a/tests/agent_execution/graph_persistence_sql_test.go b/tests/agent_execution/graph_persistence_sql_test.go new file mode 100644 index 0000000..15756c0 --- /dev/null +++ b/tests/agent_execution/graph_persistence_sql_test.go @@ -0,0 +1,20 @@ +package agent_execution_test + +import ( + "os" + "strings" + "testing" +) + +func TestGraphPersistenceMigrationIsRevisionScoped(t *testing.T) { + data, err := os.ReadFile("../../database/migrations/031_work_graph_persistence.sql") + if err != nil { + t.Fatal(err) + } + sql := string(data) + for _, marker := range []string{"work.graphs", "work.graph_nodes", "work.graph_edges", "PRIMARY KEY (graph_id, revision)", "FOREIGN KEY (graph_id, revision)"} { + if !strings.Contains(sql, marker) { + t.Fatalf("graph persistence marker missing: %s", marker) + } + } +}