diff --git a/loopx/capabilities/manager_context/inspection.py b/loopx/capabilities/manager_context/inspection.py index d7bde553e4..6b3a731c7f 100644 --- a/loopx/capabilities/manager_context/inspection.py +++ b/loopx/capabilities/manager_context/inspection.py @@ -2,6 +2,7 @@ from __future__ import annotations +import hashlib import json import re from copy import deepcopy @@ -487,6 +488,7 @@ def _portfolio(self, ids, goal_id, include_stopped, offset, limit): from ...control_plane.goals.activation import goal_activation_state from ...chat_manager_context import manager_turn_context try: + inventory_bytes = self.registry_path.read_bytes() inventory = self._registered_goals() permitted = sorted({g["id"] for g in inventory if ids is None or g["id"] in ids}) if goal_id is not None: @@ -503,22 +505,51 @@ def _portfolio(self, ids, goal_id, include_stopped, offset, limit): pass # Unknown activation stays visible as a source gap. permitted = [gid for gid in permitted if gid not in stopped] selected = permitted[offset:offset + limit] - context = manager_turn_context( - self.registry_path, - {"channel_id": self.channel_id or ("manager" if self.owner_scope else "manager.external.inspection")}, - self.runtime_root, authorized_goal_ids=ids, requested_goal_ids=selected, - include_stopped=include_stopped or goal_id is not None, include_details=False, - ) if selected else {"goals": [], "coverage": {"complete": True}} + page, contexts, collected = [], [], [] + for selected_id in selected: + context = manager_turn_context( + self.registry_path, + {"channel_id": self.channel_id or ("manager" if self.owner_scope else "manager.external.inspection")}, + self.runtime_root, authorized_goal_ids=ids, requested_goal_ids=[selected_id], + include_stopped=include_stopped or goal_id is not None, include_details=False, + ) + if not self.scope_valid(): + return {"ok": False, "error": "authorization_changed"} + rows = context.get("goals", []) + if len(rows) != 1 or rows[0].get("goal_id") != selected_id: + raise ValueError("requested portfolio row is unavailable") + contexts.append(context) + collected.extend(rows) + bounded = effect_runtime_result("presentation.goal_attention.bound", {"goals": collected})["goals"] + # Apply the existing encoded-row budget while collecting. At + # most one lookahead row is read again on the next page; do not + # collect every later Goal only to discard it in read(). A lone + # oversized row keeps the existing explicit gap/continuation. + if len(json.dumps(bounded, ensure_ascii=False)) > 24000 and page: + break + page = bounded + if len(json.dumps(page, ensure_ascii=False)) > 24000: + break + if self.registry_path.read_bytes() != inventory_bytes: + raise ValueError("Goal inventory changed during collection") + coverages = [context.get("coverage", {}) for context in contexts] + coverage = {"complete": all(c.get("complete") is True for c in coverages)} + for key in set().union(*(c.keys() for c in coverages)) - {"complete"}: + values = [c.get(key, 0) for c in coverages] + coverage[key] = ((max(values) if key == "invalid_registry_entries" else sum(values)) + if all(type(v) is int for v in values) else None) + snapshot_id = ("sha256:" + hashlib.sha256(json.dumps( + contexts, ensure_ascii=False, sort_keys=True).encode()).hexdigest() + if contexts else None) except (OSError, ValueError, KeyError, TypeError, RuntimeError): return {"ok": False, "view": "portfolio", "error": "goal_inventory_unavailable"} - page = context.get("goals", []) - end = offset + len(selected) + end = offset + len(page) return {"ok": True, "view": "portfolio", "goal_id": goal_id, "rows": page, "offset": offset, "included": len(page), "matched": len(permitted), "next_offset": end if end < len(permitted) else None, - "source": {"source": "goal_portfolio", "snapshot_id": context.get("snapshot_id"), - "coverage": context.get("coverage")}, - "unknown": bool(context.get("warnings")) or len(page) != len(selected), + "source": {"source": "goal_portfolio", "snapshot_id": snapshot_id, + "coverage": coverage}, + "unknown": any(context.get("warnings") for context in contexts), "initial_snapshot_id": self.context.get("snapshot_id"), "source_id": "local", "source_host": "local"} diff --git a/tests/test_chat_manager_inspection.py b/tests/test_chat_manager_inspection.py index 47c2340c2d..3903caa29f 100644 --- a/tests/test_chat_manager_inspection.py +++ b/tests/test_chat_manager_inspection.py @@ -333,6 +333,97 @@ def test_current_work_portfolio_keeps_authorization_fence(tmp_path): assert not records and "private" not in json.dumps(result) +@pytest.mark.parametrize("body_size, first_page", [(100, 8), (8000, 2), (26000, 1)]) +def test_portfolio_bounds_collection_and_keeps_every_page(monkeypatch, tmp_path, body_size, first_page): + tool, _ = inspector(tmp_path) + ids = [f"goal-{i}" for i in range(8)] + tool.registry_path.write_text(json.dumps({"goals": [{"id": gid} for gid in ids]})) + tool.discovery_scope = lambda: ids + collected = [] + + def collect(*args, requested_goal_ids, **kwargs): + collected.extend(requested_goal_ids) + return {"snapshot_id": "fixture:" + ",".join(requested_goal_ids), + "goals": [{"goal_id": gid, "description": "证据😀" * (body_size // 3)} + for gid in requested_goal_ids], + "coverage": {"discovered": len(requested_goal_ids), + "attempted": len(requested_goal_ids), + "verified": len(requested_goal_ids), + "invalid_registry_entries": 0, "complete": True}} + + monkeypatch.setattr("loopx.chat_manager_context.manager_turn_context", collect) + seen, offset = [], 0 + while offset is not None: + collected.clear() + page = tool.read(TOOL_NAME, {"view": "portfolio", "limit": 8, "offset": offset}) + assert page["ok"] and not page["unknown"] + assert len(page["rows"]) == min(first_page, len(ids) - offset) + # One lookahead can establish the existing page budget, but later + # projects must not be read and discarded on every page. + assert len(collected) <= len(page["rows"]) + (body_size < 24000) + assert collected == ids[offset:offset + len(collected)] + assert page["matched"] == len(ids) + if body_size > 24000: + assert page["oversized_rows"] == [offset] + else: + assert [row["description"] for row in page["rows"]] == [ + "证据😀" * (body_size // 3)] * len(page["rows"]) + seen.extend(row["goal_id"] for row in page["rows"]) + offset = page["next_offset"] + assert seen == ids + + +@pytest.mark.parametrize("change", ["revocation", "registry"]) +def test_portfolio_does_not_publish_a_torn_page(monkeypatch, tmp_path, change): + allowed = {"current": True} + tool, records = inspector(tmp_path, lambda: allowed["current"]) + ids = ["alpha", "beta"] + tool.registry_path.write_text(json.dumps({"goals": [{"id": gid} for gid in ids]})) + tool.discovery_scope = lambda: ids + + def collect(*args, requested_goal_ids, **kwargs): + if change == "revocation": + allowed["current"] = False + else: + tool.registry_path.write_text(json.dumps({"goals": [{"id": "replacement"}]})) + return {"goals": [{"goal_id": gid, "description": "private evidence"} + for gid in requested_goal_ids], "coverage": {"complete": True}} + + monkeypatch.setattr("loopx.chat_manager_context.manager_turn_context", collect) + result = tool.read(TOOL_NAME, {"view": "portfolio"}) + assert result["ok"] is False + assert result["error"] == ("authorization_changed" if change == "revocation" + else "goal_inventory_unavailable") + assert not records and "private evidence" not in json.dumps(result) + + +def test_portfolio_keeps_the_shared_attention_budget_and_rejected_lookahead(monkeypatch, tmp_path): + tool, _ = inspector(tmp_path) + ids = ["alpha", "beta", "gamma", "omega"] + tool.registry_path.write_text(json.dumps({"goals": [{"id": gid} for gid in ids]})) + tool.discovery_scope = lambda: ids + + def collect(*args, requested_goal_ids, **kwargs): + return {"goals": [{"goal_id": gid, "description": "x" * 8000, + "attention": {"status": "read", "coverage": {"known": 8}, "items": [ + {"todo_id": f"{gid}-{i}", "owner_must_act": gid == "gamma"} + for i in range(8)]}} for gid in requested_goal_ids], + "coverage": {"complete": True}} + + monkeypatch.setattr("loopx.chat_manager_context.manager_turn_context", collect) + page = tool.read(TOOL_NAME, {"view": "portfolio"}) + assert [row["goal_id"] for row in page["rows"]] == ids[:2] + # The existing typed owner permits twelve attention items across the page, + # rather than twelve per Goal. The rejected high-priority lookahead cannot + # consume the returned rows' allowance. + assert [[item["todo_id"] for item in row["attention"]["items"]] for row in page["rows"]] == [ + [f"alpha-{i}" for i in range(8)], [f"beta-{i}" for i in range(4)]] + assert page["rows"][1]["attention"]["coverage"] == {"known": 8, "included": 4, "omitted": 4} + following = tool.read(TOOL_NAME, {"view": "portfolio", "offset": page["next_offset"]}) + assert [row["goal_id"] for row in following["rows"]] == ids[2:] + assert following["next_offset"] is None + + def test_directory_attention_preview_keeps_all_workers_and_exact_scoped_read(monkeypatch, tmp_path): text = "Review the complete plan. " * 50 + "Only proceed after owner acceptance." task = {"todo_id": "todo_gate", "role": "user", "task_class": "user_gate",