fix: refresh tool receipt deadlines on execution progress

Use the latest progress timestamp to extend receipt waits and recheck concurrent progress before expiring a tool call. Preserve run timeouts and late-result protection.

Author: LeeEirc

internal/service/execution.go

@@ -535,20 +535,31 @@ func (s *Service) waitToolResult(ctx context.Context, run *domain.Run, call *dom
 		if err != nil && !errors.Is(err, ports.ErrNotFound) {
 			return agentruntime.ToolObservation{}, err
 		}
+		// Progress is a receipt too. Executor contexts and the run context bound
+		// the operation; this timer only detects an executor that stopped replying.
+		if result != nil && !result.Done && result.Status == "running" {
+			deadline.Reset(time.Until(result.CreatedAt.Add(wait)))
+		}
 		select {
 		case <-ctx.Done():
 			return agentruntime.ToolObservation{}, ctx.Err()
 		case <-deadline.C:
-			return s.expireToolWait(ctx, run, call)
+			observation, expireErr := s.expireToolWait(ctx, run, call, wait)
+			if errors.Is(expireErr, errToolWaitProgress) {
+				continue
+			}
+			return observation, expireErr
 		case <-notifications:
 		case <-ticker.C:
 		}
 	}
 }
 
+var errToolWaitProgress = errors.New("tool progress advanced the receipt deadline")
+
 // A lost executor receipt is an observation for the model, never permission to
 // retry a write. The transaction arbitrates with a concurrently arriving result.
-func (s *Service) expireToolWait(ctx context.Context, run *domain.Run, call *domain.ToolCall) (agentruntime.ToolObservation, error) {
+func (s *Service) expireToolWait(ctx context.Context, run *domain.Run, call *domain.ToolCall, wait time.Duration) (agentruntime.ToolObservation, error) {
 	var observation agentruntime.ToolObservation
 	now := time.Now().UTC()
 	err := s.store.Transaction(ctx, func(tx ports.Tx) error {
@@ -560,6 +571,9 @@ func (s *Service) expireToolWait(ctx context.Context, run *domain.Run, call *dom
 		if err != nil && !errors.Is(err, ports.ErrNotFound) {
 			return err
 		}
+		if latest != nil && latest.Status == "running" && now.Before(latest.CreatedAt.Add(wait)) {
+			return errToolWaitProgress
+		}
 		current, err := tx.RunInternal(run.ID, true)
 		if err != nil {
 			return err

internal/service/tool_timeout_test.go

@@ -3,10 +3,41 @@ package service
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"testing"
 	"time"
 )
 
+func TestReceiptExpiryRechecksConcurrentProgress(t *testing.T) {
+	s, principal, run, call, approval := approvalFixture(t)
+	ctx := context.Background()
+	if _, _, err := s.DecideApproval(ctx, principal, approval.ID, ApprovalDecisionRequest{Decision: "approve"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := s.dispatchToolCall(ctx, run, call); err != nil {
+		t.Fatal(err)
+	}
+	_, _, err := s.SubmitToolResult(ctx, principal, call.ID, ToolResultRequest{
+		RunID: run.ID, Sequence: 1, Status: "running",
+		Result: json.RawMessage(`{"status":"awaiting_approval"}`),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err = s.expireToolWait(ctx, run, call, 45*time.Second); !errors.Is(err, errToolWaitProgress) {
+		t.Fatalf("concurrent review progress was expired: %v", err)
+	}
+	if _, _, err = s.SubmitToolResult(ctx, principal, call.ID, ToolResultRequest{
+		RunID: run.ID, Sequence: 2, Done: true, Status: "success", Result: json.RawMessage(`{"output":"files"}`),
+	}); err != nil {
+		t.Fatal(err)
+	}
+	observation, err := s.waitToolResult(ctx, run, call)
+	if err != nil || observation.Status != "success" {
+		t.Fatalf("lost completion after approval: %+v %v", observation, err)
+	}
+}
+
 func TestToolReceiptDeadlineReturnsObservationAndRejectsLateResult(t *testing.T) {
 	s, principal, run, call, approval := approvalFixture(t)
 	s.toolResultTimeout = 10 * time.Millisecond