prizmkit 1.1.160 → 1.1.161

package/bundled/dev-pipeline/tests/test_runtime_commit.py

@@ -171,16 +171,15 @@ def _write_commit_ready_checkpoint(root: Path) -> tuple[Path, Path]:
     return artifact_dir, checkpoint_path
 
 
-def _write_request(root: Path, artifact_dir: Path, base_head: str, paths: list[str]) -> Path:
+def _write_request(root: Path, artifact_dir: Path, base_head: str) -> Path:
     request_path = artifact_dir / "runtime-commit-request.json"
     request_path.write_text(
         json.dumps(
             {
-                "schema_version": 1,
+                "schema_version": 2,
                 "artifact_dir": artifact_dir.relative_to(root).as_posix(),
                 "base_head": base_head,
                 "commit_message": "fix(runtime): finalize prepared task",
-                "intended_paths": paths,
             }
         ),
         encoding="utf-8",
@@ -188,7 +187,7 @@ def _write_request(root: Path, artifact_dir: Path, base_head: str, paths: list[s
     return request_path
 
 
-def test_runtime_commit_executes_exact_request_and_finalizes_only_checkpoint(tmp_path):
+def test_runtime_commit_executes_complete_workspace_and_finalizes_only_checkpoint(tmp_path):
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     caller_state = tmp_path / ".prizmkit" / "state" / "workflows" / "caller.json"
@@ -196,7 +195,7 @@ def test_runtime_commit_executes_exact_request_and_finalizes_only_checkpoint(tmp
     caller_state.write_text('{"owner":"external-coordinator"}\n', encoding="utf-8")
     expected_caller_state = caller_state.read_bytes()
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    _write_request(tmp_path, artifact_dir, base_head)
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -229,7 +228,7 @@ def test_runtime_commit_executes_exact_request_and_finalizes_only_checkpoint(tmp
         ".prizmkit/prizm-docs/src/counter.prizm",
     ],
 )
-def test_runtime_commit_admits_tracked_prizmkit_path_in_exact_request(tmp_path, durable_path):
+def test_runtime_commit_includes_tracked_prizmkit_path_from_workspace(tmp_path, durable_path):
     _init_repo(tmp_path)
     durable = tmp_path / durable_path
     durable.parent.mkdir(parents=True, exist_ok=True)
@@ -240,7 +239,7 @@ def test_runtime_commit_admits_tracked_prizmkit_path_in_exact_request(tmp_path,
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
     durable.write_text("after\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt", durable_path])
+    _write_request(tmp_path, artifact_dir, base_head)
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -261,7 +260,7 @@ def test_runtime_commit_admits_tracked_prizmkit_path_in_exact_request(tmp_path,
     assert durable.read_text(encoding="utf-8") == "after\n"
 
 
-def test_runtime_commit_ignores_runner_support_paths_but_leaves_them_unmodified(tmp_path):
+def test_runtime_commit_includes_valid_host_support_paths_from_workspace(tmp_path):
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
@@ -269,7 +268,7 @@ def test_runtime_commit_ignores_runner_support_paths_but_leaves_them_unmodified(
     codex_config = tmp_path / ".codex" / "config.toml"
     codex_config.parent.mkdir()
     codex_config.write_text("[project]\ntrusted = true\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    _write_request(tmp_path, artifact_dir, base_head)
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -278,11 +277,11 @@ def test_runtime_commit_ignores_runner_support_paths_but_leaves_them_unmodified(
     )
 
     assert result.status == "committed"
-    assert _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD") == "tracked.txt"
-    assert (tmp_path / "AGENTS.md").read_text(encoding="utf-8") == "@./AGENTS.private.md\n"
-    assert codex_config.read_text(encoding="utf-8") == "[project]\ntrusted = true\n"
-    untracked = set(_git(tmp_path, "ls-files", "--others", "--exclude-standard").splitlines())
-    assert {"AGENTS.md", ".codex/config.toml"}.issubset(untracked)
+    changed = set(
+        _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD").splitlines()
+    )
+    assert changed == {"tracked.txt", "AGENTS.md", ".codex/config.toml"}
+    assert _git(tmp_path, "status", "--porcelain") == ""
 
 
 def test_runtime_commit_allows_task_path_adjacent_to_internal_namespace(tmp_path):
@@ -291,7 +290,7 @@ def test_runtime_commit_allows_task_path_adjacent_to_internal_namespace(tmp_path
     adjacent_path = tmp_path / ".prizmkitx" / "task.txt"
     adjacent_path.parent.mkdir()
     adjacent_path.write_text("task-owned\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, [".prizmkitx/task.txt"])
+    _write_request(tmp_path, artifact_dir, base_head)
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -315,7 +314,7 @@ def test_runtime_commit_ignores_project_gitignored_transient_data(tmp_path):
     transient = tmp_path / "tmp" / "tool-cache.json"
     transient.parent.mkdir()
     transient.write_text('{"cache":true}\n', encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    _write_request(tmp_path, artifact_dir, base_head)
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -328,12 +327,12 @@ def test_runtime_commit_ignores_project_gitignored_transient_data(tmp_path):
     assert transient.read_text(encoding="utf-8") == '{"cache":true}\n'
 
 
-def test_runtime_commit_rejects_unlisted_git_visible_change(tmp_path):
+def test_runtime_commit_includes_preexisting_git_visible_change_without_manifest(tmp_path):
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    (tmp_path / "unexpected.txt").write_text("unexpected\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    (tmp_path / "preexisting.txt").write_text("validated existing work\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head)
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -341,16 +340,18 @@ def test_runtime_commit_rejects_unlisted_git_visible_change(tmp_path):
         checkpoint_path=checkpoint_path,
     )
 
-    assert result.status == "failed"
-    assert result.reason == "intended_paths_mismatch"
-    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+    assert result.status == "committed"
+    changed = set(
+        _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD").splitlines()
+    )
+    assert changed == {"tracked.txt", "preexisting.txt"}
 
 
 def test_runtime_commit_recovers_commit_created_before_state_finalization(tmp_path):
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    _write_request(tmp_path, artifact_dir, base_head)
     _git(tmp_path, "add", "tracked.txt")
     _git(tmp_path, "commit", "-m", "fix(runtime): finalize prepared task")
     committed_head = _git(tmp_path, "rev-parse", "HEAD")
@@ -367,15 +368,38 @@ def test_runtime_commit_recovers_commit_created_before_state_finalization(tmp_pa
     assert _git(tmp_path, "rev-list", "--count", f"{base_head}..HEAD") == "1"
 
 
+def test_runtime_commit_rejects_recovery_commit_containing_causal_bookkeeping(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    request_path = _write_request(tmp_path, artifact_dir, base_head)
+    _git(
+        tmp_path,
+        "add",
+        "-f",
+        "tracked.txt",
+        checkpoint_path.relative_to(tmp_path).as_posix(),
+        request_path.relative_to(tmp_path).as_posix(),
+    )
+    _git(tmp_path, "commit", "-m", "fix(runtime): finalize prepared task")
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "base_head_mismatch"
+
+
 def test_runtime_commit_recovers_after_checkpoint_finalization_failure(tmp_path, monkeypatch):
     import prizmkit_runtime.runtime_commit as runtime_commit
 
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    request_path = _write_request(
-        tmp_path, artifact_dir, base_head, ["tracked.txt"]
-    )
+    request_path = _write_request(tmp_path, artifact_dir, base_head)
 
     original_finalize = runtime_commit._finalize_checkpoint
     monkeypatch.setattr(
@@ -412,9 +436,7 @@ def test_runtime_commit_recovers_cleanup_after_completed_checkpoint(tmp_path, mo
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    request_path = _write_request(
-        tmp_path, artifact_dir, base_head, ["tracked.txt"]
-    )
+    request_path = _write_request(tmp_path, artifact_dir, base_head)
 
     original_unlink = Path.unlink
 
@@ -457,7 +479,7 @@ def test_runtime_commit_disables_repository_hooks(tmp_path):
     )
     hook.chmod(0o755)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    _write_request(tmp_path, artifact_dir, base_head)
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -479,12 +501,7 @@ def test_runtime_commit_handles_rename_as_exact_delete_and_add(tmp_path):
     base_head = _git(tmp_path, "rev-parse", "HEAD")
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     old_path.rename(tmp_path / "new-name.txt")
-    _write_request(
-        tmp_path,
-        artifact_dir,
-        base_head,
-        ["old-name.txt", "new-name.txt"],
-    )
+    _write_request(tmp_path, artifact_dir, base_head)
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -508,27 +525,116 @@ def test_runtime_commit_handles_rename_as_exact_delete_and_add(tmp_path):
 @pytest.mark.parametrize(
     "unsafe_path",
     [
-        "../escape.txt",
-        ".git/config",
         ".env",
-        "AGENTS.md",
-        "skills-lock.json",
-        ".codex/config.toml",
-        ".CLAUDE/settings.local.json",
-        ".prizmkit/prizm-docs/.env",
-        ".prizmkit/state/runtime.json",
-        ".prizmkit/dev-pipeline/cli.py",
-        ".prizmkit/scripts/helper.py",
-        ".prizmkit/manifest.json",
-        ".prizmkit/specs/001-runtime-commit/workflow-checkpoint.json",
-        ".prizmkit/specs/001-runtime-commit/runtime-commit-request.json",
+        "credentials.json",
+        "secrets.json",
+        "private.pem",
+        ".codex/settings.local.json",
     ],
 )
-def test_runtime_commit_rejects_unsafe_intended_paths(tmp_path, unsafe_path):
+def test_runtime_commit_rejects_sensitive_git_visible_workspace_path(tmp_path, unsafe_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    unsafe = tmp_path / unsafe_path
+    unsafe.parent.mkdir(parents=True, exist_ok=True)
+    unsafe.write_text("sensitive\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head)
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "sensitive_workspace_path"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+
+
+def test_runtime_commit_rejects_empty_workspace(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    _write_request(tmp_path, artifact_dir, base_head)
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "empty_workspace_change"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+
+
+def test_runtime_commit_rejects_unresolved_merge_state(tmp_path):
+    _init_repo(tmp_path)
+    initial_branch = _git(tmp_path, "branch", "--show-current")
+    _git(tmp_path, "checkout", "-b", "other")
+    (tmp_path / "tracked.txt").write_text("other\n", encoding="utf-8")
+    _git(tmp_path, "add", "tracked.txt")
+    _git(tmp_path, "commit", "-m", "other change")
+    _git(tmp_path, "checkout", initial_branch)
+    (tmp_path / "tracked.txt").write_text("master\n", encoding="utf-8")
+    _git(tmp_path, "add", "tracked.txt")
+    _git(tmp_path, "commit", "-m", "master change")
+    base_head = _git(tmp_path, "rev-parse", "HEAD")
+    merged = subprocess.run(
+        ["git", "merge", "other"],
+        cwd=tmp_path,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        check=False,
+    )
+    assert merged.returncode != 0
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    _write_request(tmp_path, artifact_dir, base_head)
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "unresolved_merge_state"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+
+
+def test_runtime_commit_rejects_already_staged_runtime_bookkeeping(tmp_path):
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, [unsafe_path])
+    request_path = _write_request(tmp_path, artifact_dir, base_head)
+    _git(
+        tmp_path,
+        "add",
+        "-f",
+        checkpoint_path.relative_to(tmp_path).as_posix(),
+        request_path.relative_to(tmp_path).as_posix(),
+    )
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "runtime_bookkeeping_staged"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+
+
+def test_runtime_commit_rejects_schema_v1_path_manifest(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    request_path = _write_request(tmp_path, artifact_dir, base_head)
+    request = json.loads(request_path.read_text(encoding="utf-8"))
+    request["schema_version"] = 1
+    request["intended_paths"] = ["tracked.txt"]
+    request_path.write_text(json.dumps(request), encoding="utf-8")
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -537,11 +643,11 @@ def test_runtime_commit_rejects_unsafe_intended_paths(tmp_path, unsafe_path):
     )
 
     assert result.status == "failed"
-    assert result.reason == "commit_request_path_unsafe"
+    assert result.reason == "commit_request_invalid_schema"
     assert _git(tmp_path, "rev-parse", "HEAD") == base_head
 
 
-def test_runtime_commit_verifies_staged_set_before_commit(tmp_path):
+def test_runtime_commit_includes_already_staged_and_unstaged_workspace(tmp_path):
     _init_repo(tmp_path)
     support = tmp_path / "AGENTS.md"
     support.write_text("before\n", encoding="utf-8")
@@ -552,7 +658,7 @@ def test_runtime_commit_verifies_staged_set_before_commit(tmp_path):
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
     support.write_text("after\n", encoding="utf-8")
     _git(tmp_path, "add", "AGENTS.md")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    _write_request(tmp_path, artifact_dir, base_head)
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -560,9 +666,11 @@ def test_runtime_commit_verifies_staged_set_before_commit(tmp_path):
         checkpoint_path=checkpoint_path,
     )
 
-    assert result.status == "failed"
-    assert result.reason == "staged_paths_mismatch"
-    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+    assert result.status == "committed"
+    changed = set(
+        _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD").splitlines()
+    )
+    assert changed == {"AGENTS.md", "tracked.txt"}
 
 
 def test_runtime_commit_keeps_tracked_post_commit_bookkeeping_out_of_snapshot(tmp_path):
@@ -570,13 +678,13 @@ def test_runtime_commit_keeps_tracked_post_commit_bookkeeping_out_of_snapshot(tm
 
     initial_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
-    request_path = _write_request(tmp_path, artifact_dir, initial_head, ["tracked.txt"])
+    request_path = _write_request(tmp_path, artifact_dir, initial_head)
     checkpoint_rel = checkpoint_path.relative_to(tmp_path).as_posix()
     request_rel = request_path.relative_to(tmp_path).as_posix()
     _git(tmp_path, "add", "-f", checkpoint_rel, request_rel)
     _git(tmp_path, "commit", "-m", "track runtime bookkeeping by project policy")
     base_head = _git(tmp_path, "rev-parse", "HEAD")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    _write_request(tmp_path, artifact_dir, base_head)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
 
     result = finalize_runtime_commit(
@@ -606,9 +714,7 @@ def test_runtime_commit_rejects_caller_orchestration_fields(tmp_path):
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    request_path = _write_request(
-        tmp_path, artifact_dir, base_head, ["tracked.txt"]
-    )
+    request_path = _write_request(tmp_path, artifact_dir, base_head)
     request = json.loads(request_path.read_text(encoding="utf-8"))
     request["caller_state_path"] = ".runtime/caller-state.json"
     request_path.write_text(json.dumps(request), encoding="utf-8")
@@ -628,9 +734,7 @@ def test_runtime_commit_rejects_ai_supplied_premature_runtime_hash(tmp_path):
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    request_path = _write_request(
-        tmp_path, artifact_dir, base_head, ["tracked.txt"]
-    )
+    request_path = _write_request(tmp_path, artifact_dir, base_head)
     request = json.loads(request_path.read_text(encoding="utf-8"))
     request["runtime_commit_hash"] = "a" * 40
     request_path.write_text(json.dumps(request), encoding="utf-8")
@@ -650,7 +754,7 @@ def test_runtime_commit_rejects_stale_base_head(tmp_path):
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, "a" * 40, ["tracked.txt"])
+    _write_request(tmp_path, artifact_dir, "a" * 40)
 
     result = finalize_runtime_commit(
         tmp_path,

package/bundled/dev-pipeline/tests/test_unified_cli.py

@@ -1313,8 +1313,9 @@ def test_headless_review_guidance_maps_stage_local_skill_result():
 
     skill_text = skill_path.read_text(encoding="utf-8")
     assert "the staged diff, and the unstaged diff" in skill_text
-    assert "untracked, deleted, and renamed paths" in skill_text
-    assert "default-excluded changed paths" in skill_text
+    assert "non-ignored untracked, deleted, renamed, and copied paths" in skill_text
+    assert "Do not maintain excluded-path metadata" in skill_text
+    assert "complete current Git-visible workspace" in skill_text
     assert "accepted = 0" in skill_text
     assert "ten completed review rounds" in skill_text
     assert "## Phase 3: Independent Code Review" in skill_text
@@ -2391,7 +2392,7 @@ def test_heartbeat_observation_stale_accumulates_by_elapsed_time_and_resets_on_p
     session_log = tmp_path / "session.log"
     progress = tmp_path / "progress.json"
     session_log.write_text("initial\n", encoding="utf-8")
-    progress.write_text('{"current_phase":"plan","current_tool":"Read","message_count":1,"total_tool_calls":1}\n', encoding="utf-8")
+    progress.write_text('{"current_phase":"plan","current_tool":null,"message_count":1,"total_tool_calls":1}\n', encoding="utf-8")
     config = HeartbeatConfig(
         heartbeat_file=tmp_path / "heartbeat.json",
         session_log=session_log,
@@ -2419,6 +2420,72 @@ def test_heartbeat_observation_stale_accumulates_by_elapsed_time_and_resets_on_p
     assert reset.last_seen_epoch == 1095.0
 
 
+def test_heartbeat_observation_active_tool_resets_stale_until_tool_clears(tmp_path, monkeypatch):
+    import prizmkit_runtime.heartbeat as heartbeat
+    from prizmkit_runtime.heartbeat import HeartbeatConfig, observe_heartbeat_state
+
+    progress = tmp_path / "progress.json"
+    progress.write_text(
+        '{"current_tool":"bash","message_count":1,"total_tool_calls":1}\n',
+        encoding="utf-8",
+    )
+    config = HeartbeatConfig(
+        heartbeat_file=tmp_path / "heartbeat.json",
+        progress_file=progress,
+        stale_after_seconds=60,
+    )
+    ticks = iter([1000.0, 1100.0, 1200.0, 1205.0, 1230.0])
+    monkeypatch.setattr(heartbeat.time, "time", lambda: next(ticks))
+
+    first = observe_heartbeat_state(config)
+    active = observe_heartbeat_state(config, first)
+    still_active = observe_heartbeat_state(config, active)
+    progress.write_text(
+        '{"current_tool":null,"message_count":1,"total_tool_calls":1}\n',
+        encoding="utf-8",
+    )
+    tool_finished = observe_heartbeat_state(config, still_active)
+    idle = observe_heartbeat_state(config, tool_finished)
+
+    assert active.details == "progress"
+    assert active.stale_seconds == 0
+    assert active.last_seen_epoch == 1100.0
+    assert still_active.details == "progress"
+    assert still_active.stale_seconds == 0
+    assert still_active.last_seen_epoch == 1200.0
+    assert tool_finished.details == "progress"
+    assert tool_finished.stale_seconds == 0
+    assert tool_finished.last_seen_epoch == 1205.0
+    assert idle.details == "no progress"
+    assert idle.stale_seconds == 25.0
+
+
+@pytest.mark.parametrize("current_tool", [None, "", "   ", 0, ["bash"]])
+def test_heartbeat_observation_rejects_inactive_or_malformed_tool_values(
+    tmp_path,
+    monkeypatch,
+    current_tool,
+):
+    import prizmkit_runtime.heartbeat as heartbeat
+    from prizmkit_runtime.heartbeat import HeartbeatConfig, observe_heartbeat_state
+
+    progress = tmp_path / "progress.json"
+    progress.write_text(json.dumps({"current_tool": current_tool}), encoding="utf-8")
+    config = HeartbeatConfig(
+        heartbeat_file=tmp_path / "heartbeat.json",
+        progress_file=progress,
+        stale_after_seconds=60,
+    )
+    ticks = iter([1000.0, 1070.0])
+    monkeypatch.setattr(heartbeat.time, "time", lambda: next(ticks))
+
+    first = observe_heartbeat_state(config)
+    stale = observe_heartbeat_state(config, first)
+
+    assert stale.details == "no progress"
+    assert stale.stale is True
+    assert stale.stale_seconds == 70.0
+
 
 def test_heartbeat_state_tracks_progress_json_child_activity(tmp_path, monkeypatch):
     import prizmkit_runtime.heartbeat as heartbeat
@@ -2495,6 +2562,104 @@ def test_heartbeat_monitor_stale_kill_uses_elapsed_no_progress_threshold(tmp_pat
     assert marker_data["stale_seconds"] >= 0
 
 
+def test_heartbeat_monitor_active_tool_defers_stale_kill_until_tool_clears(tmp_path):
+    from prizmkit_runtime.heartbeat import HeartbeatConfig, HeartbeatMonitor
+    from prizmkit_runtime.processes import ProcessSpec, is_process_running, launch_process
+
+    sleeper = tmp_path / "active_tool_sleep.py"
+    sleeper.write_text("import time\ntime.sleep(5)\n", encoding="utf-8")
+    progress = tmp_path / "progress.json"
+    progress.write_text('{"current_tool":"bash"}\n', encoding="utf-8")
+    handle = launch_process(ProcessSpec(command=(sys.executable, str(sleeper)), cwd=tmp_path))
+    monitor = HeartbeatMonitor(
+        handle,
+        HeartbeatConfig(
+            heartbeat_file=tmp_path / "heartbeat.json",
+            session_log=tmp_path / "session.log",
+            progress_file=progress,
+            marker_dir=tmp_path,
+            interval_seconds=0.05,
+            stale_after_seconds=0.1,
+            kill_after_seconds=0.2,
+            grace_seconds=0.1,
+        ),
+    )
+    monitor.start()
+
+    time.sleep(0.5)
+    assert is_process_running(handle)
+    assert not (tmp_path / "stale-kill.json").exists()
+
+    progress.write_text('{"current_tool":null}\n', encoding="utf-8")
+    deadline = time.time() + 3
+    while time.time() < deadline and not (tmp_path / "stale-kill.json").exists():
+        time.sleep(0.05)
+    result = monitor.stop()
+
+    marker = json.loads((tmp_path / "stale-kill.json").read_text(encoding="utf-8"))
+    assert result.killed is True
+    assert result.reason == "stale_session"
+    assert marker["reason"] == "stale_session"
+
+
+def test_pi_session_active_tool_stream_survives_stale_threshold(tmp_path, monkeypatch):
+    import prizmkit_runtime.sessions as sessions
+    from prizmkit_runtime.sessions import AISessionConfig, AISessionLauncher
+
+    parser_classes = sessions._load_stream_parser_classes()
+    monkeypatch.setattr(sessions, "_load_stream_parser_classes", lambda: parser_classes)
+
+    fake_cli = tmp_path / "pi_active_tool_cli.py"
+    fake_cli.write_text(
+        "#!/usr/bin/env python3\n"
+        "import json, sys, time\n"
+        "_prompt = sys.stdin.read(5)\n"
+        "for event in [\n"
+        " {'type':'session','id':'active-tool-session'},\n"
+        " {'type':'agent_start'},\n"
+        " {'type':'turn_start'},\n"
+        " {'type':'tool_execution_start','toolCallId':'call-1','toolName':'long-running-tool','args':{}},\n"
+        "]:\n"
+        " print(json.dumps(event), flush=True)\n"
+        "time.sleep(3.0)\n"
+        "for event in [\n"
+        " {'type':'tool_execution_end','toolCallId':'call-1','toolName':'long-running-tool','result':{'content':[]},'isError':False},\n"
+        " {'type':'message_end','message':{'role':'assistant','content':[{'type':'text','text':'done'}],'stopReason':'stop'}},\n"
+        " {'type':'agent_end','willRetry':False,'messages':[{'role':'assistant','content':[{'type':'text','text':'done'}],'stopReason':'stop'}]},\n"
+        "]:\n"
+        " print(json.dumps(event), flush=True)\n",
+        encoding="utf-8",
+    )
+    fake_cli.chmod(0o755)
+    prompt = tmp_path / "prompt.md"
+    prompt.write_text("hello", encoding="utf-8")
+    session_log = tmp_path / "state" / "sessions" / "active-tool" / "logs" / "session.log"
+    progress = session_log.with_name("progress.json")
+
+    result = AISessionLauncher(
+        AISessionConfig(
+            cli_command=str(fake_cli),
+            platform="pi",
+            model=None,
+            prompt_path=prompt,
+            cwd=tmp_path,
+            log_path=session_log,
+            progress_path=progress,
+            heartbeat_path=session_log.with_name("heartbeat.json"),
+            stale_kill_threshold_seconds=1.5,
+            heartbeat_stale_threshold_seconds=1.0,
+            stale_kill_grace_seconds=0.1,
+            live_progress_interval_seconds=0.05,
+        )
+    ).run()
+
+    final_progress = json.loads(progress.read_text(encoding="utf-8"))
+    assert result.exit_code == 0
+    assert result.termination_reason is None
+    assert final_progress["current_tool"] is None
+    assert not (session_log.parent / "stale-kill.json").exists()
+
+
 def test_stale_marker_preserves_subsecond_threshold(tmp_path):
     from prizmkit_runtime.heartbeat import write_stale_marker
 
@@ -2913,7 +3078,10 @@ def test_heartbeat_fatal_error_writes_shell_compatible_markers(tmp_path):
     sleeper = tmp_path / "fatal_sleep.py"
     sleeper.write_text("import time\ntime.sleep(5)\n", encoding="utf-8")
     progress = tmp_path / "progress.json"
-    progress.write_text('{"fatal_error_code":"context_overflow"}\n', encoding="utf-8")
+    progress.write_text(
+        '{"current_tool":"bash","fatal_error_code":"context_overflow"}\n',
+        encoding="utf-8",
+    )
     handle = launch_process(ProcessSpec(command=(sys.executable, str(sleeper)), cwd=tmp_path))
     monitor = HeartbeatMonitor(
         handle,