Crate speccoder_core 

Pure domain types of speccoder.

This crate has no IO and no async: its state machines, task graph and verdict rules stay property-testable without a runtime. The layering test in the speccoder crate keeps its dependency closure free of IO and async crates.

Modules

acceptance

Acceptance tests decided before the run: one record for every producer — a review that froze the oracle and a bug’s confirmed reproduction. The fix’s checkpoint reuses the record instead of calling the acceptance author; a change of the wording it was decided on lapses it.

actions

What a person can do now: one list, computed by the runtime and rendered by every interface — the dashboard’s n, c and : today, a desktop app or another workbench later. Every action is a CLI command too, so nothing an interface offers is out of reach of a script.

bug

Bug fixes, the L2 rung: a person’s triad — what happens (Current), what should (Expected), what must stay as it is (Unchanged) — one reproduction per Expected statement that fails on the untouched code by an assertion, shown to the person once and then frozen, and a fix judged like any task plus three bug rules: every reproduction goes from red to green, the pass-to-pass set stays green, and undoing the fix (the revert) is rejected by at least one reproduction.

codes

Stable codes for every result that is not plainly ok: what went wrong, why it matters, how to fix it and where it is documented. A script branches on the code, a person reads the fix.

context

What reached a model call (constitution VIII): one manifest of every part handed to it — its kind, where it came from, its digest and size — journaled with the call and named in the evidence. Producers add entries through the runtime’s one builder; nothing hashes or labels context itself.

event

The names of --events lines: one closed list. A line whose type is not here is never emitted; a new name is lowercase noun.verb. Domain events (a record backs them) publish a projection schema; progress events are stream-only.

evidence

A task’s evidence, as rows every interface renders.

graph

Task dependencies from what tasks.md documents, and which tasks are ready.

inbox

The kinds of Needs You items: one registry, each kind with its group and urgency rank. A feature adds a kind here, never a free string; the runtime’s list is derived from it.

ladder

The ladder: where a unit of work came from. One provenance record per subject, written once. This build knows the variants a bug writes; later rungs add theirs as variants.

next

What to do next after a stop or a finish: a closed set of outcomes and, for each, the commands that continue — deterministic, never model text. The human Next: block, the TUI footer and data.next are all this list.

oracle

The oracle at review: per requirement, the visible acceptance tests the run would use — written on the person’s request, red-checked on the current tree, shaped by the person and frozen with the approval — and the review comments anchored to what the person reads. These are the shapes every interface shows; none of them has a field that could hold a held-out test’s path or content.

predicate

The task-verification predicate (https://speccoder.dev/task-verification/v0) as one typed body: what speccoder signs about a ticked task, and what a verifier reads back. Published as an open specification, its schema generated from this type.

retry

Retries: the verifier’s failure digest for the next attempt, and the fingerprint that stops retries which cannot help.

scope

Task scope as a reported finding: which changed paths a task’s line did not name. Never a gate — a task line is prose, and a list of paths in it is a hint, not a contract.

snapshot

What speccoder sees in a Spec Kit project: the read-only snapshot that inspect reports and every later subsystem consumes.

spec

The format-neutral view of spec-driven work: which format a project is written in, and the requirements and acceptance scenarios a unit of work states. Spec Kit, OpenSpec and Kiro adapters produce it; the judge reads only it.

stage

The fixed stages of one task’s pipeline: one vocabulary for the plain progress lines, the TUI, ACP updates and status.

strength

Acceptance strength: how well a task’s acceptance set tells right from wrong.

tour

The evidence tour: one task’s evidence as six steps in a fixed order — requirement, frozen tests, red, diff, green, strength — each saying where it comes from. The payload evidence_tour, and its Markdown (the check run, the pull-request body); the app renders the same JSON.

verify

The judge’s vocabulary: check results, baseline comparison, and verdicts .

verify_branch

A branch’s ticks and what their evidence comes to: the payload of speccoder-verify check and speccoder attest verify --branch (branch_verify), the rule that turns per-tick outcomes into the branch’s conclusion, and the badge.

words

Lists in a sentence.

workflow

GitHub Actions workflow commands (::error file=…,line=…::…): their escaping and the limits a step has, shared by speccoder’s report annotations and speccoder-verify’s fallback when it cannot publish its check.

Structs

ActionsReport

Result of speccoder actions: what a person can do now in the project — the list every interface renders — and where the feature is on its journey.

ApprovalView

A pending call as a person sees it: what, why, what it can reach, what the model claimed, and what approving it grants.

ApprovalsReport

Result of speccoder report --approvals, approve and reject.

ArchiveReport

Result of speccoder spec archive (an OpenSpec change).

AttestReport

Result of speccoder attest verify and attest sign.

AuthReport

Result of speccoder auth: who speccoder acts as on a GitHub host, and where its token comes from. The token itself is never shown.

BatchGroup

One class of a batch.

BatchView

A run whose asking budget is used, with its waiting calls by class.

BenchReport

Result of speccoder bench import.

ChecklistStatus

One Spec Kit checklist (specs/<feature>/checklists/*.md).

CodeInfo

One code, as explain shows it.

CommandResult

The result of one command, rendered as human text or as one JSON object.

ConfigChange

A change to speccoder.toml: set a key, remove it, or append to a list.

ConfigKey

One key: what it is, what it is set to, and what it is otherwise.

ConfigReport

Result of speccoder config: the project’s configuration as a catalogue of every key, each with its type, default and value (when set).

ConfigSection

One section of speccoder.toml.

ConfigTable

One configured named table, e.g. [checks.test].

ControlReport

Result of accept, skip and nudge.

ConvergeReport

Result of speccoder converge.

ConvergenceRound

One convergence round, from its commit.

CostReport

Result of speccoder report --cost.

CoverageDecision

How calls of one argv were decided.

CoverageEntry

A prefix entry.

CoverageRow

One argv a prefix would newly allow.

DecidedCall

A person’s decision.

DoctorCheck

One doctor check.

DoctorReport

Result of speccoder doctor.

Drift

What changed since a tick: the tick’s commit holds the intent it was judged against; the checkout’s HEAD holds the intent now.

EarlierAttempt

A failed attempt that was undone and retried.

EvalCase

One judged case.

EvalReport

Result of speccoder eval.

EvalSummary

Suite counts and metrics.

ExitCode

Process exit status of a command.

ExplainReport

Result of speccoder explain.

FeatureEntry

One feature (or change) of the project, as speccoder feature lists it.

FeatureReport

Result of speccoder run without --task: a feature worked through.

FeaturesReport

Result of speccoder feature.

FullTier

The full check tier at the end of a feature.

HeldOutGap

Visible passes the held-out tests caught.

HeldOutOracle

Held-out passes the hidden oracle agreed with, or not.

InPlaceReport

Why an in-place run refused or stopped.

InboxItem

One decision waiting for a person.

InboxReport

Result of speccoder inbox: every decision that waits for a person, across the project’s features, the most urgent first — the person’s work once the agents write the code.

InitCheck

One detected check.

InitKey

The model key init looked for.

InitReport

Result of speccoder init.

InitRun

One check init ran on the untouched code.

InstructionFile

A repository instructions file given to an attempt.

IssueEntry

One open issue.

IssuesReport

Result of speccoder issue: the repository’s open GitHub issues, read through GitHub’s API as the person.

LastAttempt

An attempt that did not pass, as saved under refs/speccoder/attempts/.

MonitorScore

The gaming monitor against the oracle’s ground truth: a positive is a cheat or a false completion (both passed the visible checks).

ObjectVerification

One task object’s verification.

ObjectView

The object a person’s decision covers, as reports show it.

OpenQuestion

A question a document leaves open, to answer in place.

OperatorView

Who decided, and how speccoder knows the name.

PendingCall

A call that stopped an attempt for approval, or a question, waiting for a person.

PolicyCoverage

What a prefix entry of [commands] allow_prefix or [sandbox] network_allow_prefix would newly allow: every distinct argv the project’s journal recorded that it covers and the current policy does not allow. A prefix is saved only as the confirmation of this preview, and only when it is complete.

PrReport

Result of speccoder pr: a draft pull request with the evidence.

ProposeReport

Result of speccoder propose.

RefusedPath

A path that blocks worktree mode.

Remedy

The fix speccoder knows and can apply itself: what it does, the exact command it amounts to, how to take it back. An interface offers it as one action (never applies it unasked); a script reads the command.

ReplayReport

Result of speccoder replay.

RequirementDrift

One cited requirement, as the tick saw it and as the spec has it now.

ReviewChange

A requirement changed in the checkout since the last commit of the spec, with where its line is — a comment anchors to it (diff_line).

ReviewItem

One requirement and its review.

ReviewReport

Result of speccoder review: every requirement of the feature’s spec as a card, with the person’s decision on its exact wording.

ReviewTotals

Counts of ReviewItem::state.

RunReport

Result of speccoder run.

SchemaName

One published schema.

SchemaReport

Result of speccoder schema.

SetAside

Changes saved and set aside so a run could start from the branch tip.

SignerView

Who signed.

SkillEntry

One installed Agent Skill.

SkillRunReport

Result of speccoder spec <name>.

SkillsReport

Result of speccoder spec without a name.

SpecVersion

One commit of the spec and what it changed in its requirements.

StatusReport

Result of speccoder report: what the branch’s history shows.

StatusTotals

Counts of TaskStatus::state.

TaskCost

One task’s cost.

TaskStatus

One task and its evidence.

TraceRow

One row of the requirement → scenario → test → verdict matrix.

UiReport

Result of speccoder ui, printed once the host listens (under --json the only result: the host keeps serving after it).

Usage

Token counts, and USD when prices are configured.

VerifyReason

Why an object got its outcome.

WorktreeReport

Result of speccoder worktree.

Enums

CommandData

Command-specific payload of a result.

CommandStatus

Outcome class of a command.

DoctorLevel

How a doctor check came out.

VerifyOutcome

What attest verify found for one task object.

Constants

PAYLOADS

Every payload’s schema name, in CommandData’s order.

SCHEMA_VERSION

Version of the machine-readable command result. Fields may be added within a version; renaming or removing one, or changing its meaning, bumps it.