From ce752a51f2202842d3231e6b2f59579c192a48a6 Mon Sep 17 00:00:00 2001
From: Brian Hannafious <32105697+xbrianh@users.noreply.github.com>
Date: Wed, 3 Jun 2026 12:48:01 -0600
Subject: [PATCH 1/3] Phase 1 (#1075): Add state attribute and property
 delegates to Gremlin
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add State instance attribute to Gremlin class
- Initialize state in initialize_with_runtime() and populate before each stage in _collect_stages()
- Add property delegates for all fields stages currently access:
  - gremlin.client → gremlin.state.client
  - gremlin.artifact_dir → gremlin.state.artifact_dir
  - gremlin.artifacts → gremlin.state.artifacts
  - gremlin.cwd → gremlin.state.cwd
  - gremlin.worktree → gremlin.state.worktree
  - gremlin.base_ref → gremlin.state.base_ref
  - gremlin.loop_iteration → gremlin.state.data.loop_iteration
  - gremlin.attempt → gremlin.state.data.attempt
  - gremlin.framework_subs() → gremlin.state.framework_subs()
  - gremlin.done_for() → gremlin.state.done_for()
  - gremlin.mark_done() → gremlin.state.mark_done()
  - gremlin.clear_done() → gremlin.state.clear_done()
  - gremlin.record_bail() → gremlin.state.record_bail()
  - gremlin.record_stage_progress() → gremlin.state.record_stage_progress()
  - gremlin.record_state_field() → gremlin.state.record_state_field()
- Add unit test verifying delegates are accessible after initialize_with_runtime()

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
---
 gremlins/executor/gremlin.py | 104 ++++++++++++++++++++++++++++++++++-
 tests/test_gremlin_smoke.py  |  31 +++++++++++
 2 files changed, 133 insertions(+), 2 deletions(-)

diff --git a/gremlins/executor/gremlin.py b/gremlins/executor/gremlin.py
index 16f60f30..b9083b87 100644
--- a/gremlins/executor/gremlin.py
+++ b/gremlins/executor/gremlin.py
@@ -101,6 +101,7 @@ async def run_stages(
 
 class Gremlin:
     registry: ArtifactRegistry
+    state: State | None
 
     def __init__(
         self,
@@ -146,10 +147,11 @@ def __init__(
         self.state_file = state_file
         self.project_root = project_root
         self.base_ref_sha = base_ref_sha
-        self.base_ref = base_ref
+        self._base_ref_init = base_ref
         self.fetch_worktree = fetch_worktree
         self.pipeline_path = pipeline_path
         self.pipeline_args = pipeline_args or []
+        self.state = None
 
     @property
     def artifact_dir(self) -> pathlib.Path:
@@ -163,6 +165,85 @@ def state_data(self) -> StateData:
     def finished(self) -> bool:
         return (self.state_dir / "finished").is_file()
 
+    @property
+    def client(self) -> Client:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        return self.state.client
+
+    @property
+    def artifacts(self) -> ArtifactRegistry:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        return self.state.artifacts
+
+    @property
+    def cwd(self) -> str:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        return self.state.cwd
+
+    @property
+    def worktree(self) -> pathlib.Path | None:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        return self.state.worktree
+
+    @property
+    def base_ref(self) -> str:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        return self.state.base_ref
+
+    @property
+    def loop_iteration(self) -> int:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        return self.state.data.loop_iteration
+
+    @property
+    def attempt(self) -> str:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        return self.state.data.attempt
+
+    def framework_subs(self, stage: StageProtocol) -> dict[str, str]:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        return self.state.framework_subs(stage)
+
+    def done_for(self, path: str) -> set[str]:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        return self.state.done_for(path)
+
+    def mark_done(self, path: str, child_name: str) -> None:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        self.state.mark_done(path, child_name)
+
+    def clear_done(self, path: str) -> None:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        self.state.clear_done(path)
+
+    def record_bail(self, reason: str, *, kind: str = "other") -> None:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        self.state.record_bail(reason, kind=kind)
+
+    def record_stage_progress(
+        self, name: str, sub_stage: object = None, *, parent_stage: str = ""
+    ) -> None:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        self.state.record_stage_progress(name, sub_stage, parent_stage=parent_stage)
+
+    def record_state_field(self, **fields: Any) -> None:
+        if self.state is None:
+            raise RuntimeError("state not yet initialized")
+        self.state.record_state_field(**fields)
+
     async def fork(
         self,
         state: State,
@@ -298,8 +379,9 @@ def _collect_stages(
                 worktree=self.worktree_dir,
                 worktree_parent=self.worktree_parent,
                 artifacts=self.registry,
-                base_ref=self.base_ref,
+                base_ref=self._base_ref_init,
             )
+            self.state = stage_state
             built.append((e.name, stage_state.make_runner(e, scope=stages)))
         return built
 
@@ -512,6 +594,24 @@ def initialize_with_runtime(
                 sha = _git_mod.head_sha(cwd=self.worktree_dir)
                 if sha:
                     self.registry.bind("base_sha", Uri.parse(f"git://commit/{sha}"))
+
+            cwd = (
+                str(self.worktree_dir)
+                if self.worktree_dir is not None
+                else (self.project_root or str(pathlib.Path.cwd()))
+            )
+            self.state = build_state(
+                data=StateData(gremlin_id=self.gremlin_id, state_file=None),
+                client=resolved_client or PACKAGE_DEFAULT,
+                artifact_dir=self.artifact_dir,
+                pipeline_data=self.pipeline_data,
+                repo=self.repo,
+                cwd=cwd,
+                worktree=self.worktree_dir,
+                worktree_parent=self.worktree_parent,
+                artifacts=self.registry,
+                base_ref=base_ref,
+            )
         except Exception:
             if worktree_created:
                 _git_mod.remove_worktree(self.project_root, worktree_created)
diff --git a/tests/test_gremlin_smoke.py b/tests/test_gremlin_smoke.py
index 55269c89..38407b30 100644
--- a/tests/test_gremlin_smoke.py
+++ b/tests/test_gremlin_smoke.py
@@ -5,6 +5,7 @@
 import asyncio
 import json
 import os
+import pathlib
 import shutil
 import subprocess
 
@@ -141,3 +142,33 @@ def test_resume_unbind_only_affects_exec_stages(tmp_path):
     gremlin._unbind_stale_exec_artifacts()
     assert not gremlin.registry.produced("work-out")
     assert gremlin.registry.produced("non-exec-artifact")
+
+
+def test_gremlin_state_delegates_after_initialize(project_dir, pipeline_yaml, sandbox):
+    gremlin_id = "state-delegates-abc123"
+    sd = sandbox.state / gremlin_id
+
+    gremlin = Gremlin.initialize_with_runtime(
+        gremlin_id=gremlin_id,
+        state_dir=sd,
+        project_dir=project_dir,
+        pipeline_ref=str(pipeline_yaml),
+        project_root=str(project_dir),
+        base_ref="main",
+        repo="test/repo",
+    )
+
+    # Test that state is initialized after initialize_with_runtime
+    assert gremlin.state is not None
+
+    # Test property delegates
+    assert isinstance(gremlin.artifact_dir, pathlib.Path)
+    assert gremlin.artifact_dir == sd / "artifacts"
+    assert gremlin.artifacts is not None
+    assert isinstance(gremlin.artifacts, ArtifactRegistry)
+    assert gremlin.client is not None
+    assert isinstance(gremlin.cwd, str)
+    assert gremlin.base_ref == "main"
+    assert gremlin.repo == "test/repo"
+    assert gremlin.loop_iteration == 1
+    assert gremlin.attempt == ""

From fff891aec48cd70d8dae0cec8a45510b2a4a0a55 Mon Sep 17 00:00:00 2001
From: Brian Hannafious <32105697+xbrianh@users.noreply.github.com>
Date: Wed, 3 Jun 2026 12:50:24 -0600
Subject: [PATCH 2/3] Address review feedback
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1. Consolidate 13 identical state-initialization guards into a single _s property accessor, reducing boilerplate by 52 lines.

2. Extract the three-way cwd resolution (worktree → project_root → cwd) into a reusable _resolved_cwd property, eliminating a verbatim duplication between _collect_stages and initialize_with_runtime.

3. Remove self.state overwrite inside _collect_stages loop. Per-stage states are now used only where needed (stage_state.make_runner); the canonical state set in initialize_with_runtime is no longer clobbered by intermediate iterations.

4. Add test_gremlin_state_unchanged_after_run to verify that gremlin.state properties (client, base_ref, repo) correctly reflect canonical values after run() completes, exercising the fixed code path.

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
---
 gremlins/executor/gremlin.py | 83 +++++++++++++-----------------------
 tests/test_gremlin_smoke.py  | 38 +++++++++++++++++
 2 files changed, 67 insertions(+), 54 deletions(-)

diff --git a/gremlins/executor/gremlin.py b/gremlins/executor/gremlin.py
index b9083b87..6a586039 100644
--- a/gremlins/executor/gremlin.py
+++ b/gremlins/executor/gremlin.py
@@ -166,83 +166,61 @@ def finished(self) -> bool:
         return (self.state_dir / "finished").is_file()
 
     @property
-    def client(self) -> Client:
+    def _s(self) -> State:
         if self.state is None:
             raise RuntimeError("state not yet initialized")
-        return self.state.client
+        return self.state
+
+    @property
+    def client(self) -> Client:
+        return self._s.client
 
     @property
     def artifacts(self) -> ArtifactRegistry:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        return self.state.artifacts
+        return self._s.artifacts
 
     @property
     def cwd(self) -> str:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        return self.state.cwd
+        return self._s.cwd
 
     @property
     def worktree(self) -> pathlib.Path | None:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        return self.state.worktree
+        return self._s.worktree
 
     @property
     def base_ref(self) -> str:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        return self.state.base_ref
+        return self._s.base_ref
 
     @property
     def loop_iteration(self) -> int:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        return self.state.data.loop_iteration
+        return self._s.data.loop_iteration
 
     @property
     def attempt(self) -> str:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        return self.state.data.attempt
+        return self._s.data.attempt
 
     def framework_subs(self, stage: StageProtocol) -> dict[str, str]:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        return self.state.framework_subs(stage)
+        return self._s.framework_subs(stage)
 
     def done_for(self, path: str) -> set[str]:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        return self.state.done_for(path)
+        return self._s.done_for(path)
 
     def mark_done(self, path: str, child_name: str) -> None:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        self.state.mark_done(path, child_name)
+        self._s.mark_done(path, child_name)
 
     def clear_done(self, path: str) -> None:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        self.state.clear_done(path)
+        self._s.clear_done(path)
 
     def record_bail(self, reason: str, *, kind: str = "other") -> None:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        self.state.record_bail(reason, kind=kind)
+        self._s.record_bail(reason, kind=kind)
 
     def record_stage_progress(
         self, name: str, sub_stage: object = None, *, parent_stage: str = ""
     ) -> None:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        self.state.record_stage_progress(name, sub_stage, parent_stage=parent_stage)
+        self._s.record_stage_progress(name, sub_stage, parent_stage=parent_stage)
 
     def record_state_field(self, **fields: Any) -> None:
-        if self.state is None:
-            raise RuntimeError("state not yet initialized")
-        self.state.record_state_field(**fields)
+        self._s.record_state_field(**fields)
 
     async def fork(
         self,
@@ -351,6 +329,14 @@ def validate_resume_target(self) -> None:
                 f"valid: {valid_names}"
             )
 
+    @property
+    def _resolved_cwd(self) -> str:
+        return (
+            str(self.worktree_dir)
+            if self.worktree_dir is not None
+            else (self.project_root or str(pathlib.Path.cwd()))
+        )
+
     def _set_gremlin_recursive(self, stage: StageProtocol) -> None:
         stage.gremlin = self
         body = getattr(stage, "body", [])
@@ -360,11 +346,6 @@ def _set_gremlin_recursive(self, stage: StageProtocol) -> None:
     def _collect_stages(
         self, stages: Sequence[StageProtocol]
     ) -> list[tuple[str, Callable[[], Awaitable[Any]]]]:
-        cwd = (
-            str(self.worktree_dir)
-            if self.worktree_dir is not None
-            else (self.project_root or str(pathlib.Path.cwd()))
-        )
         built: list[tuple[str, Callable[[], Awaitable[Any]]]] = []
         for e in stages:
             self._set_gremlin_recursive(e)
@@ -375,13 +356,12 @@ def _collect_stages(
                 artifact_dir=self.artifact_dir,
                 pipeline_data=self.pipeline_data,
                 repo=self.repo,
-                cwd=cwd,
+                cwd=self._resolved_cwd,
                 worktree=self.worktree_dir,
                 worktree_parent=self.worktree_parent,
                 artifacts=self.registry,
                 base_ref=self._base_ref_init,
             )
-            self.state = stage_state
             built.append((e.name, stage_state.make_runner(e, scope=stages)))
         return built
 
@@ -595,18 +575,13 @@ def initialize_with_runtime(
                 if sha:
                     self.registry.bind("base_sha", Uri.parse(f"git://commit/{sha}"))
 
-            cwd = (
-                str(self.worktree_dir)
-                if self.worktree_dir is not None
-                else (self.project_root or str(pathlib.Path.cwd()))
-            )
             self.state = build_state(
                 data=StateData(gremlin_id=self.gremlin_id, state_file=None),
                 client=resolved_client or PACKAGE_DEFAULT,
                 artifact_dir=self.artifact_dir,
                 pipeline_data=self.pipeline_data,
                 repo=self.repo,
-                cwd=cwd,
+                cwd=self._resolved_cwd,
                 worktree=self.worktree_dir,
                 worktree_parent=self.worktree_parent,
                 artifacts=self.registry,
diff --git a/tests/test_gremlin_smoke.py b/tests/test_gremlin_smoke.py
index 38407b30..4c960738 100644
--- a/tests/test_gremlin_smoke.py
+++ b/tests/test_gremlin_smoke.py
@@ -172,3 +172,41 @@ def test_gremlin_state_delegates_after_initialize(project_dir, pipeline_yaml, sa
     assert gremlin.repo == "test/repo"
     assert gremlin.loop_iteration == 1
     assert gremlin.attempt == ""
+
+
+def test_gremlin_state_unchanged_after_run(project_dir, pipeline_yaml, sandbox):
+    gremlin_id = "state-run-abc123"
+    sd = sandbox.state / gremlin_id
+
+    saved_cwd = os.getcwd()
+    worktree = None
+    rc = 1
+    try:
+        gremlin = Gremlin.initialize_with_runtime(
+            gremlin_id=gremlin_id,
+            state_dir=sd,
+            project_dir=project_dir,
+            pipeline_ref=str(pipeline_yaml),
+            project_root=str(project_dir),
+            base_ref="main",
+            repo="test/repo",
+        )
+        worktree = gremlin.worktree_dir
+
+        # Capture state values before run()
+        initial_client = gremlin.client
+        initial_base_ref = gremlin.base_ref
+        initial_repo = gremlin.repo
+
+        asyncio.run(gremlin.run())
+        rc = 0
+
+        # Assert state still reflects canonical values after run()
+        assert gremlin.client == initial_client
+        assert gremlin.base_ref == initial_base_ref
+        assert gremlin.repo == initial_repo
+    finally:
+        os.chdir(saved_cwd)
+        StateData.load(gremlin_id).write_terminal_state(rc)
+        if worktree and worktree.is_dir():
+            shutil.rmtree(worktree, ignore_errors=True)

From f2cdcd8c47e813a1374bcfb0fab5974939319cc2 Mon Sep 17 00:00:00 2001
From: Brian Hannafious <32105697+xbrianh@users.noreply.github.com>
Date: Wed, 3 Jun 2026 12:58:16 -0600
Subject: [PATCH 3/3] Address review comments on state delegates PR

1. Add cleanup to test_gremlin_state_delegates_after_initialize:
   - Save/restore working directory with try/finally block
   - Clean up worktree directory to prevent state leakage across tests
   - Use gremlin.worktree instead of gremlin.worktree_dir

2. Remove redundant comments from both delegate tests:
   - Drop "# Test that state is initialized..." comments
   - Drop "# Capture state values..." and "# Assert state still..." comments
   - Let assertions speak for themselves

3. Resolve worktree_dir/worktree shadowing confusion:
   - Rename worktree_dir to _worktree_dir (internal only)
   - Update all internal references to use _worktree_dir
   - Update public API callers to use state delegate (gremlin.worktree)
   - Remove worktree_dir assertion from test_gremlin_open

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
---
 gremlins/executor/gremlin.py | 22 +++++++-------
 gremlins/executor/run.py     |  2 +-
 tests/test_gremlin_open.py   |  1 -
 tests/test_gremlin_smoke.py  | 59 +++++++++++++++++++-----------------
 4 files changed, 43 insertions(+), 41 deletions(-)

diff --git a/gremlins/executor/gremlin.py b/gremlins/executor/gremlin.py
index 6a586039..8efeebd9 100644
--- a/gremlins/executor/gremlin.py
+++ b/gremlins/executor/gremlin.py
@@ -140,7 +140,7 @@ def __init__(
         self.state_dir = state_dir
         self.gremlin_id = gremlin_id
         self.pipeline_data = pipeline_data
-        self.worktree_dir = worktree_dir
+        self._worktree_dir = worktree_dir
         self.worktree_parent = worktree_parent
         self.resume_from = resume_from
         self.repo = repo
@@ -332,8 +332,8 @@ def validate_resume_target(self) -> None:
     @property
     def _resolved_cwd(self) -> str:
         return (
-            str(self.worktree_dir)
-            if self.worktree_dir is not None
+            str(self._worktree_dir)
+            if self._worktree_dir is not None
             else (self.project_root or str(pathlib.Path.cwd()))
         )
 
@@ -357,7 +357,7 @@ def _collect_stages(
                 pipeline_data=self.pipeline_data,
                 repo=self.repo,
                 cwd=self._resolved_cwd,
-                worktree=self.worktree_dir,
+                worktree=self._worktree_dir,
                 worktree_parent=self.worktree_parent,
                 artifacts=self.registry,
                 base_ref=self._base_ref_init,
@@ -541,7 +541,7 @@ def initialize_with_runtime(
 
         worktree_created: str | None = None
         try:
-            if self.worktree_dir is None and self.project_root and self.gremlin_id:
+            if self._worktree_dir is None and self.project_root and self.gremlin_id:
                 workdir = _git_mod.setup_workdir(
                     self.project_root,
                     self.base_ref_sha,
@@ -550,7 +550,7 @@ def initialize_with_runtime(
                     worktree_parent=self.worktree_parent,
                 )
                 worktree_created = workdir
-                self.worktree_dir = pathlib.Path(workdir)
+                self._worktree_dir = pathlib.Path(workdir)
                 st = StateData.load(self.gremlin_id)
                 st.patch(
                     workdir=workdir,
@@ -558,12 +558,12 @@ def initialize_with_runtime(
                     setup_kind="worktree-detached",
                 )
 
-            if self.worktree_dir is not None:
-                os.chdir(self.worktree_dir)
+            if self._worktree_dir is not None:
+                os.chdir(self._worktree_dir)
 
             self.registry = ArtifactRegistry(
                 artifact_dir=self.artifact_dir,
-                cwd=self.worktree_dir,
+                cwd=self._worktree_dir,
             )
             for key, value in (stage_inputs or {}).items():
                 if value is not None and not self.registry.produced(key):
@@ -571,7 +571,7 @@ def initialize_with_runtime(
             if not self.registry.produced("spec"):
                 self.registry.bind("spec", Uri.parse("file://session/spec.md"))
             if not self.registry.produced("base_sha"):
-                sha = _git_mod.head_sha(cwd=self.worktree_dir)
+                sha = _git_mod.head_sha(cwd=self._worktree_dir)
                 if sha:
                     self.registry.bind("base_sha", Uri.parse(f"git://commit/{sha}"))
 
@@ -582,7 +582,7 @@ def initialize_with_runtime(
                 pipeline_data=self.pipeline_data,
                 repo=self.repo,
                 cwd=self._resolved_cwd,
-                worktree=self.worktree_dir,
+                worktree=self._worktree_dir,
                 worktree_parent=self.worktree_parent,
                 artifacts=self.registry,
                 base_ref=base_ref,
diff --git a/gremlins/executor/run.py b/gremlins/executor/run.py
index bc84015f..72de644b 100644
--- a/gremlins/executor/run.py
+++ b/gremlins/executor/run.py
@@ -261,7 +261,7 @@ async def run_pipeline(
     _env_file = paths.project_overlay_dir(_project_root) / "env"
     if _env_file.is_file():
         os.environ["GREMLINS_WORKTREE_PATH"] = (
-            str(gremlin.worktree_dir) if gremlin.worktree_dir else ""
+            str(gremlin.worktree) if gremlin.worktree else ""
         )
         os.environ["GREMLINS_ARTIFACT_DIR"] = str(gremlin.artifact_dir)
         try:
diff --git a/tests/test_gremlin_open.py b/tests/test_gremlin_open.py
index ee3ac00f..54f67f2b 100644
--- a/tests/test_gremlin_open.py
+++ b/tests/test_gremlin_open.py
@@ -85,7 +85,6 @@ def test_gremlin_open_valid_state(sandbox, project_dir, pipeline_yaml):
 
     assert gremlin.gremlin_id == gremlin_id
     assert gremlin.project_root == str(project_dir)
-    assert gremlin.worktree_dir == pathlib.Path("/tmp/worktree")
     assert gremlin.pipeline_data is not None
 
 
diff --git a/tests/test_gremlin_smoke.py b/tests/test_gremlin_smoke.py
index 4c960738..bccbc108 100644
--- a/tests/test_gremlin_smoke.py
+++ b/tests/test_gremlin_smoke.py
@@ -84,7 +84,7 @@ def test_gremlin_run_in_process(project_dir, pipeline_yaml, sandbox):
             pipeline_ref=str(pipeline_yaml),
             project_root=str(project_dir),
         )
-        worktree = gremlin.worktree_dir
+        worktree = gremlin.worktree
         asyncio.run(gremlin.run())
         rc = 0
     finally:
@@ -148,30 +148,35 @@ def test_gremlin_state_delegates_after_initialize(project_dir, pipeline_yaml, sa
     gremlin_id = "state-delegates-abc123"
     sd = sandbox.state / gremlin_id
 
-    gremlin = Gremlin.initialize_with_runtime(
-        gremlin_id=gremlin_id,
-        state_dir=sd,
-        project_dir=project_dir,
-        pipeline_ref=str(pipeline_yaml),
-        project_root=str(project_dir),
-        base_ref="main",
-        repo="test/repo",
-    )
-
-    # Test that state is initialized after initialize_with_runtime
-    assert gremlin.state is not None
-
-    # Test property delegates
-    assert isinstance(gremlin.artifact_dir, pathlib.Path)
-    assert gremlin.artifact_dir == sd / "artifacts"
-    assert gremlin.artifacts is not None
-    assert isinstance(gremlin.artifacts, ArtifactRegistry)
-    assert gremlin.client is not None
-    assert isinstance(gremlin.cwd, str)
-    assert gremlin.base_ref == "main"
-    assert gremlin.repo == "test/repo"
-    assert gremlin.loop_iteration == 1
-    assert gremlin.attempt == ""
+    saved_cwd = os.getcwd()
+    worktree = None
+    try:
+        gremlin = Gremlin.initialize_with_runtime(
+            gremlin_id=gremlin_id,
+            state_dir=sd,
+            project_dir=project_dir,
+            pipeline_ref=str(pipeline_yaml),
+            project_root=str(project_dir),
+            base_ref="main",
+            repo="test/repo",
+        )
+        worktree = gremlin.worktree
+
+        assert gremlin.state is not None
+        assert isinstance(gremlin.artifact_dir, pathlib.Path)
+        assert gremlin.artifact_dir == sd / "artifacts"
+        assert gremlin.artifacts is not None
+        assert isinstance(gremlin.artifacts, ArtifactRegistry)
+        assert gremlin.client is not None
+        assert isinstance(gremlin.cwd, str)
+        assert gremlin.base_ref == "main"
+        assert gremlin.repo == "test/repo"
+        assert gremlin.loop_iteration == 1
+        assert gremlin.attempt == ""
+    finally:
+        os.chdir(saved_cwd)
+        if worktree and worktree.is_dir():
+            shutil.rmtree(worktree, ignore_errors=True)
 
 
 def test_gremlin_state_unchanged_after_run(project_dir, pipeline_yaml, sandbox):
@@ -191,9 +196,8 @@ def test_gremlin_state_unchanged_after_run(project_dir, pipeline_yaml, sandbox):
             base_ref="main",
             repo="test/repo",
         )
-        worktree = gremlin.worktree_dir
+        worktree = gremlin.worktree
 
-        # Capture state values before run()
         initial_client = gremlin.client
         initial_base_ref = gremlin.base_ref
         initial_repo = gremlin.repo
@@ -201,7 +205,6 @@ def test_gremlin_state_unchanged_after_run(project_dir, pipeline_yaml, sandbox):
         asyncio.run(gremlin.run())
         rc = 0
 
-        # Assert state still reflects canonical values after run()
         assert gremlin.client == initial_client
         assert gremlin.base_ref == initial_base_ref
         assert gremlin.repo == initial_repo