perf: lock the parent up front for predictable parent effects

Roots whose transition will report to the parent now plan the agent family
before writing: a model output that ends the turn without tool calls, a
terminal model failure and a terminal compaction failure. These complete
in one attempt instead of rolling back to add the parent. Outputs that
call tools still lock only the child. AcceptOutput and the planning use
one shared rule for which outputs report to the parent.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: ksarangmath

internal/storage/executionstore/agent_inputs_backlog_store.go

@@ -53,7 +53,7 @@ func (s *Store) changeBacklog(ctx context.Context, projectID, agentID uuid.UUID,
 			if projectID == uuid.Nil || agentID == uuid.Nil || change.ID == uuid.Nil {
 				return struct{}{}, errors.New("project, agent and input are required")
 			}
-			unit, h, err := beginExecution(ctx, s, projectID, agentID)
+			unit, h, err := beginExecution(ctx, s, projectID, agentID, false)
 			if err != nil {
 				return struct{}{}, err
 			}

internal/storage/executionstore/agent_interactions_store.go

@@ -81,7 +81,7 @@ func (s *Store) CreatePermissionInteraction(
 		"CreatePermissionInteraction",
 		func(ctx context.Context) (AgentInteractionRecord,
 			error) {
-			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID)
+			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID, false)
 			if err != nil {
 				return AgentInteractionRecord{}, err
 			}

internal/storage/executionstore/agent_runtime_cancellation_store.go

@@ -28,7 +28,7 @@ func (s *Store) CancelAgent(ctx context.Context, input CancelAgentInput) (Cancel
 	return agentexecution.Retry(ctx,
 		"CancelAgent",
 		func(ctx context.Context) (CancelAgentResult, error) {
-			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID)
+			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID, false)
 			if err != nil {
 				return CancelAgentResult{}, err
 			}

internal/storage/executionstore/agent_runtime_locks_store.go

@@ -54,7 +54,7 @@ func (s *Store) EnsureRuntimeLockActive(
 			if projectID == uuid.Nil || agentID == uuid.Nil || runtimeID == uuid.Nil {
 				return struct{}{}, errors.New("project, agent, and runtime lock ids are required")
 			}
-			unit, h, err := beginExecution(ctx, s, projectID, agentID)
+			unit, h, err := beginExecution(ctx, s, projectID, agentID, false)
 			if errors.Is(err, storeerr.ErrNotFound) {
 				return struct{}{}, storeerr.ErrRuntimeLockInactive
 			}
@@ -119,7 +119,7 @@ func (s *Store) ReleaseAgentRuntimeLock(
 	_, err := agentexecution.Retry(ctx,
 		"ReleaseAgentRuntimeLock",
 		func(ctx context.Context) (struct{}, error) {
-			unit, h, err := beginExecution(ctx, s, projectID, agentID)
+			unit, h, err := beginExecution(ctx, s, projectID, agentID, false)
 			if errors.Is(err, storeerr.ErrNotFound) {
 				return struct{}{}, storeerr.ErrRuntimeLockInactive
 			}

internal/storage/executionstore/agent_work_store.go

@@ -33,7 +33,7 @@ func (s *Store) AdvanceOwnedAgentWork(
 			if input.ProjectID == uuid.Nil || input.AgentID == uuid.Nil || input.RuntimeLockID == uuid.Nil {
 				return executionResult{ClaimedAgentWork{}, false}, errors.New("project, agent, and runtime lock ids are required")
 			}
-			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID)
+			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID, false)
 			if errors.Is(err, storeerr.ErrNotFound) {
 				return executionResult{ClaimedAgentWork{}, false}, storeerr.ErrRuntimeLockInactive
 			}

internal/storage/executionstore/context_checkpoints_store.go

@@ -34,7 +34,7 @@ func (s *Store) PublishContextCheckpoint(
 		"PublishContextCheckpoint",
 		func(ctx context.Context) (ContextCheckpointRecord,
 			error) {
-			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID)
+			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID, false)
 			if err != nil {
 				return ContextCheckpointRecord{}, err
 			}

internal/storage/executionstore/context_checkpoints_terminal_failure.go

@@ -36,7 +36,7 @@ func (s *Store) RecordTerminalCompactionFailure(
 	_, err := agentexecution.Retry(ctx,
 		"RecordTerminalCompactionFailure",
 		func(ctx context.Context) (struct{}, error) {
-			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID)
+			unit, h, err := beginExecution(ctx, s, input.ProjectID, input.AgentID, true)
 			if err != nil {
 				return struct{}{}, err
 			}

internal/storage/executionstore/execution_mutation.go

@@ -12,12 +12,18 @@ func beginExecution(
 	ctx context.Context,
 	s *Store,
 	projectID, agentID uuid.UUID,
+	includeParent bool,
 ) (*agentexecution.Unit, *agentexecution.Handle, error) {
 	unit, err := s.cell.Begin(ctx)
 	if err != nil {
 		return nil, nil, err
 	}
-	plan, err := unit.PlanAgents(ctx, []lifecyclelock.AgentRef{{ProjectID: projectID, AgentID: agentID}}, nil)
+	var plan agentexecution.MutationPlan
+	if includeParent {
+		plan, err = unit.PlanAgentFamily(ctx, projectID, agentID, nil)
+	} else {
+		plan, err = unit.PlanAgents(ctx, []lifecyclelock.AgentRef{{ProjectID: projectID, AgentID: agentID}}, nil)
+	}
 	if err == nil {
 		err = unit.LockAgents(ctx, plan)
 	}

internal/storage/executionstore/execution_unit_lock_order_integration_test.go

@@ -78,7 +78,7 @@ func assertExecutionAgentOrder(
 	)
 }
 
-func TestModelMutationsFenceWithoutParentLock(t *testing.T) {
+func TestModelMutationsPlanLocksBeforeFencing(t *testing.T) {
 	for _, parentFirst := range []bool{true, false} {
 		t.Run(fmt.Sprintf("parent_first_%t", parentFirst), func(t *testing.T) {
 			f, parent, child := executionLockOrderAgents(t, parentFirst)
@@ -88,7 +88,11 @@ func TestModelMutationsFenceWithoutParentLock(t *testing.T) {
 				"begin compaction", "replace compaction", "terminal compaction",
 			} {
 				t.Run(operation, func(t *testing.T) {
-					assertExecutionAgentOrder(t, f, child, parent, func(ctx context.Context) error {
+					first, second := child, parent
+					if operation == "terminal compaction" && parentFirst {
+						first, second = parent, child
+					}
+					assertExecutionAgentOrder(t, f, first, second, func(ctx context.Context) error {
 						s := f.Store.Execution()
 						switch operation {
 						case "claim compaction":

internal/storage/executionstore/export_integration_test.go

@@ -45,7 +45,7 @@ func (s *Store) AcquireAgentRuntimeLock(
 	return agentexecution.Retry(ctx,
 		"AcquireAgentRuntimeLock",
 		func(ctx context.Context) (AgentRuntimeLockRecord, error) {
-			unit, h, err := beginExecution(ctx, s, projectID, agentID)
+			unit, h, err := beginExecution(ctx, s, projectID, agentID, false)
 			if err != nil {
 				return AgentRuntimeLockRecord{}, err
 			}
@@ -87,7 +87,7 @@ func (s *Store) RepairExecutionForTest(ctx context.Context, projectID, agentID u
 	_, retryErr := agentexecution.Retry(ctx,
 		"RepairExecutionForTest",
 		func(ctx context.Context) (struct{}, error) {
-			unit, h, err := beginExecution(ctx, s, projectID, agentID)
+			unit, h, err := beginExecution(ctx, s, projectID, agentID, false)
 			if err != nil {
 				return struct{}{}, err
 			}
@@ -122,7 +122,7 @@ func (s *Store) NextAgentModelWork(
 	retried, retryErr := agentexecution.Retry(ctx,
 		"NextAgentModelWork",
 		func(ctx context.Context) (transactionResult, error) {
-			unit, h, err := beginExecution(ctx, s, projectID, agentID)
+			unit, h, err := beginExecution(ctx, s, projectID, agentID, false)
 			if err != nil {
 				return transactionResult{}, err
 			}