Compare commits

...
Author SHA1 Message Date
BaaRai 84a623bf2d fix(db): parenthesise a top-level OR in asset DSL queries
QueryDSLInScope builds the DSL clause and then appends the task-scope clause with AND. An OR node joined its children without wrapping the whole group, so '(a) OR (b) AND id IN (scope)' let the first branch return assets outside the task scope. Wrap the whole disjunction; the children are already parenthesised.

Tests: the pure builder shape, and a PostgreSQL case where the bare-text branch matches both an in-scope and an out-of-scope asset (fails before the fix).
2026-11-20 01:34:28 +01:00
BaaRai 4a29dbfd6d Merge pull request #384 from BaaRai/fix/llm-rotate-context
fix(server): attach the rotated LLM profile pin after execContextFor
2026-11-20 01:28:50 +01:00
BaaRai b3c9708bf3 fix(server): attach rotated LLM profile pin after execContextFor (#376) 2026-11-20 01:01:08 +01:00
4 changed files with 293 additions and 11 deletions
+5 -1
View File
@@ -302,7 +302,11 @@ func (b *whereBuilder) build(node *astNode) (string, error) {
}
parts = append(parts, "("+clause+")")
}
return strings.Join(parts, " OR "), nil
// The whole disjunction must be parenthesised: callers append their own
// clauses with AND (the task scope in QueryDSLInScope, the type filter),
// and AND binds tighter than OR, so "(a) OR (b) AND scope" would let the
// first branch escape the scope.
return "(" + strings.Join(parts, " OR ") + ")", nil
case "leaf":
return b.buildLeaf(*node.expr)
}
+86
View File
@@ -0,0 +1,86 @@
package db
import (
"fmt"
"strings"
"testing"
"time"
)
// A top-level OR must be parenthesised as a whole. QueryDSLInScope appends the
// task-scope clause with AND, and AND binds tighter than OR, so an unparenthesised
// disjunction lets the first branch return rows from outside the task scope.
func TestBuildDSLWhereWrapsOr(t *testing.T) {
node, err := ParseDSL("domain=alpha OR domain=beta")
if err != nil {
t.Fatal(err)
}
where, _, err := buildDSLWhereBase(node, 0)
if err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(where, "((") || !strings.HasSuffix(where, "))") {
t.Fatalf("compiled to %q: the whole OR group must be parenthesised", where)
}
}
// TestQueryDSLInScopeOrDoesNotEscape is the behavioural form: an OR query whose
// first branch matches every row must not return an asset outside the task scope.
func TestQueryDSLInScopeOrDoesNotEscape(t *testing.T) {
d, assets, _ := testSetup(t)
t.Cleanup(func() { d.Close() })
task, err := d.CreateTask("or scope", "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
stamp := time.Now().UnixNano()
root := fmt.Sprintf("in%d.invalid", stamp)
out := fmt.Sprintf("x%d.invalid", stamp)
marker := fmt.Sprintf("or%d", stamp)
if err := assets.upsertTaskScope(TaskScope{TaskID: task.ID, Kind: "root_domain", Domain: root}); err != nil {
t.Fatalf("seed scope: %v", err)
}
var inID, outID int64
for _, r := range []struct {
domain, root string
id *int64
}{
{"a." + root, root, &inID},
{out, out, &outID},
} {
if err := d.QueryRow(`INSERT INTO assets(type,domain,root_domain,page_title,last_seen)
VALUES ('subdomain',$1,$2,$3,now()) RETURNING id`, r.domain, r.root, marker).Scan(r.id); err != nil {
t.Fatalf("insert %s: %v", r.domain, err)
}
}
t.Cleanup(func() {
cleanupExec(t, d, `DELETE FROM assets WHERE id=ANY($1::bigint[])`, []int64{inID, outID})
})
// The bare marker matches both rows; the second branch names the out-of-scope
// host. Only the in-scope row may come back.
got, err := assets.QueryDSLInScope(marker+" OR domain="+out, "", task.ID, 50, 0)
if err != nil {
t.Fatal(err)
}
var sawIn, sawOut bool
for _, a := range got {
switch a.ID {
case inID:
sawIn = true
case outID:
sawOut = true
}
}
if !sawIn {
t.Fatalf("in-scope asset %d missing from %+v", inID, got)
}
if sawOut {
t.Fatalf("out-of-scope asset %d leaked through an OR query", outID)
}
}
+23 -10
View File
@@ -1182,6 +1182,27 @@ func (e *Engine) runWorkerStep(ctx context.Context, t *Task, name string, worker
return e.runIntent(ctx, t, name, worker, intent, token, "", "")
}
// intentWorkContext resolves the cached per-task exec context and returns a
// per-intent child context with the rotated LLM profile pin attached (#85,
// #376). Attaching the pin after execContextFor ensures a cached e.execCtx
// does not drop it; attaching it after the paused/deleting check ensures a
// rolled-back claim never advances the rotation counter.
func (e *Engine) intentWorkContext(ctx context.Context, t *Task) (ectx, workCtx context.Context, workCancel context.CancelCauseFunc, ok bool) {
ectx = e.clockCtx(e.execContextFor(ctx, t.ID), t, false) // cancellable by Pause; carries the task deadline
if ectx.Err() != nil || e.IsDeleting(t.ID) {
return ectx, nil, nil, false
}
// per-work child context so the planner's kill_work can stop just this work.
workCtx, workCancel = context.WithCancelCause(ectx)
// Per-intent LLM rotation (#85): each claimed worker intent runs on the
// next chain head. The pin travels through the run context into the
// provider resolver; non-worker roles and failover keep the active head.
if head, pinned := t.nextRotatedProfile(); pinned {
workCtx = withLLMProfilePin(workCtx, head)
}
return ectx, workCtx, workCancel, true
}
// runIntent executes and fully settles one already-claimed (state=running) intent.
// Both the pool worker loop (via runWorkerStep) and the human-message handler (via
// runDetachedIntent, a dedicated goroutine outside the worker pool) call it, so the
@@ -1194,25 +1215,17 @@ func (e *Engine) runWorkerStep(ctx context.Context, t *Task, name string, worker
// while the worker is busy, and every intent state write below is fenced on it,
// so a worker whose claim was taken over cannot overwrite the new claimer.
func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *agent.Worker, intent *db.Node, token, requestID, message string) bool {
// Per-intent LLM rotation (#85): each claimed worker intent runs on the
// next chain head. The pin travels through the run context into the
// provider resolver; non-worker roles and failover keep the active head.
if head, ok := t.nextRotatedProfile(); ok {
ctx = withLLMProfilePin(ctx, head)
}
hasChatMessage := message != ""
e.stampFirstRun(t) // first real execution → stamp first_run_at + compute the deadline (only for tasks with a timeout)
e.touch(t.ID)
emit := func(r db.Activity) { e.emitActivity(t, r) }
ectx := e.clockCtx(e.execContextFor(ctx, t.ID), t, false) // cancellable by Pause; carries the task deadline
if ectx.Err() != nil || e.IsDeleting(t.ID) {
ectx, workCtx, workCancel, ok := e.intentWorkContext(ctx, t)
if !ok {
if err := t.Store.SettleIntentClaim(intent.ID, token, "open"); err != nil {
log.Printf("[worker %s] task %s intent #%d claim rollback failed: %v", name, t.ID, intent.ID, err)
}
return true
}
// per-work child context so the planner's kill_work can stop just this work.
workCtx, workCancel := context.WithCancelCause(ectx)
e.registerWork(intent.ID, workCancel)
stopHeartbeat := startClaimHeartbeat(t.Store, db.IntentClaimHeartbeatInterval, name, intent.ID, token, workCancel)
// wrap the guard hooks so steer_work can inject a mid-run course-correction
+179
View File
@@ -3,12 +3,14 @@ package server
import (
"context"
"fmt"
"iter"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"
"github.com/Autumn-27/artex/agent"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/norma/llm"
)
@@ -211,3 +213,180 @@ func TestNextRotatedProfileRoundRobin(t *testing.T) {
t.Fatal("disabled rotation must not assign a pin")
}
}
type pinCapture struct {
id int64
ok bool
}
type pinCaptureProvider struct {
mu sync.Mutex
seen []pinCapture
}
func (p *pinCaptureProvider) record(ctx context.Context) {
id, ok := llmProfilePinFrom(ctx)
p.mu.Lock()
p.seen = append(p.seen, pinCapture{id: id, ok: ok})
p.mu.Unlock()
}
func (p *pinCaptureProvider) Stream(ctx context.Context, _ llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] {
p.record(ctx)
return func(yield func(llm.StreamEvent, error) bool) {
if !yield(llm.StreamEvent{Type: llm.SETextDelta, Text: "done"}, nil) {
return
}
if !yield(llm.StreamEvent{Type: llm.SEMessageDelta, StopReason: "end_turn"}, nil) {
return
}
yield(llm.StreamEvent{Type: llm.SEMessageStop}, nil)
}
}
func (p *pinCaptureProvider) Complete(ctx context.Context, _ llm.CompletionRequest) (llm.Message, string, llm.Usage, error) {
p.record(ctx)
return llm.Message{Role: llm.RoleAssistant, Content: []llm.ContentBlock{llm.TextBlock("done")}}, "end_turn", llm.Usage{}, nil
}
// Regression test for #376 (DB-free): warming e.execContextFor first (as the
// planner does) must not drop the per-intent LLM profile pin on subsequent
// worker intents, and a paused/deleting rollback must not advance rotation.
func TestIntentWorkContextRotatesWithCachedExecCtx(t *testing.T) {
const (
taskID = "77"
profileA = int64(101)
profileB = int64(202)
)
e := NewEngine(nil)
tk := &Task{ID: taskID, LLMProfileIDs: []int64{profileA, profileB}, LLMRotate: true}
// Warm the per-task cached execCtx, simulating the planner running first.
warm := e.execContextFor(context.Background(), taskID)
if warm == nil || warm.Err() != nil {
t.Fatalf("warm execContextFor returned invalid ctx: %v", warm)
}
// A paused task must roll back without advancing the rotation counter.
e.Pause(taskID, agent.AbortPausedByUser)
if _, _, _, ok := e.intentWorkContext(context.Background(), tk); ok {
t.Fatal("paused task unexpectedly yielded a work context")
}
e.Resume(tk)
// Re-warm cached execCtx after resume (again simulating planner before worker).
_ = e.execContextFor(context.Background(), taskID)
// A deleting task must also roll back without advancing the rotation counter.
e.BeginDelete(taskID)
if _, _, _, ok := e.intentWorkContext(context.Background(), tk); ok {
t.Fatal("deleting task unexpectedly yielded a work context")
}
e.AbortDelete(taskID, false)
// Two consecutive claimed intents must carry distinct rotated pins (A then B).
_, workA, cancelA, ok := e.intentWorkContext(context.Background(), tk)
if !ok {
t.Fatal("first intentWorkContext failed")
}
defer cancelA(nil)
gotA, okA := llmProfilePinFrom(workA)
if !okA || gotA != profileA {
t.Fatalf("first workCtx pin = (%d, %v), want (%d, true)", gotA, okA, profileA)
}
_, workB, cancelB, ok := e.intentWorkContext(context.Background(), tk)
if !ok {
t.Fatal("second intentWorkContext failed")
}
defer cancelB(nil)
gotB, okB := llmProfilePinFrom(workB)
if !okB || gotB != profileB {
t.Fatalf("second workCtx pin = (%d, %v), want (%d, true)", gotB, okB, profileB)
}
if gotA == gotB {
t.Fatalf("expected distinct pinned profile IDs, both were %d", gotA)
}
}
// Regression test for #376 (end-to-end through runIntent): warm execContextFor
// first (simulating the planner running before workers), then run two intents
// through runIntent and assert the two work contexts carry distinct pinned
// profile IDs (A then B).
func TestRunIntentRotatesPinnedProfileWithCachedExecCtx(t *testing.T) {
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Skipf("postgres unavailable: %v", err)
}
defer m.Close()
ids := make([]int64, 0, 2)
for i := 0; i < 2; i++ {
id, err := m.pg.SaveProfile(&db.LLMProfile{
Name: fmt.Sprintf("runintent-rotate-%d-%d", time.Now().UnixNano(), i),
Format: "openai",
BaseURL: "http://127.0.0.1:1/v1",
Model: "test",
APIKey: "test-key",
})
if err != nil {
t.Fatal(err)
}
ids = append(ids, id)
defer m.pg.DeleteProfile(id)
}
on := true
task, err := m.CreateTaskWithOptions("runIntent rotation", "verify pin survives cached execCtx", db.TaskCreateOptions{
LLMProfileIDs: ids,
LLMRotate: &on,
})
if err != nil {
t.Fatal(err)
}
defer m.DeleteTask(task.ID, DeleteTaskOptions{})
e := NewEngine(m)
// Warm the per-task cached execCtx before any worker intent runs.
_ = e.execContextFor(context.Background(), task.ID)
// Verify paused rollback through runIntent does not advance rotation.
if _, err := task.Store.AddIntent(map[string]any{"summary": "rolled back while paused"}, 1, nil, "planner"); err != nil {
t.Fatal(err)
}
pausedIntent, pausedToken := e.claimNext(task, "work#0")
if pausedIntent == nil {
t.Fatal("failed to claim intent for paused rollback check")
}
e.Pause(task.ID, agent.AbortPausedByUser)
probe := &pinCaptureProvider{}
worker := agent.NewWorker(probe, "test-model", m.dir, nil, 0, 2)
e.runIntent(context.Background(), task, "work#0", worker, pausedIntent, pausedToken, "", "")
if len(probe.seen) != 0 {
t.Fatalf("paused runIntent called provider %d times, want 0", len(probe.seen))
}
e.Resume(task)
// Re-warm cached execCtx after resume (simulating planner before workers).
_ = e.execContextFor(context.Background(), task.ID)
// Run two intents through runIntent and assert distinct pins: ids[0] then ids[1].
if _, err := task.Store.AddIntent(map[string]any{"summary": "rotate intent 2"}, 1, nil, "planner"); err != nil {
t.Fatal(err)
}
for i, wantID := range ids {
name := fmt.Sprintf("work#%d", i+1)
intent, token := e.claimNext(task, name)
if intent == nil {
t.Fatalf("intent %d not claimed", i+1)
}
p := &pinCaptureProvider{}
w := agent.NewWorker(p, "test-model", m.dir, nil, 0, 2)
e.runIntent(context.Background(), task, name, w, intent, token, "", "")
if len(p.seen) == 0 {
t.Fatalf("intent %d: provider was not called", i+1)
}
got := p.seen[0]
if !got.ok || got.id != wantID {
t.Fatalf("intent %d: workCtx pin = (%d, %v), want (%d, true)", i+1, got.id, got.ok, wantID)
}
}
}