---
slug: not-a-workflow-yet
title: "Not a workflow yet"
tag: Engine
date: 2026-08-26
published: 2026-11-17
receipts:
  - https://github.com/supernovae-st/nika/commit/008eaa4067794e084d13aca874b0c57c01ae3a74
  - https://github.com/supernovae-st/nika/commit/7f3f7bf4d83b8efadaec3ba7a9d8f8d27530eff8
  - https://github.com/supernovae-st/nika/commit/8f13963e0913b2cf2551938ce7c950170fd71f55
  - https://github.com/supernovae-st/nika-spec/commit/85f796e58edf89d880a38fef02cdd51965c5890a
  - https://github.com/supernovae-st/nika-spec/commit/4565b9d118f8c6cc9e8e976b74d07897b5963e7c
description: "Nika v0.115.0 moved mistakes that passed nika check and then failed the run into the check itself: numbers where text belongs, reasoning budgets, blanks."
---

A green check is read as a promise: the file is a workflow, and when it runs it will not fail for a reason the checker could have seen. A check that passes a file the run then refuses breaks that promise twice. The run fails, and the next green check is trusted a little less.

Nika v0.115.0, released on 26 August 2026, closed a set of those false greens. One of the commits behind it is titled "the false-greens arc", and the name fits the whole set. The cases share a shape. A file passed `nika check`, then failed during the run, or ran and produced something useless. After the release, `nika check` catches each one before anything runs.

## A number where the language wants text

Nika workflows are written in YAML, and YAML guesses types. Write `prompt: 123` and YAML reads a number, not the text "123". The 0.115.0 notes describe what happened next: "`prompt: 123` rode through the parser because a plain scalar's source text restringifies silently". The field audited clean on a value whose type nobody had checked.

Since 0.115.0, every text field of a verb refuses a bare number or boolean and teaches the quoted form, `"123"`. The list in the notes includes the prompt, system text and model of `infer:` and `agent:` tasks, the shell line, working directory, standard input, command elements and environment values of `exec:`, an agent's tool and skill entries, and the tool or workflow name of `invoke:`. Two details keep the guard from biting where it should not: "The YAML 1.1 aliases `yes`/`no` stay strings", and `${{ }}` templates are untouched.

The release also added a test that walks every verb field against a checked-in table of field types. In the notes' words, "a new verb field without a refusing fixture fails the suite."

## A reasoning budget the provider would refuse

Some models can spend part of their output on reasoning before they answer. A workflow asks for that with a `thinking:` block and a `budget_tokens` number. Before 0.115.0 the parser checked each field's type and stopped there. Two mistakes got through:

- A `budget_tokens` at or above `max_tokens` audited green, then the provider refused the call. The notes give the reason: "the reasoning share lives inside the cap".
- `thinking: { enabled: true }` on a model the catalog knows cannot reason was "a dead declaration the wire dropped or 400'd".

Both are now refused at check.

The project's own teaching examples carried this mistake. In the spec repository, four example files declared a `thinking:` block under the same comment. It called the block "A reasoning budget, honoured by seats that support extended thinking and ignored by the ones that do not", and added that "declaring it never fails a run." Two of them did so on local models the catalog knows cannot reason. In the other two, the commit message says, the budgets "were self-defeating on ANY seat (4000 ≥ caps of 1200 and 2000)". Two commits on 26 August, the day of the release, corrected both pairs. Each file now explains the rule where the block used to be. This is the `postmortem` task of the incident-war-room example as it reads today:

```text incident-war-room.nika
  postmortem:
    with:
      events: ${{ tasks.timeline.output }}
    after:
      confirmed: success             # state, no data · recovery proven or no draft
    infer:
      # a reasoning model needs 16384 here, or a documented run.reasoning.effort: low
      max_tokens: 2000
      prompt: |
        Timeline · ${{ with.events }}
        Write the postmortem draft · summary · impact · root-cause
        hypotheses · 3 follow-up actions with owners left blank.
      # No `thinking:` block on purpose: the seat law REFUSES a thinking
      # declaration on a model the catalog knows cannot reason (a dead
      # declaration — the wire drops the budget), and a budget ≥ the cap
      # is refused on ANY seat (the reasoning share lives inside
      # `max_tokens`). Seat `postmortem` on a reasoning-capable model via
      # its own `model:` and keep the budget under the cap — THAT is what
      # licenses `thinking: { enabled: true, budget_tokens: … }`.
```

The rule is careful about what it knows. The model check fires "only when the catalog positively knows the exact model", so "a newly shipped model the dated snapshot has not met keeps its benefit of the doubt". A `model:` written as a template is judged through its declared default, or left to the run.

## Blanks the parser could not see

A new workflow can start from a skeleton: a starting file with blanks for the parts only the author can write. Before 0.115.0, the chain skeleton marked its blanks as YAML comments. A YAML parser drops comments by design, so `nika check` mentioned none of them, and the run exited 0. The output file then held the skeleton's own prompt, echoed back by the rehearsal model. The notes call it "a file that outlives the terminal line explaining it".

The fix moved the marker into the value, where the parser can see it: `<SLOT: what should the model do with the gathered text?>`. In 0.115.0, seven shipped skeletons carry one. The check names each unfilled slot with its line and ends on one command to paste. The refusal is worded as a step, not a fault:

> `not a workflow yet — 1 slot to fill, then it audits`

The notes explain the choice: the person who just created the file did nothing wrong. Fill the slot and the same file audits clean and runs. That second half is pinned by a test too, "so the refusal can never widen into a wall."

## A model task with no model

`nika check` reports in rungs, one question per rung. The MODELS rung judges whether this build can resolve every model a workflow names. It answered for a model it could not resolve, and said nothing at all when a task had no model declared. The notes explain why: "an empty requirement list is the same shape as a workflow with no inference tasks." Since 0.115.0 the rung names the `infer:` or `agent:` task that no `model:` reaches. The author reads it before the run, instead of meeting it as a provider error.

## A repair that broke the file

`nika check --fix` applies the repairs the checker knows how to make. On one reported seven-line file, it announced a repair and left a file that no longer parsed: the indentation of a `description: |` block came out wrong. The engine already rolled back a broken write in general; 0.115.0 made this case part of that judgment. The notes: "A repair that cannot re-parse still refuses; the file on disk stays YAML."

## Why "refused before" is the right place

Each of these failures costs more the later it appears. A wrong type found at check costs a moment of editing. Found at the provider, it costs a call, perhaps a paid one, and an error message written by someone else's API. Found in an output file, it costs whoever reads that file next and believes it.

There is a simpler reason too. A check exists so you can stop thinking about the mistakes it covers. Every false green in that class sends you back to checking by hand, and a checker people double-check is doing half its job.

## What this does not do

- A clean check does not prove that a model's output is right. It says the file is a workflow the engine can run, under the rules it knows.
- The reasoning-model rule depends on the catalog. A model the dated catalog does not know exactly keeps the benefit of the doubt, and a templated `model:` with no declared default is left to the run.
- The text-field guard judges literal values. `${{ }}` templates are left alone.
- The slot refusal works for skeletons that carry the new marker. A blank you leave in a file of your own, with no marker, is not something it can see.
- The command that made that skeleton, `nika new chain`, was retired in v0.120.0, when `nika compile` became the one authoring command.

Read the [v0.115.0 release](https://github.com/supernovae-st/nika/releases/tag/v0.115.0), or continue with [A recovered run is not a green tick](/blog/a-recovered-run-is-not-a-green-tick).
