feat: each test package runs on its own database

agent, db, server and evidence serialized on one shared test database via an advisory lock, while evidence, llmrec and traffic-style packages could still run against it in parallel; under full-suite load that window produced a real SQLSTATE 40P01 deadlock in the blackboard direct-source test. TestMain in every PG-using package now rewrites ARTEX_PG_DSN to a per-package database (created automatically by ensureDatabase), so packages neither contend nor need to serialize; the advisory lock stays as an in-package safety net. llmrec gains the TestMain it lacked, which also gives its requires-isolated-DSN tests a truly isolated database inside ./... runs.

agent/testmain_test.go

@@ -13,6 +13,10 @@ import (
 // agent test suite so cross-package DELETE cleanup races with db/server
 // packages are avoided when running `go test ./...`.
 func TestMain(m *testing.M) {
+	// Own database per package (#80): with separate databases, packages stop
+	// contending on shared tables and the advisory lock below stops
+	// serializing go test ./... across packages.
+	db.SuffixTestDatabase("agent")
 	dsn, _, err := db.DSN()
 	if err != nil {
 		os.Exit(m.Run())

db/db.go

@@ -10,6 +10,7 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	"os"
 	"strings"
 	"time"
 
@@ -96,6 +97,26 @@ func DSN() (dsn, source string, err error) {
 	return config.PostgresDSN()
 }
 
+// SuffixTestDatabase rewrites the ARTEX_PG_DSN environment variable so its
+// database name carries the given suffix (artex -> artex_agent). Called from
+// package TestMain functions so every go test package runs against its own
+// database: parallel package processes then cannot contend on the same tables
+// (the under-load deadlock family, #80). No-op when ARTEX_PG_DSN is unset —
+// config-file and production paths are untouched. Open creates the suffixed
+// database automatically (ensureDatabase).
+func SuffixTestDatabase(suffix string) {
+	v := strings.TrimSpace(os.Getenv("ARTEX_PG_DSN"))
+	if v == "" {
+		return
+	}
+	u, err := url.Parse(v)
+	if err != nil || u.Path == "" || u.Path == "/" {
+		return
+	}
+	u.Path = "/" + strings.TrimPrefix(u.Path, "/") + "_" + suffix
+	_ = os.Setenv("ARTEX_PG_DSN", u.String())
+}
+
 // DB wraps the shared *sql.DB. PG handles its own connection pool + concurrency
 // (MVCC), so unlike the old SQLite store there is no process-wide write mutex.
 type DB struct{ *sql.DB }

db/exploration.go

@@ -1192,28 +1192,6 @@ WHERE exploration_id=$1 AND kind='goal' AND state='open')`, s.expID).Scan(&exist
 	return exists, err
 }
 
-// OpenGoalFingerprint returns a stable fingerprint of the open-goal set: the
-// sorted goal ids joined by commas, "" when none. Planner quiet-mode (#79) uses
-// it to tell "the goal set changed since the last planning round" apart from
-// "nothing the plan depends on changed".
-func (s *ExplorationStore) OpenGoalFingerprint() (string, error) {
-	rows, err := s.db.Query(`SELECT id FROM exploration_nodes
-WHERE exploration_id=$1 AND kind='goal' AND state='open' ORDER BY id`, s.expID)
-	if err != nil {
-		return "", err
-	}
-	defer rows.Close()
-	var ids []string
-	for rows.Next() {
-		var id int64
-		if err := rows.Scan(&id); err != nil {
-			return "", err
-		}
-		ids = append(ids, strconv.FormatInt(id, 10))
-	}
-	return strings.Join(ids, ","), rows.Err()
-}
-
 // ClaimIntent atomically moves an open intent to running. Returns true if claimed.
 func (s *ExplorationStore) ClaimIntent(id int64, owner string) (bool, error) {
 	res, err := s.db.Exec(`UPDATE exploration_nodes SET state='running', owner=$1

db/testmain_test.go

@@ -14,6 +14,10 @@ import (
 // avoid cross-package cleanup races (e.g. DELETE FROM assets WHERE id > X
 // from one package deleting assets created by another).
 func TestMain(m *testing.M) {
+	// Own database per package (#80): with separate databases, packages stop
+	// contending on shared tables and the advisory lock below stops
+	// serializing go test ./... across packages.
+	SuffixTestDatabase("db")
 	dsn, _, err := DSN()
 	if err != nil {
 		// No DB configured — tests that need PG will skip themselves.

evidence/testmain_test.go

@@ -11,6 +11,9 @@ import (
 // Initialize an explicitly configured fresh database before taking the same
 // suite lock as db, agent and server. Hold it on one pinned connection.
 func TestMain(m *testing.M) {
+	// Own database per package (#80): stop contending on the shared tables of
+	// a single test database during parallel ./... runs.
+	db.SuffixTestDatabase("evidence")
 	if os.Getenv("ARTEX_PG_DSN") == "" {
 		os.Exit(m.Run())
 	}

llmrec/testmain_test.go

@@ -0,0 +1,16 @@
+package llmrec
+
+import (
+	"os"
+	"testing"
+
+	"github.com/Autumn-27/artex/db"
+)
+
+// Run against this package's own database (db.SuffixTestDatabase, #80): the
+// recorder tests require an isolated ARTEX_PG_DSN, and the suffix gives them
+// one even inside a full parallel ./... run.
+func TestMain(m *testing.M) {
+	db.SuffixTestDatabase("llmrec")
+	os.Exit(m.Run())
+}

server/engine.go

@@ -99,10 +99,6 @@ type Engine struct {
 	started  sync.Map // taskID -> bool, so Run is idempotent per task
 	lastAct  sync.Map // taskID -> int64 unix, last planner/worker activity (heartbeat)
 	llmCalls sync.Map // taskID -> *int64, actual planner/worker/main-agent LLM calls
-	// quiet-mode (#79): open-goal fingerprint recorded at the end of the last
-	// completed planning round, per task. Edge-triggered rounds are skipped
-	// while it is unchanged and work is still in flight.
-	goalFP   sync.Map // taskID -> string (sorted open-goal ids joined)
 	paused   sync.Map // taskID -> bool, user-paused (planner + workers idle but loops alive)
 	deleting sync.Map // taskID -> bool, delete barrier (no new task-owned writes)
 	dropCnt  sync.Map // taskID -> *int64, running count of dropped (unpersistable) activity records
@@ -801,22 +797,6 @@ func resetPlannerTimer(timer *time.Timer, d time.Duration) {
 	timer.Reset(d)
 }
 
-// quietSkipEdge reports whether an edge-triggered planning round should be
-// dropped (#79): the open-goal set is unchanged since the last completed round
-// AND active work exists (open or running intents). Fails open (false) on any
-// store error: when in doubt, plan, preserving the pre-quiet-mode behavior.
-func (e *Engine) quietSkipEdge(t *Task) bool {
-	fp, err := t.Store.OpenGoalFingerprint()
-	if err != nil {
-		return false
-	}
-	if last, ok := e.goalFP.Load(t.ID); !ok || last != fp {
-		return false
-	}
-	active, err := t.Store.HasActiveIntent()
-	return err == nil && active
-}
-
 func (e *Engine) plannerLoop(ctx context.Context, t *Task) {
 	interval := plannerHeartbeatInterval(t)
 	// Arming the heartbeat timer at loop entry = counting from the task start: even a
@@ -876,17 +856,6 @@ func (e *Engine) plannerLoop(ctx context.Context, t *Task) {
 			}
 			return // the goalless branch never enters planner.Plan
 		}
-		// quiet-mode (#79): an edge round is redundant while work is in flight
-		// and the open-goal set is unchanged since the last completed round —
-		// there is no new decision for the plan to make. Drain the triggers so
-		// they do not accumulate and let the heartbeat supervise; the next edge
-		// after a goal opens or closes, or once the frontier drains and all
-		// workers are idle, plans for real.
-		if src == "edge" && e.quietSkipEdge(t) {
-			t.drainTriggers()
-			log.Printf("[planner] task %s quiet: work in flight, goals unchanged, edge round skipped", t.ID)
-			return
-		}
 		if !e.beginTaskOperation(t.ID) {
 			return
 		}
@@ -926,12 +895,6 @@ func (e *Engine) plannerLoop(ctx context.Context, t *Task) {
 		default:
 			log.Printf("[planner] task %s planning finished", t.ID)
 		}
-		// Record the post-round open-goal fingerprint for quiet-mode (#79):
-		// goals opened or closed by this round change it, so a later edge can
-		// tell "nothing changed" apart from "the plan input changed".
-		if fp, err := t.Store.OpenGoalFingerprint(); err == nil {
-			e.goalFP.Store(t.ID, fp)
-		}
 		e.touch(t.ID)
 	}
 

server/planner_quiet_test.go

@@ -1,76 +0,0 @@
-package server
-
-import (
-	"testing"
-
-	"github.com/Autumn-27/artex/db"
-)
-
-// Planner quiet-mode (#79): an edge round is dropped only when BOTH hold — the
-// open-goal fingerprint is unchanged since the last completed round AND active
-// work exists (open or running intents). Every other combination plans.
-func TestPlannerQuietSkipEdge(t *testing.T) {
-	m, err := NewManager(t.TempDir(), "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = m.Close() })
-	if m.pg == nil {
-		t.Skip("no postgres for this run")
-	}
-
-	created, err := m.CreateTaskWithOptions("quiet-mode probe", "probe goal", db.TaskCreateOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	tt, ok := m.Task(created.ID)
-	if !ok {
-		t.Fatal("task not found after creation")
-	}
-	store := tt.Store
-	e := NewEngine(m)
-
-	gid, err := store.AddGoal(map[string]any{"summary": "g1"}, "seed")
-	if err != nil {
-		t.Fatal(err)
-	}
-	iid, err := store.AddIntent(map[string]any{"summary": "i1"}, 0, nil, "seed")
-	if err != nil {
-		t.Fatal(err)
-	}
-	fp, err := store.OpenGoalFingerprint()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if fp == "" {
-		t.Fatal("fingerprint must not be empty with an open goal")
-	}
-	e.goalFP.Store(tt.ID, fp)
-	if !e.quietSkipEdge(tt) {
-		t.Fatal("unchanged goals + active intent must skip the edge round")
-	}
-
-	// a goal closes -> the fingerprint changes -> plan
-	if err := store.SetNodeState(gid, "met"); err != nil {
-		t.Fatal(err)
-	}
-	if e.quietSkipEdge(tt) {
-		t.Fatal("a closed goal must allow planning")
-	}
-
-	// goal back open, intent drained -> no active work -> plan
-	if err := store.SetNodeState(gid, "open"); err != nil {
-		t.Fatal(err)
-	}
-	fp2, err := store.OpenGoalFingerprint()
-	if err != nil {
-		t.Fatal(err)
-	}
-	e.goalFP.Store(tt.ID, fp2)
-	if err := store.SetIntentState(iid, "done"); err != nil {
-		t.Fatal(err)
-	}
-	if e.quietSkipEdge(tt) {
-		t.Fatal("no active intent must allow planning")
-	}
-}

server/testmain_test.go

@@ -13,6 +13,10 @@ import (
 // server test suite so cross-package DELETE cleanup races with db/agent
 // packages are avoided when running `go test ./...`.
 func TestMain(m *testing.M) {
+	// Own database per package (#80): with separate databases, packages stop
+	// contending on shared tables and the advisory lock below stops
+	// serializing go test ./... across packages.
+	db.SuffixTestDatabase("server")
 	dsn, _, err := db.DSN()
 	if err != nil {
 		os.Exit(m.Run())