v0.10.0 (retracted)

Retracted: Do not use this version. Its tag reused a version already recorded with different content in the public Go checksum database, so standard module verification rejects it. Use v0.10.1 instead.

---

Hydaelyn v0.10.0

Status: Released

Released on 2026-07-16.

Breaking changes

MCP low-level transport contract

transport/mcp/client.Transport now aliases the official MCP SDK transport
contract. Custom transports must replace this shape:

Call(ctx context.Context, method string, params any, result any) error
Close() error

with the official connection entry point:

Connect(ctx context.Context) (mcp.Connection, error)

Use mcp.IOTransport or mcp.StreamableClientTransport when possible.
Hydaelyn no longer maintains a second JSON-RPC framing or session
implementation.

Stdio process lifecycle

DialStdio keeps its public shape and no longer starts the child process during
the dial call. Internally, a bounded command-process adapter owns the pipes and
feeds the official mcp.IOTransport; the local layer enforces a 4 MiB physical
NDJSON line limit while the SDK parses MCP. Client.Initialize starts the
process and completes negotiation. Code that checked subprocess side effects
before Initialize must move those checks after initialization.

Gateway client field and constructor types

ClientGateway.Client and NewGateway now accept mcpcontract.Client instead
of only *mcpclient.Client. Existing NewGateway(client) calls and calls to all
eight high-level methods remain source compatible: Initialize, ListTools,
CallTool, ListResources, ReadResource, ListPrompts, GetPrompt, and
Close.

Two exact static shapes require migration:

• Change var c *mcpclient.Client = gateway.Client to a checked type assertion
  when the concrete implementation matters.
• Change a function variable typed as
  func(*mcpclient.Client) mcp.ClientGateway to accept
  mcpcontract.Client, or wrap mcp.NewGateway in a function with the old
  parameter type.

Tool importer function type

tool/kit.ImportMCPTools now accepts kit.MCPClient instead of a concrete
*mcpclient.Client. Ordinary direct calls remain source compatible because
*mcpclient.Client implements the interface. An exact function value such as
func(context.Context, *mcpclient.Client) ([]tool.Driver, error) must change its
second parameter to kit.MCPClient, or wrap kit.ImportMCPTools in a function
with the old parameter type.

The mcpclient DTO source names, assignment compatibility, and JSON fields are
preserved through aliases. The defined types now belong to mcpcontract, so
reflection reports the mcpcontract package path instead of
transport/mcp/client. Official SDK result types do not enter those DTOs. Nil
and typed-nil gateway clients now return a stable error instead of panicking.

New features

• Runner construction now separates explicit NewDevelopment defaults from
  validated NewProduction dependencies. The pre-v1 New development entry
  point remains source compatible and is deprecated.
• Agent Skills support now covers the complete local progressive-disclosure
  lifecycle: trusted user/project/additional-root discovery, standards-compatible
  SKILL.md parsing, explicit activation, metadata-only catalog disclosure,
  model-driven activation, bounded on-demand resource reads, per-run activation
  de-duplication, and skill-context retention across compaction. allowed-tools
  remains advisory; agent configuration and policy still control tool access,
  and bundled scripts are never executed automatically.
• MCP stdio and HTTP clients now use github.com/modelcontextprotocol/go-sdk
  v1.6.1 for protocol parsing and sessions. HTTP applies a 30-second response
  header timeout, while an SSE response body has no total lifetime timeout.
  Streamable HTTP JSON bodies and individual SSE events have the same 4 MiB
  inbound limit as physical stdio NDJSON lines; overflow returns the typed
  InboundLimitError.
• Conversation compactors now keep each assistant tool-call batch and its
  results as one atomic turn. The agent loop rejects custom compactors that
  return an incomplete tool exchange.
• The optional agent.StepRecorder receives each finalized step. Runner-backed
  workers persist those steps as typed StepCompleted events, and callers can
  reconstruct separate execution-attempt traces from the event log.
• Storage adapters can run contract.RunRecoveryContractTests to verify Runner
  projection recovery, committed step traces, and saved scheduler decisions
  across runtime loss. The contract does not resume an in-progress model or
  tool turn, and Hydaelyn still ships no storage backend.

Fixes and hardening

• Multi-agent dispatch defaults to four concurrent executions; unbounded
  concurrency now requires an explicit option. OpenAI and Anthropic streaming
  clients retain connection/header timeouts without a total response lifetime
  timeout, and undeclared Store capabilities now fail closed.
• The pinned toolchain moves from Go 1.25.11 to Go 1.25.12. govulncheck no
  longer reports the reachable standard-library vulnerability found during the
  release audit.
• CLI version and help output now read Go build metadata. Local builds report
  devel; module-at-version installs report the installed module version.
• Workspace and transport hardening merged after v0.9.0 closes path, symlink,
  filter, process-lifecycle, and stream EOF edge cases.
• Cross-origin HTTP redirects are rejected before redirected MCP requests can
  reach another origin. Same-origin redirects retain the configured and
  SDK-owned headers required for the session.
• Concurrent Initialize calls share one terminal result. Close records one
  terminal result and runs the same session, transport, and subprocess cleanup
  path once.
• A go list based architecture check enforces the four load-bearing import
  seams. Sentrux continues to enforce global cycles, coupling, and god-file
  limits.
• The release workflow rejects tags outside origin/main, pins staticcheck and
  govulncheck, runs the architecture gate, verifies the installed CLI, and
  builds a temporary consumer that imports skill from the same tag.

Verification performed

The following checks passed on 2026-07-10 against the release-candidate
worktree:

• make verify
• make architecture-check
• GOTOOLCHAIN=go1.25.12 govulncheck ./..., with no vulnerabilities found
• go test -race ./transport/mcp/client -count=20
• go test ./... -count=1 after the MCP migration
• Official SDK stdio initialization, tool list and call, protocol failure, and
  close scenarios
• Official SDK Streamable HTTP JSON and SSE initialization, tool list and call,
  session-header, cancellation, and close scenarios
• Release workflow syntax and actionlint, main-contained and side-branch tag
  ancestry fixtures, an isolated tagged CLI install, and a temporary skill
  consumer build

The real GitHub tag event and release creation cannot be tested until a tag is
pushed. The release workflow keeps publication behind the same verification
job.

Deferred scope

Advanced schedulers, memory pipelines, artifact storage, OpenTelemetry
integration, and production pack content are not part of v0.10.0. They remain
in the unversioned future backlog.

Release operators should follow RELEASING.md after the
candidate passes the full local gate.

What's Changed

• fix(runtime): harden transports and workspace sandbox by @Viking602 in #32
• feat(skill): Agent Skills parser/registry with spec-compliant validation by @Viking602 in #33
• feat(v0.10.0): complete release stabilization by @Viking602 in #34
• feat(runtime): harden production construction and execution defaults by @Viking602 in #35
• feat(runtime): harden durable multi-agent execution by @Viking602 in #36
• feat(v0.10.0): add atomic history and runtime recovery by @Viking602 in #37

Full Changelog: v0.9.0...v0.10.0