types

type ActiveDispatch struct {
	// contains filtered or unexported fields
}

type AffectedComputer interface {
	Affected(ctx context.Context, base string) (*AffectedResult, error)
	AffectedFromPaths(ctx context.Context, paths []string) (*AffectedResult, error)
}

type AffectedPath struct {
	Seed  string   // project that contained a changed file
	Chain []string // [seed, ..., target]
}

type AffectedResult struct {
	Base        string              // ref used for the diff
	Changed     []string            // repo-relative changed paths
	Seed        []string            // project paths that contain changed files
	FilesBySeed map[string][]string // seed → changed files within it
	Affected    []string            // transitive reverse closure of Seed, sorted
	// UndeclaredBySeed is the subset of FilesBySeed that NO project's declared globs
	// name. Those files reached their seed through directory containment alone (the
	// root catch-all included), so they rerun that project's targets without moving
	// any cache key: the run is real work whose result was already correct.
	//
	// Carried rather than recomputed because every consumer of FilesBySeed asks the
	// same follow-up - `--impact` qualifies its "seeded by N changed files" with it,
	// and MGS1028 reports it - and the declarations it is derived from are not in
	// reach once the result has crossed out of the workspace.
	UndeclaredBySeed map[string][]string
}

type AffinityOutput struct {
	Definition string     `json:"definition" yaml:"definition"`
	Commits    int        `json:"commits"    yaml:"commits"`
	Since      string     `json:"since,omitempty" yaml:"since,omitempty"`
	Pairs      []CoChange `json:"pairs"      yaml:"pairs"`
}

type ArchiveEntry struct {
	Name  string
	Size  int
	IsDir bool `buzz:"is_dir"`
}

type Binding struct {
	Name string // spell identifier
}

type BisectOptions struct {
	Bad        string // commit known bad (default "HEAD")
	Good       string // commit known good; if empty, GoodBefore is used
	GoodBefore time.Time
	// TestCmd is passed to `sh -c` by the bisect runner; it must be operator-trusted.
	TestCmd string
}

type BranchChange struct {
	// Ref is the branch as a reader would name it, with any remote-tracking prefix removed:
	// "feat/audience", not "refs/remotes/origin/feat/audience".
	Ref   string   `json:"ref"`
	Paths []string `json:"paths"`
	// Local reports whether Ref is a branch in this repository rather than a remote-tracking copy
	// of somebody else's.
	//
	// It decides what the answer is AS OF, which the two kinds do not share: a local branch is
	// current, and a remote-tracking one is exactly as fresh as the reader's last fetch. A surface
	// that rendered both with one caption would be overstating half of them.
	Local bool `json:"local,omitempty"`
}

type BranchChangeReporter interface {
	// BranchChanges returns up to limit branches other than the current one, most recently
	// updated first, each with the paths it changes relative to base.
	//
	// Local branches AND remote-tracking ones. Remote-tracking alone was the shape of the
	// question when the other line of work belonged to a colleague, and it goes blind exactly
	// where agents fan out: worktrees of one repository, on local branches nobody has pushed. A
	// backend that answered about only half the branches that exist would leave the reader an
	// empty list, and an empty list here reads as "nothing competes".
	//
	// It reads what the repository already has rather than fetching: a remote-tracking answer is
	// as fresh as the reader's last fetch, which BranchChange.Local lets a caller say out loud
	// instead of implying the whole answer is live.
	//
	// limit is the backend's to apply, not the caller's to trim afterwards, so a backend can push
	// it down to the ref listing and never materialise a diff it was going to discard.
	BranchChanges(ctx context.Context, dir, base string, limit int) ([]BranchChange, error)
}

type BuildInfo struct {
	Version string `json:"version" yaml:"version"`
	Commit  string `json:"commit" yaml:"commit"`
	Date    string `json:"date" yaml:"date"`
}

type BuildStats struct {
	Nodes    int
	Edges    int
	Duration time.Duration
}

type BuildStatus struct {
	SelfUpdate bool `json:"selfupdate" yaml:"selfupdate"`
}

type BuzzObject map[string]any

type CacheStatus struct {
	Immutable bool   `json:"immutable" yaml:"immutable"`
	Dir       string `json:"dir,omitempty" yaml:"dir,omitempty"`
	SizeMB    int    `json:"size_mb,omitempty" yaml:"size_mb,omitempty"`
}

type ChainStep struct {
	Project string `json:"project,omitempty" yaml:"project,omitempty"`
	Target  string `json:"target"            yaml:"target"`
}

type ChangeStatus string

type Charm struct {
	Name         string             `json:"name"                   yaml:"name"`
	Builtin      bool               `json:"builtin,omitempty"      yaml:"builtin,omitempty"`
	Default      bool               `json:"default,omitempty"      yaml:"default,omitempty"`
	Doc          string             `json:"doc,omitempty"          yaml:"doc,omitempty"`
	Declarations []CharmDeclaration `json:"declarations,omitempty" yaml:"declarations,omitempty"`
}

type CharmDeclaration struct {
	Project string   `json:"project"          yaml:"project"`
	Target  string   `json:"target"           yaml:"target"`
	Spell   string   `json:"spell"            yaml:"spell"`
	Before  []string `json:"before,omitempty" yaml:"before,omitempty"`
	After   []string `json:"after,omitempty"  yaml:"after,omitempty"`
}

type CharmReport struct {
	Definition string  `json:"definition" yaml:"definition"`
	Count      int     `json:"count"      yaml:"count"`
	Charms     []Charm `json:"charms"     yaml:"charms"`
}

type ChurnReporter interface {
	// ChangesByCommit returns up to commits recent non-merge commits, newest
	// first, each reduced to its author, date, and touched repo-relative paths.
	// since, when non-empty, is a backend-native lower bound on the commit date
	// (a git approxidate / RFC3339); commits still caps the result.
	//
	// A backend that cannot detect renames reports them as a delete and an add,
	// which costs lineage but stays correct: PrevPath is simply never set, and
	// FileHotspots then ranks the two names separately rather than wrongly.
	ChangesByCommit(ctx context.Context, dir string, commits int, since string) ([]CommitChange, error)
}

type CoChange struct {
	A      string `json:"a"      yaml:"a"`
	AName  string `json:"a_name" yaml:"a_name"`
	B      string `json:"b"      yaml:"b"`
	BName  string `json:"b_name" yaml:"b_name"`
	Count  int    `json:"count"  yaml:"count"`
	Hidden bool   `json:"hidden,omitempty" yaml:"hidden,omitempty"`
}

type CommentAnchor struct {
	// Digest is the hunk's content digest when the remark was written.
	Digest string `json:"digest,omitempty" yaml:"digest,omitempty"`
	// Quote is the new-side line the remark sits on, verbatim.
	Quote string `json:"quote,omitempty" yaml:"quote,omitempty"`
	// Before and After are the lines around Quote, up to AnchorContextLines each.
	//
	// They are what make a short quote usable at all. A line of code is often not unique in its
	// own file - a bare closing brace, a `return nil`, a repeated field tag - so a search for the
	// quote alone lands on the first of many. The context is what picks the right one, and it is
	// the same trick the web-annotation model uses under the name prefix/suffix.
	Before []string `json:"before,omitempty" yaml:"before,omitempty"`
	After  []string `json:"after,omitempty"  yaml:"after,omitempty"`
	// Declaration is the enclosing declaration git named in the hunk header: the text after the
	// second @@, which is "func (r Diff) AttachChurn(...)" or "type Diff struct {".
	//
	// GIT'S OWN funcname, not a symbol from the knowledge graph, and the difference is what makes
	// this rung fire at all. A SCIP symbol is a better identifier - it survives a rename of the
	// surrounding file and carries real structure - and it is absent unless somebody has run
	// `magus graph build`, which in this very workspace they have not. An anchor that needs an
	// index nobody built is an anchor that never resolves. This one is in every patch already,
	// in every language git has a funcname pattern for, and costs nothing to keep.
	//
	// It is the WEAKEST of the three and deliberately last: a declaration says which function a
	// remark was about, never which line, so it is what remains when the quote is gone.
	Declaration string `json:"declaration,omitempty" yaml:"declaration,omitempty"`
}

type CommentAnchorRung string

type Commit struct {
	// ID is the content/revision identifier: git SHA, hg node, jj commit_id.
	ID    string `buzz:"id"`
	Short string // abbreviated ID
	// Author wrote the change.
	Author Person
	// Date is when the revision was recorded in the repository (git/jj commit
	// date, hg's date): the reproducible "when", distinct from any author date.
	// Zero if the VCS reported no timestamp.
	Date time.Time
	// Subject is the message's first line; Body is the remainder.
	Subject string
	Body    string
	// Parents are parent IDs; more than one for a merge.
	Parents []string
}

type CommitAuthor struct {
	Name  string
	Email string
}

type CommitChange struct {
	ID     string
	Author string
	Date   time.Time
	Files  []FileChange
}

type CommitRecord struct {
	ID      string `buzz:"id"`
	Short   string
	Author  CommitAuthor
	Date    time.Time
	Subject string
	Body    string
	Parents []string
}

type CompressResult struct {
	// Files are based at the SOURCE directory - the files that went in - where
	// UncompressResult's are based at the destination. Each is based where it exists.
	Files    []Path
	BytesIn  int `buzz:"bytes_in"`
	BytesOut int `buzz:"bytes_out"`
}

type Conflict struct {
	// Path is relative to the root passed to Conflicts, using forward slashes.
	Path string
	// Kind is why the path is unresolved, and so what can settle it.
	Kind ConflictKind
}

type ConflictKind string

type ConflictResolver interface {
	// Conflicts returns the unresolved paths of the in-progress operation. No
	// operation in progress is not an error: it returns none.
	Conflicts(ctx context.Context, root string) ([]Conflict, error)
	// KeepIncoming clears the conflict markers by taking the INCOMING side wholesale -
	// git's "theirs", the commit being replayed during a rebase - falling back to the
	// surviving side where the incoming side has none. The side is named here so two
	// backends cannot disagree about which change survives.
	//
	// It marks nothing resolved. A caller regenerates between KeepIncoming and
	// MarkResolved, so the regenerated content is what gets recorded.
	KeepIncoming(ctx context.Context, root string, paths []string) error
	// MarkResolved records paths as resolved with their current working-tree content
	// (git's staging, hg's `resolve --mark`).
	MarkResolved(ctx context.Context, root string, paths []string) error
	// RemoveConflicts resolves paths by deleting them from both the working tree and
	// the recorded state.
	RemoveConflicts(ctx context.Context, root string, paths []string) error
	// IgnoredPaths reports which paths the VCS's ignore RULES cover, tracked or not.
	// Resolution needs it to tell a generated file that is still tracked from one since
	// ignored: both are declared outputs, but only the first survives a
	// ConflictKindDeleted. Paths absent from the result are not ignored.
	IgnoredPaths(ctx context.Context, root string, paths []string) (map[string]bool, error)
}

type CrossTargetRef struct {
	Project string `json:"project" yaml:"project"`
	Target  string `json:"target"  yaml:"target"`
}

type Culprit struct {
	// ID is the offending revision, matching Commit.ID and VCSMeta.ID. It was SHA,
	// which is git's alone - hg reports a node, jj a commit id - and bisect is not a
	// git-only operation (hg has its own).
	ID   string
	Info string // one-line subject, author, and date
}

type DefaultRefReporter interface {
	// DefaultRef returns the repo's primary line of development - git's default
	// branch, hg's "default", jj's trunk() - for the repo containing dir, or ""
	// with ErrVCSUnsupported when it cannot be determined.
	DefaultRef(ctx context.Context, dir string) (string, error)
}

type DepGraphRepository interface {
	TopoSort() []string
	ReverseClosure(seeds []string) []string
	NearCycles(ctx context.Context, maxDepth int) []NearCycle
	BlastRadius() map[string]int
	NCCD() float64
	PathsFromSeeds(seeds []string, target string) []AffectedPath
	Successors(path string) []string
	Predecessors(path string) []string
	Nodes() []string
}

type Diagnostic struct {
	Code    string `json:"code" yaml:"code"`
	Message string `json:"message" yaml:"message"`
	// The buzz tag pins the Buzz name explicitly. LowerFirstWord would derive `url` from
	// URL anyway, but the tag is what a reader and a rename both see - the mirror name is
	// part of this type's contract, not a side effect of a casing rule.
	URL string `json:"url,omitempty" yaml:"url,omitempty" buzz:"url"`
}

type DiagnosticCode = diagnostics.Code

type DiagnosticError = diagnostics.Error

type DiagnosticEvent = diagnostics.Event

type DiagnosticSink = diagnostics.Sink

type Diff struct {
	// Base is the ref the diff was taken against, or "working" for the uncommitted tree.
	Base string `json:"base" yaml:"base"`
	// Files carries one entry per changed path, in the order magus recommends READING them:
	// consequence first. See SortForReading. It is the changeset's primary collection, so
	// it is what -o jsonl streams.
	Files []DiffFile `json:"files,omitempty" yaml:"files,omitempty" jsonl:"primary"`
	// SeedProjects are the projects a changed file lands in directly - the ones the author
	// actually edited, as opposed to the ones that merely rebuild.
	SeedProjects []string `json:"seed_projects,omitempty" yaml:"seed_projects,omitempty"`
	// AffectedProjects is the full reverse closure. The gap between its length and
	// SeedProjects' is the whole "why is docs in my build" question, so both ship.
	AffectedProjects []ImpactProject `json:"affected_projects,omitempty" yaml:"affected_projects,omitempty"`
	// Notes are magus-authored caveats about what could NOT be computed (no symbol index, no
	// coverage run). They are surfaced rather than swallowed: a reader who sees no reach
	// numbers must be able to tell "nothing depends on this" from "nothing was measured".
	Notes []string `json:"notes,omitempty" yaml:"notes,omitempty"`
	// Reviewed is the earlier pass this reader already made over these files, when there was one.
	Reviewed DiffReviewed `json:"reviewed,omitzero" yaml:"reviewed,omitzero"`
}

type DiffAuthor string

type DiffChurn struct {
	// Commits is how many commits in the window touched this file.
	Commits int `json:"commits" yaml:"commits"`
	// Authors is how many distinct people did. One author on a hot file is a bus-factor
	// problem; many on a hot file is a coordination one. Both are worth knowing, neither is
	// worth magus deciding.
	Authors int `json:"authors,omitempty" yaml:"authors,omitempty"`
	// Score is commits x complexity - the hotspot ranking's own metric.
	Score int `json:"score" yaml:"score"`
	// Rank is this file's 1-based position in the workspace's hotspot ranking; 0 when it did
	// not rank at all, which is the common and unremarkable case.
	Rank int `json:"rank,omitempty" yaml:"rank,omitempty"`
	// ProjectTrend is the owning project's churn delta across the window's two halves.
	// Positive is accelerating. It is PROJECT level because that is the granularity the trend
	// lens measures; a file-level trend would be inventing precision the data does not have.
	ProjectTrend int `json:"project_trend,omitempty" yaml:"project_trend,omitempty"`
}

type DiffCommandHints struct {
	CLI string
	GUI string
}

type DiffComment struct {
	ID     string     `json:"id" yaml:"id"`
	Path   string     `json:"path" yaml:"path"`
	Hunk   int        `json:"hunk" yaml:"hunk"`
	Author DiffAuthor `json:"author" yaml:"author"`
	// AgentName is the opaque host label an MCP client passed, empty for a human. Attribution
	// only: nothing branches on it, matching the hook's treatment of the same field.
	AgentName string `json:"agent_name,omitempty" yaml:"agent_name,omitempty"`
	Body      string `json:"body" yaml:"body"`
	// Anchor is what this remark remembers about the code it was written against.
	Anchor CommentAnchor `json:"anchor,omitzero" yaml:"anchor,omitzero"`
	// Rung is how the remark's Line was arrived at, recomputed whenever the changeset is tracked
	// and never stored. Output-only: a client renders it, and nothing accepts one.
	Rung     CommentAnchorRung `json:"rung,omitempty" yaml:"rung,omitempty"`
	Resolved bool              `json:"resolved" yaml:"resolved"`

	// Published records that this remark has left the machine. False for a draft, which is
	// every comment until someone publishes.
	//
	// A published comment is no longer editable here: it exists somewhere a teammate may have
	// already replied to, and a local edit that silently diverged from what they are reading
	// would be worse than no edit at all.
	//
	// What the HOST called it is deliberately not recorded. A review posts as one request and
	// its per-comment ids come back in a shape no provider is obliged to return, so a field
	// for them would have been a field nothing fills.
	Published bool `json:"published,omitempty" yaml:"published,omitempty"`

	// Line is the position in the file's NEW side, which is what a host anchors an inline
	// comment to. Hunk cannot serve: it is an index into this changeset's hunks, a coordinate
	// that means nothing outside the session that produced it.
	//
	// Zero means the writer did not pin one, and a publisher drops such a comment rather than
	// guessing. A remark that lands on the wrong line is worse than one that never left.
	Line int `json:"line,omitempty" yaml:"line,omitempty"`
}

type DiffCursor struct {
	Path string `json:"path,omitempty" yaml:"path,omitempty"`
	// Hunk is the 0-based index of the hunk within the file, or -1 for the file heading.
	Hunk int `json:"hunk" yaml:"hunk"`
}

type DiffFile struct {
	Path string `json:"path" yaml:"path"`
	// Project is the owning project, empty when no project directory contains the file.
	Project string `json:"project,omitempty" yaml:"project,omitempty"`
	// Role is one of the DiffRole constants. It is the single most useful fact about a
	// changed file, because it answers "must I read this" before any of the rest.
	Role string `json:"role" yaml:"role"`
	// Hint is magus's own sentence about the role, reused verbatim from describe file so the
	// console and the CLI never drift into two explanations of one classification.
	Hint string `json:"hint,omitempty" yaml:"hint,omitempty"`
	// Coverage is the file's observed coverage, nil when none was measured. Nil is DISTINCT
	// from zero: "no coverage run has happened" must not render as "this code is untested".
	Coverage *ImpactCoverage `json:"coverage,omitempty" yaml:"coverage,omitempty"`
	// Symbols are the changed symbols this file defines, each carrying how widely it is
	// referenced. Empty when no symbol index covers the file.
	Symbols []DiffSymbol `json:"symbols,omitempty" yaml:"symbols,omitempty"`
	// Surface is one of the DiffSurface constants: whether any changed symbol here is
	// referenced from another project. It is the semver-relevant fact, and it is evidence
	// rather than a verdict - see DiffSurface.
	Surface string `json:"surface" yaml:"surface"`
	// Touches are the agent sessions that wrote this file and what they had READ first.
	// Empty when no guard hook is wired, which is the common case and not a fault.
	Touches []DiffTouch `json:"touches,omitempty" yaml:"touches,omitempty"`
	// ReadState is one of the DiffRead constants: whether a person recorded reading
	// this file at its current content. Empty is DiffReadUnknown - nobody checked - and is
	// deliberately not "unread".
	ReadState string `json:"read_state,omitempty" yaml:"read_state,omitempty"`
	// Churn is how often this file has been changing, nil when no history lens was attached.
	// Nil is DISTINCT from zero: "nobody measured" and "this file is quiet" are different
	// facts, and a review that renders the first as the second is lying quietly.
	Churn *DiffChurn `json:"churn,omitempty" yaml:"churn,omitempty"`
	// NoHistory reports that the history lens RAN and found this file in none of the commits
	// it walked - a file added in this change, or one untouched for the whole window.
	//
	// It is a ranking signal because absence of history is not the same as absence of risk,
	// and without it the ordering conflates the two. Every other annotation here is derived
	// from a file's past, so a brand-new file collects no churn, no hotspot rank, no authors
	// and no coverage, and sinks to the bottom on the strength of having no evidence. The one
	// file in a real changeset whose tests did not compile was exactly that file. Nothing has
	// exercised this code and nobody has reviewed it before, which is a reason to read it
	// sooner rather than later.
	//
	// False when the lens did not run at all: that is "nobody looked", and it must not render
	// as "this file has history".
	NoHistory bool `json:"no_history,omitempty" yaml:"no_history,omitempty"`
	// Reach is the widest FileCount among Symbols: how many files reference the most-referenced
	// thing this file changed. It is the ranking key, and it is deliberately a COUNT OF FILES
	// rather than of references - one file calling a function forty times is one file that
	// breaks, and ranking by reference count would put a hot loop above a widely-used API.
	//
	// NIL when no symbol index was loaded, and nil is DISTINCT from zero for the same reason
	// Coverage and Churn are: "nothing references this" and "nobody looked" are different
	// facts. As a plain int an unindexed workspace serves `reach: 0` on every file - a
	// valid-looking number that a fleet dashboard reads as "no change touches widely used
	// code". DiffSurfaceUnknown already refuses that collapse; the pointer is the same refusal
	// applied to the field the ordering actually turns on.
	Reach *int `json:"reach" yaml:"reach"`
}

type DiffReviewed struct {
	// At is the revision the reader last got through, oldest where receipts disagree.
	At VCSCheckpoint `json:"at,omitzero" yaml:"at,omitzero"`
	// Files is how many of this changeset's files that revision covers.
	Files int `json:"files,omitempty" yaml:"files,omitempty"`
}

type DiffSession struct {
	ID   string `json:"id" yaml:"id"`
	Base string `json:"base" yaml:"base"`
	// AsOf is the digest of the patch this changeset was computed from - the session's
	// snapshot identity.
	//
	// Without it a client cannot tell a current answer from a frozen one, and the party least
	// able to notice is the one it hurts: an agent cannot see the tree, so it acted with
	// confidence on a changeset that had stopped existing. It also makes "9 of 12 read"
	// meaningful, because the denominator can be shown to be the one those marks were made
	// against.
	AsOf string `json:"as_of,omitempty" yaml:"as_of,omitempty"`
	// Review is the annotated changeset. Recomputed when the working tree moves.
	Diff Diff `json:"diff" yaml:"diff"`
	// Cursor is where the HUMAN is looking.
	Cursor DiffCursor `json:"cursor" yaml:"cursor"`
	// Viewed holds the content digests of hunks the human has marked read. Digests rather
	// than paths-and-line-numbers so the mark survives a rebase that did not touch the hunk -
	// the failing of every viewed-checkbox that resets on force-push.
	Viewed []string `json:"viewed,omitempty"      yaml:"viewed,omitempty"`
	// SeenThreads holds the ids of the review's threads the human has actually had on screen.
	// It is the watermark that decides what counts as NEW, and it belongs to the reader for the
	// same reason Viewed does: a mark nobody made is a claim nobody can stand behind.
	//
	// ONE watermark, deliberately. The obvious alternative - letting the job that watches the
	// forge record what it has reported - means everything is already marked seen by the time
	// the reader opens the diff, so the surface could never show them what arrived. The job
	// reads this instead and reports what lies outside it.
	SeenThreads []string         `json:"seen_threads,omitempty" yaml:"seen_threads,omitempty"`
	Comments    []DiffComment    `json:"comments,omitempty"     yaml:"comments,omitempty"`
	Suggestions []DiffSuggestion `json:"suggestions,omitempty"  yaml:"suggestions,omitempty"`
}

type DiffSuggestion struct {
	ID        string `json:"id" yaml:"id"`
	Path      string `json:"path" yaml:"path"`
	Hunk      int    `json:"hunk" yaml:"hunk"`
	AgentName string `json:"agent_name,omitempty" yaml:"agent_name,omitempty"`
	// Reason is the one line shown beside the affordance. It has to earn the interruption.
	Reason string `json:"reason" yaml:"reason"`
	// Accepted records that the human took it, so the agent can tell "not yet seen" from
	// "seen and declined" instead of repeating itself.
	Accepted bool `json:"accepted" yaml:"accepted"`
	Declined bool `json:"declined" yaml:"declined"`
}

type DiffSymbol struct {
	ID    string `json:"id" yaml:"id"`
	Label string `json:"label,omitempty" yaml:"label,omitempty"`
	// RefCount and FileCount are occurrences and distinct referencing files.
	RefCount  int `json:"ref_count"  yaml:"ref_count"`
	FileCount int `json:"file_count" yaml:"file_count"`
	// ExternalProjects are the OTHER projects that reference this symbol, sorted. Non-empty
	// is what makes a file's surface public, and naming them answers the reader's actual next
	// question - who breaks - rather than only how many.
	ExternalProjects []string `json:"external_projects,omitempty" yaml:"external_projects,omitempty"`
	// ExternalFileCount is how many referencing files sit outside the defining project.
	ExternalFileCount int `json:"external_file_count" yaml:"external_file_count"`
	// ModuleAPI reports that this symbol is exported from the MODULE - reachable by a
	// consumer outside the workspace entirely.
	//
	// It is a separate question from ExternalProjects and neither implies the other, which is
	// the whole reason both exist. A symbol can be referenced by no other project and still be
	// public API that a downstream module imports; measured on this repository, every referent
	// of the root package sits in the root project, so cross-project exposure alone reported
	// the published SDK surface as internal. Conflating the two answers the wrong question:
	// "who in this workspace breaks" is not "who in the world breaks".
	ModuleAPI bool `json:"module_api,omitempty" yaml:"module_api,omitempty"`
}

type DiffTouch struct {
	Host       string   `json:"host,omitempty"       yaml:"host,omitempty"`
	Session    string   `json:"session,omitempty"    yaml:"session,omitempty"`
	Transcript string   `json:"transcript,omitempty" yaml:"transcript,omitempty"`
	Read       []string `json:"read,omitempty"       yaml:"read,omitempty"`
	// Ran are the PROGRAMS the session ran, never their arguments - see trail.Touch.Ran for
	// the leak that shape exists to prevent. This payload is served to every MCP client.
	Ran []string `json:"ran,omitempty" yaml:"ran,omitempty"`
}

type Direction int

type DoctorCheck struct {
	Name    string            `json:"name" yaml:"name"`
	Status  DoctorCheckStatus `json:"status" yaml:"status"`
	Message string            `json:"message,omitempty" yaml:"message,omitempty"`
	Details []string          `json:"details,omitempty" yaml:"details,omitempty"`
	// Evidence is what this particular run of the check rests on. A check declares its
	// usual evidence in the registry; a run that could not look sets EvidenceUnknown
	// here, and one that looked harder than usual (tool-readiness under --probe) raises
	// it to EvidenceMeasured.
	Evidence Evidence `json:"evidence,omitempty" yaml:"evidence,omitempty"`
	// Fix is the magus command that remedies this finding, as argv without the leading
	// "magus" - nil when there is nothing mechanical to run. `doctor --fix` runs it; with
	// no --fix it is printed, so the report always names the cure even when it is not
	// applying it.
	//
	// An EXISTING first-class command, never a private repair routine. That is the whole
	// safety property: --fix can only do things you could have typed yourself and can
	// inspect afterwards, and a check whose remedy needs judgment (narrow this glob, or
	// accept the volatility?) simply declares no Fix and stays a report. It is also why a
	// config remedy is `config set ...` rather than a writer of its own - there is exactly
	// one thing in magus that edits config, and this is not a second one.
	Fix []string `json:"fix,omitempty" yaml:"fix,omitempty"`
}

type DoctorCheckStatus string

type DoctorReport struct {
	Workspace string        `json:"workspace" yaml:"workspace"`
	Checks    []DoctorCheck `json:"checks" yaml:"checks"`
	Summary   DoctorSummary `json:"summary" yaml:"summary"`
}

type DoctorSummary struct {
	OK     int `json:"ok" yaml:"ok" buzz:"ok"`
	Fail   int `json:"fail" yaml:"fail"`
	Advice int `json:"advice" yaml:"advice"`
	// Unknown counts checks that did not run, and is deliberately carved OUT of OK
	// rather than added beside it: "44 ok" that silently included six checks which
	// never looked was the number this field exists to stop reporting. It is not a
	// failure and does not affect the exit status - nothing was found to be wrong,
	// because nothing was looked at.
	Unknown int `json:"unknown" yaml:"unknown"`
}

type DriftPolicy string

type DriftResult struct {
	// Drifted is false with every other field zero when the outputs are clean, so a
	// caller reads the fields unconditionally instead of testing for absent keys.
	Drifted bool
	// Code is the MGS diagnostic: which of the three causes this was.
	Code string
	// Message is the sentence to show, already naming the remedy.
	Message string
	// URL is Code's explainer page.
	URL string
	// Files are the drifted outputs, based at the repository root like Status.Files.
	Files []Path
}

type DriftResultRecord struct {
	Drifted bool
	Code    string
	Message string
	URL     string
	Files   []Path
}

type EdgeDirection string

type EvaluatedProject struct {
	ProjectEntry
	ResolvedSpells []EvaluatedSpell  `json:"resolved_spells,omitempty" yaml:"resolved_spells,omitempty"`
	TargetPolicies map[string]Target `json:"target_policies,omitempty"  yaml:"target_policies,omitempty"`
}

type EvaluatedProjectsOutput struct {
	Definition string             `json:"definition" yaml:"definition"`
	Workspace  string             `json:"workspace"  yaml:"workspace"`
	Count      int                `json:"count"      yaml:"count"`
	Projects   []EvaluatedProject `json:"projects"   yaml:"projects"`
}

type EvaluatedSpell struct {
	Name          string   `json:"name"                        yaml:"name"`
	TargetSources []string `json:"target_sources,omitempty"    yaml:"target_sources,omitempty"`
	// Command is the fork command this spell's op would run for the target, with
	// the requested charms applied (cmd as element 0). Empty for function-op or
	// no-op targets, whose argv isn't statically knowable. Preview only: `magus
	// describe` renders it; nothing is executed.
	Command []string `json:"command,omitempty"           yaml:"command,omitempty"`
	// CharmTrace is the step-by-step application of the active charms over this
	// spell's base argv: element 0 is the base command (no charms), and each
	// subsequent step is the command after one more charm's patch, in the
	// deterministic sorted-name order magus applies them. Populated only when
	// charms are active and change the command; the RFC 6902 patch made legible by
	// `magus describe target ...:charm --explain`.
	CharmTrace []spells.CharmTraceStep `json:"charm_trace,omitempty"       yaml:"charm_trace,omitempty"`
	// Conflicts lists the active charms whose edit is overridden by another active
	// charm on this command (both edit the same argument; the winner is decided by
	// sorted charm name, so the loser has no effect). Empty when the active charms
	// have disjoint edits. `magus describe target ...:a,b` surfaces it before a run.
	Conflicts []spells.CharmConflict `json:"conflicts,omitempty"         yaml:"conflicts,omitempty"`
	// Service is set only when this spell's op is a service (a long-running process
	// magus supervises rather than runs to completion). It carries the static, pre-run
	// facts; Command above is the process itself. Nil for an ordinary command op.
	Service *spells.ServiceView `json:"service,omitempty" yaml:"service,omitempty"`
}

type EvaluatedTarget struct {
	Project string   `json:"project"             yaml:"project"`
	Target  string   `json:"target"              yaml:"target"`
	Dir     string   `json:"dir"                 yaml:"dir"`
	Sources []string `json:"sources,omitempty"    yaml:"sources,omitempty"`
	Outputs []string `json:"outputs,omitempty"    yaml:"outputs,omitempty"`
	// Chain is the targets this one composes, in invocation order; empty when it
	// composes nothing. See TargetGraphNode.Chain, which it is copied from.
	Chain     []ChainStep      `json:"chain,omitempty"      yaml:"chain,omitempty"`
	DependsOn []string         `json:"depends_on,omitempty" yaml:"depends_on,omitempty"`
	Charms    []string         `json:"charms,omitempty"     yaml:"charms,omitempty"`
	Spells    []EvaluatedSpell `json:"spells,omitempty"     yaml:"spells,omitempty"`
	Policy    *Target          `json:"policy,omitempty"    yaml:"policy,omitempty"` // only the policy fields of Target are meaningful (SkipCache/Exclusive/Drift/RetryOnVolatile)
	Exclusive bool             `json:"exclusive,omitempty" yaml:"exclusive,omitempty"`
}

type EvaluatedTargetReport struct {
	Definition string            `json:"definition" yaml:"definition"`
	Count      int               `json:"count"      yaml:"count"`
	Targets    []EvaluatedTarget `json:"targets"    yaml:"targets"`
}

type Event struct {
	SchemaVersion int            `json:"schema_version"`
	Outcome       EventOutcome   `json:"outcome"`
	Severity      EventSeverity  `json:"severity"`
	Source        EventSource    `json:"source"`
	Where         *EventLocation `json:"where,omitempty"`
	Message       string         `json:"message"`
}

type EventLocation struct {
	Workspace Path        `json:"workspace"`
	Project   *ProjectRef `json:"project,omitempty"`
	Files     []FileRef   `json:"files,omitempty"`
}

type EventOutcome string

type EventSeverity string

type EventSource struct {
	// Kind is the producer category. Producers set this; consumers match on it.
	Kind string `json:"kind"`
	// Sub is the component within Kind. Empty when there is no meaningful component.
	Sub string `json:"sub,omitempty"`
	// ID: opaque instance identity (session id, run id, process id). Empty
	// when the producer does not have one.
	ID string `json:"id,omitempty"`
}

type Evidence string

type ExecResult struct {
	Stdout string
	Stderr string
	Code   int
	OK     bool `buzz:"ok"`
}

type ExitError struct {
	Code int
}

type FileChange struct {
	Path     string
	PrevPath string
	Status   ChangeStatus
}

type FileClaim struct {
	Project string `json:"project" yaml:"project"`
	// Target is empty for a project-wide or spell-supplied glob, which every
	// target of that project carries.
	Target string `json:"target,omitempty" yaml:"target,omitempty"`
	// Role is "output" (ctx.writesFiles or a project/spell output glob), "source"
	// (ctx.readsFiles or a project/spell source glob), or "update"
	// (ctx.modifiesExistingFiles). The first two are also FileEntry.Role values;
	// "update" has no FileEntry.Role counterpart - see FileEntry.Claims.
	Role string `json:"role" yaml:"role"`
	Glob string `json:"glob" yaml:"glob"`
	// Paths is populated only on FileReport.Overlaps, where one claim is reported
	// once for the whole request and lists every path in it that the declaration
	// covers. It is empty on a FileEntry's own claims, where the path is the
	// entry's.
	Paths []string `json:"paths,omitempty" yaml:"paths,omitempty"`
}

type FileEntry struct {
	Path string `json:"path" yaml:"path"`
	// Project is the owning project by directory containment (longest project
	// path prefixing the file), empty when no project dir contains it.
	Project string `json:"project,omitempty" yaml:"project,omitempty"`
	// Role summarizes the strongest claim: "output" (a declared output glob
	// matches - the file is generated), "source" (a declared source glob
	// matches), "maintained" (no project declares it, but magus's own core writes
	// it - see IsMagusMaintained), or "unclaimed" (no declared glob matches; it
	// invalidates no cache key and affects no target). An unclaimed path may
	// still carry Claims: an in-place edit is a declaration none of these roles
	// rank, and the Hint says so when that is what happened.
	//
	// maintained is a REFINEMENT of unclaimed, not a rank above source: both are
	// invisible to the cache and the affected set. It is separate because the
	// handling rule inverts. An unclaimed path may be residue to ignore, so its
	// hint says to check the ignore rules; a maintained path is one magus wrote
	// and expects committed, and telling someone to consider ignoring it is
	// advice to drop magus's own bookkeeping.
	Role string `json:"role" yaml:"role"`
	// OutputOf and SourceOf list the projects whose declared output/source globs
	// match the path. A path can be both (a committed generated file is often a
	// source of downstream targets); Role reports output in that case because
	// the regeneration rule dominates how the file should be treated.
	OutputOf []string `json:"output_of,omitempty" yaml:"output_of,omitempty"`
	SourceOf []string `json:"source_of,omitempty" yaml:"source_of,omitempty"`
	// Claims are the individual declarations that name the path, each with the
	// target that made it and the glob that matched. OutputOf/SourceOf are the
	// project-level summary of the same facts; the declaration is the finer unit,
	// and it is the one that answers "which target rewrites this" for a caller
	// splitting work across agents.
	//
	// The set is wider than Role ranks: it also carries the in-place edits of
	// ctx.modifiesExistingFiles ("update"), which is a write nobody replays or
	// cleans, so Role deliberately leaves such a file reading as its source or
	// unclaimed self.
	Claims []FileClaim `json:"claims,omitempty" yaml:"claims,omitempty"`
	// DependsOn is the owning project's DIRECT declared dependencies, verbatim
	// from Project.DependsOn - carried here so one classification call answers
	// both "who owns this path" and "what does that owner run behind". It is not
	// the transitive closure; `magus graph deps` computes that.
	DependsOn []string `json:"depends_on,omitempty" yaml:"depends_on,omitempty"`
	// Hint is the one-line handling rule for the role, ready to surface to a
	// human or an agent.
	Hint string `json:"hint,omitempty" yaml:"hint,omitempty"`
	// Exists reports whether the path is present on disk.
	//
	// Classification is pure glob matching, which is what makes "where would a new
	// file land" answerable - so it cannot be an error for a path that is not there
	// yet. Without this field it is also not DISTINGUISHABLE: a mistyped or invented
	// path came back byte-identical to the real one beside it, declared and owned.
	//
	// Never omitempty: false is the whole signal, and a field that vanishes when it
	// is the interesting value is the one shape this cannot take.
	Exists bool `json:"exists" yaml:"exists"`
}

type FileHotspot struct {
	Path       string    `json:"path"                  yaml:"path"`
	Commits    int       `json:"commits"               yaml:"commits"`
	Complexity int       `json:"complexity"            yaml:"complexity"`
	Score      int       `json:"score"                 yaml:"score"` // commits × complexity
	Authors    int       `json:"authors"               yaml:"authors"`
	LastCommit time.Time `json:"last_commit,omitempty" yaml:"last_commit,omitempty"`
	// Moves is how many times the file changed path inside the window: the count of
	// distinct names its history folded in, minus the one it ends under. A file that
	// keeps changing address is churning architecturally rather than just textually,
	// which is a different thing to know than its edit count and is not derivable
	// from Path alone.
	Moves int `json:"moves,omitempty" yaml:"moves,omitempty"`
}

type FileInfo struct {
	Size  int64
	Mtime float64
	Mode  int64
	IsDir bool `buzz:"is_dir"`
}

type FileRef struct {
	Value string `json:"value"`
	IsDir bool   `json:"is_dir,omitempty"`
}

type FileReport struct {
	Definition string      `json:"definition" yaml:"definition"`
	Count      int         `json:"count"      yaml:"count"`
	Files      []FileEntry `json:"files"      yaml:"files"`
	// Overlaps are the declarations that cover MORE THAN ONE of the classified
	// paths, each listing the paths it covers. Grouped by declaration rather than
	// emitted per pair: a hundred paths under one glob is a hundred rows here and
	// five thousand as pairs, and the declaration is the shared thing anyway.
	//
	// A fact, not a verdict. Two paths under one glob mean one target rewrites
	// both, which may be a collision between two authors or may be exactly what a
	// single author intends; nothing here decides which.
	Overlaps []FileClaim `json:"overlaps,omitempty" yaml:"overlaps,omitempty"`
}

type Graph struct {
	// contains filtered or unexported fields
}

type GraphConfig struct {
	Obs Observer
}

type GraphOption func(*GraphConfig)

type GraphOutput struct {
	Direction string   `json:"direction" yaml:"direction"`
	SpellName string   `json:"spell_name,omitempty" yaml:"spell_name,omitempty"`
	Roots     []string `json:"roots,omitempty" yaml:"roots,omitempty"`
	Nodes     []Node   `json:"nodes" yaml:"nodes"`
}

type GraphView struct {
	Nodes     []string
	DependsOn map[string][]string
	// BlastRadius is how many projects each node can affect, transitively. It is
	// the number a magusfile branches on to decide whether a change is safe to
	// batch, and it is already computed by the graph.
	BlastRadius map[string]int
}

type HTTPResponse struct {
	Status  int
	Body    string
	Headers map[string]string
}

type HTTPRetry struct {
	// Attempts is the TOTAL number of tries, not the number of retries after the
	// first. 0 and 1 both mean "run it once"; 3 means one attempt plus two
	// retries. Counting total attempts rather than curl's --retry N avoids the
	// off-by-one that spelling invites.
	Attempts int
	// DelayMs is the pause before the second attempt, in milliseconds. It doubles
	// per attempt unless Fixed is set. Zero uses a 500ms default whenever
	// Attempts is greater than 1.
	DelayMs float64 `buzz:"delay_ms"`
	// MaxDelayMs caps the exponential growth, so a long backoff cannot stretch a
	// single request past anything useful. Zero means uncapped.
	MaxDelayMs float64 `buzz:"max_delay_ms"`
	// MaxElapsedMs is a wall-clock ceiling across all attempts including the
	// waits. It is the honest way to bound retrying: a count alone says nothing
	// about how long a build will sit there. Zero means no ceiling beyond the
	// per-request timeout.
	MaxElapsedMs float64 `buzz:"max_elapsed_ms"`
	// Fixed keeps the delay constant instead of doubling it, matching curl's
	// --retry-delay. Use it when an endpoint documents a fixed cooldown.
	Fixed bool
	// AllErrors retries every failure, including 4xx statuses that normally mean
	// the request itself is wrong. Off by default because retrying a 401 or a 404
	// cannot succeed and only delays the report.
	AllErrors bool `buzz:"all_errors"`
	// ConnRefused treats a refused connection as retryable, which it is not by
	// default. Set it when waiting for a service that is still coming up.
	ConnRefused bool `buzz:"conn_refused"`
}

type HotspotOutput struct {
	Definition string        `json:"definition" yaml:"definition"`
	Commits    int           `json:"commits"    yaml:"commits"`
	Since      string        `json:"since,omitempty" yaml:"since,omitempty"`
	Nodes      []Node        `json:"nodes"      yaml:"nodes"`
	Files      []FileHotspot `json:"files,omitempty" yaml:"files,omitempty"`
}

type IgnorePattern struct {
	Type    PatternType `json:"type" yaml:"type" validate:"required,oneof=glob regex literal"`
	Pattern string      `json:"pattern" yaml:"pattern" validate:"required"`
}

type IgnoredFileReporter interface {
	// IgnoredFiles returns the subset of paths the VCS ignores, as given. Paths are
	// interpreted relative to dir. An empty paths slice returns no results.
	IgnoredFiles(ctx context.Context, dir string, paths []string) ([]string, error)
}

type ImpactCoverage struct {
	Ratio   float64 `json:"ratio"         yaml:"ratio"`
	Covered int     `json:"covered_stmts" yaml:"covered_stmts"`
	Total   int     `json:"total_stmts"   yaml:"total_stmts"`
}

type ImpactFileCoverage struct {
	File     string         `json:"file"     yaml:"file"`
	Coverage ImpactCoverage `json:"coverage" yaml:"coverage"`
}

type ImpactProject struct {
	Path string `json:"path" yaml:"path"`
	// Seed is true when a changed file lands directly in this project (it is a root
	// of the closure, not only reached transitively).
	Seed bool `json:"seed" yaml:"seed"`
	// Files are the changed files inside this project, present only for seeds.
	Files []string `json:"files,omitempty" yaml:"files,omitempty"`
	// UndeclaredFiles is the subset of Files that no project declares: they seeded this
	// project by directory containment alone, so they rerun its targets without moving
	// a cache key. See types.AffectedResult.UndeclaredBySeed and MGS1028.
	UndeclaredFiles []string `json:"undeclared_files,omitempty" yaml:"undeclared_files,omitempty"`
	// Spells are the project's bound spells (its toolchains).
	Spells []string `json:"spells,omitempty" yaml:"spells,omitempty"`
	// Targets is the project's target vocabulary: the spell-contributed ops plus any
	// custom magusfile targets that name it, sorted and deduplicated.
	Targets []string `json:"targets,omitempty" yaml:"targets,omitempty"`
}

type ImpactResult struct {
	// Base is the ref the VCS diff was taken against ("paths" when computed from an
	// explicit path set rather than a diff).
	Base string `json:"base" yaml:"base"`
	// ChangedFileCount and ChangedFiles are the full changed-file set. Files outside
	// any project still count here (they just seed nothing).
	ChangedFileCount int      `json:"changed_file_count"      yaml:"changed_file_count"`
	ChangedFiles     []string `json:"changed_files,omitempty" yaml:"changed_files,omitempty"`
	// SeedProjects are the projects that directly contain a changed file, sorted.
	SeedProjects []string `json:"seed_projects,omitempty" yaml:"seed_projects,omitempty"`
	// AffectedProjects is the transitive reverse closure of the seeds (seeds
	// included), sorted by path. Each carries its target vocabulary and whether a
	// changed file lands in it directly.
	AffectedProjects []ImpactProject `json:"affected_projects,omitempty" yaml:"affected_projects,omitempty"`
	// ChangedSymbols is the changed-symbol caller overlay: every symbol defined in a
	// changed source file, with how widely it is referenced repo-wide. It is what a
	// plain difftool structurally cannot show - the reach of an edited definition.
	// Populated by Enrich when a symbol index is loaded; empty (with a Note) otherwise.
	// Flattened across files and sorted by descending reference count so the
	// widest-reach change leads.
	ChangedSymbols []ImpactSymbol `json:"changed_symbols,omitempty" yaml:"changed_symbols,omitempty"`
	// ChangedFileCoverage is the coverage overlay: the observed statement coverage of
	// each changed file the local coverage profile covers. Empty (with a Note) when no
	// `magus run coverage` profile is loaded. Go-only and observed, never extracted.
	ChangedFileCoverage []ImpactFileCoverage `json:"changed_file_coverage,omitempty" yaml:"changed_file_coverage,omitempty"`
	// Notes carries graceful-degradation messages (deferred overlays, missing data).
	// It never blocks a report; a formatter prints it verbatim.
	Notes []string `json:"notes,omitempty" yaml:"notes,omitempty"`
}

type ImpactSymbol struct {
	File      string         `json:"file"       yaml:"file"`
	Symbol    string         `json:"symbol"     yaml:"symbol"`
	Label     string         `json:"label,omitempty" yaml:"label,omitempty"`
	RefCount  int            `json:"ref_count"  yaml:"ref_count"`
	FileCount int            `json:"file_count" yaml:"file_count"`
	Coverage  ImpactCoverage `json:"coverage"   yaml:"coverage"`
}

type InputRef struct {
	Project string `json:"project,omitempty" yaml:"project,omitempty"`
	Glob    string `json:"glob" yaml:"glob"`
}

type InsightAnalyzer interface {
	Hotspots(ctx context.Context, opts InsightOptions) (HotspotOutput, error)
	Affinity(ctx context.Context, opts InsightOptions) (AffinityOutput, error)
	Ownership(ctx context.Context, opts InsightOptions) (OwnershipOutput, error)
	Trend(ctx context.Context, opts InsightOptions) (TrendOutput, error)
	Volatility(ctx context.Context) (VolatilityReport, error)
	Unreferenced(ctx context.Context) (UnreferencedOutput, error)
}

type InsightOptions struct {
	Dir     string
	Commits int
	Since   string
	Files   bool
}

type InsightReport struct {
	Hotspots   HotspotOutput    `json:"hotspots"    yaml:"hotspots"`
	Affinity   AffinityOutput   `json:"affinity"    yaml:"affinity"`
	Ownership  OwnershipOutput  `json:"ownership"   yaml:"ownership"`
	Trend      TrendOutput      `json:"trend"       yaml:"trend"`
	Volatility VolatilityReport `json:"volatility"  yaml:"volatility"`
	// Unreferenced is the knowledge-graph axis. Like Volatility it is a value, not a
	// pointer: the report always renders the section, and an empty list with a verdict
	// says more than an omitted section would.
	Unreferenced UnreferencedOutput `json:"unreferenced" yaml:"unreferenced"`
}

type InsightView struct {
	Hotspots  HotspotOutput   `json:"hotspots"   yaml:"hotspots"`
	Affinity  AffinityOutput  `json:"affinity"   yaml:"affinity"`
	Ownership OwnershipOutput `json:"ownership"  yaml:"ownership"`
	Trend     TrendOutput     `json:"trend"      yaml:"trend"`
	// Volatility stays a POINTER here while InsightReport's is a value, and the two
	// are not carelessly out of step: this is the console's wire shape, where absent
	// and empty say different things. docs/reference/api/insight.md commits to it -
	// null renders "no runs recorded yet", an empty report renders "no volatile
	// targets" - and volatilityToProto maps nil to a nil message to preserve it.
	// InsightReport has no such reader: it crosses into Buzz, where the mirror
	// declares the field non-optional so a magusfile reaches .volatility.targets
	// without a nil guard.
	Volatility *VolatilityReport `json:"volatility" yaml:"volatility"`
}

type Inspector interface {
	// ListCharms builds the inverse charm index: every charm name a target in the
	// workspace declares, plus the reserved built-ins and the workspace's own
	// default_charms set (read from the receiver's config), and for each the
	// project/target/spell declarations that give it a patch.
	ListCharms(ctx context.Context) ([]Charm, error)
	ListTargets(ctx context.Context) ([]TargetEntry, error)
	ListProjects(ctx context.Context) (ProjectsOutput, error)
	// EvaluateProjects returns the fully-resolved project inventory: every
	// ListProjects fact plus each project's resolved spells and target policies.
	EvaluateProjects(ctx context.Context) (EvaluatedProjectsOutput, error)
	// EvaluateTarget returns the fully-evaluated dispatch plan for t.
	EvaluateTarget(ctx context.Context, t Target) ([]EvaluatedTarget, error)
	ClassifyFiles(ctx context.Context, paths []string) ([]FileEntry, error)
	// TargetGraph returns the ctx.needs dependency DAG of each project's targets,
	// read statically from the magusfile source. A different graph, at a different
	// granularity, from WorkspaceReader.Graph: that one is the PROJECT dependency
	// graph (project -> project, from depends_on); this one is the TARGET graph
	// within and across projects (target -> target, from ctx.needs).
	TargetGraph(ctx context.Context) (TargetGraphOutput, error)
	// Workspace returns the single-entry view of this workspace: a *Magus is
	// always exactly one workspace. The CLI's `describe workspaces` merges these
	// across the daemon's declared roots when daemon.workspaces is set.
	Workspace(ctx context.Context, cfg WorkspaceConfig) (WorkspaceEntry, error)
}

type KnowledgeAnswer struct {
	Verdict      KnowledgeVerdict       `json:"verdict"                 yaml:"verdict"`
	Reason       KnowledgeUnknownReason `json:"reason,omitempty"        yaml:"reason,omitempty"`
	Gaps         []KnowledgeSymbolGap   `json:"gaps,omitempty"          yaml:"gaps,omitempty"`
	StaleIndexes []string               `json:"stale_indexes,omitempty" yaml:"stale_indexes,omitempty"`
}

type KnowledgeDocCoverage struct {
	Kind         string   `json:"kind"                   yaml:"kind"`
	Total        int      `json:"total"                  yaml:"total"`
	Documented   int      `json:"documented"             yaml:"documented"`
	Percent      int      `json:"percent"                yaml:"percent"`
	Undocumented []string `json:"undocumented,omitempty" yaml:"undocumented,omitempty"`
}

type KnowledgeEdge struct {
	Source     string  `json:"source"               yaml:"source"`
	Target     string  `json:"target"               yaml:"target"`
	Relation   string  `json:"relation"             yaml:"relation"`
	Confidence string  `json:"confidence"           yaml:"confidence"`
	Score      float64 `json:"score"                yaml:"score"`
	Provenance string  `json:"provenance,omitempty" yaml:"provenance,omitempty"`
}

type KnowledgeEdgeRef struct {
	Relation   string        `json:"relation"             yaml:"relation"`
	Direction  EdgeDirection `json:"direction"            yaml:"direction"`
	Other      string        `json:"other"                yaml:"other"`
	OtherKind  string        `json:"other_kind"           yaml:"other_kind"`
	OtherLabel string        `json:"other_label"          yaml:"other_label"`
	Provenance string        `json:"provenance,omitempty" yaml:"provenance,omitempty"`
}

type KnowledgeExplainOutput struct {
	Definition    string             `json:"definition"     yaml:"definition"`
	SchemaVersion int                `json:"schema_version" yaml:"schema_version"`
	Node          KnowledgeNode      `json:"node"           yaml:"node"`
	BlastRadius   int                `json:"blast_radius"   yaml:"blast_radius"`
	Out           []KnowledgeEdgeRef `json:"out,omitempty"  yaml:"out,omitempty"`
	In            []KnowledgeEdgeRef `json:"in,omitempty"   yaml:"in,omitempty"`
}

type KnowledgeGodNode struct {
	ID     string `json:"id"     yaml:"id"`
	Kind   string `json:"kind"   yaml:"kind"`
	Label  string `json:"label"  yaml:"label"`
	Degree int    `json:"degree" yaml:"degree"` // in + out
	In     int    `json:"in"     yaml:"in"`
	Out    int    `json:"out"    yaml:"out"`
}

type KnowledgeGraphDiff struct {
	Definition    string                `json:"definition"     yaml:"definition"`
	SchemaVersion int                   `json:"schema_version" yaml:"schema_version"`
	Base          string                `json:"base"           yaml:"base"` // the base revision or baseline label
	NodesAdded    []KnowledgeNode       `json:"nodes_added,omitempty"    yaml:"nodes_added,omitempty"`
	NodesRemoved  []KnowledgeNode       `json:"nodes_removed,omitempty"  yaml:"nodes_removed,omitempty"`
	NodesChanged  []KnowledgeNodeChange `json:"nodes_changed,omitempty"  yaml:"nodes_changed,omitempty"`
	EdgesAdded    []KnowledgeEdge       `json:"edges_added,omitempty"    yaml:"edges_added,omitempty"`
	EdgesRemoved  []KnowledgeEdge       `json:"edges_removed,omitempty"  yaml:"edges_removed,omitempty"`
}

type KnowledgeGraphOutput struct {
	Definition    string `json:"definition"    yaml:"definition"`
	SchemaVersion int    `json:"schema_version" yaml:"schema_version"`
	Directed      bool   `json:"directed"      yaml:"directed"`
	Multigraph    bool   `json:"multigraph"    yaml:"multigraph"`
	NodeCount     int    `json:"node_count"    yaml:"node_count"`
	EdgeCount     int    `json:"edge_count"    yaml:"edge_count"`
	// SourceBaseURL is the workspace's repo blob base (e.g.
	// "https://github.com/owner/repo/blob/main"), derived from the VCS remote, so a
	// viewer can turn a node's relative `source` path into a link to the RIGHT repo.
	// Empty when there is no remote or the forge is unrecognized. Additive; omitted
	// when empty, so it never bumps the schema version.
	SourceBaseURL string `json:"source_base,omitempty" yaml:"source_base,omitempty"`
	// CatalogFingerprint identifies the binary that produced this export. Generated output
	// depends on the binary's catalogs as well as the tree, but only the tree shows in a
	// diff, so regenerating with a foreign build reads as ordinary drift (MGS4005).
	// Additive and omitted when empty, so it never bumps the schema version.
	CatalogFingerprint string `json:"catalog_fingerprint,omitempty" yaml:"catalog_fingerprint,omitempty"`
	// Nodes is the export's primary collection: what -o jsonl streams, one node per line.
	Nodes []KnowledgeNode `json:"nodes"         yaml:"nodes" jsonl:"primary"`
	Links []KnowledgeEdge `json:"links"         yaml:"links"`
}

type KnowledgeMatch struct {
	ID    string `json:"id"    yaml:"id"`
	Kind  string `json:"kind"  yaml:"kind"`
	Label string `json:"label" yaml:"label"`
	Score int    `json:"score" yaml:"score"`
	// Staleness and OutrunDays travel with a prose match that ranked DOWN because the
	// thing it describes moved on without it. They are the evidence for the weight, and
	// they exist so the weight is never silent: a reader can see "ranked down: 400 days
	// behind its subject" instead of wondering why a doc sank. Empty on anything that was
	// not penalized, including prose with no history to measure.
	Staleness  string `json:"staleness,omitempty"   yaml:"staleness,omitempty"`
	OutrunDays int    `json:"outrun_days,omitempty" yaml:"outrun_days,omitempty"`
}

type KnowledgeNode struct {
	ID     string            `json:"id"               yaml:"id"`
	Kind   string            `json:"kind"             yaml:"kind"`
	Label  string            `json:"label"            yaml:"label"`
	Doc    string            `json:"doc,omitempty"    yaml:"doc,omitempty"`
	Source string            `json:"source,omitempty" yaml:"source,omitempty"` // path or path:line provenance
	Attrs  map[string]string `json:"attrs,omitempty"  yaml:"attrs,omitempty"`  // kind-specific (charm pointer, MGS URL, ...)
}

type KnowledgeNodeChange struct {
	ID     string        `json:"id"     yaml:"id"`
	Fields []string      `json:"fields" yaml:"fields"` // kind|label|doc|source|attrs
	Before KnowledgeNode `json:"before" yaml:"before"`
	After  KnowledgeNode `json:"after"  yaml:"after"`
}

type KnowledgeNote struct {
	Name    string
	Title   string
	Path    string
	Tags    []string
	Anchors []string
}

type KnowledgeOccurrencesOutput struct {
	Definition    string `json:"definition"     yaml:"definition"`
	SchemaVersion int    `json:"schema_version" yaml:"schema_version"`
	Symbol        string `json:"symbol"         yaml:"symbol"`
	Label         string `json:"label"          yaml:"label"`
	// Name is the identifier a rename would replace: the first of Names. It is derived from
	// the symbol's own descriptor, not from the index's display name - for a package those
	// differ, and the descriptor's last segment is what call sites write.
	Name string `json:"name" yaml:"name"`
	// Names is every spelling an occurrence was allowed to hold, in the order they were
	// tried. A symbol can legitimately be written more than one way - a package's import
	// statement holds its full path while its call sites hold the bare identifier - so a
	// site is checked against this whole set, not against Name alone. It is surfaced so a
	// consumer can reproduce the verdict instead of having to trust it.
	Names           []string `json:"names,omitempty"  yaml:"names,omitempty"`
	FileCount       int      `json:"file_count"       yaml:"file_count"`
	OccurrenceCount int      `json:"occurrence_count" yaml:"occurrence_count"`
	// VerifiedCount is how many of OccurrenceCount are safe to edit. A caller comparing
	// the two learns, in one subtraction, whether a rewrite would be complete - which is
	// the question that decides whether to proceed at all.
	VerifiedCount int `json:"verified_count"   yaml:"verified_count"`
	// StaleFiles is how many of Files carry a stale marker. Non-zero means a rewrite would
	// be acting on an index that no longer matches the tree, and the honest move is to
	// re-index rather than to edit around the bad sites.
	StaleFiles int                    `json:"stale_files,omitempty" yaml:"stale_files,omitempty"`
	Files      []SymbolOccurrenceFile `json:"files,omitempty"       yaml:"files,omitempty"`
	Answer     KnowledgeAnswer        `json:"answer"                yaml:"answer"`
}

type KnowledgeOrphan struct {
	ID     string `json:"id"     yaml:"id"`
	Kind   string `json:"kind"   yaml:"kind"`
	Label  string `json:"label"  yaml:"label"`
	Reason string `json:"reason" yaml:"reason"`
}

type KnowledgeOutputRef struct {
	Project string
	Target  string
	Ref     string
	OK      bool
}

type KnowledgePackage struct {
	Manager string
	Name    string
	Version string
	// Indirect marks a transitive dependency (go.mod's `// indirect`). Kept because
	// "do we depend on this directly" changes the answer to whether a version is ours
	// to bump, and because a direct dependency is the one worth reading docs about.
	Indirect bool
	// Replaced marks a dependency a replace directive redirects. Its Version is the
	// replacement's, which is what actually builds - so the node stays truthful about
	// what is on disk - and this flag is what stops a reader concluding the manifest's
	// original requirement is what shipped.
	Replaced bool
}

type KnowledgePathOutput struct {
	Definition    string              `json:"definition"     yaml:"definition"`
	SchemaVersion int                 `json:"schema_version" yaml:"schema_version"`
	From          string              `json:"from"           yaml:"from"`
	To            string              `json:"to"             yaml:"to"`
	Found         bool                `json:"found"          yaml:"found"`
	Steps         []KnowledgePathStep `json:"steps,omitempty" yaml:"steps,omitempty"`
}

type KnowledgePathStep struct {
	From     string `json:"from"     yaml:"from"`
	To       string `json:"to"       yaml:"to"`
	Relation string `json:"relation" yaml:"relation"`
	Forward  bool   `json:"forward"  yaml:"forward"`
}

type KnowledgeQueryOutput struct {
	Definition    string `json:"definition"     yaml:"definition"`
	SchemaVersion int    `json:"schema_version" yaml:"schema_version"`
	Query         string `json:"query"          yaml:"query"`
	Budget        int    `json:"budget"         yaml:"budget"`
	MatchCount    int    `json:"match_count"    yaml:"match_count"`
	// Offset is the index of the first returned match within the full ranked list;
	// 0 (omitted) for an unpaged query or the first page. Offset alone does not
	// signal paging - page 0 of a paged query and an unpaged query look the same
	// here; the MCP layer's next_cursor is what signals more pages remain.
	Offset  int              `json:"offset,omitempty" yaml:"offset,omitempty"`
	Matches []KnowledgeMatch `json:"matches"        yaml:"matches"`
	Nodes   []KnowledgeNode  `json:"nodes"          yaml:"nodes"`
	Links   []KnowledgeEdge  `json:"links"          yaml:"links"`
	// Answer says whether MatchCount 0 is a verified absence or a blind spot. Most
	// queries never seed the symbol shards, so a bare term matching nothing says nothing
	// about whether a code symbol by that name exists - this is where that is stated.
	Answer KnowledgeAnswer `json:"answer" yaml:"answer"`
}

type KnowledgeRefSite struct {
	File  string `json:"file"            yaml:"file"`
	Count int    `json:"count,omitempty" yaml:"count,omitempty"`
	Lines []int  `json:"lines,omitempty" yaml:"lines,omitempty"`
}

type KnowledgeRefsOutput struct {
	Definition    string             `json:"definition"     yaml:"definition"`
	SchemaVersion int                `json:"schema_version" yaml:"schema_version"`
	Symbol        string             `json:"symbol"         yaml:"symbol"`
	Label         string             `json:"label"          yaml:"label"`
	FileCount     int                `json:"file_count"     yaml:"file_count"`
	RefCount      int                `json:"ref_count"      yaml:"ref_count"`
	Defs          []KnowledgeRefSite `json:"defs,omitempty" yaml:"defs,omitempty"`
	Refs          []KnowledgeRefSite `json:"refs,omitempty" yaml:"refs,omitempty"`
	// Answer says whether an empty Refs list is a verified absence or a blind spot. A
	// named field rather than an embedded struct: the template renderer skips anonymous
	// fields, so `-o template` with no body would not list it, and yaml would nest what
	// json flattens.
	Answer KnowledgeAnswer `json:"answer" yaml:"answer"`
}

type KnowledgeRouting struct {
	SchemaVersion int `json:"schema_version" yaml:"schema_version"`
	// CatalogFingerprint identifies the binary that rendered this index; see the field of
	// the same name on KnowledgeGraphOutput. Carried here so MAGUS.md can show it without
	// the renderer taking another parameter. Empty when no graph was available.
	CatalogFingerprint string `json:"catalog_fingerprint,omitempty" yaml:"catalog_fingerprint,omitempty"`
	NodeCount          int    `json:"node_count"     yaml:"node_count"`
	// EdgeCount counts the edges this summary ranked on, so it excludes runtime edges and
	// is NOT KnowledgeGraphOutput's or KnowledgeStats' count. Unrendered (writeRouting
	// drops totals), kept so a renderer that adds one cannot reintroduce the dependence.
	EdgeCount int                       `json:"edge_count"     yaml:"edge_count"`
	Kinds     []KnowledgeRoutingKind    `json:"kinds"          yaml:"kinds"`
	Projects  []KnowledgeRoutingProject `json:"projects"       yaml:"projects"`
}

type KnowledgeRoutingKind struct {
	Kind    string   `json:"kind"              yaml:"kind"`
	Count   int      `json:"count"             yaml:"count"`
	Anchors []string `json:"anchors,omitempty" yaml:"anchors,omitempty"`
}

type KnowledgeRoutingProject struct {
	Path        string   `json:"path"                  yaml:"path"`
	TargetCount int      `json:"target_count"          yaml:"target_count"`
	KeyTargets  []string `json:"key_targets,omitempty" yaml:"key_targets,omitempty"`
}

type KnowledgeStats struct {
	Definition string `json:"definition"          yaml:"definition"`
	NodeCount  int    `json:"node_count"          yaml:"node_count"`
	EdgeCount  int    `json:"edge_count"          yaml:"edge_count"`
	// Gods is the headline finding and so the primary collection -o jsonl streams.
	Gods     []KnowledgeGodNode     `json:"gods"                yaml:"gods" jsonl:"primary"`
	Orphans  []KnowledgeOrphan      `json:"orphans,omitempty"   yaml:"orphans,omitempty"`
	Coverage []KnowledgeDocCoverage `json:"coverage,omitempty"  yaml:"coverage,omitempty"`
	// Connectivity is the data-quality lens: how fragmented the graph is. A high isolated count or many
	// weakly-connected components means the builder has not linked everything it could, which hurts
	// discoverability. IsolatedCount is every node with no edge at all (Orphans lists a capped sample by
	// kind); ComponentCount is the number of weakly-connected components (1 = fully reachable);
	// LargestComponentSize is the biggest component's node count (the "main" graph most nodes should
	// belong to).
	IsolatedCount        int `json:"isolated_count"         yaml:"isolated_count"`
	ComponentCount       int `json:"component_count"        yaml:"component_count"`
	LargestComponentSize int `json:"largest_component_size" yaml:"largest_component_size"`
}

type KnowledgeSymbol struct {
	Key        string
	Moniker    string
	Label      string
	Language   string
	SymbolKind string
	// Source is "<path>:<line>" of the definition, or empty when only references
	// were seen (the definition lives in another index).
	Source string
	// DefEndLine is the 1-based last line of the definition's BODY, from the SCIP
	// occurrence's enclosing range, or 0 when the indexer emits none (which is the honest
	// answer rather than a guess - see Calls, which makes the same trade).
	//
	// Source alone gives a start with no end, which is enough to point a reader at a
	// definition but not enough to fingerprint one. Pairing them bounds the exact lines a
	// symbol occupies, so a consumer can tell "this symbol still exists" from "this symbol
	// still exists and says the same thing".
	DefEndLine int
	Defs       []string
	Refs       []KnowledgeSymbolRef
	// Calls are the workspace-defined symbols referenced from inside this symbol's own
	// definition body, attributed by the SCIP occurrence's enclosing range. Collapsed per
	// (caller, callee) - the same scale decision Refs makes per (file, symbol) - so a hot
	// callee yields one entry per caller, never one per call site. Empty when the indexer
	// emits no enclosing ranges, which is the honest answer rather than a guess.
	Calls []KnowledgeSymbolCall
}

type KnowledgeSymbolCall struct {
	Key   string
	Count int
}

type KnowledgeSymbolGap struct {
	Project ProjectRef           `json:"project"          yaml:"project"`
	State   SymbolIndexFreshness `json:"state"            yaml:"state"`
	Detail  string               `json:"detail,omitempty" yaml:"detail,omitempty"`
}

type KnowledgeSymbolRef struct {
	Path  string
	Count int
	Lines []int
}

type KnowledgeTiming struct {
	Project        string
	Target         string
	P75Ms          int64
	Samples        int
	HitRate        float64
	HitRateSamples int
}

type KnowledgeUnknownReason string

type KnowledgeVCS struct {
	Path         string    `json:"path"`
	LastCommit   string    `json:"last_commit"`
	LastModified time.Time `json:"last_modified"`
	LastAuthor   string    `json:"last_author"`
	// Authors is the distinct set of authors who touched the file within the scanned
	// window (sorted), the source for the `author --authored--> file` edges. LastAuthor
	// is one of them (the most recent).
	Authors []string `json:"authors"`
	Commits int      `json:"commits"`
}

type KnowledgeVerdict string

type Lease struct {
	// ID is the lease's identity within the plan, and the key Put upserts on. The
	// console joins its drawer rows to agent activity by this value, so an
	// orchestrator should use the same id it puts in the worker's prompt.
	ID string `json:"id" yaml:"id"`
	// Parent is the id of the lease this one was handed out under, empty for a lease the
	// root spawned. Depth is read off this chain rather than stored, so a mis-stamped depth
	// cannot disagree with the tree.
	Parent string `json:"parent,omitempty" yaml:"parent,omitempty"`
	// Goal is the lease's goal and its observable acceptance criteria, as one block of
	// text. Not split into two fields: the skill requires criteria to be observable and
	// a separate empty Criteria field would read as "none required" rather than as
	// "the author did not write any".
	Goal string `json:"goal,omitempty" yaml:"goal,omitempty"`
	// Checkpoint is the working state this lease was handed, in the form
	// `magus vcs checkpoint -o name` prints: the revision, plus a dirty-patch digest
	// when the tree was not clean. A string rather than an embedded VCSCheckpoint
	// because that is the form an orchestrator has at spawn time and the form a later
	// reader feeds back to `magus graph diff --rev`.
	Checkpoint string `json:"checkpoint,omitempty" yaml:"checkpoint,omitempty"`
	// OwnedPaths and ForbiddenPaths are the declared write boundary. Empty on a
	// read-only lease BY DESIGN (see ReadOnly), which is why neither is required.
	OwnedPaths     []string `json:"owned_paths,omitempty" yaml:"owned_paths,omitempty"`
	ForbiddenPaths []string `json:"forbidden_paths,omitempty" yaml:"forbidden_paths,omitempty"`
	// DependsOn are the ids of leases that must land before this one, so a reader can
	// see the ordering the orchestrator committed to.
	DependsOn []string `json:"depends_on,omitempty" yaml:"depends_on,omitempty"`
	// Tier is the effort tier the work was matched to (principal, standard, economy in
	// the skill's table). A free string: hosts name their tiers differently and a
	// closed set here would force a lie for the ones that do not fit.
	Tier string `json:"tier,omitempty" yaml:"tier,omitempty"`
	// Validation is the magus target or named check this lease was assigned, e.g.
	// "magus run test internal/ledger".
	Validation string `json:"validation,omitempty" yaml:"validation,omitempty"`
	// State is the row's lifecycle position. See LeaseState for why no_return is
	// its own value.
	State LeaseState `json:"state,omitempty" yaml:"state,omitempty"`
	// ReadOnly marks the abbreviated row the skill describes: a lease that gathers
	// evidence and writes nothing has no write set, so empty OwnedPaths and
	// ForbiddenPaths are correct rather than missing. Without this flag a reader
	// cannot tell an abbreviated row from one whose author forgot the boundary.
	ReadOnly bool `json:"read_only,omitempty" yaml:"read_only,omitempty"`
	// Releases are the paths this lease gave up, each with the content digest the path
	// carried at that moment. Store-computed and output-only, like the timestamps: a
	// worker announces a release by shrinking OwnedPaths, and the digest is what the
	// next agent needs to tell whether it inherited the file the releaser left.
	Releases []LeaseRelease `json:"releases,omitempty" yaml:"releases,omitempty"`
	// Unattributed are paths this lease owns that somebody outside it wrote, newest last,
	// at most MaxUnattributedWrites of them and one row per path.
	//
	// Store-computed and output-only like Releases, and recorded by the AGENT GUARD, which is
	// the only thing positioned to notice: it already grades every write against these declared
	// boundaries and already tells the writer to coordinate. It threw the observation away
	// afterwards, so the lease on the other side - the one whose file moved - was the one
	// party never told.
	Unattributed []LeaseUnattributedWrite `json:"unattributed,omitempty" yaml:"unattributed,omitempty"`
	// ReportedBase is the checkpoint token the lease's WORKER reported it actually landed
	// on, in the same `magus vcs checkpoint -o name` form Checkpoint holds. Checkpoint is
	// what the orchestrator handed out; this is what the worker found. Two fields rather
	// than one overwritten in place, because a single value could never disagree with
	// itself and the disagreement is the fact worth recording.
	ReportedBase string `json:"reported_base,omitempty" yaml:"reported_base,omitempty"`
	// BaseVerdict compares the two, computed by the store at the moment the worker
	// registered and kept as the fact it was then. Empty until a lease registers, which is
	// why there is no vocabulary member for "never registered" - an absent verdict is not
	// a judgment, and inventing one would be the mistake StateNoReturn exists to avoid.
	BaseVerdict LeaseBaseVerdict `json:"base_verdict,omitempty" yaml:"base_verdict,omitempty"`
	// Registered is unix seconds, stamped by the store on the write that recorded
	// ReportedBase, off the same clock read as Updated. No write door accepts it from a
	// caller, for the reason Created and Updated do not: a client-supplied timestamp is a
	// fact about the client's clock.
	Registered int64 `json:"registered,omitempty" yaml:"registered,omitempty"`
	// Created and Updated are unix seconds, stamped by the store on write and
	// output-only to callers - a client-supplied timestamp is a fact about the client's
	// clock, not about when the row was recorded.
	//
	// Updated is the row's heartbeat. A lease that re-puts its row on every state change
	// keeps it moving; a row nobody touches goes stale, and a reader may then judge the
	// lease possibly dead. That judgment is the READER'S - nothing here transitions a row
	// on its own, and silence has no verdict in it.
	Created int64 `json:"created" yaml:"created"`
	Updated int64 `json:"updated" yaml:"updated"`
}

type LeaseBaseVerdict string

type LeaseOverlap struct {
	// LeaseA and LeaseB are the lease ids, in ledger order - LeaseA was recorded first.
	LeaseA string `json:"lease_a" yaml:"lease_a"`
	LeaseB string `json:"lease_b" yaml:"lease_b"`
	// PathsA and PathsB are the intersecting declarations from each side, deduped and
	// kept apart. They are rarely the same string - "internal/ledger" and
	// "internal/ledger/store.go" intersect - so one merged list left a reader unable to
	// tell which lease claimed which, which is the only thing they can act on.
	PathsA []string `json:"paths_a" yaml:"paths_a"`
	PathsB []string `json:"paths_b" yaml:"paths_b"`
}

type LeaseRelease struct {
	Path   string `json:"path"   yaml:"path"`
	Digest string `json:"digest" yaml:"digest"`
	// ReleasedAt is unix seconds, stamped by the store on the put that dropped the path.
	ReleasedAt int64 `json:"released_at" yaml:"released_at"`
}

type LeaseReport struct {
	Leases   []Lease        `json:"leases"             yaml:"leases"`
	Overlaps []LeaseOverlap `json:"overlaps,omitempty" yaml:"overlaps,omitempty"`
}

type LeaseState string