learning

type Blocker struct {
	Kind BlockerKind
	// Reason is one safe line: secrets redacted, controls removed.
	Reason string
	// Path is the file that the user repairs: the database for
	// BlockIndex, config.yaml for BlockConfig.
	Path string
}

type BlockerKind int

type DistillConfigError struct {
	// Path is repository-relative: .seamark/config.yaml or
	// .seamark/lessons.yaml.
	Path string
	// Err is the reader error, with its original text.
	Err error
}

type DistillPreview struct {
	// Request is the scope as the user chose it, so "prepare remaining
	// work" can plan again with the same choices.
	Request DistillRequest
	// Plan is the frozen group and evidence selection.
	Plan *distill.Plan
	// Region is the normalized repository-relative region; "" means
	// the whole repository.
	Region string
	// Invocation is the resolved agent command. Dir is empty for the
	// default Claude preset and for a custom agent.argv; only Codex sets
	// it to RepoRoot. An empty Dir runs the process in the console's
	// working directory, which can differ from RepoRoot (seamark -C).
	// A surface that discloses the directory must show os.Getwd() then.
	Invocation agent.CommandSpec
	// Config and Lessons observe config.yaml and lessons.yaml. A run
	// refuses the preview when either file changed.
	Config  integration.FileGuard
	Lessons integration.FileGuard
	// RepoRoot is the root that the index records; DBPath the database.
	RepoRoot string
	DBPath   string
	// PlannedAt is when the plan was made.
	PlannedAt time.Time
	// Blockers are safe display lines that stop a run, for example a
	// missing agent executable. The preview still discloses the plan.
	Blockers []string
}

type DistillRequest struct {
	// RegionInput is the region as typed. NormalizeRegion reads it
	// relative to the workspace root; "" means the whole repository.
	RegionInput string
	// Limit caps new groups. 0 means distill.DefaultGroupLimit, not
	// "all": all groups need the explicit AllGroups choice, because a
	// run without a bound must be a deliberate choice.
	Limit int
	// AllGroups selects every eligible group. Limit must then be 0.
	AllGroups bool
}

type Effect struct {
	// Source is index.SourceFixes, index.SourceReviews, or "" for data
	// that belongs to no source.
	Source string
	Kind   EffectKind
	// Text is one plain line that names the data and the effect.
	Text string
}

type EffectKind int

type ExtractConfigError struct {
	// Path is repository-relative: .seamark/config.yaml or
	// .seamark/lessons.yaml.
	Path string
	// Err is the reader error, with its original text.
	Err error
}

type ExtractPreview struct {
	// Request is the selection as the user made it, so "prepare remaining"
	// can plan again with the same choices.
	Request ExtractRequest
	// Plan holds the frozen batches, their exact prompts, and the
	// selected proposals that are not asked.
	Plan *distill.ExtractPlan
	// Invocation is the resolved agent command.
	Invocation agent.CommandSpec
	// WorkDir is where the agent process runs: Invocation.Dir, or the
	// console's working directory when Dir is empty. It can differ from
	// RepoRoot (seamark -C), so a surface discloses it.
	WorkDir string
	// Config and Lessons observe config.yaml and lessons.yaml. A run
	// refuses the preview when either file changed.
	Config  integration.FileGuard
	Lessons integration.FileGuard
	// RepoRoot is the root that the index records; DBPath the database.
	RepoRoot string
	DBPath   string
	// LiveNotes holds the live pin note of each planned applied row whose
	// linked pin has another note than the recorded proposal. The prompt
	// sends the recorded note, so a surface shows both. The values are
	// file text: a surface sanitizes them. Nil means no note differs.
	LiveNotes map[int64]string
	// Blockers are safe display lines that stop a run, for example a
	// missing agent executable. The preview still discloses the plan.
	Blockers []string
	// WorkDirErr is the error that kept PlanExtract from reading the
	// console's working directory, or nil. Blockers then also holds its
	// display line. A surface uses IsWorkDirBlocker to tell that line
	// from an agent blocker, because a setting cannot fix it.
	WorkDirErr error
	// PlannedAt is when the plan was made.
	PlannedAt time.Time
}

type ExtractRequest struct {
	// IDs are the explicitly selected proposals.
	IDs []int64
	// Skipped are selected Pins entries without exactly one linked
	// proposal, with the reason. The preview lists them as ineligible.
	// An ID here that IDs also holds is not asked, because the selecting
	// surface already found it ineligible.
	Skipped []distill.ExtractSkip
}

type Outcome struct {
	// Fixes and Reviews report each source. Their Cause field is the
	// typed cause, for example index.CauseAuth for a gh login problem.
	Fixes   index.SourceOutcome
	Reviews index.SourceOutcome
	// Comments and Kept are the fetched and kept review comment counts.
	Comments int
	Kept     int
	// After is the evidence state that the run left. A blocked run reads
	// it without git or gh, so its repository stays unresolved. A run
	// without a plan has no workspace, so After.CountsErr is set.
	After Snapshot
	// Conflict is non-nil when the plan went stale: before the start,
	// with both sources not attempted, or before a store open, with that
	// source failed. Each refused source carries index.CauseRefused. It
	// wraps ErrConflict.
	Conflict error
	// FinishedAt is the time the run returned.
	FinishedAt time.Time
}

type Plan struct {
	Mode      index.SourceMode
	Workspace workspace.Workspace
	Probe     workspace.IndexProbe
	// Root is the repository root that the CLI also mines: the root that
	// the index records.
	Root       string
	Repository reviews.Repository
	RepoState  reviews.RepositoryState
	// GHPath is where gh is on PATH; "" when it is missing. It is not
	// proof of a login.
	GHPath string
	Window Window
	// FixWindowDays is the fix-commit window in days. It is not
	// configurable.
	FixWindowDays int
	// Head is the HEAD commit whose history the fix mine reads. It is ""
	// when no commit exists, and for a blocked plan, which reads no git.
	Head string
	// Network is true when the refresh runs gh, which contacts GitHub.
	// Only the combined mode with a GitHub origin sets it. A local
	// refresh mines git history only, so it makes no network call.
	Network bool
	// Current is the stored evidence before the refresh.
	Current Snapshot
	// Affects discloses what the refresh does to stored data.
	Affects []Effect
	// Blockers lists why the plan cannot run; empty means ready.
	Blockers  []Blocker
	PlannedAt time.Time
	// contains filtered or unexported fields
}

type Snapshot struct {
	// Probe is the index database state.
	Probe workspace.IndexProbe
	// Findings counts the stored findings per source.
	Findings map[string]int
	// FixFindings sums the fix-mined sources; ReviewFindings is the
	// review source; Lessons counts the stored review lessons.
	FixFindings    int
	ReviewFindings int
	Lessons        int
	// DistilledGroups counts the evidence groups that a distillation
	// recorded, with or without a proposal. A group can end without a
	// proposal, so an empty ledger alone does not prove that none ran.
	DistilledGroups int
	// FixesMinedAt and ReviewsMinedAt are the last successful mine times
	// in Unix seconds; 0 means never or unknown.
	FixesMinedAt   int64
	ReviewsMinedAt int64
	// CountsErr is the store read error, or nil.
	CountsErr error
	// Repository is the GitHub target that the review fetch uses.
	Repository reviews.Repository
	RepoState  reviews.RepositoryState
	// GHPath is where gh is on PATH; "" when it is missing. A path is not
	// proof of a login, and only a fetch tests access.
	GHPath string
	// Window is the review window from config.yaml.
	Window Window
	// ObservedAt is the time of the observation.
	ObservedAt time.Time
}

type Window struct {
	// Stored is the raw reviews.window_days value; nil when absent.
	Stored *int
	// Effective is the window in days; -1 means unlimited. It is 0 when
	// ConfigErr is set, because no window is known then.
	Effective int
	// Floor is the count of newest comments that always survive the
	// window, so the window is not a strict cutoff.
	Floor int
	// ConfigErr is the config.yaml read or parse error. A plan blocks on
	// it, unlike the CLI, which falls back to the default window.
	ConfigErr error
}