kandev/apps/backend/internal/office/runtime/context_builder_test.go

package runtime

import (
	"context"
	"encoding/json"
	"errors"
	"testing"

	"github.com/kandev/kandev/internal/office/models"
)

var errBoom = errors.New("boom")

func TestContextBuilderBuildsAndPersistsRuntimeSnapshot(t *testing.T) {
	agents := &recordingAgentReader{
		agent: &models.AgentInstance{
			ID:          "agent-1",
			WorkspaceID: "ws-1",
			Role:        models.AgentRoleCEO,
		},
	}
	store := &recordingRunSnapshotStore{}
	builder := ContextBuilder{Agents: agents, Runs: store}
	run := &models.Run{
		ID:             "run-1",
		AgentProfileID: "agent-1",
		Reason:         "task_assigned",
		Payload:        `{"task_id":"task-1","session_id":"session-1"}`,
	}

	runCtx, err := builder.BuildAndPersist(context.Background(), run)
	if err != nil {
		t.Fatalf("BuildAndPersist: %v", err)
	}

	if runCtx.WorkspaceID != "ws-1" || runCtx.AgentID != "agent-1" {
		t.Fatalf("unexpected identity: %+v", runCtx)
	}
	if runCtx.TaskID != "task-1" || runCtx.SessionID != "session-1" {
		t.Fatalf("unexpected task/session: %+v", runCtx)
	}
	if !runCtx.Capabilities.Allows(CapabilityCreateAgent) {
		t.Fatal("expected CEO runtime context to allow create_agent")
	}
	if len(store.calls) != 1 {
		t.Fatalf("expected 1 snapshot write, got %d", len(store.calls))
	}
	var caps Capabilities
	if err := json.Unmarshal([]byte(store.calls[0].Capabilities), &caps); err != nil {
		t.Fatalf("decode capabilities: %v", err)
	}
	if !caps.Allows(CapabilityCreateAgent) {
		t.Fatal("persisted capabilities should include create_agent")
	}
}

type recordingAgentReader struct {
	agent *models.AgentInstance
}

func (r *recordingAgentReader) GetAgentInstance(_ context.Context, _ string) (*models.AgentInstance, error) {
	return r.agent, nil
}

func (r *recordingAgentReader) ListAgentInstances(_ context.Context, _ string) ([]*models.AgentInstance, error) {
	return []*models.AgentInstance{r.agent}, nil
}

func (r *recordingAgentReader) ListAgentInstancesByIDs(
	_ context.Context,
	_ []string,
) ([]*models.AgentInstance, error) {
	return []*models.AgentInstance{r.agent}, nil
}

type recordingRunSnapshotStore struct {
	calls []snapshotCall
}

type snapshotCall struct {
	RunID         string
	Capabilities  string
	InputSnapshot string
	SessionID     string
}

func (s *recordingRunSnapshotStore) UpdateRunRuntimeSnapshot(
	_ context.Context,
	id string,
	capabilities string,
	inputSnapshot string,
	sessionID string,
) error {
	s.calls = append(s.calls, snapshotCall{
		RunID:         id,
		Capabilities:  capabilities,
		InputSnapshot: inputSnapshot,
		SessionID:     sessionID,
	})
	return nil
}

type stubSeatResolver struct {
	held    bool
	err     error
	taskID  string
	agentID string
}

func (r *stubSeatResolver) HoldsDecisionSeat(_ context.Context, taskID, agentID string) (bool, error) {
	r.taskID = taskID
	r.agentID = agentID
	return r.held, r.err
}

func buildTestRunContext(t *testing.T, seats DecisionSeatResolver) RunContext {
	t.Helper()
	agents := &recordingAgentReader{
		agent: &models.AgentInstance{ID: "agent-1", WorkspaceID: "ws-1", Role: models.AgentRoleWorker},
	}
	builder := ContextBuilder{Agents: agents, Runs: &recordingRunSnapshotStore{}, Seats: seats}
	run := &models.Run{
		ID:             "run-1",
		AgentProfileID: "agent-1",
		Reason:         "task_assigned",
		Payload:        `{"task_id":"task-1"}`,
	}
	runCtx, err := builder.Build(context.Background(), run)
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	return runCtx
}

func hasAvailableAction(runCtx RunContext, want string) bool {
	for _, action := range runCtx.AvailableActions {
		if action == want {
			return true
		}
	}
	return false
}

func TestContextBuilderGrantsRecordStepDecisionForSeatHolder(t *testing.T) {
	runCtx := buildTestRunContext(t, &stubSeatResolver{held: true})
	if !hasAvailableAction(runCtx, AvailableActionRecordStepDecision) {
		t.Fatal("expected seat holder to be granted record_step_decision")
	}
}

func TestContextBuilderDeniesRecordStepDecisionForNonHolder(t *testing.T) {
	runCtx := buildTestRunContext(t, &stubSeatResolver{held: false})
	if hasAvailableAction(runCtx, AvailableActionRecordStepDecision) {
		t.Fatal("expected non-holder to be denied record_step_decision")
	}
}

func TestContextBuilderDeniesRecordStepDecisionWhenResolverNil(t *testing.T) {
	runCtx := buildTestRunContext(t, nil)
	if hasAvailableAction(runCtx, AvailableActionRecordStepDecision) {
		t.Fatal("expected nil resolver to deny record_step_decision")
	}
}

func TestContextBuilderReturnsResolverError(t *testing.T) {
	seats := &stubSeatResolver{held: true, err: errBoom}
	builder := ContextBuilder{
		Agents: &recordingAgentReader{
			agent: &models.AgentInstance{ID: "agent-1", WorkspaceID: "ws-1", Role: models.AgentRoleWorker},
		},
		Seats: seats,
	}
	run := &models.Run{ID: "run-1", AgentProfileID: "agent-1", Payload: `{"task_id":"task-1"}`}
	if _, err := builder.Build(context.Background(), run); !errors.Is(err, errBoom) {
		t.Fatalf("expected resolver error to abort context build, got %v", err)
	}
}

func TestContextBuilderDeniesRecordStepDecisionForTasklessRun(t *testing.T) {
	agents := &recordingAgentReader{
		agent: &models.AgentInstance{ID: "agent-1", WorkspaceID: "ws-1", Role: models.AgentRoleWorker},
	}
	builder := ContextBuilder{
		Agents: agents,
		Runs:   &recordingRunSnapshotStore{},
		Seats:  &stubSeatResolver{held: true},
	}
	run := &models.Run{ID: "run-1", AgentProfileID: "agent-1", Reason: "heartbeat", Payload: "{}"}
	runCtx, err := builder.Build(context.Background(), run)
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	if hasAvailableAction(runCtx, AvailableActionRecordStepDecision) {
		t.Fatal("expected taskless run to deny record_step_decision")
	}
}

func TestContextBuilderPersistsSeatActionAsAdvisoryMetadata(t *testing.T) {
	store := &recordingRunSnapshotStore{}
	seats := &stubSeatResolver{held: true}
	builder := ContextBuilder{
		Agents: &recordingAgentReader{
			agent: &models.AgentInstance{
				ID:          "agent-1",
				WorkspaceID: "ws-1",
				Role:        models.AgentRoleWorker,
			},
		},
		Runs:  store,
		Seats: seats,
	}
	run := &models.Run{
		ID:             "run-1",
		AgentProfileID: "agent-1",
		Reason:         "task_review_requested",
		Payload:        `{"task_id":"task-1"}`,
	}

	runCtx, err := builder.BuildAndPersist(context.Background(), run)
	if err != nil {
		t.Fatalf("BuildAndPersist: %v", err)
	}
	if seats.taskID != "task-1" || seats.agentID != "agent-1" {
		t.Fatalf("seat resolver received task=%q agent=%q", seats.taskID, seats.agentID)
	}

	rawContext, err := json.Marshal(runCtx)
	if err != nil {
		t.Fatalf("marshal run context: %v", err)
	}
	var contextSnapshot map[string]any
	if err := json.Unmarshal(rawContext, &contextSnapshot); err != nil {
		t.Fatalf("decode run context: %v", err)
	}
	actions, ok := contextSnapshot["available_actions"].([]any)
	if !ok || len(actions) != 1 || actions[0] != "record_step_decision" {
		t.Fatalf("expected advisory record_step_decision action, got %#v", contextSnapshot["available_actions"])
	}

	var capabilities map[string]any
	if err := json.Unmarshal([]byte(store.calls[0].Capabilities), &capabilities); err != nil {
		t.Fatalf("decode capabilities: %v", err)
	}
	if _, ok := capabilities["record_step_decision"]; ok {
		t.Fatalf("record_step_decision must not be serialized as a runtime capability: %s", store.calls[0].Capabilities)
	}
}