Researched: 2026-03-31 Domain: Azure AI Foundry Agent Service REST API + Backend/Frontend CRUD integration Confidence: HIGH

Phase 11 requires automatic synchronization between HCP profiles and Azure AI Foundry Agents. When an admin creates, updates, or deletes an HCP profile, the system must call the Azure AI Foundry Agent REST API to create, update, or delete a corresponding AI Agent. The Agent's id is stored on the HCP profile model for later use by the Digital Human Realtime Agent mode.

The Azure AI Foundry Agent Service uses an OpenAI Assistants-compatible REST API at {project_endpoint}/assistants. The GA API version is 2025-05-01. Authentication can use either Entra ID Bearer tokens or API key (via api-key header), and this project already uses api-key header for all AI Foundry API calls. The existing httpx library (already a project dependency) is the right tool for making these REST calls -- no new SDK dependency is needed.

The frontend work involves redesigning the HCP profiles page from a list+editor panel layout to a table format, adding agent sync status badges, and extending TanStack Query mutations to handle the new agent sync fields.

Primary recommendation: Use direct httpx REST API calls to the AI Foundry /assistants endpoint (same pattern as connection_tester.py), NOT the azure-ai-projects Python SDK -- this avoids adding a heavy dependency and keeps consistency with the existing codebase pattern.

<user_constraints>

• D-01: Full bidirectional sync -- HCP profile create -> create AI Foundry Agent, update -> update Agent instructions, delete -> delete Agent
• D-02: Agent creation/update/delete happens automatically on HCP profile save/delete -- no manual sync step
• D-03: Store agent_id (returned from AI Foundry) on HCP profile model for session wiring
• D-04: Track sync status per HCP: synced, pending, failed, none -- persisted in DB
• D-05: Template-based instruction generation from HCP profile fields (name, specialty, personality, communication_style, objections, knowledge_background)
• D-06: Template is a configurable string with {field} placeholders -- admin can customize the template (store in ServiceConfig or dedicated table)
• D-07: Agent instructions contain HCP personality only -- scenario/product context injected at session start time via system prompt, not baked into Agent
• D-08: HCP profiles page redesigned from card grid to table format
• D-09: Table columns: Name, Specialty, Personality, Communication Style, Agent Status (badge: synced/failed/pending/none), Actions (edit/delete)
• D-10: Agent creation is automatic with status badge -- no extra clicks. On save, background sync fires and badge updates
• D-11: Failed sync shows error details on hover/click, with retry option
• D-12: Digital Human Realtime Agent mode looks up agent_id from the session's HCP profile -- token broker returns it automatically. No user selection of Agent needed
• D-13: If HCP has no agent_id (sync failed or not yet synced), Realtime Agent mode option is disabled/grayed out in the mode selector with tooltip explaining why
• D-14: Token broker (get_voice_live_status) already returns agent_id -- extend it to source from HCP profile's agent_id field based on selected scenario's HCP

• Agent instruction template default content (exact wording)
• Error retry strategy for failed AI Foundry API calls (exponential backoff vs fixed retry)
• Table pagination/sorting implementation details
• Loading skeleton design for table

• Bulk agent sync for all existing HCPs (migration tool) -- could be a one-time script
• Agent versioning/rollback in AI Foundry -- future phase
• Agent analytics/usage tracking from AI Foundry -- future phase </user_constraints>

Installation: No new packages required. All dependencies are already installed.

backend/app/
├── services/
│   ├── agent_sync_service.py    # NEW: AI Foundry Agent CRUD via REST API
│   ├── hcp_profile_service.py   # MODIFY: Add post-save/post-delete sync hooks
│   ├── config_service.py        # REUSE: get_effective_endpoint/key for AI Foundry config
│   └── voice_live_service.py    # MODIFY: Source agent_id from HCP profile
├── models/
│   └── hcp_profile.py           # MODIFY: Add agent_id, agent_sync_status, agent_sync_error
├── schemas/
│   └── hcp_profile.py           # MODIFY: Add agent fields to response schemas
├── api/
│   └── hcp_profiles.py          # MODIFY: Return agent_sync_status, add retry endpoint
frontend/src/
├── pages/admin/
│   └── hcp-profiles.tsx          # REWRITE: Card grid -> Table layout
├── components/admin/
│   ├── hcp-table.tsx             # NEW: Table component with agent status badges
│   ├── hcp-editor.tsx            # MODIFY: No agent-specific UI (auto-sync)
│   └── hcp-list.tsx              # REMOVE: Replaced by hcp-table.tsx
├── types/
│   └── hcp.ts                    # MODIFY: Add agent_id, agent_sync_status fields
├── hooks/
│   └── use-hcp-profiles.ts      # MODIFY: Add retry sync mutation
└── api/
    └── hcp-profiles.ts           # MODIFY: Add retry sync API call

What: A new service module that wraps the Azure AI Foundry Agent (Assistants) REST API When to use: Called by HCP profile service on create/update/delete

# backend/app/services/agent_sync_service.py
# Source: Azure AI Foundry REST API docs (learn.microsoft.com)

import httpx
from sqlalchemy.ext.asyncio import AsyncSession
from app.services import config_service

AI_FOUNDRY_API_VERSION = "2025-05-01"

async def create_agent(
    db: AsyncSession,
    name: str,
    instructions: str,
    model: str = "gpt-4o",
) -> dict:
    """Create an AI Foundry Agent via REST API.

    Returns dict with 'id' (agent_id) on success.
    Raises on failure.
    """
    # Get AI Foundry project endpoint and key from config_service
    endpoint = await config_service.get_effective_endpoint(db, "azure_voice_live")
    api_key = await config_service.get_effective_key(db, "azure_voice_live")

    # The agent API uses the project endpoint format:
    # https://<resource>.services.ai.azure.com/api/projects/<project>/assistants
    # This needs to be derived from the AI Foundry master config
    url = f"{endpoint.rstrip('/')}/assistants"
    params = {"api-version": AI_FOUNDRY_API_VERSION}
    headers = {"api-key": api_key, "Content-Type": "application/json"}

    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.post(
            url,
            params=params,
            headers=headers,
            json={
                "model": model,
                "name": name,
                "instructions": instructions,
            },
        )
        response.raise_for_status()
        return response.json()


async def update_agent(
    db: AsyncSession,
    agent_id: str,
    name: str,
    instructions: str,
) -> dict:
    """Update an existing AI Foundry Agent's instructions."""
    endpoint = await config_service.get_effective_endpoint(db, "azure_voice_live")
    api_key = await config_service.get_effective_key(db, "azure_voice_live")

    url = f"{endpoint.rstrip('/')}/assistants/{agent_id}"
    params = {"api-version": AI_FOUNDRY_API_VERSION}
    headers = {"api-key": api_key, "Content-Type": "application/json"}

    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.post(
            url,
            params=params,
            headers=headers,
            json={"name": name, "instructions": instructions},
        )
        response.raise_for_status()
        return response.json()


async def delete_agent(
    db: AsyncSession,
    agent_id: str,
) -> bool:
    """Delete an AI Foundry Agent. Returns True on success."""
    endpoint = await config_service.get_effective_endpoint(db, "azure_voice_live")
    api_key = await config_service.get_effective_key(db, "azure_voice_live")

    url = f"{endpoint.rstrip('/')}/assistants/{agent_id}"
    params = {"api-version": AI_FOUNDRY_API_VERSION}
    headers = {"api-key": api_key}

    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.delete(url, params=params, headers=headers)
        return response.status_code == 200

What: Generate agent instructions from HCP profile fields using a configurable template When to use: Called before create_agent/update_agent

# backend/app/services/agent_sync_service.py

DEFAULT_AGENT_TEMPLATE = """You are {name}, a {specialty} specialist.

Personality: {personality_type}
Communication Style: {"direct" if communication_style < 50 else "indirect"} (level: {communication_style}/100)
Emotional State: {"calm and open" if emotional_state < 30 else "neutral" if emotional_state < 70 else "resistant"} (level: {emotional_state}/100)

Background:
- Hospital: {hospital}
- Title: {title}
- Expertise: {expertise_areas}
- Prescribing Habits: {prescribing_habits}
- Key Concerns: {concerns}

Common Objections:
{objections}

Topics You Probe About:
{probe_topics}

Stay in character throughout the conversation. Respond as this HCP would in a real face-to-face interaction with a Medical Representative."""


def build_agent_instructions(profile_data: dict, template: str | None = None) -> str:
    """Build agent instructions from HCP profile data using template."""
    tmpl = template or DEFAULT_AGENT_TEMPLATE
    # Safe format: handle list fields
    data = {**profile_data}
    for list_field in ("expertise_areas", "objections", "probe_topics"):
        if isinstance(data.get(list_field), list):
            data[list_field] = ", ".join(data[list_field])
    return tmpl.format(**data)

What: After HCP profile save, trigger async agent sync When to use: In hcp_profile_service create/update/delete

# In hcp_profile_service.py (after create/update)

async def create_hcp_profile(db, data, user_id):
    profile = HcpProfile(**profile_data)
    profile.agent_sync_status = "pending"
    db.add(profile)
    await db.flush()
    await db.refresh(profile)

    # Fire agent sync (non-blocking for the HTTP response)
    try:
        result = await agent_sync_service.sync_agent_for_profile(db, profile)
        profile.agent_id = result["id"]
        profile.agent_sync_status = "synced"
        profile.agent_sync_error = ""
    except Exception as e:
        profile.agent_sync_status = "failed"
        profile.agent_sync_error = str(e)[:500]

    await db.flush()
    await db.refresh(profile)
    return profile

What: The AI Foundry Agent API endpoint differs from the OpenAI endpoint When to use: When constructing the base URL for agent REST calls

The Agent API uses project endpoint format: https://<resource>.services.ai.azure.com/api/projects/<project>/assistants

This is different from the OpenAI endpoint (*.openai.azure.com). The project needs a way to store or derive the project endpoint.

Recommendation: Store the AI Foundry project endpoint as a new field in the master config or use the existing azure_voice_live config's model_or_deployment field (which already stores agent mode JSON with project_name). The endpoint can be constructed as: https://<resource>.services.ai.azure.com/api/projects/<project_name>

• Anti-pattern: Blocking agent sync in HTTP request path. Although the current design syncs synchronously within the save call (per D-02), wrap in try/catch to ensure the HCP profile save succeeds even if agent sync fails. Never let AI Foundry API failure prevent HCP profile CRUD.
• Anti-pattern: Storing raw API key in agent_sync_service. Always use config_service.get_effective_key() -- never cache decrypted keys in module-level variables.
• Anti-pattern: Using azure-ai-projects SDK. This adds ~50MB of dependencies, requires azure-identity for auth, and fights against the project's api-key header auth pattern. Use httpx directly.
• Anti-pattern: Putting agent instructions in the HCP database field. Agent instructions are generated on-the-fly from profile data. Store the template, not the rendered instructions.

Key insight: The Agent REST API is a simple CRUD interface (create/update/delete) with JSON payloads. The complexity is in the lifecycle management (sync status tracking, error handling, retry) -- not in the API calls themselves.

What goes wrong: The Agent (Assistants) API uses a project-scoped endpoint (*.services.ai.azure.com/api/projects/<project>/assistants), NOT the OpenAI endpoint (*.openai.azure.com). Using the wrong endpoint returns 404. Why it happens: The master config stores the OpenAI-style endpoint. The Agent API needs the AI Foundry project endpoint. How to avoid: The voice_live config already stores agent mode JSON with project_name. Use this to construct the correct project endpoint. If the master endpoint is https://<resource>.services.ai.azure.com, append /api/projects/<project_name> for agent calls. If it's *.cognitiveservices.azure.com, derive the .services.ai.azure.com variant first. Warning signs: 404 errors on /assistants endpoint; "Resource not found" from AI Foundry.

What goes wrong: AI Foundry quickstart docs show Bearer token (Entra ID) auth. But this project uses API key auth everywhere. Why it happens: Azure docs emphasize Entra ID auth. But the API also accepts api-key header (same as OpenAI endpoints on AI Foundry). How to avoid: Use api-key: {key} header, same as all other AI Foundry calls in this project. The existing connection_tester.py proves this works. Warning signs: 401 errors when using Authorization: Bearer with an API key string.

What goes wrong: Adding non-nullable columns without server_default fails on SQLite when rows already exist. Why it happens: SQLite doesn't support ALTER TABLE ADD COLUMN with NOT NULL unless a default is specified. How to avoid: Use server_default for all new columns: agent_id -> server_default="", agent_sync_status -> server_default="none", agent_sync_error -> server_default="". Use batch_alter_table per project convention. Warning signs: Alembic migration fails with "Cannot add a NOT NULL column with default value NULL".

What goes wrong: If AI Foundry is unreachable or misconfigured, HCP profile create/update fails entirely. Why it happens: Agent sync is called synchronously in the save path. How to avoid: Wrap agent sync in try/except. On failure, set agent_sync_status = "failed" and agent_sync_error with the error message. The HCP profile save itself must always succeed. Warning signs: HCP create returns 500; profile disappears after save attempt.

What goes wrong: Updating an HCP profile creates a new agent instead of updating the existing one, leading to orphaned agents in AI Foundry. Why it happens: Using create_agent on update instead of checking for existing agent_id. How to avoid: In update flow: if profile.agent_id is set and non-empty, call update_agent (PATCH/POST to /assistants/{agent_id}). Only call create_agent if no agent_id exists yet. Warning signs: Multiple agents with the same name in AI Foundry console; agent_id changes on every update.

What goes wrong: The AI Foundry project endpoint format (https://<resource>.services.ai.azure.com/api/projects/<project>) needs both the resource name AND the project name. Neither is explicitly stored in the current config schema. Why it happens: Current config stores just the base endpoint and model_or_deployment. How to avoid: The voice_live mode already parses project_name from the agent mode JSON in model_or_deployment. Reuse this. For the base endpoint, derive from the master AI Foundry config (preferring .services.ai.azure.com variant). Store the derived project endpoint or add a project_name field to the master config. Warning signs: Empty project_name; agent sync fails with "project not found".

# Source: Azure AI Foundry quickstart docs (learn.microsoft.com)
# GA API version: 2025-05-01

curl --request POST \
  --url "https://<resource>.services.ai.azure.com/api/projects/<project>/assistants?api-version=2025-05-01" \
  -H "api-key: <your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "instructions": "You are Dr. Zhang Wei, an oncologist...",
    "name": "Dr. Zhang Wei",
    "model": "gpt-4o"
  }'

# Response: {"id": "asst_abc123", "name": "Dr. Zhang Wei", ...}

# Source: OpenAI Assistants API (compatible with AI Foundry)
curl --request POST \
  --url "https://<resource>.services.ai.azure.com/api/projects/<project>/assistants/asst_abc123?api-version=2025-05-01" \
  -H "api-key: <your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "instructions": "Updated instructions...",
    "name": "Dr. Zhang Wei"
  }'

curl --request DELETE \
  --url "https://<resource>.services.ai.azure.com/api/projects/<project>/assistants/asst_abc123?api-version=2025-05-01" \
  -H "api-key: <your-api-key>"

# Source: Project convention (f09a_unified_ai_foundry_config.py)
def upgrade() -> None:
    with op.batch_alter_table("hcp_profiles") as batch_op:
        batch_op.add_column(
            sa.Column("agent_id", sa.String(100), server_default="", nullable=False)
        )
        batch_op.add_column(
            sa.Column(
                "agent_sync_status",
                sa.String(20),
                server_default="none",
                nullable=False,
            )
        )
        batch_op.add_column(
            sa.Column("agent_sync_error", sa.Text(), server_default="", nullable=False)
        )

// Source: Project convention (service-config-card.tsx badge pattern)
function AgentStatusBadge({ status, error }: { status: string; error?: string }) {
  const badgeStyles: Record<string, string> = {
    synced: "bg-green-100 text-green-700",
    pending: "bg-yellow-100 text-yellow-700",
    failed: "bg-red-100 text-red-700",
    none: "bg-gray-100 text-gray-500",
  };

  return (
    <Tooltip>
      <TooltipTrigger>
        <span className={cn("px-2 py-0.5 rounded-full text-xs font-medium", badgeStyles[status])}>
          {status}
        </span>
      </TooltipTrigger>
      {status === "failed" && error && (
        <TooltipContent>{error}</TooltipContent>
      )}
    </Tooltip>
  );
}

# In voice_live_service.py, extend get_voice_live_token to accept hcp_profile_id
async def get_voice_live_token(
    db: AsyncSession,
    hcp_profile_id: str | None = None,
) -> VoiceLiveTokenResponse:
    # ... existing token generation ...

    # If agent mode AND hcp_profile_id provided, source agent_id from HCP profile
    if is_agent and hcp_profile_id:
        from app.services import hcp_profile_service
        profile = await hcp_profile_service.get_hcp_profile(db, hcp_profile_id)
        if profile.agent_id:
            agent_id = profile.agent_id
        # project_name still comes from voice_live config

    return VoiceLiveTokenResponse(
        # ...
        agent_id=agent_id if is_agent else None,
        project_name=mode_info.get("project_name") if is_agent else None,
    )

Deprecated/outdated:

• Hub-based project connection strings: Replaced by Foundry project endpoints (May 2025)
• azure-ai-projects < 2.0: Breaking API changes in v2.0

1. AI Foundry Project Endpoint Configuration

   • What we know: The Agent API needs https://<resource>.services.ai.azure.com/api/projects/<project_name>/assistants. The voice_live config stores project_name in its agent mode JSON.
   • What's unclear: Should we add a dedicated project_name field to the AI Foundry master config, or always derive it from the voice_live agent mode config?
   • Recommendation: Add a project_name field to the AI Foundry master config (new DB column on service_configs or store in a separate config key). This makes agent sync independent of voice_live config.

2. Model Deployment Name for Agents

   • What we know: AI Foundry Agent creation requires a model parameter (deployment name, e.g., "gpt-4o").
   • What's unclear: Should this use the master config's model_or_deployment, the voice_live config's model, or a dedicated "agent model" config?
   • Recommendation: Use the master config's model_or_deployment as default. This is the model deployed on the AI Foundry resource.

3. Agent API Authentication Method

   • What we know: Quickstart docs show Entra ID Bearer auth. This project uses api-key header throughout.
   • What's unclear: Is api-key header officially supported for the Agent (Assistants) API, or only for OpenAI/Speech endpoints?
   • Recommendation: Try api-key header first (HIGH confidence it works based on AI Foundry unified auth pattern). Fall back to documenting Entra ID if needed. The quickstart REST example explicitly shows Bearer token, but the Python SDK AIProjectClient supports AzureKeyCredential as well.

Missing dependencies with no fallback:

• None -- all code dependencies are installed

Missing dependencies with fallback:

• Azure AI Foundry project (external service): If not configured, agent sync is skipped; HCP profiles work normally without agent sync; agent_sync_status stays "none"

Enforced by this phase:

• Async everywhere: All agent sync functions must be async def with await
• Service layer pattern: Agent sync logic in services/agent_sync_service.py, not in router
• Alembic migrations: New columns require migration with server_default for SQLite compatibility
• Pydantic v2 schemas: Agent fields in response schemas use ConfigDict(from_attributes=True)
• db.flush() not db.commit(): Per session middleware commit pattern
• i18n: All new UI text externalized to admin namespace (en-US + zh-CN)
• No raw SQL: Use SQLAlchemy ORM for all queries
• Static routes before parameterized: Any new /retry-sync endpoint before /{profile_id}
• Create returns 201, Delete returns 204: Maintain existing HTTP semantics
• cn() utility: Use for conditional class composition in new table components
• Design tokens only: No raw Tailwind colors in shared components
• TanStack Query hooks: New retry mutation in use-hcp-profiles.ts, not inline useQuery

• Azure AI Foundry Agent Service quickstart (learn.microsoft.com/en-us/azure/ai-services/agents/quickstart) - REST API endpoint format, create/delete curl examples, api-version 2025-05-01
• Azure AI Foundry Agent Service overview (learn.microsoft.com/en-us/azure/foundry/agents/overview) - Agent types, architecture, model support
• Azure AI Foundry environment setup (learn.microsoft.com/en-us/azure/foundry/agents/environment-setup) - Project endpoint format, auth requirements
• Existing codebase: backend/app/services/connection_tester.py - httpx REST call patterns with AI Foundry endpoints
• Existing codebase: backend/app/services/voice_live_service.py - Token broker agent_id sourcing pattern
• Existing codebase: backend/app/services/agents/adapters/azure_voice_live.py - parse_voice_live_mode with agent_id/project_name
• Existing codebase: backend/alembic/versions/f09a_unified_ai_foundry_config.py - Migration pattern with server_default

• PyPI: azure-ai-projects v2.0.1 (pypi.org) - SDK GA version, Python 3.9+ support
• Project memory: project_phase11_hcp_agent_sync.md - Phase 11 requirement context
• Project memory: project_ai_foundry_speech_auth.md - api-key header auth pattern for AI Foundry

• Agent API api-key header support: Based on inference from AI Foundry unified auth pattern, not explicitly documented for Agent (Assistants) API. Needs runtime validation.

Confidence breakdown:

• Standard stack: HIGH - All libraries already in use, no new dependencies needed
• Architecture: HIGH - Follows established project patterns (service layer, httpx REST, Alembic migrations)
• AI Foundry API: MEDIUM - REST endpoint format and auth confirmed from docs, but api-key header for Agent API specifically needs runtime validation
• Frontend table redesign: HIGH - Standard React table with existing design token system
• Pitfalls: HIGH - Based on actual codebase patterns and documented Azure quirks

Research date: 2026-03-31 Valid until: 2026-04-30 (30 days -- AI Foundry API is GA and stable)

Visual and interaction contract for the HCP Profile Agent Integration phase. Generated by gsd-ui-researcher, verified by gsd-ui-checker.

Source: Existing frontend/src/styles/index.css @theme inline block and frontend/src/components/ui/ library (20+ components).

Declared values (must be multiples of 4):

Exceptions: Table cell padding uses 16px horizontal (md) and 12px vertical (matching existing scenario-table.tsx pattern of px-4 py-3).

Source: Established project convention. Matches scenario-table.tsx and service-config-card.tsx spacing patterns.

Font weights used in this phase: 400 (normal) and 500 (medium) only.

Phase-specific usage:

• Table header cells: 14px, weight 500 (Label role)
• Table body cells: 14px, weight 400 (Body role)
• Agent status badge text: 12px (text-xs), weight 500
• Page title "HCP Profiles": 20px, weight 500 (Display role)
• Tooltip error detail text: 12px (text-xs), weight 400

Source: Existing base layer styles in frontend/src/styles/index.css lines 191-250. Table headers in scenario-table.tsx and rubric-table.tsx consistently use font-medium (500). Heading role aligned to 500 for this phase to maintain a strict 2-weight budget.

Accent reserved for: "Create New HCP" button, table sort active indicator, "Retry Sync" button when primary variant, edit action icon hover.

Source: Badge color pattern derived from existing Badge component variants (success variant uses --strength). Status dot pattern from service-config-card.tsx STATUS_DOT map. The synced status reuses the existing success Badge variant. The pending, failed, and none statuses use inline utility classes matching the DIFFICULTY_STYLES pattern in scenario-table.tsx.

Focal point: "Create New HCP" button (accent color, right-aligned in header bar) -- the primary action entry point for the entire page.

+----------------------------------------------------------+
| Page Header                                               |
| [Search Input]           [+ Create New HCP]              |
+----------------------------------------------------------+
| Table                                                     |
| Name | Specialty | Personality | Comm. Style | Agent | . |
|------|-----------|-------------|-------------|-------|---|
| Dr.X | Oncology  | Skeptical   | Direct (72) | [OK]  | v |
| Dr.Y | Cardio    | Friendly    | Indir. (35) | [!]   | v |
| ...  | ...       | ...         | ...         | ...   | . |
+----------------------------------------------------------+
| Page 1 of N                    [Previous] [Next]         |
+----------------------------------------------------------+

Key layout decisions:

• Full-width table replacing the previous 300px sidebar + editor panel layout (D-08)
• Page uses the standard admin content area (inside UserLayout with sidebar)
• Edit/Create opens in the existing HcpEditor, either as a sheet/dialog overlay or as a route change (Claude's discretion per D-08 table redesign)
• Table occupies full available width within the admin content area
• Search input left-aligned, Create button right-aligned in the header bar
• Header bar has 24px (lg) bottom margin before table

1. Column sort: Click column header to toggle asc/desc. ArrowUpDown icon (size-3.5) next to sortable column names. Matches scenario-table.tsx pattern exactly.
2. Row hover: hover:bg-slate-50/50 transition-colors on each <tr>. Matches scenario-table.tsx.
3. Pagination: Client-side, 10 rows per page. Previous/Next buttons below table. Matches scenario-table.tsx pagination pattern.
4. Search: Real-time filtering by HCP name. Debounced input at top of page.
5. Actions dropdown: Three-dot menu (MoreHorizontal icon) per row.

Retry Sync (D-11): Available as a DropdownMenuItem in the actions menu when status is failed. Triggers a POST /api/v1/hcp-profiles/{id}/retry-sync call. On click, badge transitions to pending with pulse. On success, badge transitions to synced. On failure, badge stays failed with updated error.

When useHcpProfiles is loading, render 5 skeleton rows:

| [Skeleton 24px circle] [Skeleton 120px bar] | [Skeleton 80px] | [Skeleton 60px] | [Skeleton 40px] | [Skeleton 60px] | [Skeleton 24px] |

Each skeleton row height: 52px (matching real row height of py-3 + content). Use existing Skeleton component with className="h-4 rounded" for text bars and className="size-6 rounded-full" for avatar placeholder.

Source: Skeleton component already exists at frontend/src/components/ui/skeleton.tsx.

When admin saves an HCP profile:

1. Button shows Loader2 spinner (matches service-config-card.tsx pattern)
2. Toast: "Profile saved" (success)
3. Agent status badge in table transitions to pending (with pulse animation)
4. On sync completion, badge updates to synced or failed
5. If sync fails, toast: "Agent sync failed: {error}" (warning, not error -- profile save succeeded)

Namespace: admin (existing)

{
  "hcp": {
    "agentStatus": "Agent Status",
    "actions": "Actions",
    "agentSynced": "Synced",
    "agentPending": "Syncing...",
    "agentFailed": "Failed",
    "agentNone": "Not Synced",
    "agentSyncedTooltip": "Agent synced to AI Foundry",
    "agentPendingTooltip": "Syncing agent to AI Foundry...",
    "agentNoneTooltip": "AI Foundry not configured or sync not attempted",
    "retrySync": "Retry Sync",
    "syncSuccess": "Agent synced successfully",
    "syncFailed": "Agent sync failed: {{error}}",
    "deleteConfirmWithAgent": "Delete HCP Profile: This will permanently remove this profile, delete its AI Foundry agent, and unassign it from all scenarios. This action cannot be undone."
  }
}

Corresponding zh-CN keys must be added in frontend/public/locales/zh-CN/admin.json.

This phase does NOT redesign the mode selector component. The only change is:

• If a scenario's HCP profile has agent_sync_status !== "synced" (no valid agent_id), the "Digital Human Realtime Agent" and "Voice Realtime Agent" mode options are disabled in the existing mode selector.
• Disabled option shows opacity-50 cursor-not-allowed styling.
• Tooltip on disabled option: "HCP agent not synced. Configure AI Foundry and save the HCP profile to enable Agent mode."
• New i18n key: training:modeSelector.agentNotAvailable = "HCP agent not synced. Configure AI Foundry and save the HCP profile to enable Agent mode."

No third-party registries are used. All components are project-authored Radix UI wrappers or native HTML elements styled with Tailwind utility classes.

• Dimension 1 Copywriting: PASS
• Dimension 2 Visuals: PASS
• Dimension 3 Color: PASS
• Dimension 4 Typography: PASS
• Dimension 5 Spacing: PASS
• Dimension 6 Registry Safety: PASS

Approval: pending

Phase Goal: When admin creates/updates/deletes an HCP profile, the system automatically syncs a corresponding AI Foundry Agent. Digital Human Realtime Agent mode uses the HCP's agent_id to drive conversations. HCP profiles admin page is redesigned to table format with Agent sync status. Verified: 2026-03-31T10:30:00Z Status: passed Re-verification: No -- initial verification

Score: 7/7 truths verified

No orphaned requirements found -- all 7 requirement IDs from ROADMAP.md are covered by plans and have implementation evidence.

No TODOs, FIXMEs, placeholders, stub implementations, or empty returns found in any Phase 11 artifacts.

Test: Navigate to admin HCP Profiles page. Verify table renders with 6 columns (Name with avatar, Specialty, Personality badge, Communication Style with descriptor, Agent Status badge, Actions dropdown). Expected: Clean table layout matching scenario-table.tsx visual pattern. Sorted by name ascending by default. Why human: Visual appearance and alignment cannot be verified programmatically.

Test: With profiles in different sync states (synced, pending, failed, none), verify badge styling. Expected: Synced = green, Pending = amber with pulse animation, Failed = red, None = gray. Why human: CSS color rendering and animation behavior require visual inspection.

Test: Hover over a "Failed" agent status badge. Expected: Tooltip shows the error message text from agent_sync_error. Why human: Tooltip hover interaction behavior requires human testing.

Test: Click Edit on an HCP profile in the table. Verify dialog opens with pre-filled editor. Make a change and save. Expected: Dialog opens, editor shows existing data, save closes dialog and shows toast. Table updates with new data. Why human: Dialog open/close behavior, form interaction, and toast feedback are UI flow tests.

Test: For a profile with "failed" agent status, click the Actions dropdown and select "Retry Sync". Expected: Toast shows success or failure message. Agent status badge updates. Why human: End-to-end sync requires real AI Foundry connection; local testing would need mocks.

Test: With Azure AI Foundry configured, create a new HCP profile. Expected: Agent is created in AI Foundry. Profile shows "synced" status with agent_id populated. Updating the profile updates the agent instructions. Deleting the profile deletes the agent. Why human: Requires real Azure AI Foundry credentials and environment.

No gaps found. All 7 success criteria are satisfied by the implementation:

1. Backend foundation (Plan 01): HcpProfile model extended with agent columns, migration applies cleanly, agent_sync_service provides instruction builder + REST API wrapper, 11 unit tests passing.

2. Backend wiring (Plan 02): CRUD operations auto-trigger agent sync with failure-safe try/except, retry-sync endpoint available, token broker extended with per-HCP agent_id sourcing, 8 integration tests passing.

3. Frontend (Plan 03): HcpTable component with sortable columns, agent status badges with tooltips, dropdown actions with Retry Sync. HCP profiles page fully rewritten from list+editor to table+dialog layout. All i18n keys externalized in both locales. TypeScript compiles clean, build succeeds.

Verified: 2026-03-31T10:30:00Z Verifier: Claude (gsd-verifier)