domains

type Builder interface {
	Build(rc *RunContext) (Contribution, error)
}

type Concluder interface {
	Conclude(rc *RunContext)
}

type Contribution struct {
	Rows    []string // content lines — no box framing; the renderer frames each
	Status  string   // "success" | "failed" | "skipped" — folded into the Summary
	Summary string   // one-line detail for the run Summary
	Skip    bool     // contributor participates in this domain but had no work this run
}

type Contributor interface {
	Name() string
	Order() int                  // lower renders first within a domain (binary=10, docker=20)
	Applies(rc *RunContext) bool // does this run have work for this contributor?
}

type Detector interface {
	Detect(rc *RunContext) (Contribution, error)
}

type Domain string

type HeaderMode int

type Planner interface {
	Plan(rc *RunContext) (Contribution, error)
}

type Publisher interface {
	Publish(rc *RunContext) (Contribution, error)
}

type RunContext struct {
	Ctx     context.Context
	RootDir string
	Config  *config.Config
	Writer  io.Writer
	Stderr  io.Writer
	Color   bool
	Verbose bool

	// Header selects how the run-level identity is rendered. Default (HeaderFull)
	// prints the full logo banner + code block — correct for standalone commands
	// (`build binary`, crucible `docker build`). The perform lifecycle phase sets
	// HeaderSlim so the engine prints a one-line provenance stamp instead; the
	// full logo lives in audition. See output.Banner / output.IdentityLine.
	Header HeaderMode
	DryRun bool // stop after Plan: render Detect+Plan, skip Build/Verify/Publish + manifests
	Store  cas.Store
	Target string // optional build target (docker), ignored by strategies that don't use it

	// Generic build-selection options understood by every strategy. Set by the
	// command entrypoint; contributors read them in Plan.
	Local     bool     // build only the current platform
	Platforms []string // override platforms (e.g. "linux/arm64")
	BuildID   string   // restrict to a single build entry by ID

	// Only restricts the run to the named contributors (e.g. ["binary"] for the
	// standalone `build binary` command). Empty means every applicable
	// contributor runs (perform).
	Only []string

	// Outputs + RB are the single shared manifest pair for the whole run.
	// Contributors append artifacts to Outputs and record outcomes into RB; the
	// run finalizes + writes both exactly once after every domain has run.
	Outputs *artifact.OutputsManifest
	RB      *build.ResultsBuilder

	// RenderScribeItem composes a build-fed scribe content item into the worktree at
	// its perform slot: it materializes the item's upstream build output, then renders
	// ONLY that item's files (leaving late badges for publish). Injected by the perform
	// entrypoint, which owns the cmd-layer scribe + transport functions; nil for a
	// standalone build command, in which case a scribe node is a no-op.
	RenderScribeItem func(ctx context.Context, itemID string) error
}

type SubstrateNeeds interface {
	NeedsDocker() bool
	NeedsCrucible() bool
}

type Verifier interface {
	Verify(rc *RunContext) (Contribution, error)
}