feat(capability-registry): CUST-WP-0031 domain capability registry

- Migration p3k4l5m6n7o8: nullable repo_id FK on capability_catalog
- PATCH /capability-catalog/{id} endpoint for back-filling repo attribution
- register_capability MCP tool accepts optional repo_slug
- get_domain_summary now includes compact capabilities list (type+title+repo_slug)
- New get_capability_profile MCP tool: domain → repos → capabilities tree
- 6 repo descriptions populated; 25 catalog entries attributed to repos
- 9 new capabilities registered for personhood, foerster_capabilities, coulomb_social
- TOOLS.md: Capability Catalog & Requests section with full tool reference

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

api/models/capability_catalog.py

@@ -22,6 +22,12 @@ class CapabilityCatalog(Base, TimestampMixin):
         nullable=False,
         index=True,
     )
+    repo_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("managed_repos.id", ondelete="SET NULL"),
+        nullable=True,
+        index=True,
+    )
     capability_type: Mapped[str] = mapped_column(String(50), nullable=False)
     title: Mapped[str] = mapped_column(String(255), nullable=False)
     description: Mapped[str | None] = mapped_column(Text, nullable=True)
@@ -33,7 +39,12 @@ class CapabilityCatalog(Base, TimestampMixin):
     )
 
     domain: Mapped["Domain"] = relationship("Domain", lazy="selectin")  # noqa: F821
+    repo: Mapped["ManagedRepo | None"] = relationship("ManagedRepo", lazy="selectin")  # noqa: F821
 
     @property
     def domain_slug(self) -> str:
         return self.domain.slug if self.domain is not None else ""
+
+    @property
+    def repo_slug(self) -> str | None:
+        return self.repo.slug if self.repo is not None else None

api/routers/capability_requests.py

@@ -11,9 +11,11 @@ from api.models.agent_message import AgentMessage
 from api.models.capability_catalog import CapabilityCatalog
 from api.models.capability_request import CapabilityRequest
 from api.models.domain import Domain
+from api.models.managed_repo import ManagedRepo
 from api.models.task import Task
 from api.schemas.capability_request import (
     CatalogCreate,
+    CatalogPatch,
     CatalogRead,
     CapabilityRequestAccept,
     CapabilityRequestCreate,
@@ -52,8 +54,15 @@ async def create_catalog_entry(
     session: AsyncSession = Depends(get_session),
 ) -> CapabilityCatalog:
     domain = await _resolve_domain(body.domain, session)
+
+    repo_id = None
+    if body.repo_slug:
+        repo = await _resolve_repo(body.repo_slug, session)
+        repo_id = repo.id
+
     entry = CapabilityCatalog(
         domain_id=domain.id,
+        repo_id=repo_id,
         capability_type=body.capability_type,
         title=body.title,
         description=body.description,
@@ -72,6 +81,31 @@ async def create_catalog_entry(
     return entry
 
 
+@router.patch("/capability-catalog/{entry_id}", response_model=CatalogRead)
+async def patch_catalog_entry(
+    entry_id: uuid.UUID,
+    body: CatalogPatch,
+    session: AsyncSession = Depends(get_session),
+) -> CapabilityCatalog:
+    entry = await session.get(CapabilityCatalog, entry_id)
+    if entry is None:
+        raise HTTPException(status_code=404, detail=f"Catalog entry '{entry_id}' not found")
+
+    if body.repo_slug is not None:
+        repo = await _resolve_repo(body.repo_slug, session)
+        entry.repo_id = repo.id
+    if body.description is not None:
+        entry.description = body.description
+    if body.keywords is not None:
+        entry.keywords = body.keywords
+    if body.status is not None:
+        entry.status = body.status
+
+    await session.commit()
+    await session.refresh(entry)
+    return entry
+
+
 @router.get("/capability-catalog/", response_model=list[CatalogRead])
 async def list_catalog(
     domain: str | None = Query(None),
@@ -552,6 +586,14 @@ async def _resolve_domain(slug: str, session: AsyncSession) -> Domain:
     return domain
 
 
+async def _resolve_repo(slug: str, session: AsyncSession) -> ManagedRepo:
+    result = await session.execute(select(ManagedRepo).where(ManagedRepo.slug == slug))
+    repo = result.scalar_one_or_none()
+    if repo is None:
+        raise HTTPException(status_code=404, detail=f"Repo '{slug}' not found")
+    return repo
+
+
 async def _get_request_or_404(request_id: uuid.UUID, session: AsyncSession) -> CapabilityRequest:
     req = await session.get(CapabilityRequest, request_id)
     if req is None:

api/schemas/capability_request.py

@@ -14,6 +14,14 @@ class CatalogCreate(BaseModel):
     title: str
     description: str | None = None
     keywords: list[str] = []
+    repo_slug: str | None = None  # optional repo attribution
+
+
+class CatalogPatch(BaseModel):
+    repo_slug: str | None = None
+    description: str | None = None
+    keywords: list[str] | None = None
+    status: str | None = None
 
 
 class CatalogRead(BaseModel):
@@ -21,6 +29,8 @@ class CatalogRead(BaseModel):
 
     id: uuid.UUID
     domain_slug: str
+    repo_id: uuid.UUID | None = None
+    repo_slug: str | None = None
     capability_type: str
     title: str
     description: str | None = None