@research-copilot/plugin 1.1.15 → 1.1.16

package/dist/hooks/tests/test_copilot_hook_lib.py

@@ -0,0 +1,398 @@
+"""Tests for _copilot_hook_lib."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+import _copilot_hook_lib as lib
+
+
+class TestDetectActiveAgent:
+    def test_main_only_returns_none(self, fixtures_dir):
+        p = fixtures_dir / "transcript_main_only.jsonl"
+        assert lib.detect_active_agent(str(p)) is None
+
+    def test_copilot_literature(self, fixtures_dir):
+        p = fixtures_dir / "transcript_copilot_literature.jsonl"
+        assert lib.detect_active_agent(str(p)) == "copilot-literature"
+
+    def test_copilot_experiment(self, fixtures_dir):
+        p = fixtures_dir / "transcript_copilot_experiment_complete.jsonl"
+        assert lib.detect_active_agent(str(p)) == "copilot-experiment"
+
+    def test_missing_path_returns_none(self):
+        assert lib.detect_active_agent("") is None
+        assert lib.detect_active_agent("/nonexistent/path") is None
+
+
+class TestScopePredicates:
+    def test_is_copilot_agent_positive(self):
+        for n in ["copilot-literature", "copilot-ideation", "copilot-experiment",
+                  "copilot-writer", "copilot-polisher", "copilot-reviewer",
+                  "copilot-rebuttal"]:
+            assert lib.is_copilot_agent(n) is True
+
+    def test_research_copilot_is_not_a_subagent(self):
+        assert lib.is_copilot_agent("research-copilot") is False
+
+    def test_is_copilot_agent_negative(self):
+        for n in [None, "", "general-purpose", "Explore", "code-reviewer", "main"]:
+            assert lib.is_copilot_agent(n) is False
+
+
+class TestPathNormalize:
+    def test_backslash_to_forward(self):
+        assert lib.normalize_path("D:\\article\\.copilot\\state.md") == \
+               "d:/article/.copilot/state.md"
+
+    def test_already_forward(self):
+        assert lib.normalize_path(".copilot/state.md") == ".copilot/state.md"
+
+    def test_relative_workspace(self, workspace):
+        f = workspace / ".copilot" / "state.md"
+        assert lib.normalize_path(str(f), workspace=workspace) == ".copilot/state.md"
+
+    def test_empty(self):
+        assert lib.normalize_path("") == ""
+
+
+class TestGlobMatch:
+    def test_exact(self):
+        assert lib.glob_match(".copilot/state.md", ".copilot/state.md") is True
+
+    def test_star(self):
+        assert lib.glob_match(".copilot/reviews/round-3.md",
+                              ".copilot/reviews/round-*.md") is True
+
+    def test_no_match(self):
+        assert lib.glob_match(".copilot/ideas.md", ".copilot/state.md") is False
+
+    def test_s2_pipelines(self):
+        assert lib.glob_match(".copilot/pipelines/2026-05-24-S2-ideation-round-1.md",
+                              ".copilot/pipelines/*-s2-*.md") is True
+        assert lib.glob_match(".copilot/pipelines/2026-05-24-S3-experiment-1.md",
+                              ".copilot/pipelines/*-s2-*.md") is False
+
+    def test_star_does_not_cross_slash(self):
+        # Tightened semantics: `*` is single-segment only
+        assert lib.glob_match("sections/sub/foo.tex", "sections/*.tex") is False
+        assert lib.glob_match(".copilot/reviews/round-2/sub/x.md",
+                              ".copilot/reviews/round-*.md") is False
+
+    def test_star_single_segment_still_matches(self):
+        assert lib.glob_match("sections/intro.tex", "sections/*.tex") is True
+        assert lib.glob_match(".copilot/pipelines/2026-05-24-S2-ideation.md",
+                              ".copilot/pipelines/*-s2-*.md") is True
+
+    def test_empty_pattern(self):
+        assert lib.glob_match("", "") is True
+        assert lib.glob_match("anything", "") is False
+
+
+class TestOwnedMatrix:
+    def test_literature_owns_literature(self):
+        assert lib.is_owned("copilot-literature", ".copilot/literature.md") is True
+
+    def test_literature_does_not_own_ideas(self):
+        assert lib.is_owned("copilot-literature", ".copilot/ideas.md") is False
+
+    def test_ideation_owns_s2_pipelines(self):
+        assert lib.is_owned("copilot-ideation",
+                            ".copilot/pipelines/2026-05-24-s2-ideation.md") is True
+
+    def test_experiment_owns_s3_pipelines(self):
+        assert lib.is_owned("copilot-experiment",
+                            ".copilot/pipelines/2026-05-24-s3-exp.md") is True
+
+    def test_writer_owns_sections_tex(self):
+        assert lib.is_owned("copilot-writer", "sections/intro.tex") is True
+
+    def test_writer_owns_handoff(self):
+        assert lib.is_owned("copilot-writer", ".copilot/handoff.md") is True
+
+    def test_unknown_agent(self):
+        assert lib.is_owned("unknown", ".copilot/state.md") is False
+
+
+class TestIsKnownArtifact:
+    def test_dot_copilot(self):
+        assert lib.is_known_research_artifact(".copilot/state.md") is True
+        assert lib.is_known_research_artifact(".copilot/handoff.md") is True
+
+    def test_sections(self):
+        assert lib.is_known_research_artifact("sections/intro.tex") is True
+
+    def test_references_bib(self):
+        assert lib.is_known_research_artifact("references.bib") is True
+
+    def test_unrelated_scratch(self):
+        assert lib.is_known_research_artifact("scratch/note.txt") is False
+        assert lib.is_known_research_artifact("README.md") is False
+
+
+class TestStateMachine:
+    def test_literature_machine_present(self):
+        sm = lib.STATE_MACHINE["copilot-literature"]
+        assert sm["UNINITIALIZED"] == ["SCANNING"]
+        assert "END" in sm["BASELINE_LOCKED"]
+
+    def test_experiment_machine_present(self):
+        sm = lib.STATE_MACHINE["copilot-experiment"]
+        assert sm["UNINITIALIZED"] == ["CONTEXT_LOADED"]
+        assert "END" in sm["JUDGED"]
+
+    def test_all_subagents_have_machines(self):
+        for agent in lib.COPILOT_AGENTS:
+            assert agent in lib.STATE_MACHINE, f"missing state machine for {agent}"
+
+    def test_transition_legal(self):
+        assert lib.is_transition_legal(
+            "copilot-literature", "UNINITIALIZED", "SCANNING") is True
+
+    def test_transition_illegal(self):
+        assert lib.is_transition_legal(
+            "copilot-experiment", "UNINITIALIZED", "END") is False
+
+    def test_transition_unknown_agent_allowed(self):
+        assert lib.is_transition_legal("unknown", "X", "Y") is True
+
+    def test_transition_unknown_state_allowed(self):
+        assert lib.is_transition_legal(
+            "copilot-literature", "NEW_STATE", "END") is True
+
+
+class TestExtractHandoff:
+    def test_full_block(self):
+        text = """# Some artifact
+
+Body.
+
+## __HANDOFF__
+- last_updated: 2026-05-24T10:30:00Z
+- written_by: copilot-literature
+- key_facts:
+  - locked baseline: 1706.03762
+  - 3 nearest prior works
+- next_owner: copilot-ideation
+"""
+        h = lib.extract_handoff(text)
+        assert h is not None
+        assert h["last_updated"] == "2026-05-24T10:30:00Z"
+        assert h["written_by"] == "copilot-literature"
+        assert h["next_owner"] == "copilot-ideation"
+        assert "locked baseline: 1706.03762" in h["key_facts"]
+
+    def test_no_block(self):
+        assert lib.extract_handoff("# header only\nno handoff block") is None
+
+    def test_empty(self):
+        assert lib.extract_handoff("") is None
+
+    def test_block_without_last_updated(self):
+        h = lib.extract_handoff("## __HANDOFF__\n- written_by: x\n")
+        assert h is not None
+        assert h.get("last_updated") is None
+
+
+class TestExtractStateOutput:
+    def test_full_block(self):
+        text = """prose
+[STATE_OUTPUT]
+Previous: SCANNING
+Current: BASELINE_LOCKED
+Action completed: Locked baseline
+Capability gate: passed
+Evidence: literature.md:42
+Next allowed: [RELATED_WORK_AUGMENTED, END]
+Transition reason: 2 MCP queries
+[/STATE_OUTPUT]
+trailing"""
+        so = lib.extract_state_output(text)
+        assert so["Previous"] == "SCANNING"
+        assert so["Current"] == "BASELINE_LOCKED"
+        assert so["Capability gate"] == "passed"
+
+    def test_missing_block(self):
+        assert lib.extract_state_output("no block") is None
+
+    def test_missing_fields(self):
+        text = "[STATE_OUTPUT]\nPrevious: X\nCurrent: Y\n[/STATE_OUTPUT]"
+        so = lib.extract_state_output(text)
+        assert so["Previous"] == "X"
+        assert "Capability gate" not in so
+
+    def test_required_fields_missing_returns_list(self):
+        so = lib.extract_state_output("[STATE_OUTPUT]\nPrevious: X\nCurrent: Y\n[/STATE_OUTPUT]")
+        missing = lib.state_output_missing_fields(so)
+        assert set(missing) == {"Action completed", "Capability gate", "Evidence", "Next allowed"}
+
+    def test_required_fields_complete(self):
+        so = {
+            "Previous": "X", "Current": "Y", "Action completed": "did stuff",
+            "Capability gate": "passed", "Evidence": "x:1", "Next allowed": "[A]",
+        }
+        assert lib.state_output_missing_fields(so) == []
+
+    def test_state_output_none_returns_all_missing(self):
+        missing = lib.state_output_missing_fields(None)
+        assert len(missing) >= 6
+
+
+import json as _json_in_tests
+
+
+class TestSnapshotIO:
+    def test_read_missing(self, workspace):
+        assert lib.read_snapshot(workspace) == {}
+
+    def test_write_and_read(self, workspace):
+        lib.write_snapshot(workspace, {"state.md": "2026-05-24T10:00:00Z"})
+        assert lib.read_snapshot(workspace) == {"state.md": "2026-05-24T10:00:00Z"}
+
+    def test_corrupt_returns_empty(self, workspace):
+        (workspace / ".copilot" / ".session_snapshot.json").write_text("not json")
+        assert lib.read_snapshot(workspace) == {}
+
+
+class TestCounterIO:
+    def test_read_missing(self, workspace):
+        assert lib.counter_read(workspace) == {}
+
+    def test_inc_from_zero(self, workspace):
+        assert lib.counter_inc(workspace, "copilot-literature", "literature.md") == 1
+        assert lib.counter_inc(workspace, "copilot-literature", "literature.md") == 2
+
+    def test_reset_bucket(self, workspace):
+        lib.counter_inc(workspace, "copilot-literature", "literature.md")
+        lib.counter_reset(workspace, "copilot-literature", "literature.md")
+        assert lib.counter_get(workspace, "copilot-literature", "literature.md") == 0
+
+    def test_reset_all_for_agent(self, workspace):
+        lib.counter_inc(workspace, "copilot-experiment", "experiments.md")
+        lib.counter_inc(workspace, "copilot-experiment", "other.md")
+        lib.counter_reset_all(workspace, "copilot-experiment")
+        for v in lib.counter_read(workspace).get("copilot-experiment", {}).values():
+            assert v["count"] == 0
+
+
+class TestViolationsLog:
+    def test_log_appends(self, workspace):
+        lib.log_violation(workspace, "HARD", "DENY", "copilot-literature",
+                          "test detail", file=".copilot/ideas.md")
+        log = (workspace / ".copilot" / "__violations.log").read_text(encoding="utf-8")
+        line = log.strip().splitlines()[-1]
+        rec = _json_in_tests.loads(line)
+        assert rec["sev"] == "HARD"
+        assert rec["kind"] == "DENY"
+        assert rec["agent"] == "copilot-literature"
+
+    def test_log_multiple(self, workspace):
+        lib.log_violation(workspace, "SOFT", "WARN", "copilot-experiment", "warn 1")
+        lib.log_violation(workspace, "SOFT", "WARN", "copilot-experiment", "warn 2")
+        lines = (workspace / ".copilot" / "__violations.log").read_text(encoding="utf-8").strip().splitlines()
+        assert len(lines) == 2
+
+
+class TestOverride:
+    def test_env_var_off(self, monkeypatch):
+        monkeypatch.setenv("COPILOT_HOOK_GUARD", "off")
+        assert lib.env_guard_disabled() is True
+
+    def test_env_var_unset(self, monkeypatch):
+        monkeypatch.delenv("COPILOT_HOOK_GUARD", raising=False)
+        assert lib.env_guard_disabled() is False
+
+    def test_env_var_other_value(self, monkeypatch):
+        monkeypatch.setenv("COPILOT_HOOK_GUARD", "on")
+        assert lib.env_guard_disabled() is False
+
+    def test_override_file_missing(self, workspace):
+        assert lib.override_match(workspace, "copilot-literature", "skip-handoff-check") is False
+
+    def test_override_file_match(self, workspace):
+        (workspace / ".copilot" / ".guard_override").write_text(
+            "copilot-literature: skip-handoff-check until 2099-01-01T00:00:00Z\n",
+            encoding="utf-8")
+        assert lib.override_match(workspace, "copilot-literature", "skip-handoff-check") is True
+
+    def test_override_file_expired(self, workspace):
+        (workspace / ".copilot" / ".guard_override").write_text(
+            "copilot-literature: skip-handoff-check until 2000-01-01T00:00:00Z\n",
+            encoding="utf-8")
+        assert lib.override_match(workspace, "copilot-literature", "skip-handoff-check") is False
+
+    def test_override_skip_all(self, workspace):
+        (workspace / ".copilot" / ".guard_override").write_text(
+            "copilot-experiment: skip-all until 2099-01-01T00:00:00Z\n",
+            encoding="utf-8")
+        assert lib.override_match(workspace, "copilot-experiment", "skip-handoff-check") is True
+        assert lib.override_match(workspace, "copilot-experiment", "skip-owned-check") is True
+
+    def test_override_comment(self, workspace):
+        (workspace / ".copilot" / ".guard_override").write_text(
+            "# comment\ncopilot-literature: skip-handoff-check until 2099-01-01T00:00:00Z\n",
+            encoding="utf-8")
+        assert lib.override_match(workspace, "copilot-literature", "skip-handoff-check") is True
+
+    def test_override_wrong_agent(self, workspace):
+        (workspace / ".copilot" / ".guard_override").write_text(
+            "copilot-literature: skip-handoff-check until 2099-01-01T00:00:00Z\n",
+            encoding="utf-8")
+        assert lib.override_match(workspace, "copilot-experiment", "skip-handoff-check") is False
+
+
+class TestDecisions:
+    def test_allow(self):
+        d = lib.allow_decision()
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+    def test_deny(self):
+        d = lib.deny_decision("nope")
+        assert d["hookSpecificOutput"]["permissionDecision"] == "deny"
+        assert "nope" in d["hookSpecificOutput"]["permissionDecisionReason"]
+
+    def test_block(self):
+        d = lib.block_decision("come back and write handoff")
+        assert d["decision"] == "block"
+        assert "come back" in d["reason"]
+
+
+class TestSafeMain:
+    def test_clean_exit(self, capsys):
+        def real():
+            print(_json_in_tests.dumps(lib.allow_decision()))
+            return 0
+        rc = lib.safe_main(real)
+        assert rc == 0
+        assert "allow" in capsys.readouterr().out
+
+    def test_exception_falls_open(self, capsys):
+        def real():
+            raise RuntimeError("boom")
+        rc = lib.safe_main(real)
+        assert rc == 0
+        assert "allow" in capsys.readouterr().out
+
+
+class TestOriginAttribution:
+    def test_no_agent_id_is_main(self):
+        assert lib.is_main_session({"tool_name": "Bash", "tool_input": {}}) is True
+
+    def test_empty_agent_id_is_main(self):
+        assert lib.is_main_session({"agent_id": "", "agent_type": ""}) is True
+
+    def test_present_agent_id_is_subagent(self):
+        p = {"agent_id": "sa_01", "agent_type": "copilot-experiment"}
+        assert lib.is_main_session(p) is False
+
+    def test_exempt_copilot_subagent(self):
+        p = {"agent_id": "sa_01", "agent_type": "copilot-experiment"}
+        assert lib.is_exempt_subagent(p) is True
+
+    def test_non_copilot_subagent_not_exempt(self):
+        p = {"agent_id": "sa_02", "agent_type": "Explore"}
+        assert lib.is_exempt_subagent(p) is False
+
+    def test_main_session_not_exempt(self):
+        assert lib.is_exempt_subagent({"tool_name": "Bash"}) is False

package/dist/hooks/tests/test_copilot_subagent_stop.py

@@ -0,0 +1,186 @@
+"""Tests for copilot_subagent_stop.py (SubagentStop)."""
+from __future__ import annotations
+
+import json
+from io import StringIO
+from pathlib import Path
+
+import pytest
+
+import copilot_subagent_stop as guard
+import _copilot_hook_lib as lib
+
+
+def _run(monkeypatch, payload: dict, workspace: Path) -> dict:
+    monkeypatch.setattr("sys.stdin", StringIO(json.dumps(payload)))
+    monkeypatch.chdir(workspace)
+    out = StringIO()
+    monkeypatch.setattr("sys.stdout", out)
+    guard.real_main()
+    return json.loads(out.getvalue().strip().splitlines()[-1])
+
+
+def _stop_payload(transcript_path: str, stop_hook_active: bool = False) -> dict:
+    return {"transcript_path": transcript_path, "stop_hook_active": stop_hook_active}
+
+
+class TestScope:
+    def test_main_agent_allowed(self, monkeypatch, workspace, fixtures_dir):
+        d = _run(monkeypatch, _stop_payload(str(fixtures_dir / "transcript_main_only.jsonl")), workspace)
+        assert "decision" not in d
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+    def test_non_copilot_agent_allowed(self, monkeypatch, workspace, tmp_path):
+        t = tmp_path / "trans.jsonl"
+        t.write_text('{"role":"assistant","metadata":{"subagent_type":"general-purpose"}}\n')
+        d = _run(monkeypatch, _stop_payload(str(t)), workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+
+class TestOverride:
+    def test_env_off_allows(self, monkeypatch, workspace, fixtures_dir):
+        monkeypatch.setenv("COPILOT_HOOK_GUARD", "off")
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+    def test_skip_handoff_check_allows(self, monkeypatch, workspace, fixtures_dir):
+        (workspace / ".copilot" / ".guard_override").write_text(
+            "copilot-literature: skip-handoff-check until 2099-01-01T00:00:00Z\n",
+            encoding="utf-8")
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+
+class TestHandoffFreshness:
+    def test_missing_file_blocks(self, monkeypatch, workspace, fixtures_dir):
+        # Pre-populate snapshot so we trigger HARD_FAIL (not SOFT_FAIL first-boot path)
+        lib.write_snapshot(workspace, {"literature.md": None})
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        assert d.get("decision") == "block"
+        assert "literature.md" in d["reason"] or "HANDOFF" in d["reason"]
+
+    def test_stale_handoff_blocks(self, monkeypatch, workspace, fixtures_dir, handoff_writer):
+        f = workspace / ".copilot" / "literature.md"
+        old = "2026-05-23T00:00:00Z"
+        handoff_writer(f, last_updated=old)
+        lib.write_snapshot(workspace, {"literature.md": old})
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        assert d.get("decision") == "block"
+
+    def test_fresh_handoff_allows(self, monkeypatch, workspace, fixtures_dir, handoff_writer):
+        f = workspace / ".copilot" / "literature.md"
+        handoff_writer(f, last_updated="2026-05-24T10:00:00Z")
+        lib.write_snapshot(workspace, {"literature.md": "2026-05-23T00:00:00Z"})
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+
+class TestFuse:
+    def test_strikes_1_and_2_block(self, monkeypatch, workspace, fixtures_dir):
+        lib.write_snapshot(workspace, {"literature.md": None})
+        for _ in range(2):
+            d = _run(monkeypatch,
+                     _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                     workspace)
+            assert d.get("decision") == "block"
+        assert lib.counter_get(workspace, "copilot-literature", "literature.md") == 2
+
+    def test_strike_3_releases(self, monkeypatch, workspace, fixtures_dir):
+        lib.write_snapshot(workspace, {"literature.md": None})
+        for _ in range(2):
+            _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+        assert lib.counter_get(workspace, "copilot-literature", "literature.md") == 0
+        log = (workspace / ".copilot" / "__violations.log").read_text(encoding="utf-8")
+        assert "RELEASE" in log
+
+    def test_pass_resets_counter(self, monkeypatch, workspace, fixtures_dir, handoff_writer):
+        lib.write_snapshot(workspace, {"literature.md": None})
+        _run(monkeypatch,
+             _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+             workspace)
+        assert lib.counter_get(workspace, "copilot-literature", "literature.md") == 1
+        f = workspace / ".copilot" / "literature.md"
+        handoff_writer(f, last_updated="2026-05-24T10:00:00Z")
+        lib.write_snapshot(workspace, {"literature.md": "2026-05-23T00:00:00Z"})
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+        assert lib.counter_get(workspace, "copilot-literature", "literature.md") == 0
+
+
+class TestFirstBoot:
+    def test_no_snapshot_fresh_handoff_passes(self, monkeypatch, workspace,
+                                                fixtures_dir, handoff_writer):
+        s = workspace / ".copilot" / ".session_snapshot.json"
+        if s.exists():
+            s.unlink()
+        f = workspace / ".copilot" / "literature.md"
+        handoff_writer(f, last_updated="2026-05-24T10:00:00Z")
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+    def test_no_snapshot_no_handoff_soft_not_hard(self, monkeypatch, workspace, fixtures_dir):
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_literature.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+        log = (workspace / ".copilot" / "__violations.log").read_text(encoding="utf-8")
+        assert "NO-SNAPSHOT" in log
+
+
+class TestSoftWarns:
+    def _setup_pass(self, workspace, handoff_writer, fname):
+        handoff_writer(workspace / ".copilot" / fname, last_updated="2026-05-24T10:00:00Z")
+        lib.write_snapshot(workspace, {fname: "2026-05-23T00:00:00Z"})
+
+    def test_malformed_state_output_warned(self, monkeypatch, workspace,
+                                            fixtures_dir, handoff_writer):
+        self._setup_pass(workspace, handoff_writer, "literature.md")
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_malformed_state_output.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+        log = (workspace / ".copilot" / "__violations.log").read_text(encoding="utf-8")
+        assert "SOFT" in log and "WARN" in log
+        assert "STATE_OUTPUT" in log
+
+    def test_illegal_state_jump_warned(self, monkeypatch, workspace,
+                                        fixtures_dir, handoff_writer):
+        self._setup_pass(workspace, handoff_writer, "experiments.md")
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_experiment_state_jump.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+        log = (workspace / ".copilot" / "__violations.log").read_text(encoding="utf-8")
+        assert "SOFT" in log
+        assert "UNINITIALIZED" in log or "transition" in log.lower()
+
+    def test_clean_run_no_soft_warns(self, monkeypatch, workspace,
+                                      fixtures_dir, handoff_writer):
+        self._setup_pass(workspace, handoff_writer, "experiments.md")
+        d = _run(monkeypatch,
+                 _stop_payload(str(fixtures_dir / "transcript_copilot_experiment_complete.jsonl")),
+                 workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+        log_path = workspace / ".copilot" / "__violations.log"
+        if log_path.exists():
+            assert "SOFT" not in log_path.read_text(encoding="utf-8")