ota-run/ota](https:

aligned the repo readiness contract with the container-first execution path: the root
toolchain now targets Rust 1.95.0, setup explicitly provisions rustfmt, and the hosted
readiness workflow now validates the container execution mode instead of the host-only path

added a first-class repo run preview surface: ota run <task> --dry-run now renders RUN PREVIEW with the shared readiness vocabulary and selected execution/requirement plan, while
ota run <task> --dry-run --json emits the matching machine-readable preview payload; repo-level
--json is now documented and enforced as preview-only for ota run

published and locked the ota run <task> --dry-run --json contract: run-preview.json now
defines the shipped single-target, blocked-preview, aggregate-member, and pre-preview error
envelopes, and end-to-end conformance coverage now checks real command output against that schema

added a dedicated GitHub Actions smoke workflow for the public Ota surface: core repo smoke now
runs on Linux, macOS, and Windows against the installed ota binary, while canonical example and
workspace smoke stays Linux-only for now to maximize signal without turning examples into a noisy
cross-OS matrix

added explicit ota up service-run behavior controls with --attach, --detach, and
--ready-timeout; default ota up now runs service-runtime readiness proof in cleanup-owned
mode (prepare + verify + teardown + return), while --detach keeps the proved workload running
intentionally

strengthened unsupported managed-toolchain opportunity diagnostics and JSON guidance surfaces:
doctor, detect --dry-run --json, and init --json now share one declared unsupported
ecosystem list and include stable agent-facing toolchain_opportunity metadata (including
agent_note) for unsupported ecosystems such as python

fixed ota up --detach runtime lifecycle consistency across backends: native keep-running
paths now launch detached proof-run workers in their own process group so the proved workload
remains alive after ota up returns, and detach success receipts now report the selected
workflow run execution context instead of falling back to diagnosis-only context metadata

fixed ota up --native workflow surface diagnosis drift for service-runtime proof mode:
workflow surface checks now honor the effective execution override backend instead of always
resolving from default task-context backend, and proof-teardown mode now suppresses stale
post-teardown workflow-surface findings so successful native proof runs return READY instead
of false post-up NOT READY surface timeouts

fixed service proof-readiness exit handling so successful detached ota run <task> --stream
exits no longer auto-mark ota up ready when non-surface readiness still fails; Ota now only
suppresses stale workflow-surface findings in that exit path and preserves real probe/check
blockers as NOT READY

improved ota clean container-engine failure handling across both text and JSON output:
cleanup errors now surface Container engine unavailable with structured engine/resource
semantics, concrete Next: guidance, and a compact Details: line instead of raw cleanup
failure text with an empty follow-up section

added schema-backed JSON conformance coverage for ota clean --json across repo, workspace,
stale, and structured engine-unavailable failure paths, so the published clean.json contract
is now validated against real command output instead of helper-only shaping

fixed the public ota clean --json command boundary so the CLI now accepts repo-scoped clean
JSON directly and preserves structured clean failure JSON on stderr instead of rewrapping it
into generic Operation failed prose

fixed the remaining generic ota clean --json failure paths so contract target resolution,
invalid-contract, wrong-target, and repo-load failures now stay inside the published
clean.json envelope instead of leaking ValidateFailure or bare raw-error payloads

expanded end-to-end JSON contract hardening beyond clean: representative success/failure stream
placement is now locked at the CLI boundary, validate, env, doctor, and
workspace tasks now have schema-backed command conformance coverage, check, receipt,
up, workspace check, workspace doctor, and workspace up now have end-to-end schema
coverage too, validate.json now admits the shipped warn_count summary field, doctor.json
now admits the shipped execution default_context, contexts, and env source fields,
workspace-check.json now admits shipped repo execution summaries, up.json now admits the
shipped preview execution context field, and workspace-up.json now admits the shipped
receipt status plus top-level repo readiness counts

wired the JSON contract suite into the canonical compatibility gate and GitHub release gate so
json_output_conformance now runs automatically alongside json_schema_contracts

improved runtime-proof failure classification when startup exits before readiness: proof output now
prioritizes Run task exited before readiness over generic workflow-surface readiness blockers
when both are present, so deterministic startup-exit root causes surface first

added Windows crash-code decoding guidance for common negative exit codes in both run and doctor
failure paths, including 0xC0000005 (access violation), 0xC0000409 (fast-fail/stack buffer
overrun), and 0xC000013A (interrupt), so remediation output is actionable without manual code
translation

added first-class non-gating workflow readiness signals with
workflows.<name>.readiness.signal.{checks,probes,surfaces}: Ota now executes those surfaces as
informational diagnostics that do not block repo readiness verdicts, while preserving strict
reference and attachment validation; overlap between gating and signal readiness lanes is now
rejected explicitly so one item cannot be both blocking and non-gating

tightened toolchain-owned package-manager modeling and workflow dry-run scoping: task
requirements.tools.<name> now validates against both top-level tools and selected
toolchain-owned tools/package managers (for example Corepack-owned pnpm), task-level
requirements are no longer rejected as duplicate ownership when the tool is owned by a selected
toolchain, and selected-workflow ota up activation/provisioning/preview lanes now render or
act on Corepack package-manager requirements only when the selected workflow/task closure
actually requires those tools

tightened validator determinism for toolchain-owned task tools: when a task references a
toolchain-owned tool in requirements.tools without explicitly scoping
requirements.toolchains, validation now fails with an explicit remediation message instead of
implicitly inferring ownership from all declared toolchains

fixed ota proof runtime readiness waiting for packaged/container startup paths by replacing
the fixed 180-second wait budget with a deterministic strategy-aware budget (with floor/ceiling),
so cold image pulls and first-run packaged launches have enough headroom before proof times out

tightened workflow-surface readiness observation latency in ota doctor by reducing the bounded
retry windows and capping per-attempt probe timeout to 5 seconds, so repeated
ota doctor --workflow ... polling no longer blocks for long windows while startup is still in progress

fixed host-loopback readiness probing across ota doctor, ota up, and runtime probes so
loopback surfaces declared as 127.0.0.1 now also resolve canonical local aliases (::1,
localhost) before failing; this removes false not-ready outcomes on macOS/Windows when the
runtime binds IPv6 loopback

tightened loopback alias probe behavior for explicit readiness timeouts: primary endpoints keep
the declared timeout, while fallback alias connect attempts use a short capped timeout, so
Windows/MINGW loopback probing does not burn most of the retry window on slow fallback sockets

fixed long-running workflow-surface doctor calls when startup checks fail repeatedly: failed
readiness retries are now capped to a bounded observation window (matching timeout retry
windowing), so ota doctor --workflow ... no longer blocks for many minutes on slow or
still-booting packaged startup paths

widened the bounded workflow-surface observation window used by doctor/proof retries so slow
first-run packaged startup paths (notably on Windows and Docker cold starts) get more startup
headroom without reverting to unbounded readiness hangs

raised default failed-probe retry capacity for workflow-surface readiness to match the bounded
observation window, so slower startup surfaces can use the full bounded budget instead of
stopping early at the legacy 120-check default

tightened workflow-surface probe timing in ota doctor by capping per-attempt probe timeout to
a bounded effective ceiling before retry budgeting, so default-surface observation stays
responsive even when declared surface timeouts are large

fixed workflow-surface readiness retry budgeting in ota doctor to avoid false early
not-ready outcomes on real startup paths: timeout retries now use a longer default window,
and selected surfaces now honor readiness.start_period, readiness.interval, and explicit
readiness.retries when evaluating workflow-surface readiness

fixed workflow-surface doctor probe hangs for high readiness timeouts by capping timeout-driven
retry budgets to a bounded observation window, so a single ota doctor --workflow ... call no
longer appears stuck for many minutes on slow or non-responsive startup paths

fixed native backend version probing to resolve and execute the concrete runtime/tool binary
directly (with Windows .cmd/.bat wrapper handling) instead of relying on shell-shaped
probe commands, so backend-fulfillment checks now match doctor-style command resolution and no
longer drift under shell/path differences

improved workflow-surface readiness diagnostics in ota doctor: readiness probes now retry
briefly before failing, and surface blocker details now include backend, endpoint, timeout, and
probe-attempt context so false early failures are reduced and real failures are easier to
diagnose

fixed Windows native launch.kind: command task startup parity by resolving launch executables
through the same command-path resolver used by doctor/probes before spawn, so workflows that
run commands like npx no longer fail with Windows-specific program-not-found spawn errors

fixed workflow-scoped doctor/check selection for selected workflow task-requirement surfaces:
when a workflow/task path is explicitly scoped but does not declare readiness checks, Ota no
longer falls back to unrelated global checks (for example monorepo node_modules file checks)
that contradict the selected workflow path

improved ota proof runtime failure prioritization so deterministic doctor primary blockers are
now surfaced before generic up-process timeout/exit messages in proof text and JSON wrappers;
runtime process failures still surface when no primary blocker exists

fixed ota proof runtime readiness waiting to observe selected workflow surfaces/probes with
lightweight host polling and capture the canonical doctor report once a real runtime state
change is observed, instead of rerunning full diagnosis on every wait iteration; this keeps
runtime proof responsive on slow Docker and Windows startup paths

redesigned the shared AGENT summary block used by ota tasks, ota doctor, and ota check
into grouped Overview, Execution, and Boundary sections, with counted wrapped lists and
writable-path root/exception collapsing so large agent boundaries stay readable in terminal
output; ota check --json now also keeps additive agent details alongside its verdict/finding
payload

deepened toolchains.node: Corepack-backed Node toolchains can now own declared package-manager
activation through package_managers, project those tools into doctor/up/policy activation
lanes, and reject duplicate tools.<package-manager> ownership when the toolchain already owns
that package manager

tightened the shipped toolchain provider boundary so toolchains.rust must use
provider: rustup and toolchains.node must use provider: corepack, with validator errors
driven by the shipped provider contract registry instead of a Rust-first fallback

ota run receipts now keep actual toolchain fulfillment explicit: selected receipt.toolchains[]
entries can record additive fulfilled and commands[] evidence when ota ran provider
fulfillment commands on that execution path, instead of forcing users or automation to infer
that from stdout/stderr

hardened the PowerShell bootstrap installer: checksum mismatches and missing official checksum
manifests now fail closed instead of falling back to git installs, and Windows user PATH
persistence now requires explicit -SetupPath

fixed 22 Windows CI test failures in container-mode tests: replaced the broken
set "__OTA_ARGS=%*" / delayed-expansion approach in the Windows fake-docker probe
normalizer with stable positional-arg checks (%2==--rm && %3==--name for version
probes, %3==-i for provisioning probes), and added ./bin/node.cmd → ./bin/node
normalization for the explain_narrow_premium.txt snapshot to handle the Windows
.cmd extension on fake commands

added the first canonical ota skill under skills/ota, covering Ota-specific bootstrap,
contract authoring/review, doctor-first workflow guidance, Ota gap detection, and Studio
local/cloud boundary judgment, plus a bundled reference file with official install/docs/GitHub
sources for public-facing setup and examples

added ota skills install --agent codex|claude as the canonical first-party skill lifecycle
surface; the installed binary embeds the Ota skill files, stages and validates the complete skill
tree before replacing an existing install, and the shell installer receipt now points users to the
CLI command instead of teaching installer-managed skill setup

fixed the release gate path/render regressions from the recent path-normalization refactor:
backticked URLs and commands are no longer rewritten as filesystem paths, and Windows native
task execution now routes POSIX-style script: bodies through Git Bash even when the runner only
exposes the Git-for-Windows install path, while receipt/archive paths and repo follow-up commands
keep their expected Windows-vs-contract path formatting

fixed the macOS release-gate install step to invoke the active toolchain's real Cargo binary via
rustup which cargo, avoiding the broken cached proxy/shim path on GitHub-hosted macOS runners

added the first shipped toolchains contract slice: top-level toolchains,
task-scoped requirements.toolchains, Rustup-backed diagnosis, and Rustup-backed run-path
fulfillment; duplicate ownership across toolchains, runtimes, and tools is now a hard
validation error by default, so one capability must have exactly one owner; Ota's own contract
now declares the Rust toolchain natively instead of hiding rustfmt provisioning in shell
setup, and the contract/site docs publish the ownership boundary as a first-class reference
surface; validation also rejects unsupported toolchain declarations so the shipped surface stays
explicitly bounded to toolchains.rust with provider: rustup

polished the doctor, up, and run command surfaces around toolchain ownership: duplicate
ownership now renders as a structured invalid-contract error instead of a generic validation blob,
ota up --dry-run explains selected toolchains with honest fulfillment: none vs
fulfillment: run semantics, and run/up fulfillment failures now name the selected toolchain,
provider, checked requirement slice, and rerun path without falling back to standalone-tool
wording for toolchain-owned capabilities

expanded the shipped toolchain surface with toolchains.java and provider: sdkman as a
first-class, check-only Java ecosystem owner: Java detection now writes toolchains.java
instead of runtimes.java for strong repo signals, duplicate ownership now covers java and
javac, and unsupported-toolchain opportunity guidance stays focused on ecosystems Ota still
does not ship yet

fixed mixed-backend ota up preflight so selected workflow prerequisites stay on their own
execution boundary instead of being flattened into one doctor mode; native selected-path
toolchains now diagnose on the host even when setup runs in a container, and the dry-run preview
matches that backend-aware preflight

consolidated the shipped Rust toolchain ownership model behind one internal provider definition
so validation, diagnosis, dry-run preview, and run-path fulfillment all derive ownership,
provider labels, primary executables, and fulfillment commands from the same Rustup-backed
registry slice instead of repeating Rust-specific assumptions in each command layer

tightened the provider-boundary contract for toolchains: the validator now teaches the shared
provider-agnostic fields (provider, version, fulfillment, required, only_on, and
platforms.<os>.version) vs Rustup-specific compatibility fields (profile, components,
targets), and the built-in examples/basic-rust contract now uses toolchains.rust instead
of teaching duplicate runtimes.rust / tools.cargo ownership

formalized the shipped Rustup provider contract inside Ota so validator field legality, duplicate
ownership, doctor-managed-surface checks, dry-run requirement rendering, and run-path
fulfillment all read from one provider contract instead of repeating parallel Rustup-specific
assumptions across command layers

moved Rustup-specific field-shape validation (profile, components, targets, including
platform overrides) behind that same provider contract so the validator no longer carries a
parallel copy of provider-specific field rules

added the second shipped toolchain contract slice: toolchains.node with provider: corepack
now gives Node one managed runtime/executable owner without claiming package-manager ownership;
the shipped Corepack contract stays intentionally narrow by using only the shared
provider-agnostic fields, staying check-only (fulfillment: none), and leaving pnpm / yarn
activation explicit under tools.<package-manager>.acquisition.provider: corepack

sharpened toolchain preview wording so dry-run and fulfillment-facing output now names the owned
runtime capability alongside the provider contract, which keeps toolchains.node honest as
“Node via Corepack” instead of reading like Corepack itself is the runtime being checked

exposed selected toolchain decisions as first-class machine-readable evidence: ota doctor --json
now emits top-level toolchains[], ota run <task> --dry-run --json emits top-level
preview-path toolchains[], and receipt-bearing surfaces such as ota up --json and
ota receipt --json now emit additive receipt.toolchains[] entries with provider, backend,
target OS, version, fulfillment mode, owned runtime, and owned tools/components/targets for the
selected path

bridged selected toolchain-owned runtime lanes into org-policy version/provisioning reasoning, so
ota doctor, ota up, and execution-policy previews can show approved runtime versions and
approved install sources for toolchains.rust / toolchains.node without re-declaring
duplicate runtime ownership