ir

type AgentRole struct {
	Uses         string    `json:"uses"`
	Model        string    `json:"model,omitempty"`
	SystemPrompt string    `json:"system_prompt,omitempty"`
	With         RawConfig `json:"with,omitempty"`
}

type AgentStep struct {
	ID           string      `json:"id"`
	Container    string      `json:"container,omitempty"`
	Uses         string      `json:"uses"`
	With         RawConfig   `json:"with,omitempty"`
	Continues    string      `json:"continues,omitempty"` // id of the prior agent turn to continue (engine-owned thread)
	OutputSchema *JSONSchema `json:"output_schema,omitempty"`
	OutputFiles  OutputFiles `json:"output_files,omitempty"`
	// OutputArtifact, valid on any agent step with output_schema (container-backed
	// or containerless — F39), serializes the step's validated typed Output as
	// canonical JSON and publishes it as the named artifact step.<id>.files.<name>.
	// Mutually exclusive with output_files; requires output_schema. The dispatcher
	// always produces the bytes from the committed Output, never captured from
	// the container filesystem.
	OutputArtifact string            `json:"output_artifact,omitempty"`
	Skills         *StepSkillRouting `json:"skills,omitempty"`
	// InputFiles maps an in-container destination path → a static artifact or asset
	// reference (step.<id>.files.<name> or asset.<id>). The engine resolves each to
	// a CAS blob from a prior named output_files commit or run-start asset snapshot
	// and stages the bytes via Backend.CopyTo BEFORE this step runs. Static, not a
	// {{ }} template (AWF3007). Requires a container (rejected on containerless
	// agent steps at runtime).
	InputFiles     map[string]string `json:"input_files,omitempty"`
	Timeout        *Timeout          `json:"timeout,omitempty"`
	IdempotencyKey *Template         `json:"idempotency_key,omitempty"`
	Retry          *RetryPolicy      `json:"retry,omitempty"`
}

type ArtifactContract struct {
	Format    string
	Schema    *JSONSchema
	SchemaRef string
}

type ArtifactExports map[string]string

type CallStep struct {
	ID         string                   `json:"id"`
	Call       string                   `json:"call"`
	Input      map[string]TemplateValue `json:"input,omitempty"`
	InputFiles map[string]string        `json:"input_files,omitempty"`
}

type CodeStep struct {
	ID           string      `json:"id"`
	Container    string      `json:"container,omitempty"`
	Run          string      `json:"run"`
	Timeout      *Timeout    `json:"timeout,omitempty"`
	OutputSchema *JSONSchema `json:"output_schema,omitempty"`
	OutputFiles  OutputFiles `json:"output_files,omitempty"`
	// InputFiles maps an in-container destination path → a static artifact or asset
	// reference (step.<id>.files.<name> or asset.<id>). The engine resolves each to
	// a CAS blob from a prior named output_files commit or run-start asset snapshot
	// and stages the bytes via Backend.CopyTo BEFORE this step runs. Static, not a
	// {{ }} template (AWF3007). Requires a container (rejected on containerless
	// agent steps at runtime).
	InputFiles     map[string]string `json:"input_files,omitempty"`
	IdempotencyKey *Template         `json:"idempotency_key,omitempty"`
	Retry          *RetryPolicy      `json:"retry,omitempty"`
}

type Compose struct {
	As      string   `json:"as"`
	From    string   `json:"from"`
	Service Template `json:"service"`
	Body    NodeList `json:"body"`
}

type ComposeValidationError struct {
	Code    string
	Message string
}

type Container struct {
	Image     string     `json:"image,omitempty"`
	Compose   string     `json:"compose,omitempty"`
	Service   string     `json:"service,omitempty"`
	Snapshot  string     `json:"snapshot,omitempty"`
	Cmd       []string   `json:"cmd,omitempty"`
	Keepalive *bool      `json:"keepalive,omitempty"`
	Resources *Resources `json:"resources,omitempty"`
}

type Diagnostic struct {
	Severity Severity `json:"severity"`
	Source   string   `json:"source,omitempty"`
	Path     string   `json:"path"`
	Code     string   `json:"code"`
	Message  string   `json:"message"`
}

type Duration time.Duration

type Expr string

type Gate struct {
	Generate    NodeList `json:"generate"`
	Evaluate    NodeList `json:"evaluate"`
	Until       Expr     `json:"until"`
	MaxAttempts int      `json:"max_attempts"`
}

type If struct {
	Cond Expr     `json:"cond"`
	Then NodeList `json:"then"`
	Else NodeList `json:"else,omitempty"`
}

type JSONSchema map[string]any

type LoadedAsset struct {
	ID           string            `json:"id"`
	DeclaredPath string            `json:"declared_path"`
	IsDir        bool              `json:"is_dir"`
	Files        []LoadedAssetFile `json:"files"`
}

type LoadedAssetFile struct {
	Path  string `json:"path"`
	Bytes []byte `json:"bytes"`
}

type LoadedDefinition struct {
	// Workflow is the parsed IR. Non-nil if Load succeeded.
	Workflow *Workflow

	// WorkflowPath is the absolute path of the workflow file (for error attribution).
	WorkflowPath string

	// ComposeFiles maps each container's cleaned workflow-relative compose path
	// (e.g. "lab/compose.yml") to the raw bytes the loader read. Forward-slashed regardless
	// of OS so the digest input is portable.
	ComposeFiles map[string][]byte

	// Assets maps each top-level asset id to the run-start snapshot loaded from disk.
	Assets map[string]LoadedAsset

	// Modules maps logical module ids to loaded workflow modules. The root module id is "".
	Modules map[string]*LoadedModule

	// ImportEdges records resolved parent -> child import relationships.
	ImportEdges []LoadedImportEdge
}

type LoadedImportEdge struct {
	ParentID     string
	ImportID     string
	DeclaredPath string
	ChildID      string
}

type LoadedModule struct {
	ID           string
	Workflow     *Workflow
	WorkflowPath string
	ComposeFiles map[string][]byte
	Assets       map[string]LoadedAsset

	// RawDoc is the raw top-level YAML mapping for this module's workflow file, from the
	// pre-typed-unmarshal decode stage. nil if the document's top level wasn't a mapping.
	// A future strict-key validator uses it to detect keys the typed unmarshal silently
	// discarded; nil means "no strict check available" for this module.
	RawDoc map[string]any
}

type Loop struct {
	Until    *Expr    `json:"until,omitempty"`
	MaxIters *int     `json:"max_iters,omitempty"`
	Body     NodeList `json:"body"`
}

type Map struct {
	ID string `json:"id,omitempty"`
	// Over carries the `{{ }}` expression arm of the two-arm `over:` union (F51): a JSON
	// string on the wire. Empty when the literal-sequence arm (OverItems) is populated
	// instead — exactly one of Over/OverItems is live on a decoded Map, never both. The
	// shape-dispatch lives in Map.UnmarshalJSON/MarshalJSON (node_unmarshal.go /
	// node_marshal.go); engine/map.go picks the arm to iterate.
	Over Expr `json:"over"`
	// OverItems carries the literal-sequence arm of `over:` (F51): a plain JSON array
	// instead of a `{{ }}` expression (e.g. an inline matrix `over: [a, b, c]`). Each item
	// is a scalar or flat object/array with NO `{{ }}` templates — the literal arm is
	// fully static, no engine-scope substitution. json:"-" because it is folded manually
	// into the wire "over" key (never a separate "over_items" key) by Map's custom
	// MarshalJSON; that also keeps TestEveryExportedFieldHasNonEmptyJSONTag happy the same
	// way Parallel.Children and Skip.Reason already do.
	OverItems []any    `json:"-"`
	As        string   `json:"as"`
	Container string   `json:"container"`
	Image     Template `json:"image,omitempty"`
	// Concurrency is presence-tracked (F45): nil means `concurrency:` was omitted from the
	// source, which the loader desugars to 1 (serial) BEFORE any digest/validate pass runs
	// (loader.Load) — so a workflow that omits concurrency: and one that writes
	// `concurrency: 1` produce byte-identical normalized IR (same digest). A non-nil pointer
	// to a value <= 0 is a validation error (AWF1012); engine/map.go additionally defends
	// against a stray nil/<=0 that slipped past the loader with its own capSize<1 backstop.
	Concurrency *int     `json:"concurrency,omitempty"`
	MinSuccess  *Ratio   `json:"min_success,omitempty"`
	Body        NodeList `json:"body"`
	Reduce      *Reduce  `json:"reduce,omitempty"`
	// Prune is the optional frontier clause (SP5, spec §3.2b). nil for a plain
	// result-blind map. Folds into the digest via omitempty.
	Prune *Prune `json:"prune,omitempty"`
}

type Node interface {
	// contains filtered or unexported methods
}

type NodeList []Node

type OutputFile struct {
	Name      string
	Path      string
	Format    string
	Schema    *JSONSchema
	SchemaRef string
}

type OutputFiles []OutputFile

type Parallel struct {
	// Children is carried by Parallel's custom (un)marshalers as the wrapper's array value
	// (`{"parallel":[<node>,...]}` per the standard §5.4). json:"-" documents that fact and
	// keeps the tag-reflection test happy.
	Children NodeList `json:"-"`
}

type Prune struct {
	// Score is the name of the NUMERIC field the body's last step declares in
	// its output_schema. The engine reads it from the committed item's typed
	// outputs (never parses text). Required (AWF1037 / AWF5008).
	Score string `json:"score"`
	// Keep is the "keep the top k scorers" policy. Wire form: keep: <k> (a
	// plain positive integer; F21 dropped the earlier top(<k>) wrapper — it
	// was the format's only function-call-shaped literal and top-k was
	// always the only mode, so the wrapper carried zero information).
	// Mutually exclusive with StopWhen (AWF1037).
	Keep *PruneKeep `json:"keep,omitempty"`
	// StopWhen is a bounded boolean expression over `best.score` (the running
	// best). Once true, all still-running/queued items are pruned. Mutually
	// exclusive with Keep (AWF1037). Evaluated via template.EvalBoolString.
	StopWhen string `json:"stop_when,omitempty"`
}

type PruneKeep struct {
	K int
}

type Ratio = json.Number

type RawConfig map[string]any

type React struct {
	ID           string      `json:"id,omitempty"`
	With         RawConfig   `json:"with,omitempty"`
	Prompt       string      `json:"prompt"`
	Tools        []string    `json:"tools"`
	MaxTurns     int         `json:"max_turns,omitempty"`
	OutputSchema *JSONSchema `json:"output_schema,omitempty"`
}

type Reduce struct {
	Quorum       *Ratio      `json:"quorum,omitempty"`
	Field        string      `json:"field,omitempty"`
	Run          string      `json:"run,omitempty"`
	Container    string      `json:"container,omitempty"`
	OutputSchema *JSONSchema `json:"output_schema,omitempty"`
	OutputFiles  OutputFiles `json:"output_files,omitempty"`
}

type Resources struct {
	CPU string `json:"cpu,omitempty"`
	Mem string `json:"mem,omitempty"`
}

type RetryPolicy struct {
	Attempts              int       `json:"attempts,omitempty"`
	Backoff               string    `json:"backoff,omitempty"`
	Initial               *Duration `json:"initial,omitempty"`
	Max                   *Duration `json:"max,omitempty"`
	NonRetryableExitCodes []int     `json:"non_retryable_exit_codes,omitempty"`
	// Recovery selects how a retry re-runs the step after a transient fault:
	// "continue" resumes the adapter's persistent session, "restart" re-launches
	// fresh. Unset (the omitempty zero value) means "let the engine resolve a
	// per-adapter default" — see engine.effectiveRecovery. omitempty is
	// load-bearing: an unset recovery must marshal to the exact bytes it did
	// before this field existed so ComputeDigest stays byte-identical.
	Recovery string `json:"recovery,omitempty"`
}

type Severity int

type SignalStep struct {
	ID    string `json:"id"`
	Await string `json:"await"`
	// Where is an optional bounded-boolean clause selecting WHICH buffered signal
	// of name Await to consume (F18). It is ONE `{{ }}` envelope parsed once as a
	// bounded expression — the SAME grammar/evaluator if:/until: use, never
	// string-substituted. `signal.<field>` resolves against the delivered
	// signal's JSON payload (e.g. signal.candidate_id); every other root
	// (input.*, step.*, run.*, <as>.*, …) resolves against the surrounding engine
	// scope, exactly like any other {{ }} field. Empty → earliest-first per name
	// (unchanged). Folds into the digest (omitempty keeps where-less workflows
	// byte-identical). No arithmetic/calls/loops (spec §3.5 / §8 C5).
	Where        string      `json:"where,omitempty"`
	Timeout      *Duration   `json:"timeout,omitempty"`
	OutputSchema *JSONSchema `json:"output_schema,omitempty"`
}

type SkillCorpus struct {
	From   string `json:"from"`
	Layout string `json:"layout"`
	Router string `json:"router"`
}

type Skip struct {
	// Reason is carried by Skip's custom (un)marshalers as the wrapper's string value
	// (`{"skip":"<reason>"}` per the standard §5.6). json:"-" documents that fact and
	// keeps the tag-reflection test happy.
	Reason string `json:"-"`
}

type StepSkillRouting struct {
	From  string   `json:"from"`
	Query Template `json:"query"`
	Limit int      `json:"limit"`
	Into  string   `json:"into"`
}

type Template string

type TemplateValue = json.RawMessage

type Timeout struct {
	Wall *Duration
	Idle *Duration
}

type Tool struct {
	Description string      `json:"description"`
	InputSchema *JSONSchema `json:"input_schema,omitempty"`
	Impl        ToolImpl    `json:"impl"`
}

type ToolImpl struct {
	Run         string            `json:"run,omitempty"`
	Container   string            `json:"container,omitempty"`
	Timeout     *Duration         `json:"timeout,omitempty"`
	OutputFiles OutputFiles       `json:"output_files,omitempty"`
	InputFiles  map[string]string `json:"input_files,omitempty"`
	Retry       *RetryPolicy      `json:"retry,omitempty"`
}

type Try struct {
	Do      NodeList `json:"do"`
	Catch   NodeList `json:"catch,omitempty"`
	Finally NodeList `json:"finally,omitempty"`
}

type Workflow struct {
	ID              string                   `json:"workflow"`
	Version         int                      `json:"version"`
	InputSchema     *JSONSchema              `json:"input_schema,omitempty"`
	InputFiles      WorkflowInputFiles       `json:"input_files,omitempty"`
	Env             []string                 `json:"env,omitempty"`
	Assets          map[string]string        `json:"assets,omitempty"`
	Skills          map[string]SkillCorpus   `json:"skills,omitempty"`
	Imports         map[string]string        `json:"imports,omitempty"`
	Agents          map[string]AgentRole     `json:"agents,omitempty"`
	Containers      map[string]Container     `json:"containers"`
	OutputSchema    *JSONSchema              `json:"output_schema,omitempty"`
	Outputs         map[string]TemplateValue `json:"outputs,omitempty"`
	ArtifactExports ArtifactExports          `json:"output_files,omitempty"`
	// Tools is the top-level tools: map (P3 A4) — tool name → definition. Offered
	// to react: steps. Folds into the digest automatically (whole-workflow JCS).
	Tools  map[string]Tool `json:"tools,omitempty"`
	Graph  NodeList        `json:"graph"`
	Digest string          `json:"-"`
}

type WorkflowInputFiles map[string]ArtifactContract