OpenOPC/tests/test_company_plan_metadata_shape.py

"""Regression tests for the company_work_item_plan / work_item_runtime_plan schema collision.

Work-item tasks store a per-item assignment spec under ``work_item_runtime_plan``
(keys: projection_id/turn_type/summary/deliverables/acceptance_criteria) while the
snapshot loaders used to read the same key as a serialized run-level
CompanyWorkItemRuntimePlan. Deserializing the spec shape silently produced an empty
plan, so every completed company session was misclassified as a legacy read-only run
and follow-up messages got the canned "Legacy company runtime run" reply
(project 000 forensics, 2026-07-07).
"""

from __future__ import annotations

import tempfile
import unittest
from pathlib import Path

from opc.core.models import Task, TaskStatus
from opc.database.store import OPCStore
from opc.engine import OPCEngine
from opc.layer2_organization.company_mode import (
    is_serialized_company_work_item_runtime_plan,
    serialize_company_work_item_runtime_plan,
    serialized_company_plan_from_metadata,
)
from opc.layer2_organization.org_work_item_planner import (
    CompanyWorkItemRuntimePlan,
    WorkItemProjectionSpec,
)


# Shape actually persisted on work-item tasks (verified against project 000 data).
SPEC_SHAPED_PLAN = {
    "projection_id": "ceo::delivery::1899e271",
    "turn_type": "deliver",
    "summary": "Deliver the final result to the user.",
    "inputs": ["Use the global intent summary as the mission baseline."],
    "deliverables": ["Final delivery message."],
    "acceptance_criteria": ["User receives the deliverable."],
}


def _full_plan() -> CompanyWorkItemRuntimePlan:
    return CompanyWorkItemRuntimePlan(
        profile="corporate",
        projections=[
            WorkItemProjectionSpec(
                projection_id="corporate::intake::ceo",
                turn_type="intake",
                title="CEO Intake",
                summary="Frame the mission.",
                role_id="ceo",
            )
        ],
        metadata={
            "execution_model": "multi_team_org",
            "runtime_model": "multi_team_org",
        },
    )


class SerializedPlanShapeTests(unittest.TestCase):
    def test_full_plan_serialization_is_recognized(self) -> None:
        serialized = serialize_company_work_item_runtime_plan(_full_plan())
        self.assertTrue(is_serialized_company_work_item_runtime_plan(serialized))

    def test_per_work_item_spec_is_rejected(self) -> None:
        self.assertFalse(is_serialized_company_work_item_runtime_plan(SPEC_SHAPED_PLAN))

    def test_non_dict_and_empty_are_rejected(self) -> None:
        for value in (None, {}, [], "plan", 3):
            self.assertFalse(is_serialized_company_work_item_runtime_plan(value))

    def test_metadata_accessor_skips_spec_shape_and_null(self) -> None:
        metadata = {
            "company_work_item_plan": None,
            "work_item_runtime_plan": dict(SPEC_SHAPED_PLAN),
        }
        self.assertIsNone(serialized_company_plan_from_metadata(metadata))

    def test_metadata_accessor_prefers_canonical_key(self) -> None:
        serialized = serialize_company_work_item_runtime_plan(_full_plan())
        metadata = {
            "company_work_item_plan": serialized,
            "work_item_runtime_plan": dict(SPEC_SHAPED_PLAN),
        }
        self.assertEqual(serialized_company_plan_from_metadata(metadata), serialized)

    def test_metadata_accessor_accepts_full_plan_in_fallback_key(self) -> None:
        serialized = serialize_company_work_item_runtime_plan(_full_plan())
        metadata = {"work_item_runtime_plan": serialized}
        self.assertEqual(serialized_company_plan_from_metadata(metadata), serialized)


class SnapshotClassificationTests(unittest.IsolatedAsyncioTestCase):
    """A completed run whose tasks only carry spec-shaped plans must still classify
    as a multi-team-org work-item run (never as a legacy read-only run)."""

    PARENT_SESSION = "sess-parent"

    async def _store(self) -> OPCStore:
        tmpdir = tempfile.TemporaryDirectory()
        self.addCleanup(tmpdir.cleanup)
        store = OPCStore(Path(tmpdir.name) / "tasks.db")
        await store.initialize()
        self.addAsyncCleanup(store.close)
        return store

    def _engine(self, store: OPCStore) -> OPCEngine:
        engine = OPCEngine()
        engine.project_id = "proj1"
        engine.store = store
        return engine

    def _work_item_task(
        self,
        task_id: str,
        projection_id: str,
        *,
        status: TaskStatus,
        turn_type: str = "execute",
        extra_metadata: dict | None = None,
    ) -> Task:
        metadata = {
            "company_profile": "corporate",
            "execution_model": "multi_team_org",
            "runtime_model": "multi_team_org",
            "work_item_runtime": True,
            "work_item_projection_id": projection_id,
            "work_item_turn_type": turn_type,
            # The 000 shape: canonical key null, fallback key holds the spec.
            "company_work_item_plan": None,
            "work_item_runtime_plan": dict(SPEC_SHAPED_PLAN, projection_id=projection_id),
        }
        metadata.update(extra_metadata or {})
        return Task(
            id=task_id,
            title=projection_id,
            session_id=f"{self.PARENT_SESSION}:{task_id}",
            parent_session_id=self.PARENT_SESSION,
            status=status,
            project_id="proj1",
            metadata=metadata,
        )

    async def _seed_completed_run(self, store: OPCStore) -> None:
        tasks = [
            self._work_item_task(
                "intake-task", "corporate::intake::ceo", status=TaskStatus.DONE, turn_type="intake"
            ),
            self._work_item_task(
                "execute-task", "cto::execute::d361bf3c", status=TaskStatus.DONE
            ),
            # Orphaned review attempt superseded by v2 (stuck non-terminal, as in 000).
            self._work_item_task(
                "review-v1-task", "review::467f36ff::v1", status=TaskStatus.PENDING, turn_type="review"
            ),
            self._work_item_task(
                "delivery-task",
                "ceo::delivery::1899e271",
                status=TaskStatus.DONE,
                turn_type="deliver",
                extra_metadata={"feedback_closed": True, "feedback_scope": "final"},
            ),
        ]
        for task in tasks:
            await store.save_task(task)

    async def test_snapshot_plan_classifies_as_multi_team_org(self) -> None:
        store = await self._store()
        await self._seed_completed_run(store)
        engine = self._engine(store)

        snapshot = await engine._load_company_runtime_snapshot(self.PARENT_SESSION)
        assert snapshot is not None
        plan, tasks = snapshot

        self.assertTrue(engine._runtime_uses_multi_team_org(plan))
        self.assertTrue(tasks)
        self.assertTrue(all(engine._task_uses_multi_team_org(task) for task in tasks))

    async def test_followup_after_completed_run_never_reports_legacy(self) -> None:
        store = await self._store()
        await self._seed_completed_run(store)
        engine = self._engine(store)

        class DummyCompanyExecutor:
            async def execute(self, plan, tasks):  # noqa: ANN001
                return "follow-up handled"

        engine.company_executor = DummyCompanyExecutor()

        response = await engine._maybe_resume_existing_company_runtime(
            "where is the delivered file?",
            session_id=self.PARENT_SESSION,
        )

        if response is not None:
            self.assertNotIn("Legacy company runtime run", response)


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