From 8081b4de3466f44ee398407573e4d16d559ac02d Mon Sep 17 00:00:00 2001 From: Mikhail Date: Sat, 22 Aug 2026 12:08:43 +0300 Subject: [PATCH] feat(work): persist agent execution state --- adapters/postgres/work_repository.go | 63 +++++++++++++++++++ .../029_work_agent_execution_persistence.sql | 43 +++++++++++++ dev/ACTIVE_TASK.json | 4 +- ...EV-000121-agent-execution-persistence.json | 23 +++++++ tests/agent_execution/persistence_sql_test.go | 33 ++++++++++ 5 files changed, 164 insertions(+), 2 deletions(-) create mode 100644 database/migrations/029_work_agent_execution_persistence.sql create mode 100644 dev/tasks/DEV-000121-agent-execution-persistence.json create mode 100644 tests/agent_execution/persistence_sql_test.go diff --git a/adapters/postgres/work_repository.go b/adapters/postgres/work_repository.go index f332f0e..1e9af75 100644 --- a/adapters/postgres/work_repository.go +++ b/adapters/postgres/work_repository.go @@ -2,7 +2,9 @@ package postgres import ( "context" + "errors" "fmt" + "time" "git.cin.su/m/Assistant/contracts/work" "github.com/jackc/pgx/v5/pgxpool" @@ -10,6 +12,12 @@ import ( type WorkRepository struct{ pool *pgxpool.Pool } +var ( + ErrDispatchIntentConflict = errors.New("dispatch intent idempotency conflict") + ErrAgentLeaseUnavailable = errors.New("agent lease unavailable") + ErrAgentCallbackRejected = errors.New("agent callback rejected") +) + func OpenWork(ctx context.Context, config ContinuityConfig) (*WorkRepository, error) { pool, err := openPool(ctx, config) if err != nil { @@ -39,6 +47,61 @@ func (r *WorkRepository) Load(ctx context.Context, id work.TaskID) (work.TaskTar return target, nil } +func (r *WorkRepository) SaveDispatchIntent(ctx context.Context, intent work.AgentDispatchIntent) error { + tx, err := r.pool.Begin(ctx) + if err != nil { + return err + } + defer tx.Rollback(ctx) + _, err = tx.Exec(ctx, `INSERT INTO work.agent_dispatch_intents(dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10) ON CONFLICT(idempotency_key) DO NOTHING`, intent.DispatchID, intent.IdempotencyKey, intent.DelegationID, intent.RunID, intent.ImplementationID, intent.ImplementationRevision, intent.SourceRevision, intent.WorktreeID, intent.VerificationPlanRef, intent.CreatedAtUnixMillis) + if err != nil { + return fmt.Errorf("save dispatch intent: %w", err) + } + var existing work.AgentDispatchIntent + err = tx.QueryRow(ctx, `SELECT dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis FROM work.agent_dispatch_intents WHERE idempotency_key=$1`, intent.IdempotencyKey).Scan(&existing.DispatchID, &existing.IdempotencyKey, &existing.DelegationID, &existing.RunID, &existing.ImplementationID, &existing.ImplementationRevision, &existing.SourceRevision, &existing.WorktreeID, &existing.VerificationPlanRef, &existing.CreatedAtUnixMillis) + if err != nil { + return fmt.Errorf("read dispatch intent: %w", err) + } + if existing != intent { + return ErrDispatchIntentConflict + } + return tx.Commit(ctx) +} + +func (r *WorkRepository) SaveAgentLease(ctx context.Context, lease work.AgentLease) error { + err := r.pool.QueryRow(ctx, `INSERT INTO work.agent_leases(lease_id,run_id,worker_id,fencing_token,state,acquired_at_unix_millis,expires_at_unix_millis) VALUES($1,$2,$3,$4,$5,$6,$7) ON CONFLICT(run_id) DO UPDATE SET lease_id=EXCLUDED.lease_id,worker_id=EXCLUDED.worker_id,fencing_token=EXCLUDED.fencing_token,state=EXCLUDED.state,acquired_at_unix_millis=EXCLUDED.acquired_at_unix_millis,expires_at_unix_millis=EXCLUDED.expires_at_unix_millis WHERE work.agent_leases.state='EXPIRED' OR work.agent_leases.expires_at_unix_millis <= EXCLUDED.acquired_at_unix_millis RETURNING run_id`, lease.ID, lease.RunID, lease.WorkerID, lease.FencingToken, lease.State, lease.AcquiredAt.UnixMilli(), lease.ExpiresAt.UnixMilli()).Scan(new(string)) + if err != nil { + return ErrAgentLeaseUnavailable + } + return nil +} + +func (r *WorkRepository) RenewAgentLease(ctx context.Context, lease work.AgentLease, expiresAt time.Time) error { + command, err := r.pool.Exec(ctx, `UPDATE work.agent_leases SET expires_at_unix_millis=$1 WHERE run_id=$2 AND worker_id=$3 AND fencing_token=$4 AND state='ACTIVE' AND expires_at_unix_millis > $5`, expiresAt.UnixMilli(), lease.RunID, lease.WorkerID, lease.FencingToken, time.Now().UnixMilli()) + if err != nil || command.RowsAffected() != 1 { + return ErrAgentLeaseUnavailable + } + return nil +} + +func (r *WorkRepository) AcceptAgentCallback(ctx context.Context, callback work.AgentCallback) error { + tx, err := r.pool.Begin(ctx) + if err != nil { + return err + } + defer tx.Rollback(ctx) + var runID string + err = tx.QueryRow(ctx, `SELECT run_id FROM work.agent_leases WHERE run_id=$1 AND worker_id=$2 AND fencing_token=$3 AND state='ACTIVE' AND expires_at_unix_millis > $4 FOR UPDATE`, callback.RunID, callback.WorkerID, callback.FencingToken, callback.ObservedAt.UnixMilli()).Scan(&runID) + if err != nil { + return ErrAgentCallbackRejected + } + command, err := tx.Exec(ctx, `INSERT INTO work.agent_callback_heads(run_id,last_sequence,updated_at_unix_millis) VALUES($1,$2,$3) ON CONFLICT(run_id) DO UPDATE SET last_sequence=EXCLUDED.last_sequence,updated_at_unix_millis=EXCLUDED.updated_at_unix_millis WHERE work.agent_callback_heads.last_sequence < EXCLUDED.last_sequence`, runID, callback.Sequence, callback.ObservedAt.UnixMilli()) + if err != nil || command.RowsAffected() != 1 { + return ErrAgentCallbackRejected + } + return tx.Commit(ctx) +} + func (r *WorkRepository) SavePlanningResult(ctx context.Context, result work.PlanningResult) error { tx, err := r.pool.Begin(ctx) if err != nil { diff --git a/database/migrations/029_work_agent_execution_persistence.sql b/database/migrations/029_work_agent_execution_persistence.sql new file mode 100644 index 0000000..0009685 --- /dev/null +++ b/database/migrations/029_work_agent_execution_persistence.sql @@ -0,0 +1,43 @@ +BEGIN; + +SET ROLE work_role; + +CREATE TABLE IF NOT EXISTS work.agent_dispatch_intents ( + dispatch_id TEXT PRIMARY KEY, + idempotency_key TEXT NOT NULL UNIQUE, + delegation_id TEXT NOT NULL, + run_id TEXT NOT NULL, + implementation_id TEXT NOT NULL, + implementation_revision BIGINT NOT NULL, + source_revision TEXT NOT NULL, + worktree_id TEXT NOT NULL, + verification_plan_ref TEXT NOT NULL, + created_at_unix_millis BIGINT NOT NULL, + CHECK (dispatch_id <> ''), CHECK (idempotency_key <> ''), CHECK (delegation_id <> ''), + CHECK (run_id <> ''), CHECK (implementation_id <> ''), CHECK (implementation_revision > 0), + CHECK (source_revision <> ''), CHECK (worktree_id <> ''), CHECK (verification_plan_ref <> ''), + CHECK (created_at_unix_millis > 0) +); + +CREATE TABLE IF NOT EXISTS work.agent_leases ( + lease_id TEXT PRIMARY KEY, + run_id TEXT NOT NULL UNIQUE, + worker_id TEXT NOT NULL, + fencing_token BIGINT NOT NULL, + state TEXT NOT NULL, + acquired_at_unix_millis BIGINT NOT NULL, + expires_at_unix_millis BIGINT NOT NULL, + CHECK (lease_id <> ''), CHECK (run_id <> ''), CHECK (worker_id <> ''), + CHECK (fencing_token > 0), CHECK (state IN ('ACTIVE','EXPIRED')), + CHECK (acquired_at_unix_millis > 0), CHECK (expires_at_unix_millis > acquired_at_unix_millis) +); + +CREATE TABLE IF NOT EXISTS work.agent_callback_heads ( + run_id TEXT PRIMARY KEY, + last_sequence BIGINT NOT NULL DEFAULT 0, + updated_at_unix_millis BIGINT NOT NULL, + CHECK (run_id <> ''), CHECK (last_sequence >= 0), CHECK (updated_at_unix_millis > 0) +); + +RESET ROLE; +COMMIT; diff --git a/dev/ACTIVE_TASK.json b/dev/ACTIVE_TASK.json index 6a88a96..1de2854 100644 --- a/dev/ACTIVE_TASK.json +++ b/dev/ACTIVE_TASK.json @@ -1,5 +1,5 @@ { - "task_file": "dev/tasks/DEV-000120-agent-dispatch-intent.json", - "task_id": "DEV-000120", + "task_file": "dev/tasks/DEV-000121-agent-execution-persistence.json", + "task_id": "DEV-000121", "task_revision": 1 } diff --git a/dev/tasks/DEV-000121-agent-execution-persistence.json b/dev/tasks/DEV-000121-agent-execution-persistence.json new file mode 100644 index 0000000..3ed88f7 --- /dev/null +++ b/dev/tasks/DEV-000121-agent-execution-persistence.json @@ -0,0 +1,23 @@ +{ + "task_id": "DEV-000121", + "task_revision": 1, + "architecture_revision": "ADR-0018", + "base_repo_revision": "f792d20", + "risk_tier": "E", + "intent": "Add work-owned durable persistence schema for dispatch intents, leases and callback sequence heads, with repository write boundaries.", + "requirement_ids": ["WP-301", "Durable dispatch persistence", "Atomic lease/fencing state"], + "allowed_change_scope": {"modules": ["work-agent-execution", "work-storage"], "paths": ["database/migrations/029_work_agent_execution_persistence.sql", "adapters/postgres/work_repository.go", "tests/agent_execution/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000121-agent-execution-persistence.json"]}, + "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/**", "runtime/**", "adapters/continuity*", "adapters/capability*", ".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-000120 dispatch intent", "DEV-000116 lease/fencing", "DEV-000117 callback sequence"], "may_change": ["Work-owned persistence schema and repository methods"]}, + "semantic_owner": "work-agent-execution", + "canonical_state": ["work.agent_dispatch_intents", "work.agent_leases", "work.agent_callback_heads"], + "state_transitions": ["dispatch intent persisted idempotently", "lease acquired/renewed with fencing token", "callback sequence advanced atomically"], + "side_effects_and_privileges": ["Work schema writes only through Work repository; no cross-owner SQL"], + "persistence_and_migrations": ["Append-only migration 029; work_role only"], + "failure_retry_restart": ["Duplicate idempotency key is reconciled; lease conflict is rejected; callback sequence uses row lock/conditional update"], + "assumptions": ["Migration is reviewed and applied before runtime enablement", "Production deployment is a later canary task", "No secrets are stored in dispatch payload"], + "acceptance_scenarios": ["Duplicate dispatch cannot create a second intent", "Expired/wrong lease cannot advance", "Out-of-order callback sequence is rejected", "Work owner boundaries remain intact"], + "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl/independent", "git diff --check", "migration/repository tests"], + "terminal_gap_states": ["BLOCKED_BY_MIGRATION_DECISION", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"] +} diff --git a/tests/agent_execution/persistence_sql_test.go b/tests/agent_execution/persistence_sql_test.go new file mode 100644 index 0000000..469dec1 --- /dev/null +++ b/tests/agent_execution/persistence_sql_test.go @@ -0,0 +1,33 @@ +package agent_execution_test + +import ( + "os" + "strings" + "testing" +) + +func TestDurableAgentExecutionMigrationDefinesOwnedState(t *testing.T) { + data, err := os.ReadFile("../../database/migrations/029_work_agent_execution_persistence.sql") + if err != nil { + t.Fatal(err) + } + sql := string(data) + for _, table := range []string{ + "work.agent_dispatch_intents", + "work.agent_leases", + "work.agent_callback_heads", + } { + if !strings.Contains(sql, "CREATE TABLE IF NOT EXISTS "+table) { + t.Fatalf("migration does not define %s", table) + } + } + for _, marker := range []string{ + "UNIQUE", + "CHECK (state IN ('ACTIVE','EXPIRED'))", + "CHECK (fencing_token > 0)", + } { + if !strings.Contains(sql, marker) { + t.Fatalf("migration/repository contract marker missing: %s", marker) + } + } +}