Repository navigation
v0.18.0
This release redesigns the Rust API. Handlers are plain async closures, agcli
no longer depends on tokio, the framework writes a streaming command's terminal
line, and exit and error codes are types. The wire contract is stricter: a
non-boolean value, a repeated flag or a malformed SOURCE_DATE_EPOCH is an
error, not a guess. Breaking changes are a minor bump pre-1.0.
Breaking changes
In Rust:
-
Handlers are plain async closures over an owned
CommandRequest. The
request has no lifetime and isCloneandDebug, so a handler moves it
into its future, and the framework boxes the future..handler(|req, _ctx| { let a = req.arg_parse::<f64>(0, "a"); Box::pin(async move { .. }) })
becomes.handler(|req| async move { let a: f64 = req.arg_parse(0, "a")?; .. }). -
ExecutionContextis gone, withrun_env_with_contextand
run_argv_with_context. Share state the way any closure does, by
capturing it.ctx.set("seen", value)becomes a write through a captured
Arc<Mutex<_>>. -
run_argvisrun.cli.run_argv(["app", "status"]).awaitbecomes
cli.run(["app", "status"]).await. -
Under
run_env, a handler panic ends the process from a panic hook.
catch_unwindis gone. The hook writes theHANDLER_PANICenvelope and
exits with code 1, sorun_envdoes not return. The Fixed section lists
what the hook covers.Code after
cli.run_env().awaitno longer runs when a handler panics. -
Raw handlers take the argv tail by value and resolve to an
ExitCode..raw_handler(|args, _ctx| { let args = args.to_vec(); Box::pin(async move { ..; 0 }) })
becomes.raw_handler(|args| async move { ..; ExitCode::SUCCESS }). -
A command has one handler slot.
handler,stream_handlerand
raw_handlereach fill it, and the last call wins. A raw handler used to
win over a normal one whatever the order, andaudit()reported
RAW_COMMAND_HAS_HANDLER; that finding is gone.doctor_withreplaces
whatever handler its command had..raw_handler(raw).handler(normal)runsnormal. -
Streaming moves into the framework.
Command::stream_handlerhands the
handler aStreamWriterfor its events, and the framework writes the one
terminal line from the handler's return value.NdjsonEmitter,
FlushPolicy,StreamEmitError, the terminalStreamEvent::Resultand
StreamEvent::Errorvariants,StreamEvent::result_from_envelopeand
StreamEvent::error_from_envelopeare gone.StreamEventvariants lose
theirts: the writer stamps each event from the run's clock and flushes
every line.StreamWriter::emittakes&self, and the writer isClone,
so a task the handler spawns can emit through a clone; a clone kept past
the handler's return is refused withStreamWriteError::Closed.emitter.emit(StreamEvent::Step { .., ts }).await?; emitter.emit_result(envelope).await?
becomesout.emit(&StreamEvent::Step { .. })?; Ok(CommandOutput::new(..)). -
ActionParam::defaultisdefault_value. The builder shadowed the
derivedDefault, soActionParam::default()did not compile. The wire
key staysdefault.ActionParam::new().default("worker")becomes
ActionParam::new().default_value("worker"). -
tokio is no longer a dependency. Dispatch stays async, and any executor
can driverun_envandrun.truncate_lines_with_fileand
TruncatedEntries::cleanupare synchronous, andread_stdinis gone.truncate_lines_with_file(lines, 20, "logs").await?becomes
truncate_lines_with_file(lines, 20, "logs")?, and
agcli::read_stdin().await?becomes
std::io::read_to_string(std::io::stdin())?. -
truncate_lines_with_filerefuses amax_linesof 0 and an invalid
file_prefixwithio::ErrorKind::InvalidInput, before writing
anything. It used to treat 0 as 1 and replace an invalid prefix with
agcli-output. A valid prefix is non-empty ASCII letters, digits,-and
_.truncate_lines_with_file(lines, 0, "logs")returns an error. -
Doctor checks have one constructor, and it takes the request.
Check::with_requestis gone.Check::new("ping", || Box::pin(async { CheckResult::pass() }))becomes
Check::new("ping", |_req| async { CheckResult::pass() }). -
ExitCodeis au8newtype, not a namespace ofi32constants.
CommandError::exit_code,CommandOutput::exit_code,Check::exit_code,
raw handlers,Execution::exit_code,Execution::printand
Envelope::exit_codetake or return it.ExitCode::newbuilds any status
andgetreads it.TryFrom<i32>fails outside0..=255, so nothing is
masked any more.From<ExitCode> for std::process::ExitCodeletsmain
return one.assert_eq!(run.exit_code(), 0)becomes
assert_eq!(run.exit_code(), ExitCode::SUCCESS). -
Error codes are
ErrorCodevalues, andCommandError::newtakes the code
first, so the code, the message and the fix cannot trade places. The
framework's codes are constants such asErrorCode::INVALID_ARG; a
command names its own withErrorCode::new, orErrorCode::ownedfor a
Stringbuilt at run time (format!("HTTP_{status}")). A code is never
empty: both constructors panic on one.CommandError::codeand
ErrorBody::codeareErrorCode.CommandError::new("no such issue", "NOT_FOUND", "Check the id")becomes
CommandError::new(ErrorCode::new("NOT_FOUND"), "no such issue", "Check the id"). -
The framework builds every envelope.
SuccessEnvelope::new,
ErrorEnvelope::new,ErrorBody::new, and the envelopes'
schema_version,exit_code,retryableanddatabuilders are
private.SuccessEnvelope,ErrorEnvelope,ErrorBodyand
CommandErrorare#[non_exhaustive], soCommandError::new, which
requires a fix, is the only way to build an error. Read envelopes from
Execution::envelope, or decode them with thedeserializefeature.ErrorEnvelope::new(command, message, code, fix, actions)becomes
Err(CommandError::new(code, message, fix))from a handler. -
Envelope timestamps are
Timestampvalues.SuccessEnvelope::timestamp
andErrorEnvelope::timestampare anagcli::Timestamp: a second from
1970-01-01T00:00:00Z to 9999-12-31T23:59:59Z that displays and serializes
as the RFC 3339 string and parses back strictly.StreamLine::Event
carriestimestamp: Timestamp; its wire key staysts.
SuccessEnvelopegainsselect_warning.envelope.timestamp(au64) becomesenvelope.timestamp.epoch_secs(). -
Invocation::parse(args, is_bool)replacesparse_invocationand
parse_invocation_with_bool_flags.Invocation::into_command_lineis
gone,positional_indicesis private, andParseInvocationErrorgains
RepeatedFlag.parse_invocation_with_bool_flags(args, |flag| flag == "force")becomes
Invocation::parse(args, |flag| flag == "force"). -
AgentCli::reserved_flags(false)iswithout_reserved_flags().true
was the default and meant nothing..reserved_flags(false)becomes.without_reserved_flags(). -
CommandRequest::promptis gone, andCommandRequest::selectreturns an
iterator over the requested fields, empty when--selectis absent.req.select().unwrap_or_default()becomes
req.select().collect::<Vec<_>>(). -
CommandOutput::from_serializableistry_from_serializable, so the
name says it can fail.CommandOutput::from_serializable(&value)becomes
CommandOutput::try_from_serializable(&value). -
CheckResult::failedandCheckResult::skippedareis_failedand
is_skipped, named likeis_ok.result.failed()becomesresult.is_failed(). -
reserved_flag_names()no longer listsversion, and lists the flags
in the order the root tree documents them.--help,-h,--version
and-Vare reserved always, apart from the agent flags.reserved_flag_names().contains(&"version")is nowfalse. -
More public types are
#[non_exhaustive]: the structsNextAction,
ActionParam,TruncatedEntries,CheckResult,AuditFindingand
AuditReport, and the enumsParseInvocationErrorand
StreamWriteError. Get the structs fromNextAction::new,
ActionParam::newand the other functions that return them, and give a
matchon the enums a wildcard arm.CheckResult { status: CheckStatus::Pass, detail: None, fix: None }
becomesCheckResult::pass(). -
Builder mistakes panic in every build. A duplicate name in
AgentCli::commandorCommand::subcommand, and
CommandError::exit_code(ExitCode::SUCCESS), weredebug_assert!s: a
release build silently replaced the first command, or printed an error
envelope with exit code 0. Two more mistakes panic the same way:
CommandOutput::list_truncated(items, total)with atotalbelow the
item count, which reportedcount: 3, total: 1, truncated: false, and
AgentCli::skill()on a CLI name that is not a slug, whose frontmatter
nameand--installdirectory no harness accepts. The
SKILL_NAME_INVALIDaudit finding is gone with it: such a CLI cannot be
built. Underrun_env, an assert inside a handler becomes a
HANDLER_PANICenvelope..command(status).command(status_again)panics in release builds too. -
The
deserializefeature is strict about the keys it knows. A missing
or malformed known key is an error: no epoch-integertimestamp, no
unparseable timestamp read as 0, no timestamp naming an impossible date
such as 2026-02-29, and no default for a missingexit_code,dropped
or event field. Shapes the framework never writes are refused too: a
nullforschema_version,select_warningordata(the key is left
out instead), an emptyerror.code, an error envelope withexit_code
0, and aTruncatedEntrieswhose counts disagree (linesmust count
entries,droppedmust betotal - lines,truncatedmust be true
exactly when lines were dropped, andfull_outputmust be present
exactly when truncated). Unknown keys are still ignored, so a reader
keeps working on output from a later agcli that only added a field.
StreamEventdecodes event lines only;StreamLinedecodes any line of
a stream.serde_json::from_str::<StreamEvent>(terminal_line)becomes
serde_json::from_str::<StreamLine>(terminal_line).
On the wire, for agents and the programs that read agcli output:
-
select_warningis an envelope key, betweenresultand
next_actions. It used to be inserted into the handler'sresult
object, where it could replace the handler's ownselect_warning, and an
array result had nowhere to put it.result.select_warningbecomes the top-levelselect_warning. -
The
commandfield reruns as printed: the program's file name, then
every argument, single-quoted (POSIX style) unless it is made only of
shell-safe characters. Every envelope renders it this way, including a
PARSE_ERRORraised before argv parses, which used to carry the full
argv[0] path, and the raw command,--selectadvertisement and panic
envelopes."command": "app note two words"becomes
"command": "app note 'two words'". -
Doctor check entries drop
ok.status(pass,failorskip) is
the one outcome field.checks[i].okbecomeschecks[i].status != "fail". -
--versionwith no version set omits theversionkey instead of
reporting"unknown".{"name":"app","version":"unknown"}becomes{"name":"app"}. -
A malformed
SOURCE_DATE_EPOCHis anINVALID_ENVerror, exit code 2,
checked before anything runs. The reproducible-builds spec requires an
error; agcli used to clamp a malformed, negative or too-large value.SOURCE_DATE_EPOCH=-5 app statusanswered at1970-01-01T00:00:00Z; it
now answersINVALID_ENV. -
Boolean flag values are strict. Only
true/false,1/0,
yes/noandon/offcount, in any ASCII case and untrimmed, and a
bare flag istrue. Any other value of a reserved or framework boolean is
INVALID_FLAG, exit code 2, with the named command's templates as
next_actions, and as a terminal line for a streaming command. Any value
but an off spelling used to turn the flag on.--quiet=maybeturned quiet on; it now fails withINVALID_FLAG. -
A flag given twice is a
PARSE_ERRORnaming it (--select given twice), in any spelling:--n=1 -n 2,-vv. The last value used to win
silently.--select=a --select=bprojectedb; it now fails. -
Bundled short flags with a value are a
PARSE_ERROR.-abc=5set the flagsa,b,c,=and5; it now fails, naming the
token. -
--help,-h,--versionand-Valways belong to the framework,
parsed as booleans even underwithout_reserved_flags().-V status
keepsstatusas a positional, which then has to name a command, and
--version=falseis off, so the root tree answers. A raw command still
owns them after its name.app -V fooanswered the version; it now keepsfooas a positional
and reportsUNKNOWN_COMMANDfor it. -
--versionand-Vanswer wherever they appear, as--helpdoes,
once the positionals name a command or nothing, and help wins when both
are given. Flags are checked against the named command's usage. The
versionalias takes no argument.calc add 1 2 --versionranadd; it now answers the version.
calc version extrawasUNKNOWN_COMMANDforversion; it is now
EXTRA_ARGforextra. -
The root, help and version answers reject unknown flags with
UNKNOWN_FLAG, exit code 2. Help for a command checks flags against that
command's usage, and a group without a usage string declares no flags.calc --bogusprinted the tree; it now fails.app db --bogusprinted
the group's tree with the flag dropped; it now fails. -
The tokens before a raw command's name are the framework's. A help or
version flag there is answered, a reserved or framework boolean given a
value that is not a boolean isINVALID_FLAG, and a malformed token there
isPARSE_ERROR. Everything after the name stays the command's, as before.app --help grepran grep with no arguments, andapp -h grep patran it
withpat; both now answer help forgrep.app --quiet=maybe grep pat
ran grep; it is nowINVALID_FLAG. -
A
-followed by a digit is a positional.-0x10and-1,000were
read as bundles of short flags.app add 1 -0x10failed withPARSE_ERROR: -0 given twice; it now reaches
the handler, whosearg_parsereportsINVALID_ARGfor-0x10. -
An explicit
--selectwins overcompact_fields. Beside--select,
--compactonly drops nulls and empty containers from the selection.app get --select=body --compacton a command declaring
compact_fields(["id", "name"])answered"result": {}; it now answers
the selectedbody. -
A list's
fieldsleaves out keys--selectcannot spell: one holding
.or,, or padded with whitespace.["items.a.b"]was advertised for a row keya.band projected to a
miss; the key is now left out offields.
Added
Command::stream_handlerandStreamWriter. The handler writes
start,step,progress,logandeventlines with
StreamWriter::emit. When it returns, the framework writes exactly one
terminal line: the envelope with"type":"result"or"type":"error"in
front, to which--select,--quietandnext_actionsapply. A usage
error on a streaming command is a terminal line too. Underrun_envthe
events reach stdout as they are written; underrunthey are captured,
andExecution::stream_eventsreturns them. A failed write is a
StreamWriteErrorthat poisons the writer, and?turns it into a
STREAM_WRITE_FAILEDerror.Command::is_streamand
Execution::is_streamtell a streaming command apart; the root tree and
help mark it"stream": true, and the generated skill says it streams.
examples/ops.rsgains a streamingdeploy.StreamLine, with thedeserializefeature, decodes any line of a
stream: an event, or the terminalresultorerrorenvelope.AgentCli::clocksets the clock in Unix seconds. The run reads it
whenever it writes a timestamp: an event'stsas the event is written,
the envelope'stimestampwhen it is built at the end of the run, and a
HANDLER_PANICenvelope's at the panic. Tests pin it instead of setting
SOURCE_DATE_EPOCH. A reading pastTimestamp::MAX
(9999-12-31T23:59:59Z) panics rather than write a wrong timestamp.CommandRequest::nowreads the run's clock, so a handler that stamps
its own fields (created_at) is byte-stable under a pinned clock too.Envelope::timestampis public, likecommand,okandexit_code.TimestampandParseTimestampError.Timestamp::UNIX_EPOCH,
Timestamp::MAX,from_epoch_secs(NonepastMAX),epoch_secs,
Displayas RFC 3339 UTC, and a strictFromStrthat accepts exactly
YYYY-MM-DDTHH:MM:SSZon a real calendar date.CommandOutput::next_actionsandCommandError::next_actionstake any
IntoIterator<Item = NextAction>, not only aVec.CommandRequest::flag_onreads a command's own boolean flag strictly:
falsewhen absent, the boolean a valid spelling names, else
INVALID_FLAG.req.flag("force").is_some()read--force=falseas on.- The
INVALID_ENVandSTREAM_WRITE_FAILEDerror codes, published in
error_codesand the generated skill. - The root tree and the generated skill describe the whole contract.
agent_flagssays that--quietkeeps an error'snext_actions, that a
--selectmiss is reported in a top-levelselect_warning, and why
--jsonis reserved.exit_codesanderror_codesname malformed and
repeated flags, the boolean spellings, and whenMISSING_HANDLERhappens.
The skill's contract addsselect_warning, that--helpand--version
are answered anywhere on the line, and that only a stream's terminal line
carriesok. audit()reportsINTERCEPTED_FLAG_DECLARED(error) for a usage
string that declares-h,--help,-Vor--version, which the
framework always answers itself. Raw commands are exempt.audit()reportsUSAGE_PATH_MISMATCH(error) for a usage string
whose command tokens, after the program name, do not name the command it
documents: the tree and every gate error advertiseapp fetch <id>for
get, a template that runs asUNKNOWN_COMMAND.- The generated skill says what a raw command prints: its own output and
exit code, with no envelope, when any command is raw. - More standard traits.
DebugforCheckandStreamWriter;Clone
forStreamWriter;CloneandDebugforCommandRequest;Display
forExitCode(the number);EqforNextAction,ActionParam,
CommandOutput,CommandError,SuccessEnvelope,ErrorEnvelope,
Envelope,ExecutionandStreamEvent;OrdforErrorCode;Copy,
HashandOrdforLogLevel(Info<Warn<Error);Copyand
HashforStepStatus;HashandOrdforAuditSeverity
(Warning<Error);HashforCheckStatus, which is now exhaustive
like the other wire enums, so amatchnotices a new outcome. Every
public type isSend + Sync, and a test pins it.
Fixed
-
A panicking handler always ends with one
HANDLER_PANICenvelope under
run_env. The panic hook covers the synchronous code a handler runs
before its future, whichcatch_unwindaround the poll missed. It works
underpanic = "abort", writes the envelope as the terminal line of a
streaming command and to stderr for a raw one, stamps it with the clock
at the panic, and calls the previously installed hook first. Panics
outside handlers, and panics in tasks a handler spawned that the runtime
catches, behave as they would without agcli. -
A non-UTF-8 argument is a
PARSE_ERRORenvelope naming its position
(argument 2 is not valid UTF-8).run_envread argv with
std::env::args, which panics on one. -
Printing never panics.
Execution::printandfinishwrite through
locked handles: a closed stdout (EPIPE, a broken pipe) is ignored, and
any other write failure is reported on stderr.println!panicked on a
closed pipe. -
A streaming command prints exactly one terminal line. A handler that
streamed throughNdjsonEmitterstill returned an envelope, so stdout got
two terminal lines. -
Deep command trees are documented and audited in full. A depth limit of
32 levels silently cut the root tree, help, the skill andaudit()short. -
flag_parsenames a one-letter flag with one dash (flag -n is not valid), like every other message, instead of--n. -
The
UNKNOWN_FLAGfix lists the reserved flags from the list the parser
reads, and says that--helpand--versionare accepted too. -
The root tree's
commandsis built as JSON directly, so it can no
longer fall back to a string. -
examples/ops.rsteaches typed errors.ops logsrefuses a missing
<source>withMISSING_ARGand a--linesthat is not a positive count
withINVALID_FLAG, instead of defaulting toworkerand 20. -
A
PARSE_ERRORsays how to fix its cause. A repeated--selectsays to
pass every field in one comma-separated list, another repeated flag says
to pass it once, and a malformed flag says how to spell one. Every
PARSE_ERRORused to say "Use valid CLI syntax. Run the root command to
inspect command templates." -
A literal
next_actionruns as printed. A usage string without a
placeholder became a literal action that kept its optional parts, so
wokhei gateway stream [--follow]passed[--follow]as an argument and
failed withEXTRA_ARG. The literal now drops them:
wokhei gateway stream. A variadic placeholder is a param like any
other:t run <cmd...>created none, so the action was literal and
printed<cmd...>; it is now a template with the required param
cmd.... -
--selectnever wipes a result, on any shape. A dot path that reached
nothing left an empty container behind (--select=a.zzzgave
{"a":{}},--select=items.zzzon a list gave{"items":[{},{}]}),
so the result was gone withok: trueand no warning; it is a miss like
any other, and the full result comes back with aselect_warning. A
select that matched no field in any row of an array returned rows of
{}without a warning; it warns, naming the keys found across the rows.
A partial miss on an array (--select=id,naem) was dropped in silence,
as a dot-path miss beside a hit was; both warn as an object does. A bare
--selectreached the projection as the parser's"true", so the
warning blamed a--select=truenobody typed; it now says the flag was
given no field names. A result that is not an object or an array of
objects was projected to itself in silence; it now carries a warning. -
The
--selectadvertisement runs as printed. It appended
--select=<fields>after a--, where the filled template parsed it as
a positional and grew on every hop; the flag now sits before the first
--. -
skill --installhonors--dry-runwith the agent flags off. It read
the flag only through the reserved set, so underwithout_reserved_flags()
it wrote the file. The skill reads it itself, and refuses a value that is
not a boolean withINVALID_FLAG. -
The
helpalias yields to a CLI's ownhelpcommand, as the
versionalias already did. The CLI'shelpcommand was unreachable. -
Wire prose is plain ASCII English. The
--selectadvertisement, the
non-finiteINVALID_ARGandINVALID_FLAGfixes, theEXTRA_ARGrange
(1 to 2, not1–2), the unbalanced-brackets audit message and the
generated skill's list items (`item`: description) carry no dashes
or multiplication signs. The listguidanceno longer names a--limit
the command may not have; it points at the command's own flags and
--select. The lone root action of a CLI with no commands reads "Inspect
the full command tree", like every other root action. -
The pre-commit hooks and
just publish-checkbuild throughmbx, like
the gate. -
An unknown flag before a raw command's name is
UNKNOWN_FLAG, with
the fix the root line gives, and the handler does not run. Under
without_reserved_flags()nothing is refused. Flags after the name stay
the command's.app --bogus=1 grep patran grep withpatand dropped--bogus=1; it
is nowUNKNOWN_FLAG. -
A reserved agent flag before a raw command's name is refused, not
dropped. A raw handler receives only the tokens after its name, so the
flag could reach nothing.--dry-runthere isDRY_RUN_UNSUPPORTED, and
every other reserved flag but--jsonisINVALID_FLAG; nothing runs.
--json,--helpand--versionstay accepted, and under
without_reserved_flags()nothing is refused.app --dry-run grep patran grep for real withpat; it is now
DRY_RUN_UNSUPPORTED.app --yes grep patran grep without the--yes;
it is nowINVALID_FLAG"flag --yes does not reach raw commandgrep". -
--compactbeside--selectno longer empties the selection in
silence. When every selected field is null or empty, the selection is
returned uncompacted with aselect_warning.app get 1 --select=note --compacton a nullnoteanswered
result: {}with no warning; it now answersresult: {"note": null}and
aselect_warningsaying--compactremoved every selected field. -
flag_parserefuses a bare value flag as given no value. A bare
--limitreads as"true", and the error blamed that value.req.flag_parse::<usize>("limit")onapp get 1 --limitgave
flag --limit is not valid: "true"; it now givesINVALID_FLAG
flag --limit was given no value, fixPass a value: --limit=<value>.
Internal
src/cli.rs, about 5,300 lines, is split into one module per primary item,
with unit tests beside their code. Free functions are called through their
module (usage::flag_display). Unreachable branches, among them a
MISSING_HANDLERpath in raw dispatch, and a second copy of the reserved
flag names are gone. Test names and crate-private helpers follow the
current API.- The crate-wide
#![allow(clippy::pedantic)]is gone. The crate is clean
under clippy pedantic and the repo's ast-grep rules with no lint
suppressions anywhere. Builders, constructors, getters,CommandErrorand
Executionare#[must_use], so dropping a builder's result or an
Executionthat was never printed warns. Functions that fail or panic
document# Errorsand# Panics. ci.ymlruns the gate on every push tomasterand every pull request:
rustfmt, cargo-machete, clippy pedantic with and without
--all-features, nextest, doctests, ast-grep, a check for lint
suppressions, and rustdoc with-D warnings. A second job checks the MSRV
(minimum supported Rust version) named byrust-version.release.ymlruns that gate before it publishes, fails when CHANGELOG.md
has no## [X.Y.Z]heading for the tag, and takes the GitHub Release
notes from that section. The skip-if-already-published branch and
git-cliff are gone, withcliff.toml. Every action is on its latest
release, pinned by commit SHA.rust-version = "1.88": 1.87 fails to build the crate.- Packaging: an
includelist (src,examples,tests,benches,
Cargo.toml,README.md,CHANGELOG.md,LICENSE) replacesexclude,
docs.rs builds with every feature, so thedeserializeitems are
documented, and thehomepagethat repeatedrepositoryis gone. just gateruns the CI gate throughmbx. Thereleaseandchangelog
recipes are gone: they bypassed the tag-driven flow and used the BSD-only
sed -i ''. The pre-commit hooks run clippy with--all-featuresand
callast-grep scan.- criterion 0.8, and a refreshed
Cargo.lock. - Tests: the
tests/kill_*.rsmutation-triage files are folded into
argv_parsing.rs,suggestions.rs,usage_templates.rsand
golden_envelopes.rs. Tests that need a process re-execute the test
binary instead of callingcargo run, which takes the raw end-to-end
test from about 11 s to 0.04 s; every re-executed child writes a
sentinel line to stderr, and the parent asserts it once, with the
harness'srunning 1 testline, so a child the filter never reached, or
a filter that matched a second test, fails loudly. No test sets an
environment variable; they pin the clock. New suites:panic_hook.rs,
streaming.rs,clock.rs,ops_example.rsandcalc_example.rs, plus
a serialize-then-deserialize test for every public wire type. The example
tests crawl every literalnext_actionan example prints and run it. examples/calc.rsbuilds its CLI infn cli(), which the README's
calculator copies andtests/calc_example.rsdrives in-process.- Docs: README.md is the user guide and the crate documentation, and every
Rust block in it is a doctest. Every public item has rustdoc, and
#![warn(missing_docs)]keeps it that way. No prose in the crate, the
tests or the examples carries an em-dash. AGENTS.md is the one guide to
working on the repo, and CLAUDE.md imports it.design.md, a copy of an
upstream skill, is gone; its agcli-specific content is in the README.
agent_ergonomics_audit/is gone; nothing read it.