feat: add workplan aliases and legacy meter

Adds preferred workplan REST/event surfaces, legacy-meter telemetry and weekly review summaries, documentation/dashboard terminology updates, dashboard API loading fixes, and close-out sync for STATE-WP-0052 and STATE-WP-0054.

api/routers/workstream_dependencies.py

@@ -1,6 +1,6 @@
 import uuid
 
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -9,23 +9,20 @@ from api.models.task import Task
 from api.models.workstream import Workstream
 from api.models.workstream_dependency import WorkstreamDependency
 from api.schemas.workstream_dependency import WorkstreamDependencyCreate, WorkstreamDependencyRead
+from api.routers.workstreams import _legacy_key, _meter_legacy_route
 
 router = APIRouter(prefix="/workstreams", tags=["dependencies"])
+workplan_router = APIRouter(prefix="/workplans", tags=["dependencies"])
 
 
-@router.post(
-    "/{workstream_id}/dependencies/",
-    response_model=WorkstreamDependencyRead,
-    status_code=status.HTTP_201_CREATED,
-)
-async def create_dependency(
+async def _create_dependency(
+    *,
     workstream_id: uuid.UUID,
     body: WorkstreamDependencyCreate,
-    session: AsyncSession = Depends(get_session),
+    session: AsyncSession,
 ) -> WorkstreamDependency:
-    """Record that workstream_id depends on another workstream or a task."""
     if await session.get(Workstream, workstream_id) is None:
-        raise HTTPException(status_code=404, detail="from workstream not found")
+        raise HTTPException(status_code=404, detail="from workplan not found")
 
     has_workstream_target = body.to_workstream_id is not None
     has_task_target = body.to_task_id is not None
@@ -33,11 +30,11 @@ async def create_dependency(
         raise HTTPException(status_code=422, detail="provide exactly one dependency target")
 
     if body.to_workstream_id and await session.get(Workstream, body.to_workstream_id) is None:
-        raise HTTPException(status_code=404, detail="target workstream not found")
+        raise HTTPException(status_code=404, detail="target workplan not found")
     if body.to_task_id and await session.get(Task, body.to_task_id) is None:
         raise HTTPException(status_code=404, detail="target task not found")
     if workstream_id == body.to_workstream_id:
-        raise HTTPException(status_code=422, detail="a workstream cannot depend on itself")
+        raise HTTPException(status_code=422, detail="a workplan cannot depend on itself")
 
     dep = WorkstreamDependency(
         from_workstream_id=workstream_id,
@@ -52,17 +49,13 @@ async def create_dependency(
     return dep
 
 
-@router.get(
-    "/{workstream_id}/dependencies/",
-    response_model=list[WorkstreamDependencyRead],
-)
-async def list_dependencies(
+async def _list_dependencies(
+    *,
     workstream_id: uuid.UUID,
-    session: AsyncSession = Depends(get_session),
+    session: AsyncSession,
 ) -> list[WorkstreamDependency]:
-    """Return all dependency edges touching this workstream (both directions)."""
     if await session.get(Workstream, workstream_id) is None:
-        raise HTTPException(status_code=404, detail="workstream not found")
+        raise HTTPException(status_code=404, detail="workplan not found")
     rows = await session.execute(
         select(WorkstreamDependency).where(
             (WorkstreamDependency.from_workstream_id == workstream_id)
@@ -72,20 +65,118 @@ async def list_dependencies(
     return list(rows.scalars().all())
 
 
+async def _delete_dependency(
+    *,
+    workstream_id: uuid.UUID,
+    dep_id: uuid.UUID,
+    session: AsyncSession,
+) -> None:
+    dep = await session.get(WorkstreamDependency, dep_id)
+    if dep is None:
+        raise HTTPException(status_code=404, detail="dependency not found")
+    if dep.from_workstream_id != workstream_id:
+        raise HTTPException(status_code=403, detail="dependency does not belong to this workplan")
+    await session.delete(dep)
+    await session.commit()
+
+
+@router.post(
+    "/{workstream_id}/dependencies/",
+    response_model=WorkstreamDependencyRead,
+    status_code=status.HTTP_201_CREATED,
+)
+async def create_dependency(
+    request: Request,
+    response: Response,
+    workstream_id: uuid.UUID,
+    body: WorkstreamDependencyCreate,
+    session: AsyncSession = Depends(get_session),
+) -> WorkstreamDependency:
+    """Record that workstream_id depends on another workstream or a task."""
+    await _meter_legacy_route(
+        session=session,
+        request=request,
+        response=response,
+        interface_key=_legacy_key("POST", "/workstreams/{workstream_id}/dependencies/"),
+        replacement_ref="/workplans/{workplan_id}/dependencies/",
+    )
+    return await _create_dependency(workstream_id=workstream_id, body=body, session=session)
+
+
+@workplan_router.post(
+    "/{workplan_id}/dependencies/",
+    response_model=WorkstreamDependencyRead,
+    status_code=status.HTTP_201_CREATED,
+)
+async def create_workplan_dependency(
+    workplan_id: uuid.UUID,
+    body: WorkstreamDependencyCreate,
+    session: AsyncSession = Depends(get_session),
+) -> WorkstreamDependency:
+    return await _create_dependency(workstream_id=workplan_id, body=body, session=session)
+
+
+@router.get(
+    "/{workstream_id}/dependencies/",
+    response_model=list[WorkstreamDependencyRead],
+)
+async def list_dependencies(
+    request: Request,
+    response: Response,
+    workstream_id: uuid.UUID,
+    session: AsyncSession = Depends(get_session),
+) -> list[WorkstreamDependency]:
+    """Return all dependency edges touching this workstream (both directions)."""
+    await _meter_legacy_route(
+        session=session,
+        request=request,
+        response=response,
+        interface_key=_legacy_key("GET", "/workstreams/{workstream_id}/dependencies/"),
+        replacement_ref="/workplans/{workplan_id}/dependencies/",
+    )
+    return await _list_dependencies(workstream_id=workstream_id, session=session)
+
+
+@workplan_router.get(
+    "/{workplan_id}/dependencies/",
+    response_model=list[WorkstreamDependencyRead],
+)
+async def list_workplan_dependencies(
+    workplan_id: uuid.UUID,
+    session: AsyncSession = Depends(get_session),
+) -> list[WorkstreamDependency]:
+    return await _list_dependencies(workstream_id=workplan_id, session=session)
+
+
 @router.delete(
     "/{workstream_id}/dependencies/{dep_id}",
     status_code=status.HTTP_204_NO_CONTENT,
 )
 async def delete_dependency(
+    request: Request,
+    response: Response,
     workstream_id: uuid.UUID,
     dep_id: uuid.UUID,
     session: AsyncSession = Depends(get_session),
 ) -> None:
     """Hard-delete a dependency edge. Removing a constraint is safe — no information is lost."""
-    dep = await session.get(WorkstreamDependency, dep_id)
-    if dep is None:
-        raise HTTPException(status_code=404, detail="dependency not found")
-    if dep.from_workstream_id != workstream_id:
-        raise HTTPException(status_code=403, detail="dependency does not belong to this workstream")
-    await session.delete(dep)
-    await session.commit()
+    await _meter_legacy_route(
+        session=session,
+        request=request,
+        response=response,
+        interface_key=_legacy_key("DELETE", "/workstreams/{workstream_id}/dependencies/{dep_id}"),
+        replacement_ref="/workplans/{workplan_id}/dependencies/{dep_id}",
+    )
+    await _delete_dependency(workstream_id=workstream_id, dep_id=dep_id, session=session)
+
+
+@workplan_router.delete(
+    "/{workplan_id}/dependencies/{dep_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+)
+async def delete_workplan_dependency(
+    workplan_id: uuid.UUID,
+    dep_id: uuid.UUID,
+    session: AsyncSession = Depends(get_session),
+) -> None:
+    await _delete_dependency(workstream_id=workplan_id, dep_id=dep_id, session=session)