backlog

type Acts struct {
	Report int
	Level  string
	Did    []Did
	// contains filtered or unexported fields
}

type Announcement struct {
	Quote     Quote  `yaml:"quote"`
	Why       string `yaml:"why"`
	Commit    string `yaml:"commit"`
	Announced string `yaml:"announced"`    // the day it was announced, YYYY-MM-DD
	By        string `yaml:"by,omitempty"` // the model that proposed it
}

type Backlog struct {
	Next    *forge.Issue
	Waiting map[int][]int // each issue waiting on an open one, and on which
	Blocked []int         // those issues, in the backlog's order
	Cycles  [][]int
}

type Board struct {
	NextMax   int
	StuckDays int
	Next      []forge.Issue
	Stuck     []Wait
	// contains filtered or unexported fields
}

type Change struct {
	Issue int      `yaml:"issue"`               // the issue whose sections changed, or the one opened from the lines
	What  []string `yaml:"what,flow,omitempty"` // the sections a person rewrote
	Path  string   `yaml:"path,omitempty"`      // an imported file whose lines changed
	Lines string   `yaml:"lines,omitempty"`     // those lines then, and now: "7-8 → 7-9"
	Since string   `yaml:"since,omitempty"`     // the day it was found, YYYY-MM-DD
	Touch []Touch  `yaml:"touched"`             // the open issues it touches
	Was   string   `yaml:"was,omitempty"`       // the text before, for the agent (not kept in the record)
	Now   string   `yaml:"now,omitempty"`       // the text after, for the agent (not kept in the record)
}

type Child struct {
	Title        string   `yaml:"title"`
	Need         string   `yaml:"need"`
	Verification string   `yaml:"verification"`
	Validation   string   `yaml:"validation"`
	Scope        string   `yaml:"scope"`
	Sources      []string `yaml:"sources,omitempty"`
	After        []int    `yaml:"after,flow,omitempty"` // the children it waits on, by their place in the split, from 1 (ADR-0028)
}

type ClosedImport struct {
	Issue    forge.Issue
	From, To int
	Lines    string // as a skip names them: "12", or "12-14"
}

type Closing struct {
	Issue int    `yaml:"issue"`
	Act   string `yaml:"act"`
	Level string `yaml:"level,omitempty"` // the autonomy level it was done at
}

type Config struct {
	Level        string             // cautious, normal or enterprising
	Acts         map[string]Setting // each kind's mode and cap, the project's laid over the level's
	Origins      map[string]string  // each kind's: level or setting
	MovedPercent int                // the share of the open issues a run moves
	IgnoredMax   int                // runs nobody answered before the role pauses; 0 never
	NextMax      int                // the ready issues the report lists first; 0 none (ADR-0031)
	StuckDays    int                // the days an issue waits on a person before the report says it stuck
	// Archived are the files no longer a source, as globs: an issue
	// imported from one is not flagged when its lines change (ADR-0032).
	Archived []string
	// SpecReview: the project's line runs the reviewer after the role, so
	// ready is held while the reviewer's important findings on the spec are
	// open (#128); set by the caller, from the routing.
	SpecReview bool
}

type Coverage struct {
	File       string   `json:"file"`
	Items      []Mapped `json:"items"`
	NotCovered []Mapped `json:"not-covered"`
}

type Decision struct {
	Index  int      `yaml:"index"` // the intention's place in the run
	Mode   string   `yaml:"mode"`  // act, propose, or off (dropped)
	Act    Proposal `yaml:"act"`
	Capped bool     `yaml:"capped,omitempty"` // proposed only for the cap
}

type Did struct {
	Issue int    `yaml:"issue"`
	Act   string `yaml:"act"`   // its kind, as the settings name it: close-duplicate, rename…
	Level string `yaml:"level"` // the autonomy level it was done at
	Day   string `yaml:"day"`   // the day, YYYY-MM-DD, UTC
	Line  string `yaml:"line,omitempty"`
}

type Done struct {
	Issue int    `yaml:"issue"`
	Act   string `yaml:"act"`
	Was   string `yaml:"was,omitempty"`
	Set   string `yaml:"set,omitempty"`
	Level string `yaml:"level,omitempty"` // the autonomy level it was done at
}

type Evidence struct {
	Body       string
	Parts      int
	Closed     int      // the parts closed, or gone from the forge
	Undone     []int    // the parts closed without delivering: not planned, a duplicate, gone
	Unproved   []string // the Verification items no part delivered quotes, or whose test is not in the code
	NoTest     []string // the tests a quoted item names that the code does not hold
	TestUnread []string // the tests a quoted item names that could not be looked for, with why
	Unread     []Part   // the parts whose closer the forge refused to say, with why
	AllClosed  bool
}

type Exchange struct {
	Rounds   int      // the engine's comments to the reporter
	Answered bool     // a person's comment after the last of them
	Asked    []string // each one's text, its marker left out
}

type Hand struct {
	Report   int
	Record   Record
	Broken   error    // the record does not read
	Ticks    []TickBy // the boxes ticked in the report's body now
	Comments int      // comments of people of the project on the report
	Signs    []string // what a person did since the last run: a tick, a comment, a closing or an act undone, a proposal settled
	// Undone are the role's acts a person undid since the last run, other
	// than closings; Standing, those still watched (ADR-0026).
	Undone   []Undo
	Standing []Done
	// Own are the blockers the role set on each open issue, as its record
	// keeps them: a depend's, a split's after (ADR-0028).
	Own map[int][]int
}

type ImportOpen struct {
	Title   string
	Quote   Quote
	Capped  bool // proposed in the report, past the cap of open
	Dropped bool // refused by the engine, a finding saying why
	// Opening is what opening it did, as the run recorded it: the issue
	// that holds it, and whether it was opened then.
	Opening *Recorded
}

type ImportShare struct {
	From, To int // the lines it was given
	// Own is its last line to answer for: those after it are read again by
	// the next share, which answers for them.
	Own   int
	Opens []ImportOpen
	Skips []Skip
}

type Judged struct {
	Yes    *bool  `yaml:"yes"`
	Why    string `yaml:"why"`
	Model  string `yaml:"model"`
	Level  string `yaml:"level"`
	Author string `yaml:"author"`
	Error  string `yaml:"error"`
}

type KindMode struct {
	Kind   string
	Mode   string
	Max    int
	Drafts string // refine: Need and Validation proposed when "propose"
	Origin string
}

type Mapped struct {
	Lines string `json:"lines"`
	From  int    `json:"from"`
	To    int    `json:"to"`
	Words string `json:"words"`
	State string `json:"state,omitempty"`
	Issue int    `json:"issue,omitempty"`
	Why   string `json:"why,omitempty"`
}

type Measure struct {
	Level  string `yaml:"level"`
	Ticked int    `yaml:"ticked,omitempty"` // proposals a person of the project ticked: done as proposed
	Other  int    `yaml:"other,omitempty"`  // proposals settled otherwise: their issue closed, or opened by hand
}

type Obsolete struct {
	Announcement *Announcement // nil: none waiting
	Due          bool          // its delay passed, nothing cancels it: a judge decides
	From         string        // the day it may be closed from
	Keep         string        // why it is kept open, when it is
	Say          bool          // the issue is told why it is kept: no person did it
}

type Opening struct {
	Role    string   // the role that found it, named in the issue
	Key     string   // the marker's key: issue=<subject>, or import=<a file's text>
	Also    []string // older keys the same subject was opened under
	Title   string
	Body    string
	From    string   // where it was opened from, said after "Opened": " from `ROADMAP.md`"
	Sources []string // the code it is about, for the keeper's state
	Commit  string   // the commit it was seen at
	Triage  bool     // a role's finding: labelled needs-triage, capped, said once when found after it was closed
	Wrote   []string // the sections the role wrote in its body, recorded in the keeper's state (#128)
}

type Openings struct {
	Max int // a run's findings opened as issues, at most; the rest Capped
	// contains filtered or unexported fields
}

type Part struct {
	ID      int
	Issue   forge.Issue
	Closers []forge.Closer
	Unread  error
	Gone    bool
}

type Pending struct {
	Issue int    `yaml:"issue"`
	Act   string `yaml:"act"`
	Line  string `yaml:"line"`
	Key   string `yaml:"key,omitempty"` // an issue to open: the text it would be opened from (ImportKey)
	// Capped: proposed only because the run's cap was reached, not left to
	// a person by its mode: its issue is read again at the next run.
	Capped bool `yaml:"capped,omitempty"`
	// Proposal is what the engine would do, as decided: done as it says
	// when a person of the project ticks its box (ADR-0025).
	Proposal *Proposal `yaml:"proposal,omitempty"`
	// Since is the day it was first proposed, YYYY-MM-DD: the report says
	// it stuck past stuck-days (ADR-0031).
	Since string `yaml:"since,omitempty"`
	// Agreed is who of the project ticked it, kept for one recorded
	// without its act (Undrafted): drafted, then done, at the next run
	// that reads its issue with an agent (ADR-0025, amended).
	Agreed string `yaml:"agreed,omitempty"`
}

type Plan struct {
	Decisions []Decision        `yaml:"decisions"`
	Findings  []verdict.Finding `yaml:"findings"`
	Record    Record            `yaml:"record"`
	Report    int               `yaml:"report"`  // the report issue, 0 when none is open yet
	Changed   bool              `yaml:"changed"` // the record changed: wrong closings found, proposals settled
	// Opening is what the report opens with, what is next and what is
	// stuck, as this run reads it (ADR-0031): kept with the plan so a
	// resumed run writes the same, never in the record.
	Opening string `yaml:"opening,omitempty"`
	// Rechecked are the changes this run settled with no person: every
	// issue they touch read again with them, nothing proposed on any
	// (ADR-0032). The report says them once, in a line, folded.
	Rechecked []Change `yaml:"rechecked,omitempty"`
	// contains filtered or unexported fields
}

type Proposal struct {
	Do          string   `yaml:"do"` // close or sources: the intention's kind
	Issue       int      `yaml:"issue"`
	Reason      string   `yaml:"reason,omitempty"`
	DuplicateOf int      `yaml:"duplicate-of,omitempty"`
	Sources     []string `yaml:"sources,omitempty"`
	Milestone   string   `yaml:"milestone,omitempty"`
	Title       string   `yaml:"title,omitempty"`           // an issue to open, or an issue's new title (rename)
	Into        []Child  `yaml:"into,omitempty"`            // the children of a split
	BlockedBy   []int    `yaml:"blocked-by,flow,omitempty"` // depend: the issues it waits on; undepend: those taken off (ADR-0028)
	// Native, the engine's: the blockers an undepend takes off the forge's
	// own relation, the rest being in the engine's line; never the agent's.
	Native []int  `yaml:"native,flow,omitempty"`
	Quote  *Quote `yaml:"quote"`
	Why    string `yaml:"why"`
	// Refining: the sections written, Need and Validation as drafts; Added,
	// the engine's, says which the body did not have yet.
	Scope        string   `yaml:"scope,omitempty"`
	Verification string   `yaml:"verification,omitempty"`
	Need         string   `yaml:"need,omitempty"`
	Validation   string   `yaml:"validation,omitempty"`
	Added        []string `yaml:"added,omitempty"`
	// Revise, the engine's: the sections with text this refine may rewrite,
	// to answer the reviewer's findings on the spec (#128) — the role's own
	// only (Revisable); never taken from the agent.
	Revise    []string `yaml:"revise,omitempty"`
	Questions string   `yaml:"questions,omitempty"` // asking the reporter; for an outsider's refine, what it still needs
	// The engine's, for the conversation with the reporter: the round this
	// comment would be, and whether a refine is proposed to the reporter in
	// a comment rather than written in the body (an outsider's issue).
	Round      int  `yaml:"round,omitempty"`
	ToReporter bool `yaml:"to-reporter,omitempty"`
	// Agreed, the engine's: who agreed in a reply to the text last proposed
	// to the reporter, which this refine writes; checked again on the forge
	// (Agreement), never taken from the agent.
	Agreed string `yaml:"agreed,omitempty"`
	Spent  bool   `yaml:"spent,omitempty"` // the rounds spent: proposed to a person
	// Ordering: the priority set (1 to 4); a milestone left because it is
	// released (From, the engine's); and, the engine's, the issue's
	// priority and milestone before the run, written in the report.
	Priority int    `yaml:"priority,omitempty"`
	From     string `yaml:"from,omitempty"`
	Before   string `yaml:"before,omitempty"`
	// Obsolete (ADR-0024): Announced, on the engine's closing, the day of
	// the announcement it follows; Announce and Until, the engine's, that
	// this act announces rather than closes, and the day from which it may
	// close; Judge, the engine's, the second judge's yes and its level;
	// Say, on a keep, that the issue is told why.
	Announced string `yaml:"announced,omitempty"`
	Announce  bool   `yaml:"announce,omitempty"`
	Until     string `yaml:"until,omitempty"`
	Judge     string `yaml:"judge,omitempty"`
	Say       bool   `yaml:"say,omitempty"`
	// Ticked, the engine's: who ticked this proposal's box in the report, a
	// person of the project — checked again on the forge, the act done as
	// the record says, never as the intention does (ADR-0025).
	Ticked string `yaml:"ticked,omitempty"`
}

type Quote struct {
	Path  string `yaml:"path,omitempty"`
	Issue int    `yaml:"issue,omitempty"`
	Text  string `yaml:"text"`
}

type Record struct {
	Closed  []Closing `yaml:"closed,omitempty"`
	Wrong   []Closing `yaml:"wrong,omitempty"`        // closings found wrong: their issue open again
	Propose []string  `yaml:"propose,flow,omitempty"` // kinds of act back to propose, until the person says
	// Done are the role's own acts a person may undo, other than closings:
	// a rename, a priority, a milestone, ready, a split (ADR-0026); Undone,
	// those a person undid, with what shows it.
	Done     []Done    `yaml:"done,omitempty"`
	Undone   []Undo    `yaml:"undone,omitempty"`
	Proposed []Pending `yaml:"proposed,omitempty"` // acts proposed, kept until their issue is closed or proposed again
	// The person's hand (ADR-0025): the runs in a row whose report proposed
	// something and that nobody answered, and the comments of people of the
	// project on the report when last read.
	Ignored  int `yaml:"ignored,omitempty"`
	Comments int `yaml:"comments,omitempty"`
	// Measure is what people did with the proposals at the level in force,
	// for the report to suggest another (ADR-0026).
	Measure *Measure `yaml:"measure,omitempty"`
	// ToAccept are the open parents whose parts are all closed, as the
	// report lists them for a person to accept (ADR-0029).
	ToAccept []int `yaml:"to-accept,flow,omitempty"`
	// Changes are what open issues were built on that changed, kept until
	// a person ticks each seen or its issues are closed (ADR-0032).
	Changes []Change `yaml:"changes,omitempty"`
	// Did are the acts the role did alone, with their day and level, for
	// the weekly sample to draw (ADR-0033).
	Did []Did `yaml:"did,omitempty"`
}

type Recorded struct {
	Index   int    `yaml:"index"` // the intention's place in the run
	Outcome string `yaml:"outcome"`
	Issue   int    `yaml:"issue"`
}

type Setting struct {
	Mode   string
	Max    int
	Rounds int      // asking: the times an issue's reporter is written to, then a person (ask only)
	Days   *int     // close-obsolete: the days an announcement waits; ObsoleteDays when nil
	Exempt []string // close-obsolete: labels that keep an issue from it; DefaultExempt when nil
	Drafts string   // refine: propose has Need and Validation drafts proposed, Scope and Verification written (ADR-0026)
}

type Skip struct {
	Lines  any    `yaml:"lines"` // "12", or "12-14"
	Reason string `yaml:"reason"`
	Quote  *Quote `yaml:"quote,omitempty"`
	Issue  int    `yaml:"issue,omitempty"`
	Why    string `yaml:"why,omitempty"`
}

type SpecReview struct {
	Body    string   // the digest of the body it read (BodyDigest); "" when no review was whole
	Round   int      // the reviews in a row that found an important finding open, this one included
	Open    int      // the important findings open, as it read the body
	In      []string // the sections their causes lie in
	Stopped bool     // the rounds spent: put to a person, not read again
}

type State struct {
	Sources   []string `yaml:"sources"`
	Confirmed string   `yaml:"confirmed"`
	Judged    string   `yaml:"judged,omitempty"`   // the commit the role last read it at
	Comments  int      `yaml:"comments,omitempty"` // people's comments when it was last read
	Body      string   `yaml:"body,omitempty"`     // a digest of its body, when the role last read or wrote it
	Priority  int      `yaml:"priority,omitempty"` // the priority the role last set: another on the issue is a person's
	Title     string   `yaml:"title,omitempty"`    // the title the role last set: another on the issue is a person's
	Split     []int    `yaml:"split,omitempty"`    // the children the role split it into: it is not split again
	// After are the blockers the role's split set on each child, among
	// its siblings: the role's own links, taken off once a blocker closes
	// (ADR-0028).
	After map[int][]int `yaml:"after,flow,omitempty"`
	Kept  []string      `yaml:"kept,omitempty"` // the evidence an announcement as obsolete rested on, kept open: not announced again for it
	// Sections are its Need and Scope as last read or written (Basis): a
	// person's change to them touches the issues built on it (ADR-0032).
	Sections map[string]string `yaml:"sections,omitempty"`
	// Wrote are the sections the role wrote, each the digest of its text:
	// another text there is a person's (SectionDigest). Answered is the
	// review of its spec the role was last given, by the digest of the
	// body that review read (#128): a review restarting at round 1 is
	// another review, never taken for one answered.
	Wrote    map[string]string `yaml:"wrote,omitempty"`
	Answered string            `yaml:"answered,omitempty"`
}

type TestFinder func(name string) (string, error)

type TickBy struct {
	Key string
	forge.Note
	Known bool // the forge says who ticked it: by name, or as a person of the project
}

type Touch struct {
	Issue int    `yaml:"issue"`
	How   string `yaml:"how"`
	Files string `yaml:"files,omitempty"` // the code shared, for TouchSources
	Read  bool   `yaml:"read,omitempty"`  // read again by the run that found it, with the change
}

type Undo struct {
	Issue    int    `yaml:"issue"`
	Act      string `yaml:"act"`
	Evidence string `yaml:"evidence"`
	Day      string `yaml:"day,omitempty"` // when a run found it, YYYY-MM-DD: the weekly sample counts it against one act
}

type Wait struct {
	Issue int    `yaml:"issue"`
	Waits string `yaml:"waits"`
	Since string `yaml:"since"`          // the day it started waiting, YYYY-MM-DD
	Act   string `yaml:"act,omitempty"`  // proposed: the kind of act
	Line  string `yaml:"line,omitempty"` // proposed with no issue (an issue to open): its line
}