Enum Runnable 

pub enum Runnable {
    Skill {
        name: String,
        arguments: String,
    },
    Run {
        task: Option<String>,
        agent: Option<String>,
    },
    Converge,
    Commit {
        paths: Vec<String>,
    },
    Approve {
        task: String,
        call: String,
        digest: String,
    },
    Reject {
        task: String,
        call: String,
        digest: String,
    },
    Accept {
        task: String,
    },
    Skip {
        task: String,
    },
    Nudge {
        task: String,
    },
    Done {
        task: String,
    },
    Hint {
        task: String,
    },
    Rule {
        task: String,
    },
    Review {
        ids: Vec<String>,
        verdict: String,
    },
    IssueComment {
        issue: u64,
        assign: bool,
    },
    QuickChange {
        request: String,
        checks: Vec<String>,
        run: bool,
        asked: Option<String>,
    },
    KeepSetAside {
        task: String,
    },
    DropSetAside {
        task: String,
    },
    FixSetup,
    Feature,
    PullRequest,
    BugFix {
        symptom: String,
        expected: Vec<String>,
        unchanged: Vec<String>,
        issue: Option<u64>,
        tests: Vec<String>,
        candidate: Option<String>,
        slug: Option<String>,
        run: bool,
        asked: Option<String>,
    },
    BugConfirm {
        task: String,
        digest: String,
        reject: bool,
    },
    BugKeep {
        task: String,
    },
    BugRun {
        slug: Option<String>,
        task: Option<String>,
    },
    AllowAlways {
        task: String,
        call: String,
    },
    WidenPolicy {
        key: PolicyList,
        prefix: Vec<String>,
        digest: String,
    },
    DecideBatch {
        run: String,
        verdict: BatchVerdict,
        calls: Vec<String>,
        digest: String,
        resume_asking: bool,
    },
    OracleTests {
        req: String,
        op: OracleOp,
        path: Option<String>,
        scenario: Option<String>,
        reading: Option<Reading>,
    },
    ApproveAndRun {
        mode: RunMode,
        grants: Vec<String>,
        sheet: Option<String>,
    },
    Comment {
        op: CommentOp,
        anchor: Option<CommentAnchor>,
        id: Option<String>,
    },
    CommentsSend {
        ids: Vec<String>,
    },
    RevisionUndo {
        turn: Option<String>,
    },
    CodeNudge {
        task: String,
        comments: Vec<CodeComment>,
    },
    AcceptanceAt {
        feature: String,
        story: String,
        task: String,
        revoke: bool,
    },
    DeferAcceptance {
        task: String,
        revoke: bool,
    },
    PresetAdd {
        update: bool,
    },
    PlanThrough {
        from: PlanFrom,
        through: Through,
    },
    NewProject {
        target: String,
        choices: NewChoices,
        plan_digest: String,
    },
    UndoNewProject {
        commit: String,
    },
    CloneRepository {
        repo: String,
        target: String,
    },
    OpenSample {
        fresh: bool,
    },
    SampleChecks,
    DeclinePromotion {
        task: String,
    },
    Explore {
        idea: String,
        skill: Option<String>,
        resume: Option<String>,
    },
    ExploreChoose {
        session: String,
        approach: usize,
        constraints: Vec<String>,
        questions: Vec<String>,
        flag: bool,
    },
}

How an interface runs an action itself.

Variants

Skill

A planning skill (speccoder spec <name> <arguments>).

Fields

name: String

The skill.

arguments: String

Its arguments (the input, when one is asked for).

Run

speccoder run, the feature or one task.

Fields

task: Option<String>

One task, or the feature’s ready tasks.

agent: Option<String>

This run’s agent (--agent): an ACP preset or native; None is the configured executor.

Converge

speccoder run --converge: the ready tasks, then the assessment of the code against the spec as it is now, appending what remains.

Commit

Commit exactly these planning files.

Fields

paths: Vec<String>

Repository-relative paths.

Approve

Approve the task’s waiting call: the one that was shown, refused when another waits now.

Fields

task: String

The task.

call: String

The call’s id (crate::PendingCall::id).

digest: String

The digest of the call that was shown (crate::PendingCall::digest).

Reject

Reject it (the input is the reason), bound the same way.

Fields

task: String

The task.

call: String

The call’s id (crate::PendingCall::id).

digest: String

The digest of the call that was shown (crate::PendingCall::digest).

Accept

Tick the task on the person’s word (the input is the reason).

Fields

task: String

The task.

Skip

Skip the task (the input is the reason).

Fields

task: String

The task.

Nudge

Leave a note for the task’s next attempts (the input is the note).

Fields

task: String

The task.

Done

I did it: tick a step the person took on their word (attested; the input, when given, is the reason).

Fields

task: String

The task.

Hint

Hint & retry: a note for the task (the input), then a new attempt.

Fields

task: String

The task.

Rule

Rule that a held attempt’s tests are right (the input is the reason).

Fields

task: String

The task.

Review

Record the person’s review of requirements (the input is the comment; required to request changes).

Fields

ids: Vec<String>

The requirement identifiers; empty: every one not yet approved.

verdict: String

approve, request (changes), clear; answer (ids: the question) and edit / edit-approve (ids: the requirement) take the input as the words.

IssueComment

Tell a GitHub issue it is being specified as the current feature.

Fields

issue: u64

The issue’s number.

assign: bool

Also assign it to the person.

QuickChange

Record a quick change and, when run, run it.

Fields

request: String

The change, in the person’s words.

checks: Vec<String>

When it is done: its acceptance scenarios.

run: bool

Run it once recorded.

asked: Option<String>

The Ask conversation that suggested it, recorded as its origin.

KeepSetAside

Commit the changes set aside before the task’s run onto the feature’s branch, as the person’s own.

Fields

task: String

The task.

DropSetAside

Discard them.

Fields

task: String

The task.

FixSetup

Commit the setup a run stops on (an uncommitted lockfile, build output not ignored) in the checkout.

Feature

Pick the current feature.

PullRequest

Push the feature’s branch and open (or update) its draft pull request.

BugFix

Record a bug in the person’s words (speccoder bug) and, when run, reproduce it.

Fields

symptom: String

What happens (the symptom).

expected: Vec<String>

What should happen instead (one or more).

unchanged: Vec<String>

What must keep working (zero or more).

issue: Option<u64>

The GitHub issue it comes from.

tests: Vec<String>

The person’s own reproduction tests, one per expected statement (PATH::NAME).

candidate: Option<String>

Someone else’s fix to judge: a patch file or pr:N.

slug: Option<String>

Continue a bug the format’s own bug step created.

run: bool

Reproduce it once recorded.

asked: Option<String>

The Ask conversation that suggested it, recorded as its origin.

BugConfirm

Confirm (or, with reject, reject: the input is the reason) a bug’s reproductions, bound to the digest shown.

Fields

task: String

<unit>/<task>.

digest: String

The digest the person saw.

reject: bool

Reject instead.

BugKeep

Keep an already-satisfied bug’s reproductions as a regression test: committed, the task attested (the input is the reason).

Fields

task: String

<unit>/<task>.

BugRun

Continue a bug: reproduce again, or run its confirmed fix.

Fields

slug: Option<String>

A bug of the format’s own bug structure, by slug.

task: Option<String>

Or <unit>/<task>.

AllowAlways

Always Allow: approve the waiting command once and add exactly its argv to [commands] allow (or [sandbox] network_allow).

Fields

task: String

The task.

call: String

The waiting call’s id.

WidenPolicy

Add a prefix to a prefix list, as the confirmation of its coverage preview (refused when the preview changed or is incomplete).

Fields

key: PolicyList

Which list.

prefix: Vec<String>

The prefix (two elements or more).

digest: String

The digest of the preview the person saw.

DecideBatch

Decide the calls waiting in a run’s batch together, each once.

Fields

run: String

The run.

verdict: BatchVerdict

Approve or reject (the input is the reason).

calls: Vec<String>

The listed calls decided (a non-empty subset).

digest: String

The digest of the list the person saw.

resume_asking: bool

Start the run’s asking budget again.

OracleTests

Write, reject, ask again for, edit or settle a requirement’s tests at review (the input: the reason, the comment or the content).

Fields

req: String

The requirement (US1).

op: OracleOp

What to do.

path: Option<String>

The test (reject, again, edit).

scenario: Option<String>

The ambiguous scenario (reading).

reading: Option<Reading>

The reading meant (reading).

ApproveAndRun

Approve every approvable decision line, freeze the written tests and start the feature’s run, asking or on autopilot.

Fields

mode: RunMode

How the run asks.

grants: Vec<String>

The grant ids (object-bound grants) an autopilot run holds.

sheet: Option<String>

The sheet’s sha256: what the person saw approved and frozen. Required from every interface but a terminal command.

Comment

Add, delete or keep a review comment (the input: its words).

Fields

op: CommentOp

What to do.

anchor: Option<CommentAnchor>

What a new comment is about.

id: Option<String>

The draft (delete, keep).

CommentsSend

Send the comments as one revision turn.

Fields

ids: Vec<String>

The drafts the person saw (empty: every draft in the tray); a draft sent already refuses the send.

RevisionUndo

Undo the last revision turn: the documents back, byte for byte.

Fields

turn: Option<String>

The turn the person saw.

CodeNudge

Code-view line comments as one nudge for the task’s next attempt.

Fields

task: String

The task.

comments: Vec<CodeComment>

The comments.

AcceptanceAt

Write a story’s acceptance tests at a Setup or Foundational task (revoke: take the decision back) — a decision recorded in the state directory, never an edit of the spec.

Fields

feature: String

The feature.

story: String

The story (US1).

task: String

The task.

revoke: bool

Take the decision back.

DeferAcceptance

Judge a task by its regression checks and its story’s scenarios at the story’s checkpoint (revoke: take the decision back) — a person’s decision in the state directory, never an edit of the plan.

Fields

task: String

The task.

revoke: bool

Take the decision back.

PresetAdd

Install the bundled speccoder Spec Kit preset through Spec Kit’s own specify preset add (update: the installed one, replaced).

Fields

update: bool

Replace an installed older version.

PlanThrough

Plan a new feature through the format’s own skills — the creating skill, then toward the task list, then the check — stopping where a person decides (speccoder spec <skill> --through <t>).

Fields

from: PlanFrom

A new description, or the continuation after a stop.

through: Through

How far.

NewProject

Make target a project: the plan the person saw, bound to its digest (speccoder new).

Fields

target: String

The folder, as the plan names it.

choices: NewChoices

What the person chose.

plan_digest: String

The digest of the plan on screen.

UndoNewProject

Undo the project speccoder created at the dispatch’s root (speccoder new --undo): to the Trash, or a revert of its commit.

Fields

commit: String

speccoder’s commit, as recorded.

CloneRepository

Clone a repository of the person’s with their git (their credentials).

Fields

repo: String

owner/repo.

target: String

The destination folder.

OpenSample

Copy the bundled sample into the state directory and replay its recorded run strictly (speccoder sample).

Fields

fresh: bool

Replace an existing copy.

SampleChecks

Run the sample’s own checks, offline, in its copy (the sample’s end card, Run the checks yourself).

DeclinePromotion

Decline a promotion offer: it returns only when a signal that did not hold now holds.

Fields

task: String

<unit>/<task>.

Explore

Explore an idea read-only, ending in approaches to choose from; or resume a session with more words.

Fields

idea: String

The idea (a new session) or the words added (a resumed one).

skill: Option<String>

The skill to host instead of the format’s own (--skill).

resume: Option<String>

The session to resume.

ExploreChoose

The person’s choice in a session: an approach, and the constraints and open questions they keep or add. It composes the brief.

Fields

session: String

The session (ex-…).

approach: usize

1-based, of the session’s last approaches.

constraints: Vec<String>

The constraints, as kept and added.

questions: Vec<String>

The open questions, as kept and added.

flag: bool

Chosen by a flag (--choose N), not in a prompt or the app.

Implementations

impl Runnable

pub fn examples() -> Vec<Self>

One runnable of every kind (ActionKind::example).

pub const fn kind(&self) -> ActionKind

Its kind.

Trait Implementations

impl Clone for Runnable

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 Runnable

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Runnable

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Runnable

impl JsonSchema for Runnable

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 Runnable

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Runnable

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 Runnable