zig-core 0.8.0

Core library for zig — workflow orchestration engine for AI coding agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

# Conditions

Condition expressions control whether a step runs based on the current
variable state. They are specified via the `condition` field on a step.

## Syntax

Conditions are simple expressions evaluated against workflow variables.

### Comparison Operators

| Operator | Description          | Example                    |
|----------|----------------------|----------------------------|
| `==`     | Equal                | `status == "done"`         |
| `!=`     | Not equal            | `status != "pending"`      |
| `<`      | Less than            | `score < 8`                |
| `>`      | Greater than         | `score > threshold`        |
| `<=`     | Less than or equal   | `retries <= max_retries`   |
| `>=`     | Greater than or equal| `score >= 8`               |

### Truthy Checks

A bare variable name evaluates as a truthy check:

```toml
condition = "approved"
```

A value is **truthy** if it is non-empty, not `"false"`, and not `"0"`.

A value is **falsy** if it is empty, `"false"`, or `"0"`.

## Operand Resolution

Operands in condition expressions are resolved in this order:

1. **String literals** — quoted values (`"done"`, `'pending'`) are used as-is
2. **Variable lookup** — unquoted identifiers are looked up in the variable map
3. **Numeric literals** — if no variable matches, the token is used as-is

## Comparison Behavior

When both operands can be parsed as numbers, numeric comparison is used.
Otherwise, lexicographic (string) comparison is used.

```toml
# Numeric comparison: 5 < 8 → true
condition = "score < 8"

# String comparison: "alpha" == "alpha" → true
condition = "status == \"done\""

# Variable-to-variable: compares their current values
condition = "retries < max_retries"
```

## Examples

### Skip a step when quality is high enough

```toml
[[step]]
name = "refine"
prompt = "Improve the output"
condition = "score < threshold"
```

### Run only when a specific status is set

```toml
[[step]]
name = "deploy"
prompt = "Deploy to production"
condition = "status == \"approved\""
```

### Gate on a boolean flag

```toml
[[step]]
name = "notify"
prompt = "Send notification"
condition = "notifications_enabled"
```

### Compare two variables

```toml
[[step]]
name = "retry-step"
prompt = "Try again"
condition = "attempts < max_attempts"
```

## Using Conditions for Routing

Conditions enable dispatcher patterns where different steps handle different
cases:

```toml
[[step]]
name = "simple-handler"
depends_on = ["classify"]
condition = "complexity == \"simple\""

[[step]]
name = "complex-handler"
depends_on = ["classify"]
condition = "complexity == \"complex\""
```

## See Also

- `zig docs variables` — variable declarations and data flow
- `zig docs patterns` — orchestration patterns using conditions
- `zig docs zwf` — full `.zwf` format reference