verification

type Activity ¶

type Activity struct {
	Sequence uint64       `json:"sequence"`
	Kind     ActivityKind `json:"kind"`
	ToolCall *ToolCall    `json:"tool_call,omitempty"`
	Test     *TestRun     `json:"test,omitempty"`
	Lint     *LintRun     `json:"lint,omitempty"`
}

Activity is a closed, unambiguous evidence envelope. Sequence is assigned by the runtime-issued recorder and defines stable observation order.

func CloneActivities(input []Activity) ([]Activity, error)

func (a Activity) Validate() error

type ActivityKind ¶

type ActivityKind string

const (
	ActivityToolCall ActivityKind = "tool_call"
	ActivityTest     ActivityKind = "test"
	ActivityLint     ActivityKind = "lint"
)

func (k ActivityKind) Valid() bool

type ActivityOutcome ¶

type ActivityOutcome string

const (
	ActivitySucceeded ActivityOutcome = "succeeded"
	ActivityFailed    ActivityOutcome = "failed"
	ActivitySkipped   ActivityOutcome = "skipped"
)

func (o ActivityOutcome) Valid() bool

type ActivityRecorder ¶

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

ActivityRecorder is a concurrency-safe attempt-local literal evidence sink. Runtimes issue one recorder and freeze it immediately after executor return. Trusted adapters call only the typed recording methods at actual activity boundaries; workflow/model data must never be translated into these calls.

func NewActivityRecorder() *ActivityRecorder

func (r *ActivityRecorder) Freeze() ([]Activity, error)

func (r *ActivityRecorder) RecordLint(ctx context.Context, run LintRun) error

func (r *ActivityRecorder) RecordTest(ctx context.Context, run TestRun) error

func (r *ActivityRecorder) RecordToolCall(ctx context.Context, call ToolCall) error

type CheckOutcome ¶

type CheckOutcome string

const (
	CheckPassed CheckOutcome = "passed"
	CheckFailed CheckOutcome = "failed"
	CheckError  CheckOutcome = "error"
)

func (o CheckOutcome) Valid() bool

type CheckResult ¶

type CheckResult struct {
	Index   int               `json:"index"`
	Kind    string            `json:"kind"`
	Version string            `json:"version"`
	Outcome CheckOutcome      `json:"outcome"`
	Code    string            `json:"code"`
	Message string            `json:"message"`
	Details map[string]string `json:"details,omitempty"`
	Source  *graph.SourceRef  `json:"source,omitempty"`
}

CheckResult is one durable, source-mapped verifier decision.

func (r CheckResult) Validate() error

type LintRun ¶

type LintRun struct {
	Name    string          `json:"name"`
	Outcome ActivityOutcome `json:"outcome"`
}

LintRun is literal evidence emitted by a trusted linter boundary.

type MemoryRegistry ¶

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

MemoryRegistry is a concurrency-safe exact-kind verifier registry. Verifier kinds are intentionally unversioned in graph checks; their immutable version remains visible in the registry result and durable report.

func NewDefaultRegistry() *MemoryRegistry

func NewRegistry() *MemoryRegistry

func SnapshotRegistry(source Registry) (*MemoryRegistry, error)

func (r *MemoryRegistry) List() []VerifierSpec

func (r *MemoryRegistry) Lookup(kind string) (Verifier, bool)

func (r *MemoryRegistry) Register(verifier Verifier) error

type Registry ¶

type Registry interface {
	Register(Verifier) error
	Lookup(kind string) (Verifier, bool)
	List() []VerifierSpec
}

type Report ¶

type Report struct {
	SchemaVersion string        `json:"schema_version"`
	SpecDigest    string        `json:"spec_digest"`
	Status        ReportStatus  `json:"status"`
	Reason        string        `json:"reason,omitempty"`
	Checks        []CheckResult `json:"checks,omitempty"`
	Evidence      []Activity    `json:"evidence,omitempty"`
}

Report is the durable verification data-plane payload. SpecDigest binds it to the source declaration; Evidence contains only frozen literal activity.

func CloneReport(report Report) (Report, error)

func (r Report) Validate() error

type ReportStatus ¶

type ReportStatus string

const (
	ReportPassed ReportStatus = "passed"
	ReportFailed ReportStatus = "failed"
	ReportNotRun ReportStatus = "not_run"
)

func (s ReportStatus) Valid() bool

type Request ¶

type Request struct {
	Check        graph.VerificationCheck
	OutputSchema graph.Schema
	Outputs      values.ValueSet
	Evidence     []Activity
}

Request is a defensive verifier input. OutputSchema is the registered kind's trusted output schema; Outputs and Evidence are typed runtime observations.

type ReviewerDecision ¶

type ReviewerDecision struct {
	Passed  bool              `json:"passed"`
	Code    string            `json:"code"`
	Message string            `json:"message"`
	Details map[string]string `json:"details,omitempty"`
}

ReviewerDecision is the strict provider-neutral result expected from future LLM/reviewer adapters. Passing requires an explicit boolean plus stable code and message; unknown fields, duplicate fields, and trailing documents fail.

func ParseReviewerDecision(data []byte) (ReviewerDecision, error)

func (d ReviewerDecision) Validate() error

type TestRun ¶

type TestRun struct {
	Name    string          `json:"name"`
	Outcome ActivityOutcome `json:"outcome"`
}

TestRun is literal evidence emitted by a trusted test harness boundary.

type ToolCall ¶

type ToolCall struct {
	Server  string          `json:"server"`
	Tool    string          `json:"tool"`
	Outcome ActivityOutcome `json:"outcome"`
}

ToolCall is literal evidence emitted at an actual tool client boundary. It intentionally excludes arguments, results, credentials, and arbitrary transport metadata.

type Verifier ¶

type Verifier interface {
	Spec() VerifierSpec
	ValidateConfig(context.Context, graph.VerificationCheck) []diagnostic.Diagnostic
	Verify(context.Context, Request) (CheckResult, error)
}

type VerifierMode ¶

type VerifierMode string

const (
	ModeDeterministic VerifierMode = "deterministic"
	ModeReviewer      VerifierMode = "reviewer"
)

func (m VerifierMode) Valid() bool

type VerifierSpec ¶

type VerifierSpec struct {
	Kind             string         `json:"kind"`
	Version          string         `json:"version"`
	Mode             VerifierMode   `json:"mode"`
	ConfigSchema     graph.Schema   `json:"config_schema"`
	RequiredEvidence []ActivityKind `json:"required_evidence,omitempty"`
}

VerifierSpec is immutable registry metadata. ConfigSchema describes the opaque graph check config; RequiredEvidence is an inspectable fail-closed declaration used by compilers and policy before execution.

func (s VerifierSpec) Validate() error