YAML Schema Reference

# Universal; accept any model the caller passes.
allowedTargets: { strategy: universal }

# Constrained; only listed providers/models accepted.
allowedTargets:
  strategy: constrained
  providers: [openai, anthropic]
  models: [gpt-4o, claude-sonnet-4-20250514]

knobs:
  branches:                                # knob id (map key)
    name: Branches                         # display name
    type: nodes                            # semantic category
    input: slider                          # UI input kind
    steps:                                 # slider input: discrete ticks
      - { title: Low,  value: 3, default: true }
      - { title: Mid,  value: 5 }
      - { title: High, value: 7 }
  rounds:                                  # another knob
    name: Rounds
    type: loops
    input: numerical                       # numerical input: continuous range
    default: 2
    min: 1
    max: 4

steps:
  - id: draft                              # required, unique
    name: Draft                             # required
    type: normal                            # required: normal | sequential | group
    nodes: 5                                # optional: number | "template" | { from: ... }
    fields:                                 # optional but usually present
      - { name: Context, type: text, from: "input.context" }
    systemPrompt: "..."                     # optional
    timeline: circle                        # optional: circle | init
    recursion: { maxDepth: 3 }              # optional
    checkpoint: { ... }                     # optional (advanced)
    if: { ... }                             # optional: gate (see Control Flow)
    slateWrite: { ... }                     # optional: schema-matched write (see Writes)
    retrieve: { ... }                       # optional: bounded fetch (see Retrieve)
    dynamic: false                          # optional: load config at runtime
    from: previous                          # optional: used when dynamic: true
    onInvalid: continue                     # optional: fallback when dynamic load fails

  # Group step; parallel siblings.
  - id: parallel_review
    name: Parallel Review
    type: group
    steps:
      - { id: security, type: normal, ... }
      - { id: style,    type: normal, ... }

fields:
  # Text; reads input or a literal.
  - { name: Context, type: text, from: "input.context" }

  # Ingest; single step's matching node (parallel alignment).
  - name: Draft
    type: ingest
    from: { stepId: draft, loopRef: current }
  - name: Earlier Draft
    type: ingest
    from: { stepId: final, loopRef: previous, nodeRef: current }

  # Multi-ingest; many node outputs joined into one string.
  - name: Evaluations
    type: multi_ingest
    from:
      - { stepId: evaluate, loopRef: current, nodeRef: accumulate }

  # Node info; runtime injects the current node number.
  - { name: Branch Number, type: nodeInfo }

  # Knob info; runtime injects the knob's current value.
  - { name: Total Branches, type: knobInfo, from: branches }

  # Slate read; file contents, metatag, or system metatag (index/tree).
  - name: Core
    type: slateRead
    from: { slate: "Project Memory", folder: facts, file: core.md }
  - name: Tags
    type: slateRead
    from: { slate: "Project Memory", folder: facts, metatag: tags }
  - name: Tree
    type: slateRead
    from: { slate: "Project Memory", folder: facts, metatag: tree, depth: 2 }

  # Manifest; runtime injects the full available-source snapshot (for dynamic steps).
  - { name: Available, type: manifest }

# Shorthand; exact string equality, then continue, else abort.
if: "1"

# Full form; condition + then/else actions.
if:
  <conditionKey>: <value>
  then: <action>      # default: continue
  else: <action>      # default: abort

slateWrite:
  to: { slate: "Memory", folder: facts, file: core.md }
  field: fact                              # optional: extract one field from validated JSON
  on: append                               # optional: append | overwrite | mergeByKey (default: append)
  key: id                                  # required for mergeByKey: field name INSIDE JSON objects
  atomic: true                             # optional: array writes are all-or-nothing
  match:                                   # required: JSON Schema for validation
    type: object
    required: [fact, confidence]
    properties:
      fact: { type: string, minLength: 1 }
      confidence: { type: number, minimum: 0, maximum: 1 }
    additionalProperties: false

if:
  equals: "RECORD"
  then:
    write:
      to: { slate: "Memory", folder: facts, file: core.md }
      from: previous                       # write all survivors of preceding step
      on: append                           # default
  else: continue