Agent lifecycle typed against a sum type — typos become compile errors

soma.toml

[package]
name = "agents-corpus"
version = "0.1.0"
description = "Verified AI-agent example cells (training corpus)"

# Agent LLM config. `mock = "echo"` keeps every example in this directory
# hermetic: `soma test` / `soma run` need no network and no API key, and
# results are deterministic. For a live run, delete the `mock` line (or
# override with SOMA_LLM_MOCK) and provide the key via env.
[agent]
provider = "anthropic"
model    = "claude-opus-4-6"
key      = "${ANTHROPIC_API_KEY}"
mock     = "echo"

# Termination proof for verified_termination.cell's `workflow` machine:
# every path eventually reaches a terminal, no deadlocks.
# `cells` scopes these properties to Solver — the other agents in this
# directory have their own state names and must not inherit them.
[verify]
cells = ["Solver"]
deadlock_free = true
eventually    = ["done", "failed"]

[verify.after.understanding]
eventually = ["solving", "failed"]

[verify.after.solving]
eventually = ["verifying", "failed"]

[verify.after.verifying]
eventually = ["done", "failed"]

typed_lifecycle.cell

// Agent lifecycle typed against a sum type — typos become compile errors.
// Demonstrates: `cell type` variants typing a `state X: T { }` machine,
// transition() taking a VARIANT not a string, get_status() returning the
// variant name as a string, and an exhaustive match over the status.
//
// Run:  SOMA_LLM_MOCK=echo soma run typed_lifecycle.cell --signal handle "refund"
// Test: SOMA_LLM_MOCK=echo soma test typed_lifecycle.cell

cell type TaskStatus {
    variants { Queued  Working  Reviewed  Shipped  Aborted }
}

cell agent Worker {
    face {
        signal handle(kind: String) -> Map
        signal label(s: String) -> String
    }

    state task: TaskStatus {
        initial: Queued
        Queued   -> Working
        Working  -> Reviewed
        Reviewed -> Shipped
        *        -> Aborted
    }

    // Exhaustive match over the sum type — drop an arm and check fails.
    on label(s: String) {
        match s {
            "Queued"   -> "waiting in queue"
            "Working"  -> "in progress"
            "Reviewed" -> "passed review"
            "Shipped"  -> "delivered"
            "Aborted"  -> "cancelled"
            _          -> "unknown"
        }
    }

    on handle(kind: String) {
        set_budget(1000)
        let id = to_string(next_id())
        transition(id, Working)
        transition(id, Reviewed)
        transition(id, Shipped)
        map("kind", kind, "state", get_status(id), "label", label(get_status(id)))
    }
}

cell test WorkerTests {
    rules {
        assert label("Working") == "in progress"
        assert label("Shipped") == "delivered"
        assert handle("refund").state == "Shipped"
        assert handle("refund").label == "delivered"
    }
}