Baixar Common Agent Runtime 0.54.0 per a Windows

## v0.54.0

### Changes

• Releases can now refresh the built-in model catalog's per-token prices from the Artificial Analysis aggregate (https://artificialanalysis.ai/), which republishes each vendor's own list prices. Base input and output prices feed model routing's cost term and its cost-budget filter, and were previously hand-entered and left to drift. Prompt-cache rates, which no catalog entry carried, make the cost figures in `car`'s usage display exact instead of approximations bounded by the base input rate. Only curated model joins are written, and the step is skipped when no API key is configured.
• Both catalog-writing release steps now replace the file atomically, so an interrupted write can no longer leave a truncated `builtin_catalog.json` for the release commit to pick up.

• Document historical draft proposals for Advisor live wiring and offer exchange; these proposals do not represent implemented runtime behavior.

• Enforce the agent builder's advertised end-to-end deadline, report live phase/model/attempt/scenario/elapsed progress through `coder.get`, and end timeouts with actionable `budget_exhausted` state.
• Mark `agent_scenarios_pass` passed when an agent build succeeds instead of leaving the builder contract pending.
• Stop an agent build's scenario turns at their next turn boundary on `coder.cancel`, and show the model serving the current repair or scenario instead of the spec-generation model.

• Stop offering the Parslee platform tools (`parslee_capabilities`, `parslee_m365_generate_document`) to a generated agent's build unless a Parslee account is signed in, so a signed-out local build is no longer derailed by `car auth login` guidance flowing back through its scenario checks; signing in and rebuilding offers them again.

• Agent builder：choosing another starting point now keeps the answers you wrote instead of silently erasing them; a "Continue your draft" action returns to them, and a stopped or abandoned build parks its answers for a retry instead of losing them.
• "Continue your draft" and the replace confirmation appear only for answers you typed yourself — an untouched template is not a draft.
• Picking a template while a draft with answers is waiting asks for confirmation before replacing them; the Home research starter no longer auto-picks its template over a waiting draft.
• Leaving setup ("Back to Agents" or cancel) still clears everything.

• `car agent new` no longer mints over-long agent IDs：ids derived from long descriptions are now capped at 64 characters (well under the 128-character peer-name limit that agent registration enforces) and suffixed with a 64-bit digest of the full name, so a long description always yields an ID that every CAR surface accepts and two different long descriptions are kept apart with collision-resistant odds (car#1492).

• The daemon now keeps token-bearing per-agent `manifest.toml` files owner-only on Unix and repairs permissive files and directories from older releases before loading them.

• `car agent new` now accepts long descriptions without creating overlong project directory names, while keeping the complete description as the agent builder's input.
• Clarified that a managed project's committed `agent.json` is build output and the daemon runs the separately registered `declagents.json` copy.

• **Supervised agents can now receive read-only daemon credentials.** Add `method_allowlist` to an `agents.upsert` record or external-process `manifest.toml` to restrict that agent token to named non-host daemon methods; excluded calls are rejected before dispatch, while registrations without the field keep their existing access.

• Kept `car agent new` successful during CLI/daemon version skew by falling back to the CLI's declarative registry path when an older daemon omits `registry_path`; `car agent where` now surfaces declarative lookup failures, emits daemon-canonical IDs in JSON, and `car info` marks corrupt declarative state unavailable instead of reporting zero agents.

• `car agent new` now reports the exact declarative registry file alongside the new agent id, with `agent_id` and `registry_path` available from `--json`.
• Added read-only `car agent where <id>` human and JSON output for both in-daemon declarative agents and lifecycle-supervised agents, including their registry or manifest and log locations.
• `car info` now summarizes declarative and supervised agent counts and the state directories that hold them; `car inspect` shows a supervised agent's manifest path.

• The daemon now keeps token-bearing `agents.json` files owner-only on Unix and repairs permissive files from older releases before loading them.

• **New crate `car-topology` — pick a multi-agent communication topology from a
short list, in one pass, scored on measured tokens rather than edge count.**
Applies arXiv:2609.02264 ("Codebook Agent"). CAR decides how to coordinate
agents in two places and neither learns：`Coordinator` spends an LLM round trip
on a hand-written prompt, and `car-multi` runs whatever the caller named — while
every `AgentOutput` already carries the `TokenAccounting` that says what the run
cost. The crate fits a codebook of reward-surviving topologies, a
reward-weighted prior mapping a query embedding to a distribution over them,
and a proxy regressed on measured utility and per-task normalized token cost;
selection is one predictor pass, at most M decodes, and one batched scoring
call, with no search and no message passing. Deterministic and dependency-light
(serde only)：no model calls, no network, no unseeded randomness, and a fitted
selector round-trips through serde. The fitting and selection core touches no
filesystem; `journal` (below) is the one module that does.
• **The three measurements the design rests on ship as first-class diagnostics,
runnable against your own execution records.** `design_space_collapse` (does
the reward-surviving set stay small as codebook capacity grows?),
`edge_count_token_correlation` (is `|E|` correlated with measured tokens
*negatively*, so that minimizing it raises the bill?), and `team_homogeneity` /
`scorer_advice` (do the agents share a profile, in which case a message-passing
scorer over profile nodes pools identical features and scores every candidate
the same?). These are workload properties, not theorems — the paper's numbers
are the paper's, measured on their benchmarks under their implementation, and
nothing here has been evaluated against them. The third check matters most for
CAR, whose teams are usually N clones of one `AgentSpec`:
`car_multi::topology::scorer_advice` answers it straight off the specs with no
encoder involved.
• **`car_multi::topology` bridges finished coordination runs into records.**
`execution_record` folds a run's outputs into one `ExecutionRecord`, returning
`None` rather than a zero-cost record when the runner reported no token
accounting — a fabricated zero would drag the cost head toward whatever merely
went unmetered. `select_shape` returns a `CoordinationShape` a `car-multi`
caller can execute.
• **Records persist, and a persisted record can never be read in the wrong
embedding space.** `car_topology::journal` is an append-only JSONL log at
`<car-home root>/topology/records.jsonl` following the `car-eventlog` idiom
(one record per line, torn-line tolerant on load, missing file reads as empty,
an exclusive advisory lock for one writer per path);
`car_multi::topology::record_run` is the one-call write path from a finished
coordination run. Every line names the encoder that produced its query
embedding, because the prior is a kernel over cosine similarity between query
*directions* — fold two encoders into one record set, or query a fitted
selector with a third, and nothing fails, slows down, or looks wrong; it just
answers from arbitrary similarities. So the tag is enforced at the boundary:
`RecordJournal::load_records` refuses a mixed journal unless you name the
encoder, `TopologySelector::fit` carries the label through, and
`select_with(query, embedder)` refuses a foreign query. An unlabeled selector
passes the check — "nobody recorded it" is not "any encoder fits".
• **The three diagnostics fold into one report you can actually read.**
`car_topology::diagnose` returns a serde-serializable `DiagnosticsReport` over
a record set, with `render()` for a terminal and `headline()` for a log line.
Two design points are deliberate. The homogeneity claim needs the team's agent
profiles, which execution records do not carry, so it renders as `NOT MEASURED`
unless you call `diagnose_with_profiles` — naming the gap beats silently
omitting the claim most likely to hold for CAR. And every report carries a
`Sufficiency` verdict against the paper's own collection protocol (300 records
over 50 tasks), so a thin journal reads as provisional rather than as a
finding; a set with no variation in edge count or cost is reported as
`Insufficient` rather than given a verdict.
• **The utility label has a principled source, and the ergonomic path cannot
fabricate it.** `car_multi::topology::run_utility` derives a coordination run's
utility from the agents' structured `car_ir::AgentOutcome`s, with the mapping
dictated by the type rather than chosen：`Success` to 1.0, `PartialSuccess` to
0.5, `Failure`/`GiveUp`/`Timeout` to 0.0, and `Done` to **none**, because
`car-ir` documents that status as "neutral -- may or may not have succeeded"
and scoring it either way would invent the number the crate exists to measure.
`UtilityEvidence::Grounded` additionally refuses a success backed only by the
agent's own assessment, mirroring the receipts-decide-completion rule the
flagship assistant already applies -- and yields *none*, never 0.0, since
"nobody checked" is not "it failed". `record_run_from_outcomes` derives both
measured numbers and writes nothing when either is mis