v2026.06.18

flocks/session/streaming/stream_processor.py

@@ -71,6 +71,16 @@ def _resolve_tool_error(result: ToolResult) -> str:
     return "Unknown error"
 
 
+def _invalid_tool_call_parse_error(tool_input: Dict[str, Any]) -> tuple[str, str]:
+    """Return original tool name and user-facing parse error for invalid tool events."""
+    original_tool = str(tool_input.get("tool") or "unknown").strip() or "unknown"
+    raw_error = str(tool_input.get("error") or "Failed to parse tool arguments.").strip()
+    prefix = f"Failed to parse tool arguments for {original_tool}"
+    if raw_error.startswith(prefix):
+        return original_tool, raw_error
+    return original_tool, f"{prefix}: {raw_error}"
+
+
 @dataclass
 class ToolCallState:
     """State for tracking tool calls"""
@@ -508,6 +518,56 @@ async def _handle_tool_call(self, event: ToolCallEvent) -> None:
 
         tool_state = self.tool_calls[tool_call_id]
         tool_state.input = tool_input
+
+        if tool_name == "invalid":
+            original_tool, parse_error = _invalid_tool_call_parse_error(tool_input)
+            tool_state.name = original_tool
+            tool_state.status = "error"
+            tool_state.error = parse_error
+
+            tool_error_time = int(datetime.now().timestamp() * 1000)
+            error_state = ToolStateError(
+                status="error",
+                input=tool_input,
+                error=parse_error,
+                time={"start": tool_error_time, "end": tool_error_time},
+            )
+            error_part = ToolPart(
+                id=tool_state.part_id,
+                sessionID=self.session_id,
+                messageID=self.assistant_message.id,
+                type="tool",
+                callID=tool_call_id,
+                tool=original_tool,
+                state=error_state,
+            )
+            await Message.store_part(self.session_id, self.assistant_message.id, error_part)
+
+            if self.event_publish_callback:
+                await self.event_publish_callback("message.part.updated", {
+                    "part": {
+                        "id": tool_state.part_id,
+                        "messageID": self.assistant_message.id,
+                        "sessionID": self.session_id,
+                        "type": "tool",
+                        "callID": tool_call_id,
+                        "tool": original_tool,
+                        "state": {
+                            "status": "error",
+                            "input": tool_input,
+                            "error": parse_error,
+                            "time": {"start": tool_error_time, "end": tool_error_time},
+                        },
+                    },
+                })
+
+            log.warn("stream.tool_call.invalid_arguments", {
+                "tool_call_id": tool_call_id,
+                "tool_name": original_tool,
+                "error": parse_error,
+            })
+            return
+
         tool_state.status = "running"
 
         # Update ToolPart to running state (like Flocks's Session.updatePart)

flocks/tool/agent/delegate_task.py

@@ -37,12 +37,6 @@ async def _subagent_session_permissions(agent_name: str) -> list:
     from flocks.agent.registry import Agent
     from flocks.session.session import PermissionRule as SessionPermissionRule
 
-    def deny_nested_delegation() -> list:
-        return [
-            SessionPermissionRule(permission="delegate_task", action="deny", pattern="*"),
-            SessionPermissionRule(permission="task", action="deny", pattern="*"),
-        ]
-
     try:
         agent = await Agent.get(agent_name)
     except Exception as exc:
@@ -67,7 +61,6 @@ def deny_nested_delegation() -> list:
                     pattern=getattr(rule, "pattern", None) or "*",
                 )
             )
-        rules.extend(deny_nested_delegation())
         return rules
 
     if agent_name == "prometheus":
@@ -78,7 +71,6 @@ def deny_nested_delegation() -> list:
         ])
     elif not rules:
         rules.append(SessionPermissionRule(permission="question", action="deny", pattern="*"))
-    rules.extend(deny_nested_delegation())
     return rules
 
 

install.ps1

@@ -157,6 +157,22 @@ function Unblock-InstallFiles {
     }
 }
 
+function Remove-ExistingInstallDirectory {
+    param([string]$TargetDir)
+
+    if ([string]::IsNullOrWhiteSpace($TargetDir) -or -not (Test-Path -LiteralPath $TargetDir)) {
+        return
+    }
+
+    Write-Info "Removing previous Flocks installation: $TargetDir"
+    try {
+        Remove-Item -LiteralPath $TargetDir -Recurse -Force -ErrorAction Stop
+    }
+    catch {
+        Fail "Failed to remove previous Flocks installation directory '$TargetDir'. Close any running Flocks process and retry. Error: $($_.Exception.Message)"
+    }
+}
+
 function Invoke-WorkspaceInstaller {
     param(
         [string]$InstallerPath,
@@ -252,9 +268,7 @@ function Main {
         if ((-not [string]::IsNullOrWhiteSpace($installParent)) -and -not (Test-Path -LiteralPath $installParent)) {
             New-Item -ItemType Directory -Path $installParent -Force | Out-Null
         }
-        if (Test-Path $InstallDir) {
-            Remove-Item -Path $InstallDir -Recurse -Force
-        }
+        Remove-ExistingInstallDirectory -TargetDir $InstallDir
         Copy-Item -Path $projectRoot -Destination $InstallDir -Recurse -Force
         Unblock-InstallFiles -TargetDir $InstallDir
 

install_zh.ps1

@@ -163,6 +163,22 @@ function Unblock-InstallFiles {
     }
 }
 
+function Remove-ExistingInstallDirectory {
+    param([string]$TargetDir)
+
+    if ([string]::IsNullOrWhiteSpace($TargetDir) -or -not (Test-Path -LiteralPath $TargetDir)) {
+        return
+    }
+
+    Write-Info "正在删除历史 Flocks 安装目录: $TargetDir"
+    try {
+        Remove-Item -LiteralPath $TargetDir -Recurse -Force -ErrorAction Stop
+    }
+    catch {
+        Fail "无法删除历史 Flocks 安装目录 '$TargetDir'。请关闭正在运行的 Flocks 进程后重试。错误: $($_.Exception.Message)"
+    }
+}
+
 function Invoke-WorkspaceInstaller {
     param(
         [string]$InstallerPath,
@@ -291,9 +307,7 @@ function Main {
         if ((-not [string]::IsNullOrWhiteSpace($installParent)) -and -not (Test-Path -LiteralPath $installParent)) {
             New-Item -ItemType Directory -Path $installParent -Force | Out-Null
         }
-        if (Test-Path $InstallDir) {
-            Remove-Item -Path $InstallDir -Recurse -Force
-        }
+        Remove-ExistingInstallDirectory -TargetDir $InstallDir
         Copy-Item -Path $projectRoot -Destination $InstallDir -Recurse -Force
         Unblock-InstallFiles -TargetDir $InstallDir
 

packaging/windows/flocks-setup.iss

@@ -76,6 +76,31 @@ Type: filesandordirs; Name: "{app}\*"
 Type: dirifempty; Name: "{app}"
 
 [Code]
+procedure RemoveExistingFlocksRepoDir;
+var
+  ExistingRepoDir: string;
+begin
+  ExistingRepoDir := ExpandConstant('{app}\flocks');
+  if not DirExists(ExistingRepoDir) then
+    exit;
+
+  WizardForm.StatusLabel.Caption := 'Removing previous Flocks installation...';
+  if not DelTree(ExistingRepoDir, True, True, True) then
+  begin
+    RaiseException(
+      'Failed to remove previous Flocks installation directory:' + #13#10 +
+      ExistingRepoDir + #13#10 + #13#10 +
+      'Please close any running Flocks process and retry.'
+    );
+  end;
+end;
+
+procedure CurStepChanged(CurStep: TSetupStep);
+begin
+  if CurStep = ssInstall then
+    RemoveExistingFlocksRepoDir;
+end;
+
 function IsUnderBaseDir(const CandidateDir, BaseDir: string): Boolean;
 var
   NormalizedCandidate: string;

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flocks"
-version = "v2026.6.17"
+version = "v2026.6.18"
 description = "AI-Native SecOps platform with multi-agent collaboration"
 authors = [
     {name = "Flocks Team", email = "team@example.com"}

tests/scripts/test_install_script_sources.py

@@ -238,6 +238,20 @@ def test_windows_bootstrap_installers_only_create_missing_parent_directories() -
         assert "Test-Path -LiteralPath $installParent" in script
 
 
+def test_windows_bootstrap_installers_remove_existing_install_directory_before_copy() -> None:
+    for path in (
+        REPO_ROOT / "install.ps1",
+        REPO_ROOT / "install_zh.ps1",
+    ):
+        script = path.read_text(encoding="utf-8-sig")
+        assert "function Remove-ExistingInstallDirectory" in script
+        assert "Remove-Item -LiteralPath $TargetDir -Recurse -Force -ErrorAction Stop" in script
+        assert "Remove-ExistingInstallDirectory -TargetDir $InstallDir" in script
+        assert script.index("Remove-ExistingInstallDirectory -TargetDir $InstallDir") < script.index(
+            "Copy-Item -Path $projectRoot -Destination $InstallDir -Recurse -Force"
+        )
+
+
 def test_main_bash_installer_falls_back_to_nvm_when_brew_is_missing_on_macos() -> None:
     script = (SCRIPT_DIR / "install.sh").read_text(encoding="utf-8")
     script_without_main = re.sub(r'\nmain "\$@"\s*$', "\n", script)

tests/server/routes/test_session_routes.py

@@ -121,6 +121,60 @@ async def test_list_sessions_roots_excludes_children(self, client: AsyncClient):
         assert parent_id in ids
         assert child_id not in ids
 
+    @pytest.mark.asyncio
+    async def test_list_sessions_light_manager_filters_and_omits_heavy_fields(self, client: AsyncClient):
+        """Lightweight manager list returns only sidebar metadata."""
+        from flocks.session.goal import GoalManager
+
+        user_resp = await client.post("/api/session", json={"title": "User"})
+        user_id = user_resp.json()["id"]
+        workflow_resp = await client.post(
+            "/api/session",
+            json={"title": "Workflow", "category": "workflow"},
+        )
+        workflow_id = workflow_resp.json()["id"]
+        task_resp = await client.post(
+            "/api/session",
+            json={"title": "Task", "category": "task"},
+        )
+        task_id = task_resp.json()["id"]
+        child_resp = await client.post(
+            "/api/session",
+            json={"title": "Child", "parentID": user_id},
+        )
+        child_id = child_resp.json()["id"]
+        await GoalManager.set_goal(user_id, "Do not hydrate in list mode")
+
+        resp = await client.get(
+            "/api/session",
+            params={"view": "list", "manager": "true", "roots": "true", "limit": "100"},
+        )
+
+        assert resp.status_code == status.HTTP_200_OK
+        data = resp.json()
+        ids = {item["id"] for item in data}
+        assert user_id in ids
+        assert workflow_id in ids
+        assert task_id not in ids
+        assert child_id not in ids
+
+        row = next(item for item in data if item["id"] == user_id)
+        assert set(row) == {
+            "id",
+            "title",
+            "time",
+            "category",
+            "parentID",
+            "provider",
+            "model",
+            "model_pinned",
+            "canWrite",
+            "canDelete",
+            "isShared",
+        }
+        assert "goal" not in row
+        assert "summary" not in row
+
     @pytest.mark.asyncio
     async def test_get_session(self, client: AsyncClient, session_id: str):
         """GET /api/session/{id} returns the specific session."""
@@ -289,6 +343,41 @@ async def test_list_messages_uses_preloaded_orphan_recovery_path(
         preloaded_recovery.assert_awaited_once()
         legacy_recovery.assert_not_called()
 
+    @pytest.mark.asyncio
+    async def test_list_messages_page_uses_lazy_recent_path(
+        self,
+        client: AsyncClient,
+        session_id: str,
+        monkeypatch: pytest.MonkeyPatch,
+    ):
+        old_msg = await Message.create(session_id, MessageRole.USER, "old")
+        mid_msg = await Message.create(session_id, MessageRole.USER, "middle")
+        new_msg = await Message.create(session_id, MessageRole.ASSISTANT, "new")
+
+        async def _fail_full_list(*args, **kwargs):
+            raise AssertionError("full list_with_parts should not be used for paged reads")
+
+        monkeypatch.setattr(Message, "list_with_parts", _fail_full_list)
+
+        first_resp = await client.get(
+            f"/api/session/{session_id}/message",
+            params={"page": "true", "limit": "2"},
+        )
+
+        assert first_resp.status_code == status.HTTP_200_OK
+        first_page = first_resp.json()
+        assert [item["info"]["id"] for item in first_page["items"]] == [mid_msg.id, new_msg.id]
+        assert first_page["hasMore"] is True
+        assert first_page["nextBefore"] == mid_msg.id
+
+        older_resp = await client.get(
+            f"/api/session/{session_id}/message",
+            params={"page": "true", "limit": "2", "before": first_page["nextBefore"]},
+        )
+        assert older_resp.status_code == status.HTTP_200_OK
+        older_page = older_resp.json()
+        assert [item["info"]["id"] for item in older_page["items"]] == [old_msg.id]
+        assert older_page["hasMore"] is False
 
 # ===========================================================================
 # Delete permissions (single-admin model)

tests/session/test_message_parts_persistence.py

@@ -86,6 +86,38 @@ async def test_legacy_blob_reads_without_migration() -> None:
     assert await Storage.list_keys(prefix=f"message_parts:{session_id}:") == []
 
 
+@pytest.mark.asyncio
+async def test_recent_legacy_page_reads_legacy_blob_once(monkeypatch: pytest.MonkeyPatch) -> None:
+    session_id = "ses_parts_legacy_recent_page"
+    await _write_legacy_session(
+        session_id,
+        {
+            "msg_a": "legacy a",
+            "msg_b": "legacy b",
+            "msg_c": "legacy c",
+        },
+    )
+
+    original_get = Storage.get
+    legacy_blob_reads = 0
+
+    async def counting_get(key: str):
+        nonlocal legacy_blob_reads
+        if key == f"message_parts:{session_id}":
+            legacy_blob_reads += 1
+        return await original_get(key)
+
+    monkeypatch.setattr(Storage, "get", counting_get)
+
+    messages, has_more, next_before = await Message.list_recent_with_parts(session_id, limit=3)
+
+    assert [message.info.id for message in messages] == ["msg_a", "msg_b", "msg_c"]
+    assert [message.parts[0].text for message in messages] == ["legacy a", "legacy b", "legacy c"]
+    assert has_more is False
+    assert next_before is None
+    assert legacy_blob_reads == 1
+
+
 @pytest.mark.asyncio
 async def test_legacy_session_updates_continue_writing_legacy_blob() -> None:
     session_id = "ses_parts_legacy_update"