support

package
v0.1.3 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 8, 2026 License: Apache-2.0 Imports: 13 Imported by: 0

Documentation

Overview

Package support is what the harness conformance kits and the README's harness table share: the harness profiles as a client reads them, the capabilities a harness is measured on, the live suite's recorded results, and the support matrix built from them. It reads only the public contracts (the profiles in adapters/ and their schema), so a kit outside this repository could use it the same way.

Index

Constants

View Source
const Baseline = "baseline"

Baseline is the capability every supported harness has: it joins a board with a join line, its session has an identity so commands act as its agent, it posts and reads, the skill is installed, aboard init and uninstall leave its files clean, and it has a docs page. A harness without it isn't supported.

View Source
const ResultsFile = "e2e/live/support.json"

ResultsFile is the record's path from the repository's root.

Variables

View Source
var Capabilities = []Capability{
	{ID: Baseline, Label: "Baseline", Scenarios: []string{"JoinsAndTalks"}, /* contains filtered or unexported fields */},
	{
		ID: "idle_delivery", Label: "Wakes when idle", Scenarios: []string{"WakesAndReplies", "PingPong", "PingPongAcrossHarnesses", "RepliesReachPromptly", "KilledSessionRedelivers", "RestartsLoseNothing"},
		// contains filtered or unexported fields
	},
	{ID: "turn_end", Label: "Peers at turn end", Scenarios: []string{"OwnerReachesBusy"}, /* contains filtered or unexported fields */},
	{ID: "owner_mid_turn", Label: "Owner mid-turn", Scenarios: []string{"OwnerReachesBusy"}, /* contains filtered or unexported fields */},
	{ID: "waiting_notice", Label: "Waiting notice", Scenarios: []string{"PeerWaitsButNoticeArrives"}, /* contains filtered or unexported fields */},
	{ID: "presence", Label: "Presence", Scenarios: []string{"WakesAndReplies"}, /* contains filtered or unexported fields */},
	{ID: "reconnect", Label: "Reconnects on resume", Scenarios: []string{"ResumeReconnects"}, /* contains filtered or unexported fields */},
	{ID: "subagents", Label: "Subagents", Scenarios: []string{"SubagentCannotActAsItsParent"}, /* contains filtered or unexported fields */},
	{ID: "project_scope", Label: "Project setup", Scenarios: []string{"ProjectScopeSetup"}, /* contains filtered or unexported fields */},
	{
		ID: "launcher", Label: "Started by a launcher", Scenarios: []string{"SwarmUpStartsEveryHarness", "SwarmUpResumesTheLastSession", "SwarmUpStartsFreshAfterNoTurn"},
		// contains filtered or unexported fields
	},
	{
		ID: "sandbox", Label: "Sandbox check", Scenarios: []string{"SandboxNeedsTheAllowRule"},
		// contains filtered or unexported fields
	},
}

Capabilities are what the conformance kits measure, in the order the README's table shows them.

Functions

func Evidence

func Evidence(p Profile, h *HarnessResults) string

Evidence says on which harness versions and days the live kit proved a harness's capabilities, and how long a delivery to it typically took, or "" when it never ran live: "Claude Code: proven on 2.1.288, 2026-10-04; a delivery typically began 0.1 s after its message was posted, and Claude Code confirmed it 2.3 s later (median of 14)."

func ScenarioCapabilities

func ScenarioCapabilities(scenario string) []string

ScenarioCapabilities lists the capabilities a live scenario proves.

func SupportedHarness

func SupportedHarness(cells []Cell) bool

SupportedHarness reports whether a harness counts as supported: it has the baseline.

func Table

func Table(profiles []Profile, results *Results) string

Table renders the README's harness table: one row per harness, one column per capability, then each note, under the table, naming its harness and capability.

func VersionAtLeast

func VersionAtLeast(v, minimum string) bool

VersionAtLeast reports whether the version v is at least minimum, comparing dotted numbers. An empty minimum is always reached.

Types

type Capability

type Capability struct {
	// ID names the capability in results and notes.
	ID string
	// Label heads its column in the README's table.
	Label string
	// Scenarios are the live scenarios that prove it. A capability with none is proven
	// by the fast kit alone.
	Scenarios []string
	// contains filtered or unexported fields
}

Capability is one thing a harness is measured on.

type Cell

type Cell struct {
	Capability Capability
	Status     Status
	Note       string
}

Cell is one capability of one harness in the matrix.

func Matrix

func Matrix(p Profile, r *HarnessResults) []Cell

Matrix is a harness's capabilities: what its profile declares, checked against its live results. A declared capability a live scenario measures counts only once that scenario passed; one that failed in the latest run is partial until it passes again.

type Fallback

type Fallback struct {
	Event string `yaml:"event"`
	Since string `yaml:"since"`
}

Fallback is an event a hook runs on in older versions, with the first version that knows it.

func (*Fallback) UnmarshalYAML

func (f *Fallback) UnmarshalYAML(n *yaml.Node) error

UnmarshalYAML reads a fallback written as an event name or as {event, since}.

type Handover

type Handover struct {
	AboardMS   int64  `json:"aboard_ms"`
	HarnessMS  int64  `json:"harness_ms"`
	Deliveries int    `json:"deliveries"`
	Date       string `json:"date"`
}

Handover is how long a delivery typically took, the median of the deliveries a live run measured from the daemon's log: from the message's posting until the daemon began handing it to the session (Aboard's part), and from then until the session confirmed it had it (the harness's part: a waiting hook's next event, a queue taking it, or an extension's received).

type HarnessResults

type HarnessResults struct {
	// Version is the harness version the latest run used.
	Version string `json:"version,omitempty"`
	// Notes say more about a capability than its status, by capability ID; written by
	// hand, for what the profile can't say.
	Notes     map[string]string `json:"notes,omitempty"`
	Scenarios map[string]Result `json:"scenarios"`
	// Handover is how long deliveries to the harness typically took in the latest run
	// that measured any.
	Handover *Handover `json:"handover,omitempty"`
}

HarnessResults are a harness's recorded live results.

type Hook

type Hook struct {
	Event   string         `yaml:"event"`
	Run     string         `yaml:"run"`
	Op      string         `yaml:"op"`
	Matcher string         `yaml:"matcher"`
	Timeout int            `yaml:"timeout"`
	Options map[string]any `yaml:"options"`
	// Since is the first version of the harness that runs the hook as written, and
	// Fallback the events it runs on instead on older versions.
	Since    string     `yaml:"since"`
	Fallback []Fallback `yaml:"fallback"`
}

Hook is one hook the profile lists.

type Item

type Item struct {
	Kind    string `yaml:"kind"`
	Global  string `yaml:"global"`
	Project string `yaml:"project"`
	Format  string `yaml:"format"`
	Rule    string `yaml:"rule"`
	// Source is, for a file Aboard installs inside the harness, its name in aboard.
	Source string `yaml:"source"`
	// Required is set for an allow rule the harness can't reach Aboard without.
	Required map[string]string `yaml:"required"`
	Missing  *struct {
		Level string `yaml:"level"`
	} `yaml:"missing"`
	Text string `yaml:"text"`
}

Item is one thing aboard init installs.

type Profile

type Profile struct {
	Harness   string `yaml:"harness"`
	Name      string `yaml:"name"`
	Command   string `yaml:"command"`
	CheckName string `yaml:"check_name"`
	Checks    struct {
		MinVersion string `yaml:"min_version"`
	} `yaml:"checks"`
	SandboxEnv        []string `yaml:"sandbox_env"`
	SandboxNetworkEnv []string `yaml:"sandbox_network_env"`
	SessionEnv        []string `yaml:"session_env"`
	ConfigDir         struct {
		Env     string `yaml:"env"`
		Default string `yaml:"default"`
	} `yaml:"config_dir"`
	Install     []Item `yaml:"install"`
	Interactive struct {
		Start  []string `yaml:"start"`
		Resume []string `yaml:"resume"`
	} `yaml:"interactive"`
	Headless struct {
		Via string `yaml:"via"`
	} `yaml:"headless"`
	Identity struct {
		Kind     string   `yaml:"kind"`
		Env      string   `yaml:"env"`
		RootEnv  string   `yaml:"root_env"`
		EnvFile  string   `yaml:"env_file"`
		YieldsTo []string `yaml:"yields_to"`
	} `yaml:"identity"`
	SubagentIdentity string `yaml:"subagent_identity"`
	Lifecycle        struct {
		Liveness         string `yaml:"liveness"`
		OutlivesTerminal bool   `yaml:"outlives_terminal"`
		ResumeKeepsID    bool   `yaml:"resume_keeps_id"`
		ResumeStart      string `yaml:"resume_start"`
		SubagentField    string `yaml:"subagent_field"`
	} `yaml:"lifecycle"`
	Delivery struct {
		Method        string   `yaml:"method"`
		Capabilities  []string `yaml:"capabilities"`
		Hooks         []Hook   `yaml:"hooks"`
		MidTurn       string   `yaml:"mid_turn"`
		WaitingNotice bool     `yaml:"waiting_notice"`
	} `yaml:"delivery"`
}

Profile is the part of a harness profile (spec/harness-profile.schema.json) the kits and the table read.

func Profiles

func Profiles() ([]Profile, error)

Profiles reads every profile built into aboard, in the order of their folders.

func (Profile) Delivers

func (p Profile) Delivers() bool

Delivers reports whether the harness has automatic delivery of any kind.

func (Profile) Has

func (p Profile) Has(capability string) bool

Has reports whether the profile declares a delivery capability.

func (Profile) HoldsWhileBusy

func (p Profile) HoldsWhileBusy() bool

HoldsWhileBusy reports whether Aboard holds a busy session's messages until its turn ends and hands them over together, rather than the harness's own queue taking each as it comes: through a hook that waits while the session is idle, or the connection of Aboard's extension inside the harness.

func (Profile) Hook

func (p Profile) Hook(op string) (Hook, bool)

Hook returns the profile's hook for an operation, such as "wait".

func (Profile) Item

func (p Profile) Item(kind string) (Item, bool)

Item returns the profile's first install item of a kind.

func (Profile) WaitsForIdle

func (p Profile) WaitsForIdle() bool

WaitsForIdle reports whether bundles go only to a hook that waits while the session is idle, so a handed bundle is confirmed later, by the session's next event.

type Result

type Result struct {
	// Result is pass, fail or n/a (the scenario doesn't apply to the harness).
	Result string `json:"result"`
	// Date is the day it ran, YYYY-MM-DD.
	Date string `json:"date,omitempty"`
	// Version is the harness version it ran with, as the harness's --version prints it.
	Version string `json:"version,omitempty"`
	// Test is the test that produced it.
	Test string `json:"test"`
}

Result is one live scenario's latest outcome for a harness.

type Results

type Results struct {
	Harnesses map[string]*HarnessResults `json:"harnesses"`
}

Results is the live suite's record, e2e/live/support.json.

func LoadResults

func LoadResults(path string) (*Results, error)

LoadResults reads the record, or returns an empty one if there is none.

func (*Results) Record

func (r *Results) Record(harness, scenario string, res Result)

Record sets a scenario's result for a harness.

func (*Results) Save

func (r *Results) Save(path string) error

Save writes the record, indented, with a final newline.

type Status

type Status string

Status is how far a harness has a capability.

const (
	Supported     Status = "supported"
	Partial       Status = "partial"
	Unsupported   Status = "unsupported"
	NotApplicable Status = "n/a"
)

Statuses of a capability.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL