Enum CommandData 

pub enum CommandData {
    Inspect(Box<ProjectSnapshot>),
    Verify(Box<VerifyReport>),
    Worktree(WorktreeReport),
    Propose(Box<ProposeReport>),
    Replay(ReplayReport),
    Run(Box<RunReport>),
    Eval(Box<EvalReport>),
    Feature(Box<FeatureReport>),
    Converge(Box<ConvergeReport>),
    Report(Box<StatusReport>),
    Approvals(Box<ApprovalsReport>),
    Control(Box<ControlReport>),
    Cost(Box<CostReport>),
    Pr(Box<PrReport>),
    Bench(Box<BenchReport>),
    Init(Box<InitReport>),
    Skills(Box<SkillsReport>),
    Skill(Box<SkillRunReport>),
    Checklists(Vec<ChecklistStatus>),
    Archive(Box<ArchiveReport>),
    InPlace(Box<InPlaceReport>),
    Attest(Box<AttestReport>),
    Explain(Box<ExplainReport>),
    Schema(Box<SchemaReport>),
    Doctor(Box<DoctorReport>),
    Features(Box<FeaturesReport>),
    Ui(Box<UiReport>),
    Config(Box<ConfigReport>),
    Issues(Box<IssuesReport>),
    Inbox(Box<InboxReport>),
    Shape(Box<ShapeReport>),
    Review(Box<ReviewReport>),
    Auth(Box<AuthReport>),
    BranchVerify(Box<BranchReport>),
    EvidenceTour(Box<EvidenceTour>),
    Actions(Box<ActionsReport>),
    Bug(Box<BugReport>),
    PolicyCoverage(Box<PolicyCoverage>),
    Comments(Box<CommentsView>),
    Preset(Box<PresetReport>),
    NewProject(Box<NewProjectReport>),
    Sample(Box<SampleReport>),
    Similar(Box<SimilarReport>),
    RungSuggestion(Box<RungSuggestion>),
    PlanningChain(Box<PlanningChainReport>),
}

Command-specific payload of a result.

Variants

Inspect(Box<ProjectSnapshot>)

inspect: the project snapshot.

Verify(Box<VerifyReport>)

verify: the check results.

Worktree(WorktreeReport)

worktree: where speccoder works, or why it won’t.

Propose(Box<ProposeReport>)

propose: what the model proposes for one task (never executed).

Replay(ReplayReport)

replay: whether a recorded run reproduces.

Run(Box<RunReport>)

run: one attempt and its verdict.

Eval(Box<EvalReport>)

eval: a suite of judged attempts.

Feature(Box<FeatureReport>)

run without --task: a feature worked through.

Converge(Box<ConvergeReport>)

converge: a feature assessed against its artifacts.

Report(Box<StatusReport>)

report: a feature’s tasks and their evidence.

Approvals(Box<ApprovalsReport>)

approvals / approve / reject: calls awaiting a person.

Control(Box<ControlReport>)

accept / skip / nudge: a person’s control over one task.

Cost(Box<CostReport>)

cost: tokens (and money, if priced) per task.

Pr(Box<PrReport>)

speccoder pr.

Bench(Box<BenchReport>)

speccoder bench import.

Init(Box<InitReport>)

init: the configuration written.

Skills(Box<SkillsReport>)

skill without a name: the installed skills.

Skill(Box<SkillRunReport>)

skill <name>: a hosted skill’s run.

Checklists(Vec<ChecklistStatus>)

run stopped by unfinished checklists.

Archive(Box<ArchiveReport>)

spec archive: an OpenSpec change merged into the main specs.

InPlace(Box<InPlaceReport>)

An in-place run refused or stopped (DIRTY-CHECKOUT, INTENT-CHANGED, …).

Attest(Box<AttestReport>)

attest verify / attest sign: what each task’s attestation says.

Explain(Box<ExplainReport>)

explain: catalog entries.

Schema(Box<SchemaReport>)

schema: the published schemas, or one of them.

Doctor(Box<DoctorReport>)

doctor: every check of the machine and the project.

Features(Box<FeaturesReport>)

feature: the project’s features and which one is current.

Ui(Box<UiReport>)

ui: where the web interface is served.

Config(Box<ConfigReport>)

config: every key of speccoder.toml, its value and its default.

Issues(Box<IssuesReport>)

issue: the repository’s open issues.

Inbox(Box<InboxReport>)

inbox: what waits for a person’s decision, across features.

Shape(Box<ShapeReport>)

shape: a person’s words made into a requirement, and what changed.

Review(Box<ReviewReport>)

review: the feature’s requirements and the person’s review of each.

Auth(Box<AuthReport>)

auth: who speccoder is on a GitHub host.

BranchVerify(Box<BranchReport>)

attest verify --branch / attest badge: every tick of a branch and what its evidence comes to.

EvidenceTour(Box<EvidenceTour>)

attest tour / /api/tour: one task’s evidence tour.

Actions(Box<ActionsReport>)

actions: what can be done now.

Bug(Box<BugReport>)

bug: a bug, its reproductions and how far it got.

PolicyCoverage(Box<PolicyCoverage>)

config coverage: what a prefix entry would newly allow.

Comments(Box<CommentsView>)

review comments: the comment tray and the last revision turn.

Preset(Box<PresetReport>)

preset add: the speccoder Spec Kit preset, installed or offered.

NewProject(Box<NewProjectReport>)

new: a new project’s plan, its steps and its commit.

Sample(Box<SampleReport>)

sample: the bundled sample, copied and replayed.

Similar(Box<SimilarReport>)

feature similar: requirements close to a description.

RungSuggestion(Box<RungSuggestion>)

suggest: the rung a description suggests.

PlanningChain(Box<PlanningChainReport>)

spec <skill> --through: plan through, and where it stopped.

Implementations

impl CommandData

pub const fn kind(&self) -> &'static str

The payload’s schema name (run, feature, in-place, …): the envelope’s payload.

Trait Implementations

impl Clone for CommandData

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CommandData

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl JsonSchema for CommandData

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for CommandData

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for CommandData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CommandData