from __future__ import annotations import tempfile import unittest from pathlib import Path from unittest.mock import AsyncMock from opc.core.models import DelegationWorkItem, Phase, Task, TaskResult, TaskStatus from opc.database.store import OPCStore from opc.layer2_organization.metadata_ownership import ( EXECUTION_COPY_KEYS, MetadataOwner, append_work_item_progress, build_work_item_owner_execution_copy, copy_work_item_execution_metadata, is_runtime_task_owned_key, is_work_item_owned_key, metadata_owner_for_key, migrate_work_item_owned_metadata_from_linked_tasks, strip_disallowed_work_item_metadata_from_runtime_task, sync_work_item_current_turn_mode, update_runtime_task_owned_metadata, validate_metadata_ownership, ) from opc.layer2_organization.work_item_links import set_linked_work_item_id def _work_item(metadata: dict | None = None) -> DelegationWorkItem: return DelegationWorkItem( work_item_id="wi-1", run_id="run-1", cell_id="cell-1", role_id="engineer", seat_id="seat-1", kind="execute", phase=Phase.READY, metadata=dict(metadata or {}), ) class MetadataOwnershipMatrixTests(unittest.TestCase): def test_matrix_covers_key_company_fields(self) -> None: expected_work_item = { "current_turn_mode", "progress_log", "review_owner_role_id", "report_target_work_item_id", "employee_assignment", "employee_prompt_context", "work_item_summary_for_downstream", "structured_review_verdict", "verification_status", } for key in expected_work_item: self.assertTrue(is_work_item_owned_key(key), key) self.assertEqual(metadata_owner_for_key(key), MetadataOwner.WORK_ITEM) for key in { "runtime_v2", "external_resume_session_id", "external_resume_agent_type", "working_memory", "interrupted_recovery", }: self.assertTrue(is_runtime_task_owned_key(key), key) self.assertEqual(metadata_owner_for_key(key), MetadataOwner.RUNTIME_TASK) def test_copy_work_item_execution_metadata_uses_matrix_not_ad_hoc_list(self) -> None: item = _work_item( { "current_turn_mode": "review_execute", "review_owner_role_id": "cto", "progress_log": ["visible progress"], "employee_assignment": {"employee_id": "emp-1"}, } ) copied = copy_work_item_execution_metadata(item) self.assertEqual(copied["current_turn_mode"], "review_execute") self.assertEqual(copied["review_owner_role_id"], "cto") self.assertEqual(copied["employee_assignment"], {"employee_id": "emp-1"}) self.assertNotIn("progress_log", copied) self.assertIn("current_turn_mode", EXECUTION_COPY_KEYS) def test_validate_metadata_ownership_reports_task_only_work_item_field(self) -> None: item = _work_item({}) task = Task( id="task-1", metadata={"progress_log": ["task-only"], "runtime_v2": {"runtime_session_id": "rt"}}, ) set_linked_work_item_id(task, item.work_item_id) issues = validate_metadata_ownership(item, task) self.assertIn("metadata_ownership_violation", {issue.code for issue in issues}) self.assertIn("progress_log", {issue.key for issue in issues}) self.assertNotIn("runtime_v2", {issue.key for issue in issues}) def test_runtime_task_owned_updates_filter_out_work_item_fields(self) -> None: task = Task(id="task-1", metadata={}) applied = update_runtime_task_owned_metadata( task, { "runtime_v2": {"runtime_session_id": "rt"}, "progress_log": ["wrong owner"], }, ) self.assertEqual(applied, {"runtime_v2": {"runtime_session_id": "rt"}}) self.assertEqual(task.metadata, {"runtime_v2": {"runtime_session_id": "rt"}}) def test_owner_execution_copy_uses_work_item_seat(self) -> None: item = _work_item({"seat_id": "wrong-task-seat", "work_kind": "execute"}) item.seat_id = "seat::team::ceo::cto" item.team_id = "team::ceo" item.manager_role_id = "ceo" item.manager_seat_id = "seat::team::ceo::ceo" copied = build_work_item_owner_execution_copy(item) self.assertEqual(copied["delegation_seat_id"], "seat::team::ceo::cto") self.assertEqual(copied["delegation_team_id"], "team::ceo") self.assertEqual(copied["manager_seat_id"], "seat::team::ceo::ceo") def test_strip_disallowed_work_item_metadata_keeps_runtime_audit(self) -> None: task = Task( id="task-1", metadata={ "verification_evidence": {"status": "provided"}, "work_item_artifact_index": [{"kind": "file"}], "current_turn_mode": "worker_execute", "runtime_verification_evidence": {"status": "provided"}, }, ) removed = strip_disallowed_work_item_metadata_from_runtime_task(task) self.assertIn("verification_evidence", removed) self.assertIn("work_item_artifact_index", removed) self.assertNotIn("verification_evidence", task.metadata) self.assertNotIn("work_item_artifact_index", task.metadata) self.assertEqual(task.metadata["current_turn_mode"], "worker_execute") self.assertEqual(task.metadata["runtime_verification_evidence"], {"status": "provided"}) def test_linked_company_output_keeps_verification_on_work_item_context(self) -> None: from opc.layer2_organization.company_mode import CompanyWorkItemExecutor executor = CompanyWorkItemExecutor.__new__(CompanyWorkItemExecutor) executor._active_plan = None task = Task( id="task-1", title="Runtime", metadata={ "work_item_projection_id": "wi-1", "work_item_turn_type": "execute", "work_kind": "execute", }, ) set_linked_work_item_id(task, "wi-1") bundle = executor._capture_work_item_outputs( task, TaskResult( status=TaskStatus.DONE, content="Done", artifacts={ "verification_evidence": { "status": "provided", "verdict": "pass", "checks": [{"command": "pytest -q"}], } }, ), ) self.assertNotIn("verification_evidence", task.metadata) self.assertEqual(task.metadata["runtime_verification_evidence"]["verdict"], "pass") self.assertEqual(bundle.work_item_updates["verification_evidence"]["verdict"], "pass") self.assertEqual( task.context_snapshot["work_item_owned_outputs"]["verification_evidence"]["verdict"], "pass", ) def test_delivery_package_reads_work_item_owned_context(self) -> None: from opc.layer2_organization.company_mode import CompanyWorkItemExecutor from opc.layer2_organization.org_work_item_planner import CompanyWorkItemRuntimePlan executor = CompanyWorkItemExecutor.__new__(CompanyWorkItemExecutor) executor.org_engine = None worker = Task( id="worker", title="Worker item", assigned_to="engineer", status=TaskStatus.DONE, metadata={ "work_item_projection_id": "engineer::execute::1", "work_item_turn_type": "execute", }, context_snapshot={ "work_item_owned_outputs": { "work_item_summary": "Built the feature.", "work_item_artifact_index": [{"kind": "file", "value": "app.py"}], "risks": ["Needs staging validation"], "structured_review_verdict": {"label": "reject", "summary": "Missing docs"}, } }, ) delivery = Task( id="delivery", title="Delivery", assigned_to="ceo", status=TaskStatus.DONE, result={"content": "Ship it"}, metadata={ "execution_mode": "company_mode", "work_item_projection_id": "ceo::deliver::1", "work_item_turn_type": "deliver", "authoritative_output": True, }, ) package = executor._build_authoritative_delivery_package( CompanyWorkItemRuntimePlan(profile="corporate"), [worker, delivery], delivery, ) self.assertEqual(package["delivered_items"][0]["summary"], "Built the feature.") self.assertEqual(package["artifact_manifest"][0]["value"], "app.py") self.assertIn("Needs staging validation", package["risks"]) self.assertIn("Missing docs", package["open_issues"][0]) def test_materialization_uses_central_execution_copy_helper(self) -> None: from opc.layer2_organization import company_mode source = Path(company_mode.__file__).read_text(encoding="utf-8") self.assertIn("copy_work_item_execution_metadata(work_item)", source) self.assertIn("build_work_item_owner_execution_copy(work_item)", source) self.assertNotIn( 'for key in (\n "current_turn_mode",', source, "WorkItem execution-copy fields must live in metadata_ownership.py, not an ad hoc tuple.", ) def test_company_runtime_owner_seat_writes_use_owner_helper(self) -> None: repo_root = Path(__file__).resolve().parents[1] offenders = [] for rel in ( "opc/layer2_organization/company_mode.py", "opc/engine.py", "opc/layer2_organization/company_runtime.py", ): source = (repo_root / rel).read_text(encoding="utf-8") if '"delegation_seat_id":' in source or '["delegation_seat_id"]' in source: offenders.append(rel) self.assertEqual( offenders, [], "Runtime code must get delegation_seat_id from build_work_item_owner_execution_copy, " "not ad hoc session metadata writes.", ) def test_owner_matrix_doc_tracks_key_categories(self) -> None: repo_root = Path(__file__).resolve().parents[1] doc_path = repo_root / "docs" / "company-metadata-ownership.md" if not doc_path.exists(): self.skipTest("metadata ownership docs are local-only and excluded from release") doc = doc_path.read_text(encoding="utf-8") for token in ("work_item", "runtime_task", "execution_copy"): self.assertIn(token, doc) for key in ("progress_log", "runtime_v2", "external_resume_*"): self.assertIn(key, doc) def test_company_hot_paths_do_not_read_legacy_work_item_link_metadata(self) -> None: repo_root = Path(__file__).resolve().parents[1] legacy_link_key = "delegation_" + "work_item_id" hot_paths = ( "opc/layer2_organization/company_mode.py", "opc/layer1_perception/context_assembler.py", "opc/plugins/office_ui/snapshot_builder.py", "opc/plugins/cli_board/services/board_repository.py", ) offenders = [ rel for rel in hot_paths if legacy_link_key in (repo_root / rel).read_text(encoding="utf-8") ] self.assertEqual( offenders, [], "Company hot paths must use hydrated linked_work_item_id/link table, " "not legacy task metadata link keys.", ) class MetadataOwnershipMigratorTests(unittest.IsolatedAsyncioTestCase): async def asyncSetUp(self) -> None: self._tmpdir = tempfile.TemporaryDirectory() self.store = OPCStore(db_path=Path(self._tmpdir.name) / "store.db") await self.store.initialize() async def asyncTearDown(self) -> None: await self.store.close() self._tmpdir.cleanup() async def test_migrator_dry_run_backfills_missing_work_item_owned_fields(self) -> None: item = _work_item({}) task = Task( id="task-1", title="Runtime", metadata={ "progress_log": ["legacy progress"], "employee_prompt_context": "legacy persona", "runtime_v2": {"runtime_session_id": "rt"}, }, ) await self.store.save_task(task) await self.store.save_delegation_work_item(item) await self.store.link_work_item_runtime_task(item.work_item_id, task.id) dry = await migrate_work_item_owned_metadata_from_linked_tasks( self.store, run_id=item.run_id, dry_run=True, ) self.assertTrue(dry.dry_run) self.assertEqual(dry.changed_work_items, 1) self.assertEqual(dry.changes[0].updates["progress_log"], ["legacy progress"]) self.assertEqual(dry.changes[0].updates["employee_prompt_context"], "legacy persona") self.assertNotIn("runtime_v2", dry.changes[0].updates) after_dry = await self.store.get_delegation_work_item(item.work_item_id) self.assertNotIn("progress_log", after_dry.metadata) applied = await migrate_work_item_owned_metadata_from_linked_tasks( self.store, run_id=item.run_id, dry_run=False, ) self.assertEqual(applied.changed_work_items, 1) after = await self.store.get_delegation_work_item(item.work_item_id) self.assertEqual(after.metadata["progress_log"], ["legacy progress"]) self.assertEqual(after.metadata["employee_prompt_context"], "legacy persona") async def test_migrator_conflict_keeps_work_item_value(self) -> None: item = _work_item({"progress_log": ["work-item-wins"]}) task = Task(id="task-1", title="Runtime", metadata={"progress_log": ["task-loses"]}) await self.store.save_task(task) await self.store.save_delegation_work_item(item) await self.store.link_work_item_runtime_task(item.work_item_id, task.id) report = await migrate_work_item_owned_metadata_from_linked_tasks( self.store, run_id=item.run_id, dry_run=False, ) self.assertEqual(report.changed_work_items, 0) self.assertIn("metadata_ownership_conflict", {issue.code for issue in report.issues}) after = await self.store.get_delegation_work_item(item.work_item_id) self.assertEqual(after.metadata["progress_log"], ["work-item-wins"]) async def test_owner_writers_append_progress_and_sync_turn_mode(self) -> None: item = _work_item({}) await self.store.save_delegation_work_item(item) progress = await append_work_item_progress(self.store, item.work_item_id, "step 1") await append_work_item_progress(self.store, item.work_item_id, "step 1", dedupe=True) synced = await sync_work_item_current_turn_mode(self.store, item.work_item_id, "worker_execute") after = await self.store.get_delegation_work_item(item.work_item_id) self.assertEqual(progress, ["step 1"]) self.assertTrue(synced) self.assertEqual(after.metadata["progress_log"], ["step 1"]) self.assertEqual(after.metadata["current_turn_mode"], "worker_execute") async def test_authoritative_delivery_package_persists_to_work_item_not_task_metadata(self) -> None: from opc.layer2_organization.company_mode import CompanyWorkItemExecutor from opc.layer2_organization.org_work_item_planner import CompanyWorkItemRuntimePlan from opc.layer2_organization.work_item_links import set_linked_work_item_id item = _work_item({"work_kind": "deliver", "work_item_turn_type": "deliver"}) item.work_item_id = "delivery-wi" item.kind = "deliver" await self.store.save_delegation_work_item(item) task = Task( id="delivery-task", title="Delivery", assigned_to="ceo", status=TaskStatus.DONE, result={"content": "Final package"}, metadata={ "execution_mode": "company_mode", "work_item_projection_id": "ceo::deliver::1", "work_item_turn_type": "deliver", "authoritative_output": True, }, ) set_linked_work_item_id(task, item.work_item_id) await self.store.save_task(task) await self.store.link_work_item_runtime_task(item.work_item_id, task.id) executor = CompanyWorkItemExecutor.__new__(CompanyWorkItemExecutor) executor.store = self.store executor.org_engine = None executor._active_plan = CompanyWorkItemRuntimePlan(profile="corporate") executor._active_tasks = [task] executor.save_task = AsyncMock() executor._ceo_pre_delivery_assessment = AsyncMock(return_value={"deliverable": True, "summary": "ok"}) await executor._finalize_completed_work_item(task) after = await self.store.get_delegation_work_item(item.work_item_id) self.assertIn("delivery_package", after.metadata) self.assertNotIn("delivery_package", task.metadata) self.assertIn("delivery_package", task.context_snapshot["work_item_owned_outputs"]) executor.save_task.assert_awaited_once() if __name__ == "__main__": unittest.main()