taskreplay

type BaseSource string

type Comparison struct {
	// BaseSHA is the commit both changes are measured from.
	BaseSHA string `json:"base_sha,omitempty"`
	// OriginalCommit and ReplayCommit are the two tips.
	OriginalCommit string `json:"original_commit,omitempty"`
	ReplayCommit   string `json:"replay_commit,omitempty"`
	// OriginalTree and ReplayTree are what actually decides IDENTICAL.
	OriginalTree string `json:"original_tree,omitempty"`
	ReplayTree   string `json:"replay_tree,omitempty"`
	// Identical is OriginalTree == ReplayTree.
	Identical bool `json:"identical"`
	// BaseConfirmed reports that the original commit really is a descendant of
	// BaseSHA. False means the base was inferred and could not be corroborated,
	// which caps how strong a verdict may be.
	BaseConfirmed bool `json:"base_confirmed"`
	// OriginalCommits is how many commits the original write-back carried.
	// More than one on an inferred base means the base is wrong.
	OriginalCommits int `json:"original_commits,omitempty"`
	// DiffStat is the --stat summary of the diff-of-diffs, DiffOfDiffs the
	// patch itself, truncated at maxDiffBytes.
	DiffStat    string `json:"diff_stat,omitempty"`
	DiffOfDiffs string `json:"diff_of_diffs,omitempty"`
	// DiffTruncated reports that DiffOfDiffs hit the cap.
	DiffTruncated bool `json:"diff_truncated,omitempty"`
	// FilesDiffering names the paths the two changes disagree on.
	FilesDiffering []string `json:"files_differing,omitempty"`
}

type Options struct {
	// Target is the provider being compared against (required).
	Target provider.Provider
	// TargetName is the registered name of the target provider (e.g. "anthropic").
	TargetName string
	// TargetModel is the model identifier (empty = provider default).
	TargetModel string
	// MaxTokens for the target completion (0 = provider default).
	MaxTokens int
	// Timeout caps the target completion call (0 = 5 minutes).
	Timeout time.Duration

	// Judge, when non-nil, is asked to rate semantic equivalence on a 1–10 scale.
	// The judge is typically a strong general-purpose model (e.g. claude-opus).
	// When nil, EquivalenceScore is left at 0 and EquivalenceRationale is empty.
	Judge      provider.Provider
	JudgeModel string
}

type Provenance struct {
	TaskID    int           `json:"task_id"`
	TaskTitle string        `json:"task_title"`
	Status    pm.TaskStatus `json:"status"`

	// The plan side of the input.
	Goal         string `json:"goal,omitempty"`
	Instructions string `json:"instructions,omitempty"`
	Prompt       string `json:"prompt,omitempty"`
	PromptSHA256 string `json:"prompt_sha256,omitempty"`

	// The model side. Effort is the reasoning-effort level (Task 20149).
	Provider string `json:"provider,omitempty"`
	Model    string `json:"model,omitempty"`
	Effort   string `json:"effort,omitempty"`

	// The sandbox side: the stamp the original run left, plus whether the
	// project's .cloop/sandbox.yaml still hashes to what that run used.
	Sandbox        artifact.SandboxRecord `json:"sandbox"`
	SandboxHashNow string                 `json:"sandbox_hash_now,omitempty"`
	SandboxDrift   bool                   `json:"sandbox_drift"`

	// The git side.
	BaseSHA        string     `json:"base_sha,omitempty"`
	BaseSource     BaseSource `json:"base_source,omitempty"`
	OriginalCommit string     `json:"original_commit,omitempty"`
	OriginalBranch string     `json:"original_branch,omitempty"`

	// Warnings name each link of the chain that could not be recovered. They
	// are the caller's evidence for how much a verdict is worth.
	Warnings []string `json:"warnings,omitempty"`
}

type ReproduceOptions struct {
	// Runner places the sandbox. Required — see ErrNoRunner.
	Runner SandboxRunner
	// Timeout bounds the whole reproduction. 0 means DefaultReproduceTimeout.
	Timeout time.Duration
	// TestCommand overrides the detected test command. Supply it for a project
	// whose suite is not what testrun.Detect would guess.
	TestCommand []string
	// SkipTests suppresses the behavioural gate entirely. The result is that a
	// non-identical reproduction can only ever be INCONCLUSIVE — which is the
	// honest outcome, and why this is off by default.
	SkipTests bool
	// Emit receives progress lines. May be nil.
	Emit func(string)
}

type Reproduction struct {
	ID        int64     `json:"id,omitempty"`
	CreatedAt time.Time `json:"created_at"`
	TaskID    int       `json:"task_id"`
	TaskTitle string    `json:"task_title,omitempty"`

	Verdict Verdict `json:"verdict"`
	// Reason states, in one sentence, why this verdict and not another. It is
	// the field an operator reads first and the only one that is never empty.
	Reason string `json:"reason"`

	Provenance *Provenance `json:"provenance,omitempty"`
	Comparison *Comparison `json:"comparison,omitempty"`

	// Where the reproduction ran.
	ExecutorID   string `json:"executor_id,omitempty"`
	ExecutorKind string `json:"executor_kind,omitempty"`
	Isolation    string `json:"isolation,omitempty"`
	PinnedImage  string `json:"pinned_image,omitempty"`

	// The behavioural gate: the same command on both trees.
	OriginalTest *TestOutcome `json:"original_test,omitempty"`
	ReplayTest   *TestOutcome `json:"replay_test,omitempty"`

	// AgentExitCode and AgentOutput are the re-execution's own result.
	AgentExitCode int    `json:"agent_exit_code"`
	AgentOutput   string `json:"agent_output,omitempty"`

	Duration time.Duration `json:"duration,omitempty"`
	// Err is set when the harness failed rather than the comparison.
	Err string `json:"error,omitempty"`
}

type Result struct {
	TaskID               int
	TaskTitle            string
	OriginalProvider     string
	OriginalModel        string
	TargetProvider       string
	TargetModel          string
	Prompt               string
	OriginalOutput       string
	ReplayedOutput       string
	SimilarityScore      float64 // Jaccard 0.0–1.0
	EquivalenceScore     int     // 0 = not judged, 1–10 = AI verdict
	EquivalenceRationale string
	Duration             time.Duration
	InputTokens          int
	OutputTokens         int
	Err                  string // non-empty on failure (still persisted for visibility)
	CreatedAt            time.Time
}

type Run struct {
	ID                   int64
	CreatedAt            time.Time
	TaskID               int
	TaskTitle            string
	OriginalProvider     string
	OriginalModel        string
	TargetProvider       string
	TargetModel          string
	Prompt               string
	OriginalOutput       string
	ReplayedOutput       string
	SimilarityScore      float64
	EquivalenceScore     int
	EquivalenceRationale string
	DurationMS           int64
	InputTokens          int
	OutputTokens         int
	Error                string
}

type RunOutcome struct {
	// BundlePath is the git bundle holding the sandbox's commit. The runner
	// owns creating it; Reproduce removes it when it is done.
	BundlePath string
	// Branch is the ref inside the bundle.
	Branch string
	// ExitCode and Output are the agent harness's.
	ExitCode int
	Output   string
	// Skipped and SkipReason report a sandbox that ran and changed nothing.
	Skipped    bool
	SkipReason string
	// Where it ran, for the record and for the UI.
	ExecutorID   string
	ExecutorKind string
	Isolation    string
	PinnedImage  string
	// Test is the project's test command run on the reproduced tree, when a
	// command was supplied.
	Test *TestOutcome
}

type RunRequest struct {
	// ProjectDir is the hub-side project this reproduction belongs to. It
	// supplies the executor binding and the workspace source; the runner must
	// not execute anything in it.
	ProjectDir string
	// Provenance is the reconstructed input state: prompt, model settings,
	// sandbox, and the commit to start from (Provenance.BaseSHA).
	Provenance *Provenance
	// Branch is the write-back branch the sandbox must commit to. It is
	// generated per reproduction and never collides with a real task branch.
	Branch string
	// TestCommand is the project's own test command, to run inside the sandbox
	// after the agent exits. Empty when none was detected.
	TestCommand []string
	// Timeout bounds the whole sandbox run.
	Timeout time.Duration
}

type SandboxRunner interface {
	RunReproduction(ctx context.Context, req RunRequest) (*RunOutcome, error)
	VerifyCommit(ctx context.Context, req VerifyRequest) (*TestOutcome, error)
}

type SuiteOptions struct {
	Options
	// Tags, when non-empty, restricts the replay set to tasks matching ANY of
	// the given tags (matches pm.TaskMatchesTags semantics).
	Tags []string
	// IncludeFailed re-runs failed tasks too. Default is done-only.
	IncludeFailed bool
	// MaxTasks limits how many tasks are replayed (0 = unlimited).
	MaxTasks int
}

type SuiteSummary struct {
	TotalTasks     int
	Replayed       int
	Skipped        int
	Failed         int
	AverageJaccard float64
	AverageEquiv   float64
	HighEquivCount int // equivalence_score >= 8
	LowEquivCount  int // equivalence_score in [1,4]
	Results        []*Result
}

type TestOutcome struct {
	// Command is what was run, for the record.
	Command []string `json:"command,omitempty"`
	// Framework is the detected harness name ("go test", "pytest", …).
	Framework string `json:"framework,omitempty"`
	// Ran reports that the command actually executed. False means the sandbox
	// could not run it at all, which is not the same as a failing suite.
	Ran bool `json:"ran"`
	// Passed reports a zero exit status.
	Passed bool `json:"passed"`
	// ExitCode is the command's status, meaningful only when Ran.
	ExitCode int `json:"exit_code"`
	// Output is the tail of the command's output, for a reviewer.
	Output string `json:"output,omitempty"`
	// Duration is how long it took.
	Duration time.Duration `json:"duration,omitempty"`
}

type Verdict string

type VerifyRequest struct {
	ProjectDir  string
	Provenance  *Provenance
	CommitSHA   string
	TestCommand []string
	Timeout     time.Duration
}