voidx 3.7.2__tar.gz → 3.7.4__tar.gz

{voidx-3.7.2/src/voidx.egg-info → voidx-3.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.7.2
+Version: 3.7.4
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
 Author: chikhamx
 License: MIT

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/graph/test_call_llm_compaction.py

@@ -19,6 +19,7 @@ from voidx.agent.task_state import TaskState, TodoRunState
 from voidx.config import Config, ModelConfig
 from voidx.agent.graph.compaction_coordinator import CompactionResult, PreflightCompactionResult
 from voidx.llm.compaction import CompactionSelection, SUMMARY_TEMPLATE
+from voidx.llm.usage import estimate_context_tokens
 from voidx.llm.message_markers import is_guidance_message
 from voidx.memory.context_frames import load_context_frames
 from voidx.memory.session import MessageRow, create_session, delete_session, save_message
@@ -181,6 +182,7 @@ async def test_call_llm_updates_usage_stats_across_turn_control_calls(tmp_path,
         "messages": [HumanMessage(content="hi")],
         "step_count": 0,
         "persona": "voidx",
+        "turn_state": "running",
     })
 
     assert result["step_count"] == 1
@@ -188,11 +190,38 @@ async def test_call_llm_updates_usage_stats_across_turn_control_calls(tmp_path,
     assert graph.model.calls == 2
     assert graph._usage_stats.last_input_tokens == 2
     assert graph._usage_stats.last_output_tokens == 1
+    assert graph._usage_stats.context_tokens == 2
     assert graph._usage_stats.total_input_tokens == 9
     assert graph._usage_stats.total_output_tokens == 4
     assert graph._usage_stats.total_calls == 2
 
 
+@pytest.mark.asyncio
+async def test_call_llm_fallback_context_estimate_includes_tool_schema(tmp_path, monkeypatch):
+    import voidx.agent.graph.core.llm as graph_module
+
+    monkeypatch.setattr(graph_module, "StreamingRenderer", FakeRenderer)
+
+    graph = VoidXGraph(
+        Config(
+            model=ModelConfig(provider="openai", model="gpt-4o"),
+            workspace=str(tmp_path),
+        ),
+        api_key=None,
+    )
+    graph.model = FakeStreamingModel()
+
+    await graph._call_llm({
+        "messages": [HumanMessage(content="hi")],
+        "step_count": 0,
+        "persona": "voidx",
+        "turn_state": "running",
+    })
+
+    messages_only = estimate_context_tokens(graph.model.messages, graph.config.model.model)
+    assert graph._usage_stats.context_tokens > messages_only
+
+
 @pytest.mark.asyncio
 async def test_call_llm_persists_context_frame_for_session(tmp_path, monkeypatch):
     import voidx.agent.graph.core.llm as graph_module

voidx-3.7.4/src/tests/test_agent/graph/test_call_llm_structure.py

@@ -0,0 +1,12 @@
+"""Structure tests for the call_llm refactor."""
+
+import importlib
+
+
+def test_call_llm_helpers_live_in_core_modules():
+    for module_name in (
+        "voidx.agent.graph.core.loop",
+        "voidx.agent.graph.core.turn",
+        "voidx.agent.graph.core.context",
+    ):
+        assert importlib.import_module(module_name)

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/graph/test_graph_authorization.py

@@ -145,7 +145,6 @@ def test_permission_decision_splits_readonly_and_implement_agents():
 @pytest.mark.asyncio
 async def test_graph_authorization_auto_allows_readonly_agent(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "untrusted"
     approved, denied = await graph._authorize_tool_calls(
         [{
             "name": "agent",
@@ -217,7 +216,7 @@ async def test_graph_authorization_respects_session_deny_for_safe_bash(tmp_path)
 @pytest.mark.asyncio
 async def test_graph_authorization_never_approves_mixed_blocked_batch(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.permission_preset = "safe"
+    graph._permission.permission_mode = "safe"
     asked: list[list[object]] = []
 
     async def approve(tool_calls):
@@ -242,10 +241,59 @@ async def test_graph_authorization_never_approves_mixed_blocked_batch(tmp_path):
     assert [item.tool_call["id"] for item in asked[1]] == ["ask"]
 
 
+@pytest.mark.asyncio
+async def test_full_access_workflow_gate_advisory_allows_without_approval(tmp_path):
+    graph = _graph(tmp_path)
+    graph._permission.set_permission_mode("full_access")
+
+    async def fail_if_asked(_tool_calls):
+        pytest.fail("workflow gate should not prompt for approval under full_access")
+
+    graph._ask_tool_permission = fail_if_asked
+
+    approved, denied = await graph._authorize_tool_calls(
+        [{"name": "write", "args": {"file_path": "app.py", "content": "x"}, "id": "call_1"}],
+        plan_mode=False,
+        session_id="test",
+        workflow_runs=[
+            WorkflowRunState(name="brainstorm", status=WorkflowRunStatus.ACTIVE),
+        ],
+    )
+
+    assert [call["id"] for call in approved] == ["call_1"]
+    assert denied == []
+
+
+@pytest.mark.asyncio
+async def test_safe_mode_workflow_gate_still_prompts(tmp_path):
+    """Under safe mode, workflow gate advisory does not bypass permission approval."""
+    graph = _graph(tmp_path)
+    graph._permission.set_permission_mode("safe")
+    asked: list = []
+
+    async def approve(tool_calls):
+        asked.extend(tool_calls)
+        return "y"
+
+    graph._ask_tool_permission = approve
+
+    approved, denied = await graph._authorize_tool_calls(
+        [{"name": "write", "args": {"file_path": "app.py", "content": "x"}, "id": "call_1"}],
+        plan_mode=False,
+        session_id="test",
+        workflow_runs=[
+            WorkflowRunState(name="brainstorm", status=WorkflowRunStatus.ACTIVE),
+        ],
+    )
+
+    assert [call["id"] for call in approved] == ["call_1"]
+    assert denied == []
+    assert len(asked) > 0
+
+
 @pytest.mark.asyncio
 async def test_graph_authorization_asks_for_write_by_active_workflow_gate(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
     asked: list[list[dict]] = []
 
     async def approve(tool_calls):
@@ -271,7 +319,13 @@ async def test_graph_authorization_asks_for_write_by_active_workflow_gate(tmp_pa
 @pytest.mark.asyncio
 async def test_graph_authorization_uses_current_workflow_gate_only(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
+    asked: list[list[dict]] = []
+
+    async def approve(tool_calls):
+        asked.append(tool_calls)
+        return "y"
+
+    graph._ask_tool_permission = approve
 
     approved, denied = await graph._authorize_tool_calls(
         [{
@@ -288,14 +342,15 @@ async def test_graph_authorization_uses_current_workflow_gate_only(tmp_path):
         ],
     )
 
+    assert [[call["id"] for call in _asked_tool_calls(batch)] for batch in asked] == [["call_1"]]
     assert [call["id"] for call in approved] == ["call_1"]
     assert denied == []
 
 
 @pytest.mark.asyncio
-async def test_graph_authorization_allows_plan_gate_doc_paths_only(tmp_path):
+async def test_graph_authorization_plan_gate_no_longer_bypasses_doc_paths(tmp_path):
+    """allowed_paths bypass removed: both docs and src edits go through normal permission."""
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
     asked: list[list[dict]] = []
 
     async def deny(tool_calls):
@@ -325,16 +380,22 @@ async def test_graph_authorization_allows_plan_gate_doc_paths_only(tmp_path):
         ],
     )
 
-    assert [call["id"] for call in approved] == ["call_docs"]
-    assert [[call["id"] for call in _asked_tool_calls(batch)] for batch in asked] == [["call_src"]]
-    assert [call["id"] for call, _reason in denied] == ["call_src"]
-    assert denied[0][1] == "User denied: replace"
+    assert approved == []
+    assert [call["id"] for call, _reason in denied] == ["call_docs", "call_src"]
+    assert all(reason == "User denied: replace" for _tc, reason in denied)
 
 
 @pytest.mark.asyncio
-async def test_graph_authorization_allowed_paths_match_nested_docs(tmp_path):
+async def test_graph_authorization_nested_docs_go_through_normal_permission(tmp_path):
+    """allowed_paths bypass removed: nested docs edits go through normal permission."""
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
+    asked: list[list[dict]] = []
+
+    async def approve(tool_calls):
+        asked.append(tool_calls)
+        return "y"
+
+    graph._ask_tool_permission = approve
 
     approved, denied = await graph._authorize_tool_calls(
         [{
@@ -350,6 +411,7 @@ async def test_graph_authorization_allowed_paths_match_nested_docs(tmp_path):
         ],
     )
 
+    assert [[call["id"] for call in _asked_tool_calls(batch)] for batch in asked] == [["call_nested_docs"]]
     assert [call["id"] for call in approved] == ["call_nested_docs"]
     assert denied == []
 
@@ -357,8 +419,7 @@ async def test_graph_authorization_allowed_paths_match_nested_docs(tmp_path):
 @pytest.mark.asyncio
 async def test_graph_authorization_does_not_block_tools_outside_active_workflow_node_allowlist(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
-
+    
     approved, denied = await graph._authorize_tool_calls(
         [{
             "name": "todo",
@@ -380,7 +441,6 @@ async def test_graph_authorization_does_not_block_tools_outside_active_workflow_
 @pytest.mark.asyncio
 async def test_graph_authorization_asks_for_workflow_gate_tools_instead_of_denying(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
     asked: list[list[dict]] = []
 
     async def approve(tool_calls):
@@ -411,7 +471,6 @@ async def test_graph_authorization_asks_for_workflow_gate_tools_instead_of_denyi
 @pytest.mark.asyncio
 async def test_graph_authorization_asks_for_persona_blocked_write(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
     asked: list[list[dict]] = []
 
     async def approve(tool_calls):
@@ -434,7 +493,6 @@ async def test_graph_authorization_asks_for_persona_blocked_write(tmp_path):
 @pytest.mark.asyncio
 async def test_permission_result_uses_transient_output(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "untrusted"
     test_dock = BottomInputDock()
     set_dock(test_dock)
     test_dock.begin_capture()
@@ -520,9 +578,7 @@ async def test_permission_prompt_uses_dock_details_when_events_are_active(tmp_pa
 @pytest.mark.asyncio
 async def test_read_only_permission_prompt_limits_choices_to_once(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.sandbox_mode = "read-only"
-    graph._permission.permission_mode = "read-only"
-    graph._permission.approval_policy = "untrusted"
+    graph._permission.set_permission_mode("read_only")
     captured_choices = None
 
     class FakeApp:
@@ -550,8 +606,7 @@ async def test_read_only_permission_prompt_limits_choices_to_once(tmp_path):
 @pytest.mark.asyncio
 async def test_permission_prompt_details_include_risk_and_scopes(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.permission_mode = "default"
-    graph._permission.approval_policy = "untrusted"
+    graph._permission.set_permission_mode("safe")
     received_details = None
 
     class FakeApp:
@@ -589,10 +644,9 @@ async def test_permission_prompt_details_include_risk_and_scopes(tmp_path):
 @pytest.mark.asyncio
 async def test_graph_authorization_attaches_approved_risk_token_to_approved_shell_call(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.sandbox_mode = "read-only"
-    graph._permission.permission_mode = "read-only"
-    graph._permission.approval_policy = "untrusted"
-
+    graph._permission.set_permission_mode("read_only")
+    graph._permission.set_permission_mode("read_only")
+    
     async def approve(_tool_calls):
         return "y"
 
@@ -618,8 +672,7 @@ async def test_graph_authorization_attaches_approved_risk_token_to_approved_shel
 @pytest.mark.asyncio
 async def test_blocked_permission_prompt_only_acknowledges_and_denies_execution(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.permission_mode = "default"
-    graph._permission.approval_policy = "untrusted"
+    graph._permission.set_permission_mode("safe")
     captured_choices = None
     captured_details = None
 
@@ -649,9 +702,8 @@ async def test_blocked_permission_prompt_only_acknowledges_and_denies_execution(
 @pytest.mark.asyncio
 async def test_blocked_permission_prompt_cannot_be_approved_with_yes(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.permission_mode = "default"
-    graph._permission.approval_policy = "untrusted"
-
+    graph._permission.set_permission_mode("safe")
+    
     class FakeApp:
         async def ask_choice(self, _prompt, _choices, details=None):
             return "y"

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/graph/test_subagent_runner.py

@@ -323,7 +323,6 @@ async def test_subagent_runner_authorizes_with_child_interaction_mode(tmp_path,
 @pytest.mark.asyncio
 async def test_graph_authorization_does_not_treat_goal_as_read_only_mode(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
     asked: list[list[dict]] = []
 
     async def approve(tool_calls):

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/graph/test_tool_execution_auth.py

@@ -135,7 +135,7 @@ def _tree_nodes(root):
 @pytest.mark.asyncio
 async def test_graph_on_request_auto_approves_need_ask_tools(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.permission_preset = "full_access"
+    graph._permission.permission_mode = "full_access"
 
     approved, denied = await graph._authorize_tool_calls(
         [{"name": "write", "args": {"file_path": "app.py", "op": "append", "new_string": "x"}, "id": "call_1"}],
@@ -149,10 +149,30 @@ async def test_graph_on_request_auto_approves_need_ask_tools(tmp_path):
 
 
 @pytest.mark.asyncio
-async def test_graph_on_failure_asks_unsafe_bash_before_prompt(tmp_path):
+async def test_full_access_auto_approves_write_without_implement_persona(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-failure"
+    graph._permission.permission_mode = "full_access"
+
+    async def fail_if_asked(_tool_calls):
+        pytest.fail("full_access should not prompt for workspace edit")
+
+    graph._ask_tool_permission = fail_if_asked
+
+    approved, denied = await graph._authorize_tool_calls(
+        [{"name": "replace", "args": {"file_path": "app.py", "bounds": [{"line_no": 1, "anchor": "x"}], "new_string": "y"}, "id": "call_1"}],
+        runtime_persona="coordinate",
+        plan_mode=False,
+        session_id="test",
+    )
+
+    assert [tc["name"] for tc in approved] == ["replace"]
+    assert denied == []
+
 
+@pytest.mark.asyncio
+async def test_graph_on_failure_asks_unsafe_bash_before_prompt(tmp_path):
+    graph = _graph(tmp_path)
+    
     asked: list[dict] = []
 
     async def ask(tool_calls):

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/graph/test_turn_control_e2e.py

@@ -102,6 +102,7 @@ async def test_regular_tool_call_resets_missing_turn_count(tmp_path, monkeypatch
         "messages": [HumanMessage(content="hello")],
         "step_count": 0,
         "persona": "coordinate",
+        "turn_state": "running",
     })
     # The regular tool call should route to execute, not end
     assert result1["messages"][0].tool_calls
@@ -113,6 +114,7 @@ async def test_regular_tool_call_resets_missing_turn_count(tmp_path, monkeypatch
         "messages": [HumanMessage(content="hello"), *result1["messages"]],
         "step_count": 1,
         "persona": "coordinate",
+        "turn_state": result1.get("turn_state", "running"),
     })
     assert result2["messages"][0].content == "Final answer."
     assert not result2["messages"][0].tool_calls
@@ -170,6 +172,7 @@ async def test_turn_call_never_emits_permission_or_execution_events(tmp_path, mo
         "messages": [HumanMessage(content="hello")],
         "step_count": 0,
         "persona": "coordinate",
+        "turn_state": "running",
     })
 
     # Check that no tool permission or tool execution events were emitted
@@ -195,6 +198,7 @@ async def test_successful_barrier_emits_one_committed_stream(tmp_path, monkeypat
         "messages": [HumanMessage(content="hello")],
         "step_count": 0,
         "persona": "coordinate",
+        "turn_state": "running",
     })
 
     msgs = result["messages"]
@@ -221,6 +225,7 @@ async def test_regular_tool_continues_after_turn_prompt(tmp_path, monkeypatch):
         "messages": [HumanMessage(content="hello")],
         "step_count": 0,
         "persona": "coordinate",
+        "turn_state": "running",
     })
 
     assert result["messages"][0].tool_calls

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/graph/test_turn_control_integration.py

@@ -1,7 +1,7 @@
 """Integration tests for turn control inside _call_llm."""
 
 import pytest
-from langchain_core.messages import AIMessage, AIMessageChunk, HumanMessage
+from langchain_core.messages import AIMessage, AIMessageChunk, HumanMessage, ToolMessage
 
 from voidx.agent.graph import VoidXGraph
 from voidx.agent.graph.turn_control import TURN_TOOL_DEFINITION
@@ -291,11 +291,11 @@ async def test_regular_tool_call_routes_to_execute(tmp_path, monkeypatch):
     assert msgs[0].tool_calls[0]["name"] == "read"
 
 
-# ── Test 4: first plain-text triggers first completion prompt ───────────────
+# ── Test 4: first plain-text answer can complete immediately ────────────────
 
 
 @pytest.mark.asyncio
-async def test_first_plain_text_triggers_first_prompt_then_turn(tmp_path, monkeypatch):
+async def test_first_plain_text_commits_without_start_prompt(tmp_path, monkeypatch):
     model = ScriptedStreamingModel([
         [_text_chunk("Provisional answer.")],
         [_turn_call_chunk()],
@@ -311,11 +311,13 @@ async def test_first_plain_text_triggers_first_prompt_then_turn(tmp_path, monkey
     msgs = result["messages"]
     assert msgs[0].content == "Provisional answer."
     assert not msgs[0].tool_calls
-    assert model.call_index == 2
+    assert result["turn_state"] == "committed"
+    assert model.call_index == 1
+    assert len(model.received_messages) == 1
 
 
 @pytest.mark.asyncio
-async def test_missing_turn_reprompt_keeps_full_tool_set_and_appends_turn_prompt(tmp_path, monkeypatch):
+async def test_initial_plain_text_keeps_full_tool_set_without_reprompt(tmp_path, monkeypatch):
     model = ScriptedStreamingModel([
         [_text_chunk("Provisional answer.")],
         [_turn_call_chunk()],
@@ -329,12 +331,8 @@ async def test_missing_turn_reprompt_keeps_full_tool_set_and_appends_turn_prompt
     })
 
     assert result["messages"][0].content == "Provisional answer."
-    assert model.call_index == 2
-    turn_prompt_messages = model.received_messages[1]
-    assert any(
-        isinstance(msg, HumanMessage) and "operation='start'" in str(msg.content)
-        for msg in turn_prompt_messages
-    )
+    assert model.call_index == 1
+    assert len(model.received_messages) == 1
     tool_names = [tool["function"]["name"] for tool in model.bound_tools]
     assert "turn" in tool_names
     assert "read" in tool_names
@@ -352,6 +350,7 @@ async def test_regular_tool_after_turn_prompt_continues_without_committing_text(
         "messages": [HumanMessage(content="read x.py")],
         "step_count": 0,
         "persona": "coordinate",
+        "turn_state": "running",
     })
 
     assert result["messages"][0].tool_calls
@@ -384,7 +383,7 @@ async def test_decision_only_turn_with_text_is_rejected_before_stop(tmp_path, mo
 
 
 @pytest.mark.asyncio
-async def test_plain_text_prompts_start_then_stop_without_ui_leak(tmp_path, monkeypatch):
+async def test_initial_plain_text_commits_without_hidden_ui_followups(tmp_path, monkeypatch):
     RecordingRenderer.reset()
     model = ScriptedStreamingModel([
         [_text_chunk("First provisional.")],
@@ -400,10 +399,12 @@ async def test_plain_text_prompts_start_then_stop_without_ui_leak(tmp_path, monk
     })
 
     visible_text = "".join(RecordingRenderer.visible_text)
-    assert result["messages"][0].content == "Second provisional."
+    assert result["messages"][0].content == "First provisional."
     assert "First provisional." in visible_text
+    assert "Second provisional." not in visible_text
     assert RecordingRenderer.headless_values[0] is False
-    assert all(RecordingRenderer.headless_values[1:])
+    assert RecordingRenderer.headless_values == [False]
+    assert model.call_index == 1
 
 
 # ── Test 6: second plain-text fallback keeps latest response ────────────────
@@ -422,6 +423,7 @@ async def test_invalid_turn_continue_recovers_with_regular_tool(tmp_path, monkey
         "messages": [HumanMessage(content="hello")],
         "step_count": 0,
         "persona": "coordinate",
+        "turn_state": "running",
     })
 
     assert result["messages"][0].tool_calls
@@ -512,8 +514,8 @@ async def test_turn_with_non_empty_args_is_rejected(tmp_path, monkeypatch):
         }],
     )
     model = ScriptedStreamingModel([
-        [_text_chunk("answer")],
         [malformed_turn],
+        [_text_chunk("answer")],
         [_turn_call_chunk()],
     ])
     graph = _make_graph(tmp_path, model, monkeypatch)
@@ -623,7 +625,19 @@ async def test_start_prompt_injected_once_then_stop_prompt(tmp_path, monkeypatch
     graph = _make_graph(tmp_path, model, monkeypatch)
 
     result = await graph._call_llm({
-        "messages": [HumanMessage(content="hello")],
+        "messages": [
+            HumanMessage(content="hello"),
+            AIMessage(
+                content="",
+                tool_calls=[{
+                    "name": "read",
+                    "args": {"file_path": "x.py"},
+                    "id": "tc-prior",
+                    "type": "tool_call",
+                }],
+            ),
+            ToolMessage(content="ok", tool_call_id="tc-prior", name="read"),
+        ],
         "step_count": 0,
         "persona": "coordinate",
         "turn_state": "initial",

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/graph/test_workflow_transactions_barrier.py

@@ -293,7 +293,6 @@ async def test_multiple_barriers_apply_patches_in_order(tmp_path):
 @pytest.mark.asyncio
 async def test_workflow_transaction_reauthorizes_following_write(tmp_path):
     graph = _graph(tmp_path)
-    graph._permission.approval_policy = "on-request"
     invalidations = 0
 
     class FakeApp:

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/loop/test_manager.py

@@ -33,6 +33,23 @@ async def test_fixed_loop_fires_after_interval(tmp_path) -> None:
     assert host.turns[:1] == ["tick"]
 
 
+@pytest.mark.asyncio
+async def test_first_fire_is_immediate(tmp_path) -> None:
+    host = FakeHost()
+    idle = asyncio.Event()
+    idle.set()
+    manager = LoopManager(host, idle_event=idle, workspace=str(tmp_path))
+
+    manager.start(PromptSource.from_raw("tick"), 60)
+    for _ in range(20):
+        if host.turns:
+            break
+        await asyncio.sleep(0.005)
+    await manager.cleanup()
+
+    assert host.turns[:1] == ["tick"]
+
+
 @pytest.mark.asyncio
 async def test_stop_cancels_active_loop_before_fire(tmp_path) -> None:
     host = FakeHost()
@@ -56,12 +73,13 @@ async def test_dynamic_wakeup_interrupts_default_sleep(tmp_path) -> None:
     manager = LoopManager(host, idle_event=idle, workspace=str(tmp_path), default_interval_seconds=10)
 
     manager.start(PromptSource.from_raw("tick"), None)
-    await asyncio.sleep(0)
+    await asyncio.sleep(0.02)
+    assert host.turns == ["tick"]
     manager.schedule_wakeup(0.01)
     await asyncio.sleep(0.04)
     await manager.cleanup()
 
-    assert host.turns == ["tick"]
+    assert host.turns == ["tick", "tick"]
 
 
 

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/slash/test_slash_model.py

@@ -15,7 +15,7 @@ from voidx.config import (
     McpServerConfig,
     ModelConfig,
     ParallelSubagentsConfig,
-    PermissionPreset,
+    PermissionMode,
     Settings,
     UserProfile,
 )
@@ -565,7 +565,7 @@ async def test_usage_dispatch_reads_usage_stats():
 
 
 @pytest.mark.asyncio
-async def test_permission_preset_dispatch_updates_service_and_settings(tmp_path):
+async def test_permission_mode_dispatch_updates_service_and_settings(tmp_path):
     settings = Settings(str(tmp_path))
     permission = PermissionService()
     graph = SimpleNamespace(
@@ -574,13 +574,13 @@ async def test_permission_preset_dispatch_updates_service_and_settings(tmp_path)
         _app=None,
     )
 
-    assert await SlashHandler(graph).dispatch("/permission-preset full_access") is True
+    assert await SlashHandler(graph).dispatch("/permission full_access") is True
 
     reloaded = await Settings.create(str(tmp_path))
     cfg = await reloaded.build_config()
-    assert permission.permission_preset == "full_access"
-    assert cfg.permission_preset == PermissionPreset.FULL_ACCESS
-    assert reloaded.get_permission_preset() == PermissionPreset.FULL_ACCESS
+    assert permission.permission_mode == "full_access"
+    assert cfg.permission_mode == PermissionMode.FULL_ACCESS
+    assert reloaded.get_permission_mode() == PermissionMode.FULL_ACCESS
     assert await SlashHandler(graph).dispatch("/permission-mode full-access") is False
     assert await SlashHandler(graph).dispatch("/approval never") is False
 

{voidx-3.7.2 → voidx-3.7.4}/src/tests/test_agent/slash/test_slash_model_advanced.py

@@ -15,7 +15,7 @@ from voidx.config import (
     McpServerConfig,
     ModelConfig,
     ParallelSubagentsConfig,
-    PermissionPreset,
+    PermissionMode,
     Settings,
     UserProfile,
 )
@@ -329,7 +329,7 @@ def test_model_ctx_command_is_in_palette():
     assert ("/model ctx", "Set context window size") in COMMANDS
 
 @pytest.mark.asyncio
-async def test_permission_preset_without_args_uses_prompt_app_choice(tmp_path):
+async def test_permission_mode_without_args_uses_prompt_app_choice(tmp_path):
     settings = Settings(str(tmp_path))
     permission = PermissionService()
     app = FakeChoiceApp(result="project_trusted")
@@ -339,11 +339,11 @@ async def test_permission_preset_without_args_uses_prompt_app_choice(tmp_path):
         _app=app,
     )
 
-    assert await SlashHandler(graph).dispatch("/permission-preset") is True
+    assert await SlashHandler(graph).dispatch("/permission") is True
 
-    assert app.prompt == "Permission preset"
-    assert permission.permission_preset == "project_trusted"
-    assert settings.get_permission_preset() == PermissionPreset.PROJECT_TRUSTED
+    assert app.prompt == "Permission mode"
+    assert permission.permission_mode == "project_trusted"
+    assert settings.get_permission_mode() == PermissionMode.PROJECT_TRUSTED
 
 
 @pytest.mark.asyncio