Module substrate 

The execution substrate: agentplane, embedded.

This module is the only place speccoder touches agentplane. A Plane is a redb journal in speccoder’s state directory, the speccoder agent declared in Rust, and the model driver. Every run is journaled; every recorded run can be replayed strictly, without the model.

Modules

acceptance

speccoder.task.acceptance: derive acceptance tests from the spec before an attempt.

ask

The Ask plane: a journal of its own beside the project’s, holding one run per conversation. Only Ask’s skill, only reading tools.

attempt

speccoder.task.attempt: one bounded, governed attempt at a task .

converge

speccoder.feature.converge: assess a feature’s code against its spec, plan and tasks, read-only.

host

speccoder.skill.run: an installed Agent Skill, hosted.

model_config

[model] in speccoder.toml.

monitor

speccoder.task.monitor: a reasoning-blind gaming monitor.

near_miss

speccoder.task.near_miss: wrong and permitted variants of a task’s change, to test its acceptance tests.

propose

speccoder.task.propose: one governed model call that proposes how to do a task. The answer is recorded, never executed.

provenance

Where content came from.

run_config

[budget] and [commands] in speccoder.toml (policy).

shape

speccoder.shape: a person’s rough words made into a requirement (or a bug line, a quick change, a note) in the project’s spec format. One model call; the person’s words are data, never instructions. What the answer added, dropped and assumed is decided afterwards by code (speccoder_core::shape), never taken from the model.

Structs

AccountTurn

One model turn of an attempt, as the person is shown it afterwards: the model’s summary of its reasoning, its words beside its calls and how it ended — its account, a claim. Control characters escaped.

Always

A call answered Always Allow inline.

Hooks

What a live run hands its skills besides the model: someone to ask and somewhere to report progress. Neither is journaled; replay gets neither.

Inline

What Plane::decide_inline leaves.

Plane

An open plane.

PlaneError

A failure to open or use the plane.

RecordedCall

One recorded call.

RecordedCalls

Calls the journal records, and what of it could not be read.

Constants

AGENTPLANE_VERSION

The agentplane release speccoder is built against (the exact pin in the workspace Cargo.toml), named in every verification summary.

JOURNAL

The journal file inside a project’s state directory.

PRE_054_DECISION

What a run that failed on a decision speccoder 0.2.0 recorded is told.

Functions

account

The model’s account of run, turn by turn: every turn that reasoned, said something or ended the attempt, in order.

admitted

The input run was admitted with, with its root and field labels — from the journal’s RunAdmitted record, never from anything a tool returned.

answered

How the model ended its attempt, in its words: the final answer’s summary (its text when the answer has no structure), or why it stopped (report_blocked). None for a turn that did neither.

exhausted

A plane budget that stopped an attempt, in words, with the setting that raises it.

manifest

The speccoder agent, declared in code (Manifest::builder runs the same validation as a parsed manifest).

manifest_with

manifest with grants for the run’s MCP tools: mutating (speccoder cannot know otherwise), every argument field the model’s.

open_reader

Opens the journal to read beside its writer, in this process or another: None when there is none (a read never creates one). Never registered, moved aside or written — any write through it is refused.

provider_refusal

What a model provider refused, from a run’s failure: the text after agentplane’s “refused the request:” — a refusal, which no retry changes.

refused_account

The first run in the journal at dir that ended on a provider refusing the account — an exhausted quota or credit, billing, a missing or invalid key, a permission the key lacks — rather than one request: every later call would be refused too. Read from the records (the effect the run failed on and the provider’s code), read-only; a refusal without a code is not taken for one. None with no journal.

replay_strict

Strictly re-derives a recorded run and says whether this build reproduces it: history is consumed, nothing is dispatched. The model driver is agentplane’s replay-only provider, which reads the request profile back from the history and refuses every call, so no credential is needed. A faithful replay of a run that failed is Finding::Verified too — the recorded ending is what is verified. Ok(None) when the run is not in the journal.

said

What the model said in a turn beside its answer — a claim, never evidence: its commentary, where the provider marks it apart (OpenAI Responses), then its text when the turn called tools (a turn without calls answers with its text). None when it said nothing.

spent

What run’s model turns used, summed from the journal: the usage of an attempt the plane stopped before it could report its own. None when no turn completed.

why_not

Why a run did not succeed, for a person: a failure in its own words, without agentplane’s effect key and attempt count ('openai/gpt-5.4-mini' returned an unusable answer: …), cut at 300 characters; else the status (suspended, exhausted, …).