semantic-score: strengthen lobby queue aging and extend Resume wait to 5m

Longer door-queue wait now boosts admit score so low-priority knockers
eventually win, and SEMANTIC_WAIT_SEC defaults to 300s to cut not-best timeouts.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: FAUST-BENCHOU

internal/policy/policy.go

@@ -5,6 +5,7 @@ package policy
 
 import (
 	"context"
+	"time"
 
 	"github.com/actordock/actordock/internal/signals"
 	"github.com/actordock/actordock/internal/types"
@@ -37,6 +38,9 @@ type ResumeRequest struct {
 	// semantic-score uses this so only the highest-score knocker may Place/Evict;
 	// other policies ignore it.
 	Waiting []types.Sandbox
+	// WaitingSince maps sandbox ID → when it joined the Resume lobby.
+	// Used for queue-age boost so long waiters eventually become top-ranked.
+	WaitingSince map[string]time.Time
 }
 
 // Policy chooses placement, eviction, and resume targets.

internal/policy/semantic_score.go

@@ -28,11 +28,11 @@ var ErrNotBestWaiter = errors.New("semantic-score: not highest-score Resume wait
 // running sandbox with the lowest agent-semantic keepScore after a phase-lock filter.
 // See docs/architecture/semantic-score.md.
 type SemanticScore struct {
-	WL, WU, WF, WC float64
-	Override       bool
-	PriorMix       float64
-	EmbedAlpha     float64
-	Now            func() time.Time
+	WL, WU, WF, WC, WQ float64
+	Override           bool
+	PriorMix           float64
+	EmbedAlpha         float64
+	Now                func() time.Time
 }
 
 func NewSemanticScore() *SemanticScore {
@@ -41,6 +41,7 @@ func NewSemanticScore() *SemanticScore {
 		WU:         envFloat("SEMANTIC_W_U", 2),
 		WF:         envFloat("SEMANTIC_W_F", 2),
 		WC:         envFloat("SEMANTIC_W_C", 1),
+		WQ:         envFloat("SEMANTIC_W_Q", 2),
 		Override:   envBool("SEMANTIC_OVERRIDE", false),
 		PriorMix:   envFloat("SEMANTIC_PRIOR_MIX", 0.3),
 		EmbedAlpha: envFloat("SEMANTIC_EMBED_ALPHA", 0.2),
@@ -87,7 +88,7 @@ func (p *SemanticScore) Resume(ctx context.Context, req ResumeRequest) (PlaceRes
 }
 
 // RequireBestWaiter returns ErrNotBestWaiter unless req.Sandbox has the highest
-// admit keepScore among Waiting (continuous single-knocker ranking).
+// admit score among Waiting (keepScore + queue-age boost; single-knocker ranking).
 func (p *SemanticScore) RequireBestWaiter(req ResumeRequest) error {
 	if len(req.Waiting) == 0 {
 		return nil
@@ -96,12 +97,12 @@ func (p *SemanticScore) RequireBestWaiter(req ResumeRequest) error {
 	if p.Now != nil {
 		now = p.Now()
 	}
-	mine := keepScore(req.Sandbox, req.SandboxSignals, p, now)
+	mine := admitScore(req.Sandbox, req.SandboxSignals, p, now, req.WaitingSince)
 	for _, other := range req.Waiting {
 		if other.ID == "" || other.ID == req.Sandbox.ID {
 			continue
 		}
-		sc := keepScore(other, req.SandboxSignals, p, now)
+		sc := admitScore(other, req.SandboxSignals, p, now, req.WaitingSince)
 		if sc > mine {
 			return ErrNotBestWaiter
 		}
@@ -117,6 +118,26 @@ func (p *SemanticScore) RequireBestWaiter(req ResumeRequest) error {
 	return nil
 }
 
+// admitScore is keepScore plus lobby queue aging so long waiters eventually win.
+func admitScore(sb types.Sandbox, sandboxSig map[string]signals.SandboxSignals, p *SemanticScore, now time.Time, waitingSince map[string]time.Time) float64 {
+	base := keepScore(sb, sandboxSig, p, now)
+	queueSec := 0.0
+	if waitingSince != nil {
+		if t, ok := waitingSince[sb.ID]; ok && !t.IsZero() {
+			queueSec = now.Sub(t).Seconds()
+			if queueSec < 0 {
+				queueSec = 0
+			}
+		}
+	}
+	return base + p.WQ*queueAging(queueSec)
+}
+
+// queueAging maps lobby wait seconds → unscaled score units (per minute of wait).
+func queueAging(sec float64) float64 {
+	return sec / 60.0
+}
+
 func pickSemanticVictim(running []types.Sandbox, sandboxSig map[string]signals.SandboxSignals, p *SemanticScore, now time.Time) (types.Sandbox, string, error) {
 	var candidates []types.Sandbox
 	for _, sb := range running {

internal/policy/semantic_score_test.go

@@ -324,3 +324,69 @@ func TestSemanticScoreResumeBestWaiterCanPreemptLLMWait(t *testing.T) {
 		t.Fatalf("victim=%q want hold (llm_wait preempt)", res.VictimID)
 	}
 }
+
+func TestSemanticScoreQueueAgingPromotesLongWaiter(t *testing.T) {
+	p := policy.NewSemanticScore()
+	now := time.Date(2026, 7, 23, 12, 0, 0, 0, time.UTC)
+	p.Now = func() time.Time { return now }
+
+	low := -0.4
+	high := 0.4
+	longWait := types.Sandbox{ID: "long", State: types.SandboxSuspended, CreatedAt: now}
+	shortWait := types.Sandbox{ID: "short", State: types.SandboxSuspended, CreatedAt: now.Add(-time.Minute)}
+	sandboxSig := map[string]signals.SandboxSignals{
+		"long": {SandboxID: "long", Semantic: signals.SemanticResource{
+			Phase: signals.PhaseLLMWait,
+			TaskProfile: &signals.TaskProfile{
+				ComplexitySignal: &low, Confidence: 0.9,
+			},
+		}},
+		"short": {SandboxID: "short", Semantic: signals.SemanticResource{
+			Phase: signals.PhaseLLMWait,
+			TaskProfile: &signals.TaskProfile{
+				ComplexitySignal: &high, Confidence: 0.9,
+			},
+		}},
+	}
+	waiting := []types.Sandbox{longWait, shortWait}
+
+	// Fresh lobby: high static score still wins.
+	err := p.RequireBestWaiter(policy.ResumeRequest{
+		Sandbox:        longWait,
+		SandboxSignals: sandboxSig,
+		Waiting:        waiting,
+		WaitingSince: map[string]time.Time{
+			"long":  now,
+			"short": now,
+		},
+	})
+	if !errors.Is(err, policy.ErrNotBestWaiter) {
+		t.Fatalf("fresh long waiter err=%v want ErrNotBestWaiter", err)
+	}
+
+	// After ~3 minutes in lobby, queue aging should promote the low static score.
+	err = p.RequireBestWaiter(policy.ResumeRequest{
+		Sandbox:        longWait,
+		SandboxSignals: sandboxSig,
+		Waiting:        waiting,
+		WaitingSince: map[string]time.Time{
+			"long":  now.Add(-3 * time.Minute),
+			"short": now.Add(-10 * time.Second),
+		},
+	})
+	if err != nil {
+		t.Fatalf("aged long waiter err=%v want nil", err)
+	}
+	err = p.RequireBestWaiter(policy.ResumeRequest{
+		Sandbox:        shortWait,
+		SandboxSignals: sandboxSig,
+		Waiting:        waiting,
+		WaitingSince: map[string]time.Time{
+			"long":  now.Add(-3 * time.Minute),
+			"short": now.Add(-10 * time.Second),
+		},
+	})
+	if !errors.Is(err, policy.ErrNotBestWaiter) {
+		t.Fatalf("short waiter err=%v want ErrNotBestWaiter after aging", err)
+	}
+}

internal/scheduler/scheduler.go

@@ -41,14 +41,19 @@ type Scheduler struct {
 	goldenMu sync.Mutex
 
 	// resumeWaiters tracks sandboxes blocked in Resume (candidates to knock).
-	// Under semantic-score only the highest keepScore waiter may knock at a time.
+	// Under semantic-score only the highest admit-score waiter may knock at a time.
 	resumeWaitMu  sync.Mutex
-	resumeWaiters map[string]types.Sandbox
+	resumeWaiters map[string]resumeWaiter
 
 	// knockMu serializes the single active knocker's Place/Evict/Restore.
 	knockMu sync.Mutex
 }
 
+type resumeWaiter struct {
+	Sandbox types.Sandbox
+	Since   time.Time
+}
+
 func New(st store.Store, pol policy.Policy, snapRoot string, log *slog.Logger, m *metrics.Metrics, sig *signals.Store) *Scheduler {
 	if log == nil {
 		log = slog.Default()
@@ -64,7 +69,7 @@ func New(st store.Store, pol policy.Policy, snapRoot string, log *slog.Logger, m
 		log:           log,
 		metrics:       m,
 		signals:       sig,
-		resumeWaiters: make(map[string]types.Sandbox),
+		resumeWaiters: make(map[string]resumeWaiter),
 	}
 	if m != nil {
 		m.SetPoolStats(s)
@@ -344,10 +349,11 @@ func (s *Scheduler) Resume(ctx context.Context, id string) (types.Sandbox, error
 		}
 		now := time.Now().UTC()
 		sandboxSig, workerSig := s.signalViews(now)
+		waiting, waitingSince := s.listResumeWaitState()
 		res, err := s.policy.Resume(ctx, policy.ResumeRequest{
 			Sandbox: sb, Workers: workers, Running: running,
 			SandboxSignals: sandboxSig, WorkerSignals: workerSig,
-			Waiting: s.listResumeWaiters(),
+			Waiting: waiting, WaitingSince: waitingSince,
 		})
 		if err != nil {
 			lastErr = err
@@ -373,7 +379,7 @@ func (s *Scheduler) Resume(ctx context.Context, id string) (types.Sandbox, error
 				"err", err.Error(),
 				"running", len(running),
 				"workers", len(workers),
-				"waiters", len(s.listResumeWaiters()),
+				"waiters", len(waiting),
 			)
 			select {
 			case <-ctx.Done():
@@ -512,10 +518,12 @@ func (s *Scheduler) ensureKnockerTurn(sb types.Sandbox) error {
 	}
 	now := time.Now().UTC()
 	sandboxSig, _ := s.signalViews(now)
+	waiting, waitingSince := s.listResumeWaitState()
 	return ss.RequireBestWaiter(policy.ResumeRequest{
 		Sandbox:        sb,
 		SandboxSignals: sandboxSig,
-		Waiting:        s.listResumeWaiters(),
+		Waiting:        waiting,
+		WaitingSince:   waitingSince,
 	})
 }
 
@@ -692,9 +700,14 @@ func (s *Scheduler) addResumeWaiter(sb types.Sandbox) {
 	s.resumeWaitMu.Lock()
 	defer s.resumeWaitMu.Unlock()
 	if s.resumeWaiters == nil {
-		s.resumeWaiters = make(map[string]types.Sandbox)
+		s.resumeWaiters = make(map[string]resumeWaiter)
 	}
-	s.resumeWaiters[sb.ID] = sb
+	if w, ok := s.resumeWaiters[sb.ID]; ok {
+		w.Sandbox = sb
+		s.resumeWaiters[sb.ID] = w
+		return
+	}
+	s.resumeWaiters[sb.ID] = resumeWaiter{Sandbox: sb, Since: time.Now()}
 }
 
 func (s *Scheduler) removeResumeWaiter(id string) {
@@ -703,14 +716,16 @@ func (s *Scheduler) removeResumeWaiter(id string) {
 	delete(s.resumeWaiters, id)
 }
 
-func (s *Scheduler) listResumeWaiters() []types.Sandbox {
+func (s *Scheduler) listResumeWaitState() ([]types.Sandbox, map[string]time.Time) {
 	s.resumeWaitMu.Lock()
 	defer s.resumeWaitMu.Unlock()
 	out := make([]types.Sandbox, 0, len(s.resumeWaiters))
-	for _, sb := range s.resumeWaiters {
-		out = append(out, sb)
+	since := make(map[string]time.Time, len(s.resumeWaiters))
+	for id, w := range s.resumeWaiters {
+		out = append(out, w.Sandbox)
+		since[id] = w.Since
 	}
-	return out
+	return out, since
 }
 
 // resumeRetryable reports Place/Resume errors that should keep the knocker retrying.
@@ -729,11 +744,11 @@ func resumeRetryable(err error) bool {
 func semanticWaitDuration() time.Duration {
 	v := os.Getenv("SEMANTIC_WAIT_SEC")
 	if v == "" {
-		return 120 * time.Second
+		return 300 * time.Second
 	}
 	sec, err := strconv.Atoi(v)
 	if err != nil || sec < 0 {
-		return 120 * time.Second
+		return 300 * time.Second
 	}
 	return time.Duration(sec) * time.Second
 }