Add JSON output support for erk current command

Extends the `erk current` command with `--json` flag to output worktree information in machine-readable format. Enables automation tools and scripts to reliably extract current worktree details (name, path, is_root status) with strict schema validation.

## Files Changed

### Added
- `src/erk/cli/json_schemas.py` CurrentCommandResponse class

### Modified
- `src/erk/cli/commands/current.py` - Added --json flag and JSON response handling
- `tests/commands/display/test_current.py` - Added 3 new JSON output tests

## Key Changes

- New `CurrentCommandResponse` Pydantic schema (name, path, is_root fields)
- `--json` flag routes output through JSON serialization layer
- Refactored output logic to support both text and JSON formats
- Full test coverage: worktree JSON, root worktree JSON, and schema validation

## Test Results

All 1575 tests passing. CI validation complete.

Author: schrockn

src/erk/cli/commands/current.py

@@ -3,15 +3,23 @@
 import click
 
 from erk.cli.core import discover_repo_context
+from erk.cli.json_output import emit_json
+from erk.cli.json_schemas import CurrentCommandResponse
 from erk.cli.output import user_output
 from erk.core.context import ErkContext
 from erk.core.repo_discovery import RepoContext
 from erk.core.worktree_utils import find_current_worktree, is_root_worktree
 
 
 @click.command("current", hidden=True)
+@click.option(
+    "--json",
+    "output_json",
+    is_flag=True,
+    help="Output JSON format",
+)
 @click.pass_obj
-def current_cmd(ctx: ErkContext) -> None:
+def current_cmd(ctx: ErkContext, output_json: bool) -> None:
     """Show current erk name (hidden command for automation)."""
     # Use ctx.repo if it's a valid RepoContext, otherwise discover
     if isinstance(ctx.repo, RepoContext):
@@ -28,7 +36,17 @@ def current_cmd(ctx: ErkContext) -> None:
     if wt_info is None:
         raise SystemExit(1)
 
-    if is_root_worktree(wt_info.path, repo.root):
-        user_output("root")
+    # Determine name and is_root status
+    is_root = is_root_worktree(wt_info.path, repo.root)
+    name = "root" if is_root else wt_info.path.name
+
+    # Output based on format
+    if output_json:
+        response = CurrentCommandResponse(
+            name=name,
+            path=str(wt_info.path),
+            is_root=is_root,
+        )
+        emit_json(response.model_dump(mode="json"))
     else:
-        user_output(wt_info.path.name)
+        user_output(name)

src/erk/cli/json_schemas.py

@@ -34,6 +34,22 @@ class CreateCommandResponse(BaseModel):
     status: str = Field(..., pattern="^(created|exists)$")
 
 
+class CurrentCommandResponse(BaseModel):
+    """JSON response schema for the `erk current` command.
+
+    Attributes:
+        name: Name of the worktree (or "root" if in root worktree)
+        path: Absolute path to the worktree directory
+        is_root: Whether this is the root worktree
+    """
+
+    model_config = ConfigDict(strict=True)
+
+    name: str
+    path: str
+    is_root: bool
+
+
 class StatusWorktreeInfo(BaseModel):
     """Worktree information in status command output.
 

tests/commands/display/test_current.py

@@ -230,3 +230,137 @@ def test_current_handles_nested_worktrees(tmp_path: Path) -> None:
     # Should return the deepest (most specific) worktree
     assert result.exit_code == 0
     assert result.output.strip() == "nested"
+
+
+def test_current_json_output_for_worktree() -> None:
+    """Test that current --json outputs correct JSON structure in named worktree."""
+    import json
+
+    runner = CliRunner()
+    with erk_inmem_env(runner) as env:
+        # Construct sentinel paths (no filesystem operations needed)
+        work_dir = env.erk_root / env.cwd.name
+        feature_x_path = work_dir / "feature-x"
+
+        # Configure FakeGitOps with worktrees - feature-x is current
+        git_ops = FakeGitOps(
+            worktrees={
+                env.cwd: [
+                    WorktreeInfo(path=env.cwd, branch="main", is_root=True),
+                    WorktreeInfo(path=feature_x_path, branch="feature-x", is_root=False),
+                ]
+            },
+            current_branches={
+                env.cwd: "main",
+                feature_x_path: "feature-x",
+            },
+            git_common_dirs={
+                env.cwd: env.git_dir,
+                feature_x_path: env.git_dir,
+            },
+            default_branches={env.cwd: "main"},
+        )
+
+        # Use env.build_context() helper to eliminate boilerplate
+        test_ctx = env.build_context(git_ops=git_ops, cwd=feature_x_path, repo=env.repo)
+
+        # Run current command with --json flag
+        result = runner.invoke(cli, ["current", "--json"], obj=test_ctx)
+
+        assert result.exit_code == 0
+
+        # Parse JSON output
+        data = json.loads(result.output)
+
+        # Verify JSON structure
+        assert data["name"] == "feature-x"
+        assert data["path"] == str(feature_x_path)
+        assert data["is_root"] is False
+
+
+def test_current_json_output_for_root() -> None:
+    """Test that current --json outputs correct JSON for root worktree."""
+    import json
+
+    runner = CliRunner()
+    with erk_inmem_env(runner) as env:
+        # Configure FakeGitOps with just root worktree
+        git_ops = FakeGitOps(
+            worktrees={
+                env.cwd: [
+                    WorktreeInfo(path=env.cwd, branch="main", is_root=True),
+                ]
+            },
+            current_branches={env.cwd: "main"},
+            git_common_dirs={env.cwd: env.git_dir},
+            default_branches={env.cwd: "main"},
+        )
+
+        # Use env.build_context() helper to eliminate boilerplate
+        test_ctx = env.build_context(git_ops=git_ops, cwd=env.cwd, repo=env.repo)
+
+        # Run current command with --json flag
+        result = runner.invoke(cli, ["current", "--json"], obj=test_ctx)
+
+        assert result.exit_code == 0
+
+        # Parse JSON output
+        data = json.loads(result.output)
+
+        # Verify JSON structure for root worktree
+        assert data["name"] == "root"
+        assert data["path"] == str(env.cwd)
+        assert data["is_root"] is True
+
+
+def test_current_json_validates_schema() -> None:
+    """Test that current --json output validates against expected schema."""
+    import json
+
+    runner = CliRunner()
+    with erk_inmem_env(runner) as env:
+        # Construct sentinel paths
+        work_dir = env.erk_root / env.cwd.name
+        test_path = work_dir / "test-worktree"
+
+        # Configure FakeGitOps
+        git_ops = FakeGitOps(
+            worktrees={
+                env.cwd: [
+                    WorktreeInfo(path=env.cwd, branch="main", is_root=True),
+                    WorktreeInfo(path=test_path, branch="test", is_root=False),
+                ]
+            },
+            current_branches={
+                env.cwd: "main",
+                test_path: "test",
+            },
+            git_common_dirs={
+                env.cwd: env.git_dir,
+                test_path: env.git_dir,
+            },
+            default_branches={env.cwd: "main"},
+        )
+
+        test_ctx = env.build_context(git_ops=git_ops, cwd=test_path, repo=env.repo)
+
+        # Run current command with --json flag
+        result = runner.invoke(cli, ["current", "--json"], obj=test_ctx)
+
+        assert result.exit_code == 0
+
+        # Parse JSON output
+        data = json.loads(result.output)
+
+        # Validate all expected keys are present
+        assert "name" in data
+        assert "path" in data
+        assert "is_root" in data
+
+        # Validate types
+        assert isinstance(data["name"], str)
+        assert isinstance(data["path"], str)
+        assert isinstance(data["is_root"], bool)
+
+        # Validate path is absolute
+        assert Path(data["path"]).is_absolute()