v1.6.21

• fixed structured Helm dependency hydration so repository-cache state no longer lives under the
  chart tree and poison helm dependency build with oversized cached index files; the runner now
  keeps Helm repo state out of chart inputs while preserving deterministic per-chart isolation

• widened structured task commands with command.cwd and launch.kind: command plus launch.cwd,
  so finite tasks and structured service launches rooted in subdirectories no longer need fake
  cd ... && ... shell bodies just to express working-directory truth; previews and task listings
  now surface the declared command cwd directly

• tightened replaceable-shell governance for package-manager install lanes, so obvious dependency
  hydration shells such as pnpm install and yarn install --immutable now point authors toward
  prepare.kind: dependency_hydration instead of the weaker generic command suggestion

• clarified bootstrap-source discoverability across the contract and install docs, so
  agent.bootstrap.ota.source now explicitly documents the exact shell and PowerShell mapping for
  kind: version, kind: git_rev, and kind: branch, and the setup/action/hosted-validation
  docs now point humans and agents at the same canonical install truth

• tightened ota tasks human output so task listings now show the effective runnable default mode,
  include first-class command bodies in command previews, hide empty placeholder rows, and keep
  ota tasks / ota tasks --use default plus alternate runnable mode guidance aligned with the
  effective mode instead of surfacing empty Default Mode: - task blocks, redundant default-only
  mode rows, or default-branch duplication inside Mode Branches:; multi-mode task output now
  also shows explicit alternate runnable invocations

• documented the new standalone ota-run/action@v1 source: contract install mode in the
  GitHub Actions and hosted-validation specs, so first-party docs now cover both the canonical
  setup + action install: never split and the wrapper-owned contract-consumption path

• aligned the Ota repo's own agent.bootstrap.ota.source with deterministic unreleased proof
  truth by pinning active 1.6.21 work to an exact git revision instead of claiming unreleased
  v1.6.21 release availability

• documented the unified GitHub install contract around ota-run/setup@v1 contract mode, so
  repos can keep agent.bootstrap.ota.source as the single install truth without introducing a
  second GitHub-specific helper surface

• sharpened container-mode doctor probe guidance for repo-local executables backed by unresolved
  dependency hydration, so high-confidence Bundler and node_modules hydration failures now tell
  authors to hydrate the selected container dependency lane first instead of surfacing only a
  generic probe failure

• widened agent.bootstrap.ota with first-class source.kind: version | git_rev | branch, so
  repo contracts can now declare released proof pins, deterministic unreleased proof pins, and
  active pressure-testing branch truth structurally instead of hiding ota install ownership only
  inside raw shell strings; ota now renders shell and PowerShell installer commands from
  structured source truth, validates source-specific pin semantics, and warns when branch
  tracking is used as non-deterministic pressure bootstrap drift

• widened repo-level tools.<name>.acquisition with provider: release_asset, so standalone CLI
  tools can now own exact downloadable binary fulfillment directly in the repo contract instead of
  only through org policy; validator, doctor, selected-path preview JSON, and run-path
  provisioning now all honor the same surface

• widened provider: release_asset so platform assets may also declare archive extraction
  metadata; ota now supports downloading a release archive, extracting one declared executable,
  and installing that executable into the managed tool path for the selected task/workflow lane

• widened archive-backed provider: release_asset again so archive.format now supports zip
  alongside tar_gz, closing the first-class Windows-style release archive lane for standalone
  CLI ownership

• fixed execution-context requirement projection so container-selected and other non-native task
  paths preserve top-level detailed tool acquisition metadata instead of collapsing to bare
  version-only tool requirements during preview and doctor selection

• publish selected-path provisioning and provisioning_request in ota run --dry-run --json
  so direct tool acquisition source truth is machine-readable in task preview output

• allow tools.<name>.acquisition.source_config for package-manager-backed standalone CLI
  ownership and pass that provider truth through doctor provisioning requests

• widened tools.<name>.acquisition with package-manager-backed standalone CLI ownership across
  apt, brew, winget, choco, and scoop, including OS-specific platforms.<os>.acquisition
  overrides so repos can keep tool identity and host fulfillment truth in the tools layer
  instead of splitting standalone CLIs such as Helm across tools and native_prerequisites

• widened first-class adapter ownership with adapter_inputs.overlays.helm.*, so Helm task paths
  can now declare contract-owned cwd, values_files, chart, release_name, and namespace
  truth instead of hard-coding that selection in argv or shell

• Helm dependency hydration now owns clean-host repository bootstrap too: ota reads chart
  repositories from Chart.yaml, seeds them into isolated repo-owned Helm state under
  .ota/state/helm/..., and then runs helm dependency build . without depending on preexisting
  user-global helm repo add state

• Fix Helm tool version probing to use helm version --short before generic fallback probes, so
  Helm-backed contract requirements and dependency hydration lanes do not fail on healthy hosts
  due to the invalid generic helm --version probe path.

• fixed ota skills install so Codex and Claude installs now stage the full canonical Ota skill
  payload instead of a partial bundle; the installer now includes the referenced agents/ and
  references/ support files and validates that the staged skill tree is complete before replace

• widened first-class Node dependency hydration with explicit npm force ownership across both
  npm install --force and npm ci --force, so repos can now model those exceptional override
  lanes structurally under prepare.kind: dependency_hydration instead of burying them in shell

• validate/doctor now warn when contracts declare the exceptional npm --force hydration path,
  and they also flag raw npm install --force / npm ci --force task bodies as replaceable
  structured dependency hydration

• tightened adapter-overlay ownership internals so backend adapter resolution now runs through the
  same adapter-field registry that already owns workflow/task advisory identity, making Compose and
  Bake overlay widening safer without splitting field truth across duplicate match arms

• widened the public adapter-overlay contract from family-specific adapter_inputs.compose.* /
  .bake.* teaching to the canonical adapter_inputs.overlays.<family>.* model, while keeping
  compose and bake as compatibility aliases for existing contracts

• fixed workflow overlay compatibility projection so legacy compose alias inputs such as
  env.compose_files, env.compose_project_name, and compatibility adapter_inputs.compose.*
  still merge correctly when the canonical workflow contract already uses
  adapter_inputs.overlays.compose.*

• tightened runtime-proof auth evidence recovery so likely-cause classification can recover service
  identity from resolved host hints and more endpoint-style auth logs

• refreshed canonical Rust, .NET, and Java examples onto current first-class setup surfaces, so
  setup now uses typed dependency hydration and finite verification/build tasks use command

• widened first-class Node dependency hydration with Yarn inline_builds support, so repos can
  now model yarn install --inline-builds structurally under
  prepare.kind: dependency_hydration instead of hiding that setup lane in shell

• validate/doctor now warn when task bodies still shell yarn install --inline-builds directly
  instead of keeping that dependency-hydration ownership on typed prepare.kind: dependency_hydration

• added first-class prepare.kind: tool_bootstrap for contract-owned tool installation, with the
  first shipped slice modeling tool: uv via source.kind: pip and explicit source.exe

• widened task network classification with effects.network_kind: tool_bootstrap, so ota can
  distinguish typed tool installation from repo dependency hydration and broader remote-call
  execution in doctor, validate, policy, and receipts

• validate/doctor now warn on replaceable shell-owned Python pip install uv task bodies when
  that tool bootstrap truth belongs on typed prepare.kind: tool_bootstrap

• agent-safe dependency-hydration governance is now narrower and more truthful: ota no longer
  emits the generic agent-safe dependency-hydration contract advisory when the task path is
  already modeled on the first-class prepare.kind: dependency_hydration surface; weaker or
  shell-modeled networked hydration still keeps the warning

• Corepack-backed native activation is now provider-owned instead of repo-burdened when npm
  is already available: ota doctor no longer blocks on a missing corepack shim that Ota can
  bootstrap itself, ota up now installs corepack before enable/prepare when needed, and
  direct native run-path Corepack activation follows the same bootstrap lane

• ota doctor now treats inferred task-command and launch-command executables as presence-owned
  prerequisites instead of strict versioned tools, so valid command surfaces no longer fail
  diagnosis just because their executable does not support --version; explicit tools: contract
  requirements remain strict and still fail on broken or unparseable version probes

• added a first-class typed systemd host-service manager lane on top of the existing
  manager.kind: host surface: services can now declare manager.host.kind: systemd plus a unit
  and optional scope so ota derives host lifecycle and supports structured
  readiness.kind: systemd_active without shell systemctl glue

• validate/doctor now warn when task bodies still shell systemctl start, stop, or
  is-active directly instead of keeping that host-service ownership on the typed manager.host
  plus readiness.kind: systemd_active surface

• added a dedicated self-hosted Linux native proof workflow for the typed systemd lane, using a
  temporary user-scoped systemd unit on an OrbStack-backed runner instead of pretending
  GitHub-hosted Ubuntu provides honest host-systemd runtime truth

• improved native run-path failure trust for command-owned Compose tasks: when a native task launches
  podman or docker and the selected engine backend is unavailable, ota run now reports
  first-class Container engine unavailable guidance with engine-specific repair steps instead of
  flattening the failure into generic non-zero-exit wording

• added first-class podman compose ownership across the shipped Compose-family surfaces:
  compose-managed services can now declare services.<name>.manager.engine: podman, docker-compose
  dependency hydration can declare prepare.source.engine: podman, and adapter governance/doctor
  now recognize replaceable Compose truth in both docker compose and podman compose task bodies

• runtime proof now short-circuits fast terminal ota up --stream failures from captured
  up.log, emits the stronger failure text into proof output and doctor.json, and avoids the
  previous long full-diagnosis stall when readiness proof was already terminally blocked

• workflow-owned adapter truth now flows through one internal shared overlay model before task
  projection, so Compose and Bake both bind through the same workflow overlay path and governance
  now points authors at that shared workflow adapter surface more explicitly

• generalized workflow-owned adapter overlays onto a workflow-level canonical surface:
  workflows.<name>.adapter_inputs.* now owns cross-adapter Compose/Bake overlay truth, while
  workflows.<name>.env.adapter_inputs.* stays accepted only as a compatibility lane and legacy
  env.compose_files / compose_project_name aliases now resolve toward the workflow-level
  surface

• sharpened runtime-proof root-cause recovery without widening the schema surface: DNS/service-name
  failures now recover lookup-style unresolved hosts more reliably, auth/credential failures can
  recover endpoint-style and addr= / hostname= host evidence, and readiness-target mismatch
  now catches path drift when the app advertises a live endpoint in proof artifacts

• tightened runtime-proof failure-class ordering onto one shared priority path, so
  install/toolchain startup breaks now classify consistently from proof logs even when the proof
  path only has log evidence and not a richer recovered likely-cause object

• ota detect write modes now publish first-class field-admission rationale alongside detect
  ownership metadata: written contracts and JSON output record
  metadata.ota.detect.field_admission as direct for high-confidence detector-owned fields and
  promoted for the narrow conservative detect-write starter fields admitted by policy

• tightened the conservative ota detect --write lane without broadening it into a full starter
  rewrite path: sparse Node repos can now still seed toolchains.node plus starter-owned npm
  dependency hydration from repo-root markers, and solution-backed .NET repos now treat
  .sln-derived project.name as high-confidence so the high-confidence write lane can proceed

• unified the detect-write policy surface across repo and workspace onboarding: repo
  ota detect --write, workspace auto-provision, and workspace rewrite now all build from the
  same conservative detect-write candidate instead of mixing stricter raw high-confidence writes
  with widened repo-local detect-write behavior

• detector-led ota init now widens strong starter signals onto current first-class contract
  surfaces instead of leaving obvious setup and finite task bodies in raw shell: supported Node,
  Ruby, Java, and .NET starter drafts now prefer toolchains.*, prepare.kind: dependency_hydration for setup, and command for simple modeled task execution, while ota init --pack now emits those same command-owned task bodies for shipped simple starter lanes

• runtime proof interrupt cleanup now resolves and signals the actual detached ota up process
  group before falling back to direct child termination, so ota proof runtime teardown is less
  likely to leave nested ota up or downstream workload processes running after user interruption

• validate/doctor now explicitly flag legacy toolchain compatibility ownership on
  toolchains.<name>.provider and flat toolchains.<name>.fulfillment: run|none, while keeping
  those shapes parseable as migration lanes; canonical public toolchain truth is now consistently
  pushed onto structured fulfillment

• ota init starter packs and ota detect --merge now stop emitting legacy shipped-toolchain
  provider fields for canonical toolchain shapes, so generated contracts align with the
  structured no-provider public contract model instead of writing migration-lane compatibility
  fields back into repo truth

• ota init --pack now seeds first-class dependency-hydration setup tasks for shipped Node
  package-manager lanes (npm, pnpm, yarn, bun), Ruby/Bundler, and Go modules instead of
  defaulting those starter packs back to opaque install shell when Ota already owns the setup
  path structurally

• validate/doctor now explicitly flag legacy service readiness shell ownership
  (services.<name>.readiness.run) and push canonical modeling onto structured
  services.<name>.readiness.kind or named probe, so service-readiness ownership stays
  compatible without remaining governance-silent

• validate/doctor now explicitly flag legacy top-level host service lifecycle ownership
  (services.<name>.start / .stop) and push canonical modeling onto manager.kind: host, so
  host-managed service ownership stays truthful for compatibility without remaining governance-silent

• aligned ota clean host-service cleanup with the rest of the lifecycle surface: cleanup now
  honors legacy host-owned services.<name>.stop commands in addition to structured
  services.<name>.manager.stop, and workflow-scoped cleanup now includes those legacy host-owned
  services instead of silently skipping them

• widened typed host service ownership so services.<name>.manager.kind: host can now own
  lifecycle through structured manager.start / manager.stop commands; ota up and
  requires_services execution paths now run that first-class host-manager lifecycle truth
  directly instead of forcing authors back to legacy top-level shell start / stop strings

• interrupt-driven cleanup now consumes typed host manager.stop for Ota-started required
  services, so detached/proof teardown can actually stop host-managed service lifecycles Ota
  started instead of treating structured shutdown as validation-only truth

• ota clean now consumes typed host manager.stop for Ota-owned host-managed services, scopes
  that cleanup to the selected workflow when requested, and reports host-service cleanup in both
  text and JSON instead of only owning container/volume repo state

• repo execution lock ownership now records Ota-owned host-managed services for the active run,
  ota clean now honors that lock before mutating lifecycle-owned repo state, and lock-busy
  diagnostics now show the active execution’s owned host services instead of only PID/process
  metadata

• proof/runtime execution receipts now emit first-class host_service_cleanup evidence for
  interrupt-driven host-managed service stop attempts, so machine-readable consumers can see the
  service, action, status, trigger, and any failure detail instead of inferring cleanup from
  summary prose alone

• runtime proof JSON now emits first-class likely_cause_evidence when ota can derive a
  higher-confidence readiness root cause from captured proof logs, so automation can distinguish
  loopback service config drift and detached-run failure signals without parsing advisory prose

• runtime proof JSON now also emits additive structured cleanup_failure detail when ota can
  classify proof-boundary cleanup failures, so automation can distinguish cleanup resource/reason
  truth without scraping top-level proof error prose

• centralized task adapter-input runtime env projection behind one shared registry-driven helper,
  so future adapter families widen one projection surface instead of repeating family-specific
  Compose/Bake binding logic across execution paths

• runtime proof now classifies address-in-use startup failures as first-class bind_conflict
  likely-cause evidence and failure class, and the published proof schema now documents
  likely_cause_evidence explicitly instead of leaving that machine-readable surface implicit

• runtime proof now also emits first-class install_or_toolchain_failure likely-cause evidence
  from captured up.log, so package-manager/compiler/toolchain startup breaks no longer stop at a
  class-only lane or prose-only diagnosis

• proof-runtime.json now explicitly publishes workflow_env_artifacts in the success schema, so
  the shipped machine contract matches the additive rendered-env evidence already present in proof
  JSON output

• runtime proof can now emit first-class missing_env likely-cause evidence and failure
  classification from captured up.log, including the missing variable name when Ota can recover
  it

• runtime proof can now emit first-class readiness_target_mismatch likely-cause evidence and
  failure classification when the declared proof endpoint differs from the runtime endpoint Ota
  observed in proof artifacts

• runtime proof can now emit first-class dns_service_name_resolution_failure likely-cause
  evidence and failure classification when proof logs show unresolved service-name or host
  resolution failures

• runtime proof can now emit first-class auth_credential_failure likely-cause evidence and
  failure classification when proof logs show rejected credentials or authorization

• policy-backed tool governance now resolves common executable aliases across provisioning and
  strict version policy lanes, so canonical tool names like bundler and maven can govern the
  executable-facing requirements bundle and mvn without forcing org policy authors onto
  shell-name quirks

• org policy validation now rejects unsupported provisioning sources instead of letting doctor/up
  plan unimplemented backends as if they were actionable, so provisioning truth stays aligned to
  the shipped mutating adapter set

• validate/doctor now flag non-canonical effects.external_state aliases like docker_compose,
  postgresql, and k8s, pushing repo contracts and policy packs onto the shipped canonical
  token vocabulary so cross-repo effect governance stays reusable

• fixed container-mode doctor precondition scoping across mixed container contexts, so runtime,
  tool, and toolchain probes only evaluate the selected workflow/task container images instead of
  leaking failures from unrelated container contexts

• widened first-class file checks with checks[].scope: workspace, so contracts can truthfully
  own sibling workspace inputs such as ../task-sdk/schema.json without falling back to shell
  test -f ... glue; validator/doctor/docs/examples now keep repo-bound file checks strict by
  default and use explicit workspace scope only when that broader ownership is real

• replaced the whole-run repo execution mutex with an active-execution registry, so compatible
  runs can now coexist in one repo (ota run dev plus a finite task path) while ota clean and
  duplicate long-running service ownership still block on first-class execution conflicts instead
  of a coarse single-command lock; that conflict ownership now widens to shared host-managed
  services, shared Compose project ownership, shared persistent backend families, and shared
  deterministic env-file materialization outputs instead of staying task-name-only, and the
  conflict surface now emits typed reason identities instead of forcing operators and agents to
  infer the cause from owner detail text alone; failure receipts now also publish a first-class
  execution_conflict object derived from those reason identities instead of hiding the signal in
  generic blocked strings alone; ota clean --json now classifies active execution cleanup
  barriers as their own structured failure lane instead of collapsing them into generic repo-state
  errors

• made stream-phase loader timing explicit in the runner, so noisy task-output paths now use the
  governed delayed loader policy instead of ad hoc immediate spinner behavior that could dirty
  terminal output handoff before real task logs arrive

• widened native_prerequisites from diagnose-only package guidance into a first-class host
  preparation lane for ota up and ota run, so selected native prerequisite package-manager
  bundles (apt, brew, winget, choco, scoop) can now be fulfilled by Ota before
  rerunning preconditions instead of leaking that install burden into CI workflow glue

• tightened that native prerequisite fulfillment lane under org policy: when .ota/org-policy.yaml
  is active, selected host package installs now require explicit approval under
  policies.native_packages.<manager>.approved, ota doctor reports unapproved package bundles
  as policy violations, and policy-approved native package actions now flow through the same
  governed ota up / selected ota run provisioning path instead of bypassing policy

• removed generic native_prerequisites.platforms.<os>.packages; native prerequisite host package
  guidance is now manager-scoped only (apt, brew, winget, choco, scoop) so fulfillment,
  policy approval, and contract truth stay deterministic

• added first-class policy-backed release-asset provisioning for exact standalone tool binaries,
  so org policy can now approve platform-specific release URLs plus version probes, Ota can
  materialize those binaries into a source-managed workspace path for native/container execution,
  and repos no longer need local download helpers just to own exact tools like Mike Farah yq

• generalized adapter-overlay internals behind a shared adapter-input field registry, so
  workflow-overlay binding, duplicate-ownership governance, and runtime file-readiness checks now
  consume one canonical metadata surface instead of carrying separate Compose/Bake match ladders

• widened adapter_inputs.compose and adapter_inputs.bake with first-class cwd, so tasks and
  workflows can own adapter-root execution truth without shell cd ... && docker compose/buildx
  glue; Ota now reprojects repo-relative adapter files against that root at runtime and
  validate/doctor call out replaceable shell-owned adapter cwd patterns

• widened workflow-owned host preparation so workflows.<name>.prepare can now declare either a
  reusable task or an inline first-class action, letting workflows own deterministic bootstrap
  actions and bundles directly without synthetic helper tasks while keeping ota up and workflow
  summaries truthful

• widened action.kind: ensure_bundle so bundled deterministic native setup can now include
  kind: ensure_container_network steps, letting one setup owner compose shared Docker network
  bootstrap with other governed bootstrap mutations without falling back to shell orchestration

• added first-class container-network bootstrap through action.kind: ensure_container_network,
  so contracts can own external Docker network readiness without shell docker network inspect || docker network create glue; validation, dry-run preview, contract schemas, capability
  publication, and replaceable-shell governance now understand the new surface

• fixed workflow prepare validation drift: workflows.<name>.prepare.task now accepts finite
  native command tasks, matching the published contract/reference surface instead of forcing
  authors back to shell run

• fixed workflow-owned adapter-overlay provenance during diagnosis: when Ota injects selected
  workflow Compose/Bake adapter inputs into runnable task paths for execution, doctor/validate no
  longer misclassify those synthetic bound values as task-authored duplicate ownership

• added three missing canonical example families across core and public examples: Bake
  adapter-input ownership through adapter_inputs.bake.files, deterministic env bootstrap through
  action.kind: ensure_env_file, and bundled host file preparation through
  action.kind: ensure_bundle, so users, agents, and crawlers now have compact reference shapes
  for those newer contract surfaces instead of only spec prose

• tightened adapter-input governance in two connected ways: workflow-owned Compose/Bake overlays
  now recognize launch.kind: command task paths as real adapter consumers, and validate/doctor
  now warn when adapter_inputs.compose or adapter_inputs.bake is declared as an empty marker
  instead of owning concrete adapter truth

• widened task adapter input ownership with first-class
  tasks.<name>.adapter_inputs.compose.env_files plus mode-branch overrides, so task-owned
  docker compose interpolation files no longer have to hide inside shell --env-file flags or
  misuse task env_files; run preview, ota env, execution, validate/doctor, task JSON output,
  and the published contract schema now all project the same declarative compose adapter input
  truth

• widened that same task-owned compose adapter surface beyond env-file interpolation: contracts can
  now declare tasks.<name>.adapter_inputs.compose.files and
  tasks.<name>.adapter_inputs.compose.project_name with mode-branch overrides, and Ota projects
  them through COMPOSE_FILE / COMPOSE_PROJECT_NAME so compose file selection and project
  naming no longer need to stay trapped in shell flags when the task owns them

• validate/doctor now treat shell-owned compose file and project-name flags as the same governance
  class as shell-owned --env-file, so hard-coded docker compose -f / --file / -p /
  --project-name truth is now pushed toward tasks.<name>.adapter_inputs.compose.*

• selected workflow env-profile materialization now routes rendered dotenv artifacts into
  compose-running tasks through tasks.<name>.adapter_inputs.compose.env_files instead of
  misrouting that workflow-owned compose interpolation input through process env_files; ota env --task now also validates task adapter-input files, not just task process env-files

• widened workflow-owned compose adapter truth beyond rendered dotenv injection: workflows can now
  declare canonical workflows.<name>.env.adapter_inputs.compose.* overlays, with
  compose_files / compose_project_name kept as backward-compatible aliases; Ota projects that
  workflow-owned adapter truth into compose-running task paths with branch-aware precedence,
  validate/doctor warn when task-local compose project naming drifts against workflow ownership,
  and the published contract schema now carries the same generalized workflow adapter surface

• proved that generalized adapter surface with a second adapter family: contracts can now declare
  tasks.<name>.adapter_inputs.bake.files plus
  workflows.<name>.env.adapter_inputs.bake.files, and Ota projects that truth into
  docker buildx bake task paths through BUILDX_BAKE_FILE instead of forcing Bake file
  selection to stay hidden in shell -f flags

• validate/doctor now also treat shell-owned docker buildx bake -f / --file truth as a
  governance smell, pushing Bake file selection toward tasks.<name>.adapter_inputs.bake.files
  instead of opaque shell flags

• widened the Compose adapter family again: contracts can now declare
  tasks.<name>.adapter_inputs.compose.profiles plus
  workflows.<name>.env.adapter_inputs.compose.profiles, Ota projects that truth through
  COMPOSE_PROFILES, and validate/doctor now treat shell docker compose --profile ... truth as
  the same adapter-ownership governance class as shell --env-file, -f, and -p

• widened Compose service-manager ownership to match those task/workflow surfaces:
  services.<name>.manager.profiles is now first-class for manager.kind: compose, Ota threads
  that declarative profile truth through derived compose service commands, and validation rejects
  empty profile entries or host managers pretending to own compose profile selection

• generalized the workflow adapter-overlay engine behind one shared adapter-family path for
  Compose and Bake, so support detection, selected-workflow validation, and overlay binding no
  longer depend on separate hand-wired branches in validator and runtime orchestration

• narrowed the public workflow Compose authoring story to one canonical surface:
  compatibility aliases (compose_files, compose_project_name) are still accepted, but shared
  alias interpretation and duplicate checks now live under the adapter-input engine and
  validation explicitly pushes authors toward workflows.<name>.env.adapter_inputs.compose.*

• completed the matching doctor/advisory parity for adapter-owned flags: Compose/Bake replaceable
  ownership advisories are now family-specific, no longer get suppressed by unrelated adapter
  inputs, and cover structured command bodies as well as shell run/script bodies

• tightened advisory identity governance behind that same surface: the duplicate workflow
  adapter-input advisory is now internally family-generic instead of Compose-hardcoded, while
  doctor identity fallback coverage now matches the current Bake and workflow adapter-ownership
  summary shapes

• widened duplicate workflow adapter-input governance beyond Compose project_name: doctor and
  validate now also surface field-specific duplicate ownership advisories for
  compose.env_files, compose.files, compose.profiles, and bake.files, with contract-pack
  JSON coverage locking those identities into the shipped doctor surface

• restored Python starter command provenance truth all the way through init JSON field paths, so
  generated structured command bodies now publish tasks.<name>.command.exe /
  tasks.<name>.command.args.* provenance instead of collapsing that ownership back to legacy
  run fields

• fail workflow-owned rendered env artifacts earlier on policy drift: run-path env rendering now
  rejects selected workflow outputs that violate the governing contract or can no longer be
  materialized cleanly, instead of deferring the mismatch into later runtime or service startup
  failures

• made workflow-owned env materialization more first-class across real execution paths: selected
  workflow profiles can now declare env.compose_env_file_services to bind one rendered dotenv
  artifact directly into named compose-managed services, direct ota run now materializes
  selected workflow dotenv artifacts before executing tasks in the workflow closure, and proof
  runtime likely-cause hints now point operators at workflow overlays, rendered artifacts, task
  env_files, and compose manager.env_file instead of implying shell glue is the primary fix

• widened first-party sync governance beyond ota-run/skills: the release gate and repo task
  surface now also govern ota-run/ota-site through one shared first-party consumer sync check,
  with explicit status records for both the skills package and the public docs site so canonical
  docs or contract-surface widening cannot ship quietly while one consumer still lags behind

• added a Rust-owned published canonical docs manifest at
  docs/spec/published-docs/canonical-docs.json, with release publication to
  https://dist.ota.run/spec/published-docs/latest/canonical-docs.json; this gives downstream
  consumers a machine-readable source-of-truth map for key docs surfaces such as contract,
  workspace, command, JSON output, topology, and doctor finding references instead of forcing
  them to scrape page chrome or hardcode upstream source paths

• clarified that command.exe is not allowlisted: the docs now say the executable may be any repo-truthful binary or path, and that the named examples are illustrative rather than exhaustive

• clarified the public command-body contract: command.exe is now documented explicitly as a generic executable name or path rather than an npm-shaped field, with representative families such as npm, pnpm, yarn, bun, node, python3, go, bundle, docker, absolute paths, and repo-local binaries

• widened finite setup modeling again: tasks can now declare prepare.kind: sequence to execute
  more than one ordered structural prepare step in a single truthful setup lane, which closes the
  remaining mixed-ecosystem fallback to ad hoc shell setup bodies such as Node hydration plus
  Python uv hydration in one repo-level setup task

• widened first-class dependency hydration across the remaining starter-owned setup families:
  contracts can now model Maven, Gradle, Cargo, and dotnet restore hydration structurally under
  prepare.kind: dependency_hydration, with Java wrapper awareness for mvnw / gradlew; ota init --pack now seeds those first-class setup bodies for Java, Rust, and .NET instead of
  falling back to raw shell install commands

• widened Maven hydration one step further under that same surface: source.kind: maven now
  supports explicit mode: resolve|go_offline plus optional skip_tests, so real setup lanes
  like mvn -q -DskipTests dependency:go-offline can stay first-class instead of falling back to
  opaque shell

• aligned published task inventory truth with the widened setup surface: ota tasks text now
  renders structured prepare lanes truthfully, the published tasks.json / workspace-tasks.json
  schemas now cover additive prepare, additive aggregate, additive effects, task env /
  inputs, ensure_bundle, and the concrete emitted task kinds (sequence,
  dependency_hydration, aggregate), and regression coverage now locks both the schema surface
  and the emitted JSON/task-listing shapes against future drift

• fixed recursive published-schema validation on the machine path itself: ota json validate
  no longer flattens every $ref before compilation, so recursive task schemas such as
  tasks.json / workspace-tasks.json validate through the library’s own internal-ref handling
  plus a preloaded published-schema document store, and regression coverage now proves that both
  repo and workspace task inventory payloads validate successfully through the shipped command

• widened finite task execution with first-class command: tasks and mode branches can now model
  stable argv-owned finite execution without shell glue, published task inventory schemas now emit
  structured command objects alongside existing launch summaries, and the Python starter plus
  first-party Python examples now use that surface for uv run ... test lanes instead of opaque
  run strings

• fixed Python starter machine-truth and Python ownership symmetry together: ota init --pack python --json now publishes provenance for the actual tasks.setup.prepare / requirements /
  effects fields instead of stale tasks.setup.run, and both the Python starter and uv-backed
  detector synthesis now declare toolchains.python.package_managers.uv when uv owns the lane

• strengthened the hosted install contract for CI and especially Windows GitHub Actions: the
  release installers now export the resolved ota bin directory to GITHUB_PATH automatically when
  that environment file is present, so workflow authors no longer need to guess post-install
  binary locations such as %LOCALAPPDATA%\\ota\\bin; the install docs and hosted-validation
  guidance now treat the plain installer invocation as the canonical GitHub Actions pattern