release: v0.1.1

- mcp: thread the binary version into Serve so MCP serverInfo.version
  matches the release tag automatically (no more hard-coded constant)
- changelog: 0.1.1 entry

Author: css521

CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/), and the project aims to follow
 [Semantic Versioning](https://semver.org/).
 
+## [0.1.1] - 2026-06-16
+
+### Changed
+- `mcp.Serve` now takes the agentenv binary's resolved release tag and
+  reports it in the MCP `initialize` handshake's `serverInfo.version`
+  (previously hard-coded to `"0.1.0"`). Single source of truth — bumping
+  the next tag no longer needs a code edit.
+
+### Fixed
+- `gofmt` formatting on three files (`internal/cli/ctl.go`,
+  `internal/mcp/server.go`, `internal/mcp/server_test.go`); CI was red
+  on the first push.
+- `staticcheck` ST1005: dropped trailing `...` from two `tournament`
+  usage error strings (illustrative, not literal).
+
 ## [0.1.0] - 2026-06-16
 
 First public release. The whole rewindable-environment story end-to-end —
@@ -103,4 +118,5 @@ drive rollback natively.
   incremental checkout (copy only the diff); `AGENTENV_IGNORE` excludes ephemeral
   paths; auto-snapshot labels list the changed files.
 
+[0.1.1]: https://github.com/css521/agentenv/releases/tag/v0.1.1
 [0.1.0]: https://github.com/css521/agentenv/releases/tag/v0.1.0

internal/cli/commands.go

@@ -27,11 +27,11 @@ import (
 //
 // Sockets are resolved via --socket / AGENTENV_SOCKET / AGENTENV_ROOT in that
 // order. Cancelled by SIGINT/SIGTERM (typical: Claude Code closes stdin).
-func cmdMCP(args []string) error {
+func cmdMCP(args []string, version string) error {
 	sock := daemonclient.SocketPath(flagValue(args, "--socket"))
 	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer cancel()
-	return mcp.Serve(ctx, sock)
+	return mcp.Serve(ctx, sock, version)
 }
 
 // cmdInit creates the root node from one of two sources, exactly one of which

internal/cli/run.go

@@ -44,7 +44,10 @@ func Run(version string) int {
 		// MCP server (stdio JSON-RPC) — bridges Claude Code / other MCP hosts
 		// to a running daemon. No repo/lock here either: it forwards every
 		// call as a fresh socket round-trip, so the daemon owns concurrency.
-		if err := cmdMCP(rest); err != nil {
+		// `version` flows from main.resolveVersion → the MCP initialize
+		// handshake's serverInfo.version, so hosts log which build they're
+		// talking to.
+		if err := cmdMCP(rest, version); err != nil {
 			fmt.Fprintln(os.Stderr, "error:", err)
 			return 1
 		}

internal/mcp/server.go

@@ -35,10 +35,6 @@ import (
 	"github.com/css521/agentenv/internal/protocol"
 )
 
-// version reported to clients in the initialize handshake. Bumped alongside
-// the agentenv release tag.
-const serverVersion = "0.1.0"
-
 // emptyArgs is the input type for the zero-arg tools (head, log, branches).
 // The SDK still infers a JSON Schema object for it; empty struct → "no
 // properties, no required" — exactly what we want.
@@ -55,11 +51,14 @@ type diffArgs struct {
 
 // Serve runs the MCP server on stdin/stdout (the transport Claude Code uses
 // when it spawns this binary), bridging tool calls to the agentenv daemon's
-// unix socket. Returns when stdin EOFs or ctx is cancelled.
-func Serve(ctx context.Context, sock string) error {
+// unix socket. The `version` is reported to clients in the initialize
+// handshake — pass the agentenv binary's resolved release tag (main.go's
+// resolveVersion) so MCP hosts can log which build they connected to.
+// Returns when stdin EOFs or ctx is cancelled.
+func Serve(ctx context.Context, sock, version string) error {
 	server := mcp.NewServer(&mcp.Implementation{
 		Name:    "agentenv",
-		Version: serverVersion,
+		Version: version,
 	}, nil)
 	register(server, sock)
 	err := server.Run(ctx, &mcp.StdioTransport{})

internal/mcp/server_test.go

@@ -100,7 +100,7 @@ func (d *fakeDaemon) requests() []protocol.Request {
 // Claude Code would drive us, minus the stdio framing.
 func startMCP(t *testing.T, sock string) *mcpsdk.ClientSession {
 	t.Helper()
-	server := mcpsdk.NewServer(&mcpsdk.Implementation{Name: "agentenv", Version: serverVersion}, nil)
+	server := mcpsdk.NewServer(&mcpsdk.Implementation{Name: "agentenv", Version: "test"}, nil)
 	register(server, sock)
 
 	t1, t2 := mcpsdk.NewInMemoryTransports()