feat(classification-spine): implement STATE-WP-0065 repo-anchored model

Replace the ad-hoc coordination-domain spine with the Repo Classification Standard: 14 market domains, classification columns on managed_repos, and workplans anchored by repo_id (topic_id optional). - Add Alembic migration d8e9f0a1b2c3 with data backfill and workstream→workplan rename - Add api/classification.py validation and register-from-classification tooling - Expose workplan-first REST/MCP surface with legacy workstream aliases - Add C-24 consistency rule and legacy domain frontmatter mapping - Update dashboard repos page with category/capability/stake filters - Update orientation docs; mark STATE-WP-0065 finished
2026-06-22 13:52:13 +02:00
parent 279be4ffbd
commit 0949d4c0d8
84 changed files with 4494 additions and 1111 deletions
--- a/api/routers/repos.py
+++ b/api/routers/repos.py
@@ -9,9 +9,10 @@ import uuid
 from datetime import datetime, timezone
 from pathlib import Path

-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy import case, func, select
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from sqlalchemy import case, func, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import noload

 from api.config import settings
 from api.database import get_session
@@ -29,11 +30,11 @@ from api.models.managed_repo import ManagedRepo
 from api.models.repo_goal import RepoGoal
 from api.models.tpsc import TPSCSnapshot
 from api.models.task import Task
-from api.models.workstream import Workstream
+from api.models.workplan import Workplan
 from api.schemas.doi import DoICriterion, DoIReport, DoISummaryEntry
 from api.schemas.managed_repo import (
    DispatchTask,
-    DispatchWorkstream,
+    DispatchWorkplan,
    PendingInterfaceChange,
    RepoCreate,
    RepoDispatch,
@@ -44,6 +45,8 @@ from api.schemas.managed_repo import (
    RepoScopeHealth,
    RepoUpdate,
    ScopeIssueDetail,
+    classification_fields_set,
+    validate_repo_classification_fields,
 )
 from hub_core.routers.repos import create_repos_router

@@ -76,13 +79,107 @@ def _core_repo_router(**route_flags) -> APIRouter:
        repo_read_schema=RepoRead,
        repo_path_register_schema=RepoPathRegister,
        list_noload_fields=("goals",),
-        create_extension_fields=("topic_id",),
+        create_extension_fields=(
+            "topic_id",
+            "category",
+            "secondary_domains",
+            "capability_tags",
+            "business_stake",
+            "business_mechanics",
+            "classified_at",
+            "classified_by",
+            "standard_version",
+        ),
        after_register=_publish_repo_registered,
        **route_flags,
    )


-router.include_router(_core_repo_router(include_slug_routes=False))
+router.include_router(
+    _core_repo_router(include_collection_routes=False, include_slug_routes=False)
+)
+
+
+@router.get("/", response_model=list[RepoRead])
+async def list_repos(
+    response: Response,
+    domain: str | None = None,
+    category: str | None = None,
+    capability_tag: str | None = None,
+    business_stake: str | None = None,
+    session: AsyncSession = Depends(get_session),
+) -> list[ManagedRepo]:
+    """List repos with optional domain and classification filters."""
+    response.headers["Cache-Control"] = "max-age=60, stale-while-revalidate=30"
+    q = (
+        select(ManagedRepo)
+        .options(noload(ManagedRepo.goals))
+        .order_by(ManagedRepo.name)
+    )
+    if domain:
+        domain_result = await session.execute(select(Domain).where(Domain.slug == domain))
+        domain_obj = domain_result.scalar_one_or_none()
+        if domain_obj is None:
+            raise HTTPException(status_code=404, detail=f"Domain '{domain}' not found")
+        q = q.where(
+            or_(
+                ManagedRepo.domain_id == domain_obj.id,
+                ManagedRepo.secondary_domains.contains([domain]),
+            )
+        )
+    if category:
+        q = q.where(ManagedRepo.category == category)
+    if capability_tag:
+        q = q.where(ManagedRepo.capability_tags.contains([capability_tag]))
+    if business_stake:
+        q = q.where(ManagedRepo.business_stake.contains([business_stake]))
+    result = await session.execute(q)
+    return list(result.scalars().all())
+
+
+@router.post("/", response_model=RepoRead, status_code=status.HTTP_201_CREATED)
+async def register_repo(
+    body: RepoCreate,
+    session: AsyncSession = Depends(get_session),
+) -> ManagedRepo:
+    domain_result = await session.execute(select(Domain).where(Domain.slug == body.domain_slug))
+    domain_obj = domain_result.scalar_one_or_none()
+    if domain_obj is None:
+        raise HTTPException(status_code=404, detail=f"Domain '{body.domain_slug}' not found")
+    existing = await session.execute(select(ManagedRepo).where(ManagedRepo.slug == body.slug))
+    if existing.scalar_one_or_none():
+        raise HTTPException(status_code=409, detail=f"Repo slug '{body.slug}' already exists")
+
+    payload = body.model_dump()
+    validate_repo_classification_fields(
+        domain_slug=body.domain_slug,
+        fields=payload,
+        require_complete=classification_fields_set(payload),
+    )
+    repo = ManagedRepo(
+        domain_id=domain_obj.id,
+        slug=body.slug,
+        name=body.name,
+        local_path=body.local_path,
+        host_paths=body.host_paths,
+        remote_url=body.remote_url,
+        git_fingerprint=body.git_fingerprint,
+        description=body.description,
+        topic_id=body.topic_id,
+        category=body.category,
+        secondary_domains=body.secondary_domains,
+        capability_tags=body.capability_tags,
+        business_stake=body.business_stake,
+        business_mechanics=body.business_mechanics,
+        classified_at=body.classified_at,
+        classified_by=body.classified_by,
+        standard_version=body.standard_version,
+    )
+    session.add(repo)
+    await session.commit()
+    await session.refresh(repo)
+    await _publish_repo_registered(repo, body, domain_obj)
+    return repo


@router.post("/onboard", response_model=RepoOnboardResult)
@@ -428,6 +525,38 @@ async def list_repo_scope_health(
    return entries


+@router.patch("/{slug}", response_model=RepoRead)
+async def update_repo_with_classification(
+    slug: str,
+    body: RepoUpdate,
+    session: AsyncSession = Depends(get_session),
+) -> ManagedRepo:
+    """Patch repo metadata including classification spine fields."""
+    repo = await _get_repo_by_slug(slug, session)
+    payload = body.model_dump(exclude_unset=True)
+    domain_result = await session.execute(select(Domain).where(Domain.id == repo.domain_id))
+    domain_obj = domain_result.scalar_one_or_none()
+    domain_slug = domain_obj.slug if domain_obj else ""
+    if classification_fields_set(payload):
+        merged = {
+            "category": payload.get("category", repo.category),
+            "secondary_domains": payload.get("secondary_domains", repo.secondary_domains),
+            "capability_tags": payload.get("capability_tags", repo.capability_tags),
+            "business_stake": payload.get("business_stake", repo.business_stake),
+            "business_mechanics": payload.get("business_mechanics", repo.business_mechanics),
+        }
+        validate_repo_classification_fields(
+            domain_slug=domain_slug,
+            fields=merged,
+            require_complete=True,
+        )
+    for field, value in payload.items():
+        setattr(repo, field, value)
+    await session.commit()
+    await session.refresh(repo)
+    return repo
+
+
 router.include_router(
    _core_repo_router(
        include_collection_routes=False,
@@ -480,19 +609,19 @@ async def get_repo_dispatch(

    # Active workstreams
    ws_result = await session.execute(
-        select(Workstream)
-        .where(Workstream.repo_id == repo.id, Workstream.status == "active")
-        .order_by(Workstream.created_at)
+        select(Workplan)
+        .where(Workplan.repo_id == repo.id, Workplan.status == "active")
+        .order_by(Workplan.created_at)
    )
    workstreams = list(ws_result.scalars().all())

-    dispatch_workstreams: list[DispatchWorkstream] = []
+    dispatch_workstreams: list[DispatchWorkplan] = []
    all_interventions: list[DispatchTask] = []

    for ws in workstreams:
        task_result = await session.execute(
            select(Task)
-            .where(Task.workstream_id == ws.id, Task.status.in_(["todo", "progress"]))
+            .where(Task.workplan_id == ws.id, Task.status.in_(["todo", "progress"]))
            .order_by(Task.created_at)
        )
        tasks = list(task_result.scalars().all())
@@ -511,7 +640,7 @@ async def get_repo_dispatch(
        all_interventions.extend(interventions)

        dispatch_workstreams.append(
-            DispatchWorkstream(
+            DispatchWorkplan(
                id=ws.id,
                title=ws.title,
                status=ws.status,
@@ -554,7 +683,7 @@ async def get_repo_dispatch(
    return RepoDispatch(
        repo_slug=slug,
        active_goal=active_goal,
-        active_workstreams=dispatch_workstreams,
+        active_workplans=dispatch_workstreams,
        human_interventions=all_interventions,
        pending_interface_changes=pending_changes,
        scope_needs_review=scope_needs_review,