Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
33.2 KB
Raw Blame
# coding: utf-8
# pylint: disable=protected-access
"""Tests for skill active-state lifecycle: activation, switch, completion, teardown."""

import asyncio
import unittest
from pathlib import Path
from unittest.mock import MagicMock

import pytest
from openjiuwen.core.single_agent.rail.base import (
    AgentCallbackContext,
    InvokeInputs,
    ToolCallInputs,
)

from jiuwenswarm.agents.harness.common.rails.interrupt.interrupt_helpers import (
    is_interrupt_resume_source,
)
from jiuwenswarm.agents.harness.common.rails.skill_active_state import (
    _DEFAULT_SESSION_ID,
    _SESSION_ID_EXTRA_KEY,
    SkillActiveStateRail,
    clear_session_skill_state,
    get_session_active_skill,
    resolve_skill_session_id,
    resolve_stale_invoke_limit,
)
from jiuwenswarm.agents.harness.common.rails.skill_credential_injection_rail import (
    SkillCredentialInjectionRail,
)


@pytest.fixture(autouse=True)
def session_files(tmp_path, monkeypatch):
    import re

    from jiuwenswarm.agents.harness.common.rails import skill_active_state
    from jiuwenswarm.agents.harness.common.rails.permissions.skill_authorization import (
        file_store,
    )

    context_token = file_store._session_file_context.set(None)
    sessions = tmp_path / "sessions"
    # Existing lifecycle cases use these session identifiers as real sessions.
    # The test module is UTF-8 (Chinese comments); read_text must pin the
    # encoding or every test errors out on GBK-locale Windows hosts.
    for sid in set(
        re.findall(
            r'officeclaw_[A-Za-z0-9_]+',
            Path(__file__).read_text(encoding="utf-8"),
        )
    ):
        (sessions / sid).mkdir(parents=True, exist_ok=True)
    monkeypatch.setattr(file_store, "get_agent_sessions_dir", lambda: sessions)
    monkeypatch.setattr(file_store, "get_user_workspace_dir", lambda: tmp_path)
    token = skill_active_state._current_session_var.set(None)
    yield
    skill_active_state._current_session_var.reset(token)
    file_store._session_file_context.reset(context_token)


@pytest.mark.asyncio
@pytest.mark.parametrize("failure", ["timeout", "corruption"])
async def test_state_write_failure_stops_callback_chain(monkeypatch, failure):
    from openjiuwen.core.runner.callback.errors import AbortError
    from openjiuwen.core.runner.callback.framework import AsyncCallbackFramework

    from jiuwenswarm.agents.harness.common.rails import skill_active_state

    sid = "officeclaw_storage_failure"
    store = skill_active_state._shared_store(sid)
    store.update_active_skill_state(
        sid, lambda _: {"active_skill": "old", "invokes_since_skill_tool": 5}
    )
    monkeypatch.setattr(skill_active_state, "_shared_store", lambda _sid: store)
    if failure == "corruption":
        (store.session_directory(sid) / ".skill_authorization/state.json").write_text("{")
    else:
        def fail_write(*_args, **_kwargs):
            raise TimeoutError("injected lock timeout")
        monkeypatch.setattr(store, "update_active_skill_state", fail_write)

    rail = SkillActiveStateRail(session_id=sid, sessions_root=store.sessions_root())
    ctx = AgentCallbackContext(agent=MagicMock())
    ctx.inputs = InvokeInputs(query="next turn", conversation_id=sid)
    ctx.extra = {}
    later_callback = []

    async def use_credentials(_ctx):
        later_callback.append(True)

    callbacks = AsyncCallbackFramework()
    await callbacks.register("before_invoke", rail.before_invoke, priority=10)
    await callbacks.register("before_invoke", use_credentials, priority=0)
    with pytest.raises(AbortError, match="Skill state storage unavailable"):
        await callbacks.trigger("before_invoke", ctx)
    assert not later_callback


@pytest.mark.asyncio
async def test_missing_session_callback_does_not_recreate_directory(monkeypatch, caplog):
    import shutil

    from jiuwenswarm.agents.harness.common.rails import skill_active_state

    sid = "officeclaw_missing_session"
    store = skill_active_state._shared_store(sid)
    directory = store.session_directory(sid)
    shutil.rmtree(directory)
    monkeypatch.setattr(skill_active_state, "_shared_store", lambda _sid: store)
    rail = SkillActiveStateRail(session_id=sid, sessions_root=store.sessions_root())
    ctx = AgentCallbackContext(agent=MagicMock())
    ctx.inputs = InvokeInputs(query="late request", conversation_id=sid)
    ctx.extra = {}
    await rail.before_invoke(ctx)
    assert not directory.exists()
    assert not [record for record in caplog.records if record.levelno >= 40]


class TestResolveSkillSessionId(unittest.TestCase):
    def _ctx(self, *, conversation_id=None, session_id=None, extra=None):
        ctx = AgentCallbackContext(agent=MagicMock())
        inputs = ToolCallInputs(
            tool_call=MagicMock(),
            tool_name="bash",
            tool_args={"command": "echo hi"},
            tool_result=None,
            tool_msg=None,
        )
        if conversation_id is not None:
            inputs.conversation_id = conversation_id
        ctx.inputs = inputs
        if session_id is not None:
            session = MagicMock()
            session.get_session_id.return_value = session_id
            ctx.session = session
        if extra is not None:
            ctx.extra = extra
        else:
            ctx.extra = {}
        return ctx

    def test_preset_wins(self):
        ctx = self._ctx(conversation_id="from-inputs")
        assert resolve_skill_session_id(ctx, "officeclaw_preset") == "officeclaw_preset"

    def test_inputs_conversation_id(self):
        ctx = self._ctx(conversation_id="officeclaw_from_inputs")
        assert resolve_skill_session_id(ctx) == "officeclaw_from_inputs"

    def test_session_object(self):
        ctx = self._ctx(session_id="officeclaw_from_session")
        assert resolve_skill_session_id(ctx) == "officeclaw_from_session"

    def test_ctx_extra_shared_key(self):
        ctx = self._ctx(extra={_SESSION_ID_EXTRA_KEY: "officeclaw_from_extra"})
        assert resolve_skill_session_id(ctx) == "officeclaw_from_extra"

    def test_fallback_default(self):
        ctx = self._ctx()
        assert resolve_skill_session_id(ctx) == _DEFAULT_SESSION_ID


class TestInterruptResumeSource(unittest.TestCase):
    def test_interrupt_sources(self):
        assert is_interrupt_resume_source("permission_interrupt")
        assert is_interrupt_resume_source("confirm_interrupt")
        assert is_interrupt_resume_source("ask_user_interrupt")
        # Evolution / forward-compat sources are out of OCR/HITL scope.
        assert not is_interrupt_resume_source("evolution_interrupt")
        assert not is_interrupt_resume_source("skill_evolution_approval")
        assert not is_interrupt_resume_source("custom_interrupt")
        assert not is_interrupt_resume_source("user")
        assert not is_interrupt_resume_source("")


class TestSkillActiveStateRailPreset(unittest.TestCase):
    def tearDown(self):
        clear_session_skill_state("officeclaw_preset_sess")
        clear_session_skill_state(_DEFAULT_SESSION_ID)

    def _activate_ctx(self, skill_name="hwocr"):
        ctx = AgentCallbackContext(agent=MagicMock())
        tool_call = MagicMock()
        tool_call.arguments = {"skill_name": skill_name}
        tool_msg = MagicMock()
        tool_msg.metadata = {"skill_name": skill_name}
        inputs = ToolCallInputs(
            tool_call=tool_call,
            tool_name="skill_tool",
            tool_args={"skill_name": skill_name},
            tool_result=None,
            tool_msg=tool_msg,
        )
        ctx.inputs = inputs
        ctx.extra = {}
        return ctx

    def test_preset_session_used_when_tool_inputs_lack_conversation_id(self):
        rail = SkillActiveStateRail(session_id="officeclaw_preset_sess")
        ctx = self._activate_ctx()
        asyncio.run(rail.after_tool_call(ctx))
        assert get_session_active_skill("officeclaw_preset_sess") == "hwocr"
        assert get_session_active_skill(_DEFAULT_SESSION_ID) is None

    def test_before_invoke_binds_extra(self):
        rail = SkillActiveStateRail(session_id="officeclaw_preset_sess")
        ctx = self._activate_ctx()
        ctx.inputs = InvokeInputs(query="hello", conversation_id="officeclaw_preset_sess")
        asyncio.run(rail.before_invoke(ctx))
        assert ctx.extra[_SESSION_ID_EXTRA_KEY] == "officeclaw_preset_sess"


class TestSkillActiveLifecycle(unittest.TestCase):
    sid = "officeclaw_hitl_sess"

    def tearDown(self):
        clear_session_skill_state(self.sid)

    def _rail(self):
        return SkillActiveStateRail(session_id=self.sid)

    def _activate(self, rail, skill_name="hwocr"):
        ctx = AgentCallbackContext(agent=MagicMock())
        tool_call = MagicMock()
        tool_call.arguments = {"skill_name": skill_name}
        tool_msg = MagicMock()
        tool_msg.metadata = {"skill_name": skill_name}
        ctx.inputs = ToolCallInputs(
            tool_call=tool_call,
            tool_name="skill_tool",
            tool_args={"skill_name": skill_name},
            tool_result=None,
            tool_msg=tool_msg,
        )
        ctx.extra = {}
        asyncio.run(rail.after_tool_call(ctx))

    def _invoke_ctx(self, *, query="hello"):
        ctx = AgentCallbackContext(agent=MagicMock())
        ctx.inputs = InvokeInputs(
            query=query,
            conversation_id=self.sid,
        )
        ctx.extra = {}
        return ctx

    def test_after_invoke_does_not_clear(self):
        rail = self._rail()
        self._activate(rail)
        asyncio.run(rail.after_invoke(self._invoke_ctx()))
        assert get_session_active_skill(self.sid) == "hwocr"

    def test_permission_resume_before_invoke_keeps_active(self):
        rail = self._rail()
        self._activate(rail)
        asyncio.run(rail.before_invoke(self._invoke_ctx(query="")))
        assert get_session_active_skill(self.sid) == "hwocr"

    def test_new_user_task_before_invoke_keeps_active(self):
        # 生命周期修正:新用户任务不再清空 active_skill。
        rail = self._rail()
        self._activate(rail)
        asyncio.run(rail.before_invoke(self._invoke_ctx(query="下一题")))
        assert get_session_active_skill(self.sid) == "hwocr"

    def test_switch_to_another_skill_replaces_active(self):
        # 切换到另一个 skill:旧 skill 清空,仅新 skill 激活。
        rail = self._rail()
        self._activate(rail, "hwocr")
        assert get_session_active_skill(self.sid) == "hwocr"
        self._activate(rail, "ppt-creation")
        assert get_session_active_skill(self.sid) == "ppt-creation"

    def test_session_teardown_clears_active(self):
        # 会话结束:clear_session_skill_state(adapter 淘汰 / teardown)清空。
        rail = self._rail()
        self._activate(rail)
        assert get_session_active_skill(self.sid) == "hwocr"
        clear_session_skill_state(self.sid)
        assert get_session_active_skill(self.sid) is None

    def test_resume_then_inject_bash(self):
        rail = self._rail()
        inject = SkillCredentialInjectionRail(
            skill_envs={"hwocr": {"HWOCR_AK": "ak", "HWOCR_SK": "sk"}},
            preset_session_id=self.sid,
        )
        self._activate(rail)
        # Simulate interrupted invoke ending without clearing.
        asyncio.run(rail.after_invoke(self._invoke_ctx()))
        # Permission resume.
        asyncio.run(rail.before_invoke(self._invoke_ctx(query="")))
        bash_ctx = AgentCallbackContext(agent=MagicMock())
        bash_ctx.inputs = ToolCallInputs(
            tool_call=MagicMock(),
            tool_name="bash",
            tool_args={"command": "hwocr.exe general-text"},
            tool_result=None,
            tool_msg=None,
        )
        bash_ctx.extra = {}
        asyncio.run(inject.before_tool_call(bash_ctx))
        assert bash_ctx.inputs.tool_args["env"]["HWOCR_AK"] == "ak"

    def test_skill_complete_clears(self):
        rail = self._rail()
        self._activate(rail)
        ctx = AgentCallbackContext(agent=MagicMock())
        tool_call = MagicMock()
        tool_call.arguments = {"skill_name": "hwocr"}
        tool_msg = MagicMock()
        tool_msg.metadata = {}
        ctx.inputs = ToolCallInputs(
            tool_call=tool_call,
            tool_name="skill_complete",
            tool_args={"skill_name": "hwocr"},
            tool_result=None,
            tool_msg=tool_msg,
        )
        ctx.extra = {}
        asyncio.run(rail.after_tool_call(ctx))
        assert get_session_active_skill(self.sid) is None

    def test_skill_complete_name_mismatch_keeps_active_and_warns(self):
        # 激活名 ≠ 完成名:不清空当前激活态,但记录 warn 便于排查
        rail = self._rail()
        self._activate(rail, "hwocr")
        ctx = AgentCallbackContext(agent=MagicMock())
        tool_call = MagicMock()
        tool_call.arguments = {"skill_name": "ppt-creation"}
        tool_msg = MagicMock()
        tool_msg.metadata = {}
        ctx.inputs = ToolCallInputs(
            tool_call=tool_call,
            tool_name="skill_complete",
            tool_args={"skill_name": "ppt-creation"},
            tool_result=None,
            tool_msg=tool_msg,
        )
        ctx.extra = {}
        with self.assertLogs(
            "jiuwenswarm.agents.harness.common.rails.skill_active_state",
            level="WARNING",
        ) as captured:
            asyncio.run(rail.after_tool_call(ctx))
        assert get_session_active_skill(self.sid) == "hwocr"
        assert any("ignored" in line for line in captured.output)


class TestStaleInvokeExpiry(unittest.TestCase):
    """改动 3:连续 N 轮 invoke 无 skill_tool 调用 → 过期清空 active_skill。"""

    sid = "officeclaw_stale_sess"

    def tearDown(self):
        clear_session_skill_state(self.sid)

    def _rail(self, limit=5):
        return SkillActiveStateRail(
            session_id=self.sid, stale_invoke_limit=limit
        )

    def _activate(self, rail, skill_name="hwocr"):
        ctx = AgentCallbackContext(agent=MagicMock())
        tool_call = MagicMock()
        tool_call.arguments = {"skill_name": skill_name}
        tool_msg = MagicMock()
        tool_msg.metadata = {"skill_name": skill_name}
        ctx.inputs = ToolCallInputs(
            tool_call=tool_call,
            tool_name="skill_tool",
            tool_args={"skill_name": skill_name},
            tool_result=None,
            tool_msg=tool_msg,
        )
        ctx.extra = {}
        asyncio.run(rail.after_tool_call(ctx))

    def _invoke(self, rail, query="q", source=None):
        ctx = AgentCallbackContext(agent=MagicMock())
        if source:
            run_context = MagicMock()
            run_context.extra = {"chat_send_source": source}
            ctx.inputs = InvokeInputs(
                query=query,
                conversation_id=self.sid,
                run_context=run_context,
            )
        else:
            ctx.inputs = InvokeInputs(query=query, conversation_id=self.sid)
        ctx.extra = {}
        asyncio.run(rail.before_invoke(ctx))

    def test_expires_after_limit(self):
        rail = self._rail(limit=5)
        self._activate(rail)
        for i in range(5):
            self._invoke(rail, query=f"q{i}")
        # 连续 5 轮无 skill_tool 调用,第 5 轮结束仍存活
        assert get_session_active_skill(self.sid) == "hwocr"
        # 第 6 轮开始时清空
        self._invoke(rail, query="q6")
        assert get_session_active_skill(self.sid) is None

    def test_hitl_resume_invoke_not_counted(self):
        # CR-3a:HITL 恢复轮(同一任务的继续)不计入过期计数——
        # 密集审批/ask_user 交互不会误清空 active_skill
        rail = self._rail(limit=3)
        self._activate(rail)
        self._invoke(rail)  # count=1
        self._invoke(rail)  # count=2
        # 连续多轮 HITL 恢复:计数冻结
        for i in range(5):
            self._invoke(
                rail, query=f"resume{i}", source="permission_interrupt"
            )
        assert get_session_active_skill(self.sid) == "hwocr"
        # 恢复 normal 轮后从冻结值继续累计
        self._invoke(rail)  # count=3
        assert get_session_active_skill(self.sid) == "hwocr"
        self._invoke(rail)  # count>=3 → 清空
        assert get_session_active_skill(self.sid) is None

    def test_evolution_source_still_counted(self):
        # 非 HITL 恢复 source(如 evolution)照常计数
        rail = self._rail(limit=2)
        self._activate(rail)
        self._invoke(rail, source="evolution_interrupt")  # count=1
        self._invoke(rail, source="evolution_interrupt")  # count=2
        self._invoke(rail)  # count>=2 → 清空
        assert get_session_active_skill(self.sid) is None

    def test_skill_tool_call_resets_counter(self):
        rail = self._rail(limit=3)
        self._activate(rail)
        self._invoke(rail)
        self._invoke(rail)
        # 重新 skill_tool 调用 → 计数清零,重新累计
        self._activate(rail)
        self._invoke(rail)
        self._invoke(rail)
        assert get_session_active_skill(self.sid) == "hwocr"
        self._invoke(rail)
        assert get_session_active_skill(self.sid) == "hwocr"
        self._invoke(rail)
        assert get_session_active_skill(self.sid) is None

    def test_switch_resets_counter(self):
        rail = self._rail(limit=2)
        self._activate(rail, "hwocr")
        self._invoke(rail)
        # 切换技能 → 新技能计数从零开始
        self._activate(rail, "ppt-creation")
        self._invoke(rail)
        self._invoke(rail)
        assert get_session_active_skill(self.sid) == "ppt-creation"
        self._invoke(rail)
        assert get_session_active_skill(self.sid) is None

    def test_limit_nonpositive_disables_expiry(self):
        rail = self._rail(limit=0)
        self._activate(rail)
        for _ in range(10):
            self._invoke(rail)
        assert get_session_active_skill(self.sid) == "hwocr"


class TestCredentialInjectionUsesPreset(unittest.TestCase):
    def tearDown(self):
        clear_session_skill_state("officeclaw_inject_sess")

    def test_injects_when_active_skill_keyed_by_preset(self):
        active = SkillActiveStateRail(session_id="officeclaw_inject_sess")
        inject = SkillCredentialInjectionRail(
            skill_envs={"hwocr": {"HWOCR_AK": "ak", "HWOCR_SK": "sk"}},
            preset_session_id="officeclaw_inject_sess",
        )

        activate_ctx = AgentCallbackContext(agent=MagicMock())
        tool_call = MagicMock()
        tool_call.arguments = {"skill_name": "hwocr"}
        tool_msg = MagicMock()
        tool_msg.metadata = {"skill_name": "hwocr"}
        activate_ctx.inputs = ToolCallInputs(
            tool_call=tool_call,
            tool_name="skill_tool",
            tool_args={"skill_name": "hwocr"},
            tool_result=None,
            tool_msg=tool_msg,
        )
        activate_ctx.extra = {}
        asyncio.run(active.after_tool_call(activate_ctx))

        bash_ctx = AgentCallbackContext(agent=MagicMock())
        bash_ctx.inputs = ToolCallInputs(
            tool_call=MagicMock(),
            tool_name="bash",
            tool_args={"command": "hwocr.exe general-text"},
            tool_result=None,
            tool_msg=None,
        )
        bash_ctx.extra = {}
        asyncio.run(inject.before_tool_call(bash_ctx))
        env = bash_ctx.inputs.tool_args["env"]
        assert env["HWOCR_AK"] == "ak"
        assert env["HWOCR_SK"] == "sk"


class TestResolveStaleInvokeLimit(unittest.TestCase):
    """CR-3b:react.skill_stale_invoke_limit 配置解析。"""

    def test_missing_returns_none(self):
        assert resolve_stale_invoke_limit(None) is None
        assert resolve_stale_invoke_limit({}) is None
        assert resolve_stale_invoke_limit({"react": {}}) is None
        assert resolve_stale_invoke_limit({"react": {"other": 1}}) is None
        assert resolve_stale_invoke_limit("not-a-dict") is None

    def test_valid_value(self):
        assert (
            resolve_stale_invoke_limit(
                {"react": {"skill_stale_invoke_limit": 10}}
            )
            == 10
        )
        assert (
            resolve_stale_invoke_limit(
                {"react": {"skill_stale_invoke_limit": "7"}}
            )
            == 7
        )

    def test_zero_and_negative_passthrough(self):
        # <=0 原样透传(显式禁用兜底)
        assert (
            resolve_stale_invoke_limit({"react": {"skill_stale_invoke_limit": 0}})
            == 0
        )
        assert (
            resolve_stale_invoke_limit({"react": {"skill_stale_invoke_limit": -1}})
            == -1
        )

    def test_invalid_falls_back_to_default(self):
        assert (
            resolve_stale_invoke_limit(
                {"react": {"skill_stale_invoke_limit": "abc"}}
            )
            is None
        )

    def test_react_section_form_accepted(self):
        # N2:reload 路径传入的 config 本身即 react 子 dict,顶层 key 直接命中
        assert (
            resolve_stale_invoke_limit({"skill_stale_invoke_limit": 10}) == 10
        )
        assert resolve_stale_invoke_limit({"other": 1}) is None

    def test_full_config_form_takes_precedence(self):
        # 完整 agent 配置形态:react 子 dict 优先于顶层同名 key
        assert (
            resolve_stale_invoke_limit(
                {
                    "skill_stale_invoke_limit": 99,
                    "react": {"skill_stale_invoke_limit": 7},
                }
            )
            == 7
        )

    def test_rail_stale_limit_property(self):
        # N2:公开只读属性,供装配点检测配置变化(默认 5 / 传参 / 禁用 0)
        assert SkillActiveStateRail().stale_invoke_limit == 5
        assert (
            SkillActiveStateRail(stale_invoke_limit=10).stale_invoke_limit == 10
        )
        assert (
            SkillActiveStateRail(stale_invoke_limit=0).stale_invoke_limit == 0
        )

    def test_rail_stale_limit_inplace_update(self):
        # N2:reload 原位更新(不重建实例);None 归一化为默认值
        rail = SkillActiveStateRail(stale_invoke_limit=3)
        rail.update_stale_invoke_limit(10)
        assert rail.stale_invoke_limit == 10
        rail.update_stale_invoke_limit(None)
        assert rail.stale_invoke_limit == 5
        rail.update_stale_invoke_limit(0)
        assert rail.stale_invoke_limit == 0


class TestAdoptDefaultActiveSkill(unittest.TestCase):
    def tearDown(self):
        clear_session_skill_state("officeclaw_adopt_sess")
        clear_session_skill_state("officeclaw_other_sess")
        clear_session_skill_state(_DEFAULT_SESSION_ID)

    def _activate_under_default(self):
        default_rail = SkillActiveStateRail()
        ctx = AgentCallbackContext(agent=MagicMock())
        tool_call = MagicMock()
        tool_call.arguments = {"skill_name": "hwocr"}
        tool_msg = MagicMock()
        tool_msg.metadata = {"skill_name": "hwocr"}
        ctx.inputs = ToolCallInputs(
            tool_call=tool_call,
            tool_name="skill_tool",
            tool_args={"skill_name": "hwocr"},
            tool_result=None,
            tool_msg=tool_msg,
        )
        ctx.extra = {}
        asyncio.run(default_rail.after_tool_call(ctx))
        assert get_session_active_skill(_DEFAULT_SESSION_ID) is None
        return default_rail, ctx

    def test_adopt_unowned_orphan_for_hitl_session(self):
        from jiuwenswarm.agents.harness.common.rails.skill_active_state import (
            adopt_default_active_skill,
        )

        self._activate_under_default()
        assert adopt_default_active_skill("officeclaw_adopt_sess") is None
        assert get_session_active_skill("officeclaw_adopt_sess") is None
        assert get_session_active_skill(_DEFAULT_SESSION_ID) is None

    def test_inject_does_not_adopt_default_orphan(self):
        """Injection rail is read-only: must not migrate default -> foreign session."""
        self._activate_under_default()
        inject = SkillCredentialInjectionRail(
            skill_envs={"hwocr": {"HWOCR_AK": "ak"}},
            preset_session_id="officeclaw_adopt_sess",
        )
        bash_ctx = AgentCallbackContext(agent=MagicMock())
        bash_ctx.inputs = ToolCallInputs(
            tool_call=MagicMock(),
            tool_name="bash",
            tool_args={"command": "hwocr.exe general-text"},
            tool_result=None,
            tool_msg=None,
        )
        bash_ctx.extra = {}
        asyncio.run(inject.before_tool_call(bash_ctx))
        assert "env" not in bash_ctx.inputs.tool_args
        assert get_session_active_skill(_DEFAULT_SESSION_ID) is None
        assert get_session_active_skill("officeclaw_adopt_sess") is None

    def test_no_process_local_orphan_state(self):
        from jiuwenswarm.agents.harness.common.rails import skill_active_state

        assert not hasattr(skill_active_state, "_sessions")
        assert not hasattr(skill_active_state, "_get_or_create_state")
        assert get_session_active_skill("officeclaw_other_sess") is None

    def test_before_invoke_adopts_unowned_orphan(self):
        self._activate_under_default()
        rail = SkillActiveStateRail(session_id="officeclaw_adopt_sess")
        invoke_ctx = AgentCallbackContext(agent=MagicMock())
        invoke_ctx.inputs = InvokeInputs(
            query="",
            conversation_id="officeclaw_adopt_sess",
        )
        invoke_ctx.extra = {}
        asyncio.run(rail.before_invoke(invoke_ctx))
        assert get_session_active_skill("officeclaw_adopt_sess") is None
        assert get_session_active_skill(_DEFAULT_SESSION_ID) is None

        inject = SkillCredentialInjectionRail(
            skill_envs={"hwocr": {"HWOCR_AK": "ak"}},
            preset_session_id="officeclaw_adopt_sess",
        )
        bash_ctx = AgentCallbackContext(agent=MagicMock())
        bash_ctx.inputs = ToolCallInputs(
            tool_call=MagicMock(),
            tool_name="bash",
            tool_args={"command": "hwocr.exe general-text"},
            tool_result=None,
            tool_msg=None,
        )
        bash_ctx.extra = {}
        asyncio.run(inject.before_tool_call(bash_ctx))
        assert "env" not in bash_ctx.inputs.tool_args


class TestCancelledScopeRevival(unittest.TestCase):
    """A fresh explicit skill_tool call reopens a task-cancelled window.

    Regression (SKILL_GATE false blocking): interrupt(cancel) ->
    revoke_grants(sid, "main") writes ``main`` into the session file's
    invalidated list; FileSkillGrantStore.operate then silently dropped
    every later update_active_skill_state activation in the SAME session
    (the "activated" log still printed), so the bash gate kept reading
    active=None forever - skill_tool then bash failed no matter the
    ordering (same batch, serial, strict serial barrier). Fix: the
    skill_tool before_tool_call drops the stale main breaker first
    (aligned with activate_pending's discard when the feature is on);
    the late-callback guard stays unchanged.
    """

    sid = "officeclaw_revive_sess"

    def tearDown(self):
        clear_session_skill_state(self.sid)

    def _skill_tool_ctx(self, skill_name="hwocr", listing=False):
        ctx = AgentCallbackContext(agent=MagicMock())
        tool_call = MagicMock()
        tool_call.arguments = {"skill_name": skill_name}
        tool_msg = MagicMock()
        if listing:
            tool_msg.metadata = {"is_directory_listing": True}
        else:
            tool_msg.metadata = {"skill_name": skill_name}
        ctx.inputs = ToolCallInputs(
            tool_call=tool_call,
            tool_name="skill_tool",
            tool_args={"skill_name": skill_name},
            tool_result=None,
            tool_msg=tool_msg,
        )
        ctx.extra = {}
        return ctx

    def _bash_ctx(self):
        ctx = AgentCallbackContext(agent=MagicMock())
        ctx.inputs = ToolCallInputs(
            tool_call=MagicMock(),
            tool_name="bash",
            tool_args={"command": "hwocr.exe general-text"},
            tool_result=None,
            tool_msg=None,
        )
        ctx.extra = {}
        return ctx

    def _store(self):
        from jiuwenswarm.agents.harness.common.rails import skill_active_state

        return skill_active_state._shared_store(self.sid)

    def test_late_callback_after_cancel_stays_dropped(self):
        # Control: no fresh skill_tool call after the cancel - a late
        # callback stays dropped (existing safety semantics, see
        # test_revocation_is_seen_by_original_process).
        rail = SkillActiveStateRail(session_id=self.sid)
        self._store().revoke_grants(self.sid, "main")
        asyncio.run(rail.after_tool_call(self._skill_tool_ctx()))
        assert get_session_active_skill(self.sid) is None

    def test_fresh_skill_tool_after_cancel_activates_and_gates_pass(self):
        # Fix target: a fresh explicit skill_tool call (before + after on
        # the SAME ctx, as the framework dispatches it) persists the
        # activation atomically with the breaker drop, and the bash gate
        # can read it and inject credentials.
        rail = SkillActiveStateRail(session_id=self.sid)
        self._store().revoke_grants(self.sid, "main")
        fresh_ctx = self._skill_tool_ctx()
        asyncio.run(rail.before_tool_call(fresh_ctx))
        asyncio.run(rail.after_tool_call(fresh_ctx))
        assert get_session_active_skill(self.sid) == "hwocr"
        inject = SkillCredentialInjectionRail(
            skill_envs={"hwocr": {"HWOCR_AK": "ak", "HWOCR_SK": "sk"}},
            preset_session_id=self.sid,
        )
        bash_ctx = self._bash_ctx()
        asyncio.run(inject.before_tool_call(bash_ctx))
        assert bash_ctx.inputs.tool_args["env"]["HWOCR_AK"] == "ak"

    def test_late_callback_between_fresh_before_and_after_stays_dropped(self):
        # SF-1 regression: a late after-callback from the cancelled round
        # lands after the fresh call's before but before its after. The
        # breaker drop is deferred into the fresh activation transaction,
        # so the stale write must still be dropped; the fresh call then
        # activates normally.
        rail = SkillActiveStateRail(session_id=self.sid)
        self._store().revoke_grants(self.sid, "main")
        fresh_ctx = self._skill_tool_ctx(skill_name="hwocr")
        asyncio.run(rail.before_tool_call(fresh_ctx))
        # Late after-callback from the cancelled round (stale skill, no
        # revive marker: its own before ran before the cancel).
        asyncio.run(
            rail.after_tool_call(self._skill_tool_ctx(skill_name="stale-skill"))
        )
        assert get_session_active_skill(self.sid) is None
        # The fresh call's after now persists atomically.
        asyncio.run(rail.after_tool_call(fresh_ctx))
        assert get_session_active_skill(self.sid) == "hwocr"

    def test_listing_only_call_does_not_revive(self):
        # SF-2 regression: a directory-listing skill_tool call activates
        # nothing, so it must not drop the breaker either (symmetry with
        # after_tool_call's listing skip).
        rail = SkillActiveStateRail(session_id=self.sid)
        self._store().revoke_grants(self.sid, "main")
        listing_ctx = self._skill_tool_ctx(listing=True)
        asyncio.run(rail.before_tool_call(listing_ctx))
        asyncio.run(rail.after_tool_call(listing_ctx))
        assert get_session_active_skill(self.sid) is None
        # Breaker still up: a late callback is still dropped...
        asyncio.run(rail.after_tool_call(self._skill_tool_ctx()))
        assert get_session_active_skill(self.sid) is None
        # ...while a fresh explicit call still activates.
        fresh_ctx = self._skill_tool_ctx()
        asyncio.run(rail.before_tool_call(fresh_ctx))
        asyncio.run(rail.after_tool_call(fresh_ctx))
        assert get_session_active_skill(self.sid) == "hwocr"

    def test_bash_or_other_tools_do_not_revive(self):
        # Only an explicit skill_tool call drops the breaker; bash and
        # other tools must not revive it.
        rail = SkillActiveStateRail(session_id=self.sid)
        self._store().revoke_grants(self.sid, "main")
        asyncio.run(rail.before_tool_call(self._bash_ctx()))
        asyncio.run(rail.after_tool_call(self._skill_tool_ctx()))
        assert get_session_active_skill(self.sid) is None

    def test_revive_marker_travels_the_real_callback_framework(self):
        # NTH-R2-1: pin the framework contract the marker relies on.
        # The revive marker is stamped in before_tool_call and consumed in
        # after_tool_call; it only works because the callback framework
        # dispatches both events on the SAME AgentCallbackContext
        # (ctx.extra persists across events). Drive both hooks through the
        # real AsyncCallbackFramework so a future per-event ctx copy fails
        # LOUDLY here instead of silently re-introducing the SKILL_GATE
        # false-blocking bug.
        from openjiuwen.core.runner.callback.framework import AsyncCallbackFramework

        rail = SkillActiveStateRail(session_id=self.sid)
        self._store().revoke_grants(self.sid, "main")
        ctx = self._skill_tool_ctx()

        async def run_through_framework():
            callbacks = AsyncCallbackFramework()
            await callbacks.register("before_tool", rail.before_tool_call)
            await callbacks.register("after_tool", rail.after_tool_call)
            await callbacks.trigger("before_tool", ctx)
            await callbacks.trigger("after_tool", ctx)

        asyncio.run(run_through_framework())
        assert get_session_active_skill(self.sid) == "hwocr"


if __name__ == "__main__":
    unittest.main()