availsync 0.1.0

package/frontend/lib/api.ts

@@ -0,0 +1,1282 @@
+import {
+  agentSchema,
+  availabilityWindowSchema,
+  holdSchema,
+  orgSchema,
+  slotSchema,
+  workClaimSchema,
+  workResourceSchema,
+  workspaceUserSchema,
+  type AgentType,
+} from './schemas';
+
+const API_URL = process.env.NEXT_PUBLIC_API_URL || '';
+
+async function request<T>(path: string, options: RequestInit = {}): Promise<T> {
+  const response = await fetch(`${API_URL}${path}`, {
+    ...options,
+    credentials: 'include',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(options.headers || {}),
+    },
+    cache: 'no-store',
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw Object.assign(new Error(body.message || body.error || `Request failed with ${response.status}`), {
+      status: response.status,
+      body,
+    });
+  }
+  return body as T;
+}
+
+function authHeaders(apiKey?: string): Record<string, string> {
+  return apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+}
+
+export async function signupWorkspace(input: {
+  workspace_name: string;
+  email: string;
+  password: string;
+  agent: {
+    name: string;
+    agent_type: AgentType;
+    priority: number;
+  };
+}) {
+  const response = await request<{
+    org: unknown;
+    user: unknown;
+    agent: unknown;
+    api_key: string;
+  }>('/v1/auth/signup', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+  return {
+    org: orgSchema.parse(response.org),
+    user: workspaceUserSchema.parse(response.user),
+    agent: agentSchema.parse(response.agent),
+    apiKey: response.api_key,
+  };
+}
+
+export async function loginWorkspace(email: string, password: string) {
+  return request<{ ok: boolean }>('/v1/auth/login', {
+    method: 'POST',
+    body: JSON.stringify({ email, password }),
+  });
+}
+
+export async function logoutWorkspace() {
+  return request<{ ok: boolean }>('/v1/auth/logout', { method: 'POST' });
+}
+
+export async function restoreSession() {
+  const response = await request<{ org: unknown; user: unknown }>('/v1/session');
+  return {
+    org: orgSchema.parse(response.org),
+    user: workspaceUserSchema.parse(response.user),
+  };
+}
+
+export async function createOrg(name: string) {
+  const response = await request<{ org: unknown }>('/v1/orgs', {
+    method: 'POST',
+    body: JSON.stringify({ name }),
+  });
+  return orgSchema.parse(response.org);
+}
+
+export async function createAgent(input: {
+  orgId: string;
+  name: string;
+  agent_type: AgentType;
+  priority: number;
+}) {
+  const response = await request<{ agent: unknown; api_key: string }>(
+    `/v1/orgs/${input.orgId}/agents`,
+    {
+      method: 'POST',
+      body: JSON.stringify({
+        name: input.name,
+        agent_type: input.agent_type,
+        priority: input.priority,
+      }),
+    },
+  );
+  return {
+    agent: agentSchema.parse(response.agent),
+    apiKey: response.api_key,
+  };
+}
+
+export async function updateAgent(input: {
+  orgId: string;
+  agentId: string;
+  name: string;
+  agent_type: AgentType;
+  priority: number;
+  enforcement_mode?: 'enforce' | 'observe';
+}) {
+  const response = await request<{ agent: unknown }>(
+    `/v1/orgs/${input.orgId}/agents/${input.agentId}`,
+    {
+      method: 'PUT',
+      body: JSON.stringify({
+        name: input.name,
+        agent_type: input.agent_type,
+        priority: input.priority,
+        enforcement_mode: input.enforcement_mode,
+      }),
+    },
+  );
+  return agentSchema.parse(response.agent);
+}
+
+export async function deleteAgent(orgId: string, agentId: string) {
+  const response = await request<{ agent: unknown }>(
+    `/v1/orgs/${orgId}/agents/${agentId}`,
+    { method: 'DELETE' },
+  );
+  return agentSchema.parse(response.agent);
+}
+
+export async function rotateAgentKey(orgId: string, agentId: string) {
+  const response = await request<{ agent: unknown; api_key: string }>(
+    `/v1/orgs/${orgId}/agents/${agentId}/rotate-key`,
+    { method: 'POST' },
+  );
+  return {
+    agent: agentSchema.parse(response.agent),
+    apiKey: response.api_key,
+  };
+}
+
+export async function testAgentConnection(orgId: string, agentId: string) {
+  return request<{
+    agent_id: string;
+    last_seen_at: string | null;
+    mcp_status: 'online' | 'recent' | 'offline';
+    mcp_last_seen_at: string | null;
+    mcp_client_name: string | null;
+    last_successful_api_call: {
+      activity_type: string;
+      endpoint: string | null;
+      method: string | null;
+      status_code: number | null;
+      client_name: string | null;
+      created_at: string;
+    } | null;
+    last_error: {
+      activity_type: string;
+      endpoint: string | null;
+      method: string | null;
+      status_code: number | null;
+      error_code: string | null;
+      error_message: string | null;
+      created_at: string;
+    } | null;
+    setup_readiness: {
+      agent_created: boolean;
+      availability_window_created: boolean;
+      mcp_heartbeat_seen: boolean;
+      first_availability_check: boolean;
+      first_conflict_preview: boolean;
+      first_hold_created: boolean;
+      first_work_check: boolean;
+      first_work_claim: boolean;
+      first_work_extend: boolean;
+      first_work_release: boolean;
+      latest_activity_at: string | null;
+      latest_activity_type: string | null;
+      mcp: {
+        heartbeat_seen: boolean;
+        status: 'online' | 'recent' | 'offline';
+        last_seen_at: string | null;
+      };
+      calendar: {
+        availability_window_created: boolean;
+        first_availability_check: boolean;
+        first_conflict_preview: boolean;
+        first_hold_created: boolean;
+      };
+      work: {
+        first_work_check: boolean;
+        first_work_claim: boolean;
+        first_work_extend: boolean;
+        first_work_release: boolean;
+      };
+      activity: {
+        latest_activity_at: string | null;
+        latest_activity_type: string | null;
+      };
+    };
+  }>(`/v1/orgs/${orgId}/agents/${agentId}/test-connection`, { method: 'POST' });
+}
+
+export type SetupTestStep = {
+  name: string;
+  status: 'pending' | 'running' | 'success' | 'warning' | 'blocked' | 'error';
+  latency_ms: number;
+  summary: string;
+  next_action: string | null;
+  details?: Record<string, unknown>;
+};
+
+export type SetupTestRun = {
+  run_id: string;
+  status: 'success' | 'warning' | 'blocked' | 'error';
+  steps: SetupTestStep[];
+  started_at: string;
+  finished_at: string;
+};
+
+export async function runAgentSetupTest(orgId: string, agentId: string, resourceKey = 'setup/demo-repo') {
+  return request<SetupTestRun>(`/v1/orgs/${orgId}/agents/${agentId}/setup-test`, {
+    method: 'POST',
+    body: JSON.stringify({ resource_key: resourceKey }),
+  });
+}
+
+export type OnboardingVerifyResult = {
+  verified_at: string;
+  resource_key: string;
+  duration_ms: number;
+  winner: {
+    agent_id: string;
+    agent_name: string;
+    agent_type: AgentType;
+    priority: number;
+    claim_id: string;
+    completed_at: string;
+    outcome: 'claimed';
+  };
+  loser: {
+    agent_id: string;
+    agent_name: string;
+    agent_type: AgentType;
+    priority: number;
+    claim_id: null;
+    completed_at: string;
+    outcome: 'blocked';
+    retry_after: string | null;
+  };
+  rule_applied: 'none' | 'priority_over_agents' | 'agent_type' | 'priority' | 'first_created';
+  rule_explanation: string;
+  tie_warning?: string;
+};
+
+export async function verifyOnboarding(input?: { agent_a_id?: string; agent_b_id?: string }) {
+  return request<OnboardingVerifyResult>('/v1/onboarding/verify', {
+    method: 'POST',
+    body: JSON.stringify(input ?? {}),
+  });
+}
+
+export async function listAgents(orgId: string) {
+  const response = await request<{ agents: unknown[] }>(`/v1/orgs/${orgId}/agents`);
+  return response.agents.map((agent) => agentSchema.parse(agent));
+}
+
+export async function createAvailabilityWindow(input: {
+  agent_id: string;
+  start_at: string;
+  end_at: string;
+  window_type: 'available' | 'focus' | 'blocked';
+  apiKey?: string;
+}) {
+  const response = await request<{ window: unknown }>('/v1/availability-windows', {
+    method: 'POST',
+    headers: authHeaders(input.apiKey),
+    body: JSON.stringify({
+      agent_id: input.agent_id,
+      start_at: input.start_at,
+      end_at: input.end_at,
+      window_type: input.window_type,
+    }),
+  });
+  return availabilityWindowSchema.parse(response.window);
+}
+
+export async function updateAvailabilityWindow(input: {
+  window_id: string;
+  start_at: string;
+  end_at: string;
+  window_type: 'available' | 'focus' | 'blocked';
+  recurrence?: 'daily' | 'weekly' | null;
+  apiKey?: string;
+}) {
+  const response = await request<{ window: unknown }>(
+    `/v1/availability-windows/${input.window_id}`,
+    {
+      method: 'PUT',
+      headers: authHeaders(input.apiKey),
+      body: JSON.stringify({
+        start_at: input.start_at,
+        end_at: input.end_at,
+        window_type: input.window_type,
+        recurrence: input.recurrence ?? null,
+      }),
+    },
+  );
+  return availabilityWindowSchema.parse(response.window);
+}
+
+export async function deleteAvailabilityWindow(windowId: string, apiKey?: string) {
+  const response = await request<{ window: unknown }>(`/v1/availability-windows/${windowId}`, {
+    method: 'DELETE',
+    headers: authHeaders(apiKey),
+  });
+  return availabilityWindowSchema.parse(response.window);
+}
+
+export async function checkAvailability(input: {
+  agent_id: string;
+  from: string;
+  to: string;
+  duration_minutes: number;
+  include_competing_agents?: boolean;
+  apiKey?: string;
+}) {
+  const query = new URLSearchParams({
+    agent_id: input.agent_id,
+    from: input.from,
+    to: input.to,
+    duration_minutes: String(input.duration_minutes),
+  });
+  if (input.include_competing_agents !== undefined) {
+    query.set('include_competing_agents', String(input.include_competing_agents));
+  }
+  const response = await request<{ slots: unknown[]; total_slots: number }>(
+    `/v1/availability?${query.toString()}`,
+    { headers: authHeaders(input.apiKey) },
+  );
+  return {
+    slots: response.slots.map((slot) => slotSchema.parse(slot)),
+    totalSlots: response.total_slots,
+  };
+}
+
+export async function checkConflict(input: {
+  agent_id: string;
+  start_at: string;
+  end_at: string;
+  reason?: string;
+  metadata?: Record<string, unknown>;
+  apiKey?: string;
+}) {
+  return request<{
+    status: 'available' | 'would_win' | 'would_lose';
+    would_create_hold: boolean;
+    winning_hold_id: string | null;
+    losing_hold_ids: string[];
+    rule_applied: string;
+    explanation: string;
+    suggested_alternatives: Array<{ start: string; end: string; confidence: number }>;
+  }>('/v1/conflicts/check', {
+    method: 'POST',
+    headers: authHeaders(input.apiKey),
+    body: JSON.stringify({
+      agent_id: input.agent_id,
+      start_at: input.start_at,
+      end_at: input.end_at,
+      reason: input.reason,
+      metadata: input.metadata,
+    }),
+  });
+}
+
+export async function createHold(input: {
+  agent_id: string;
+  start_at: string;
+  end_at: string;
+  reason?: string;
+  apiKey?: string;
+}) {
+  const response = await request<{ hold: unknown }>('/v1/holds', {
+    method: 'POST',
+    headers: authHeaders(input.apiKey),
+    body: JSON.stringify({
+      agent_id: input.agent_id,
+      start_at: input.start_at,
+      end_at: input.end_at,
+      reason: input.reason,
+    }),
+  });
+  return holdSchema.parse(response.hold);
+}
+
+export async function listHolds(input: {
+  agent_id?: string;
+  from?: string;
+  to?: string;
+  status?: 'confirmed' | 'superseded' | 'released';
+  apiKey?: string;
+} = {}) {
+  const params = new URLSearchParams();
+  if (input.agent_id) params.set('agent_id', input.agent_id);
+  if (input.from) params.set('from', input.from);
+  if (input.to) params.set('to', input.to);
+  if (input.status) params.set('status', input.status);
+  const response = await request<{ holds: unknown[] }>(`/v1/holds?${params.toString()}`, {
+    headers: authHeaders(input.apiKey),
+  });
+  return response.holds.map((hold) => holdSchema.parse(hold));
+}
+
+export async function releaseHold(holdId: string, apiKey?: string) {
+  const response = await request<{ hold: unknown }>(`/v1/holds/${holdId}`, {
+    method: 'DELETE',
+    headers: authHeaders(apiKey),
+  });
+  return holdSchema.parse(response.hold);
+}
+
+export async function createCheckout(input: {
+  plan: 'individual' | 'team';
+  org_id?: string;
+}) {
+  return request<{ url?: string }>('/v1/billing/checkout', {
+    method: 'POST',
+    body: JSON.stringify({ plan: input.plan, org_id: input.org_id }),
+  });
+}
+
+export async function getBillingPortal() {
+  return request<{ url: string }>('/v1/billing/portal');
+}
+
+export async function getBillingStatus() {
+  return request<{
+    plan: 'free' | 'individual' | 'team';
+    subscription_status: string;
+    renewal_date: string | null;
+    cancel_at_period_end: boolean;
+    billing_email: string | null;
+    limits: {
+      agents: number | null;
+      protected_resources: number;
+      active_work_claims: number;
+      api_calls_month: number;
+      activity_retention_days: number;
+    };
+    usage: {
+      agents: number;
+      protected_resources: number;
+      active_work_claims: number;
+      api_calls_month: number;
+      activity_retention_days: number;
+    };
+    upgrade_reasons: Array<{
+      limit_type: string;
+      usage: number;
+      limit: number;
+      state: 'near' | 'reached';
+      upgrade_plan: 'individual' | 'team' | null;
+    }>;
+    agents_used: number;
+    agent_limit: number;
+    stripe_customer_id: boolean;
+    stripe_subscription_id: boolean;
+    billing_upgrades_enabled: boolean;
+  }>('/v1/billing/status');
+}
+
+export async function deleteWorkspaceAccount(input: { confirmation: 'DELETE' }) {
+  return request<{ ok: true }>('/v1/account/workspace', {
+    method: 'DELETE',
+    body: JSON.stringify(input),
+  });
+}
+
+export async function getMetricsOverview() {
+  return request<{
+    active_agents: number;
+    mcp_online: number;
+    confirmed_holds: number;
+    conflicts_resolved: number;
+    conflicts_blocked: number;
+    released_holds: number;
+    api_calls_today: number;
+    connected_agents: number;
+    recent_errors: number;
+    token_usage_reported: number;
+    active_work_claims: number;
+    protected_resources: number;
+    blocked_agent_runs: number;
+    released_work_slots: number;
+    latest_event_at: string | null;
+  }>('/v1/metrics/overview');
+}
+
+export type AgentHealthStatus = 'healthy' | 'quiet' | 'never_connected' | 'error';
+
+export type ValueHealth = {
+  window: {
+    starts_at: string;
+    ends_at: string;
+    days: number;
+  };
+  summary: {
+    conflicts_prevented_7d: number;
+    blocked_work_runs_7d: number;
+    would_have_blocked_runs_7d: number;
+    calendar_conflicts_7d: number;
+    api_calls_7d: number;
+    errors_7d: number;
+    latest_real_activity_at: string | null;
+  };
+  agent_health: Array<{
+    agent_id: string;
+    name: string;
+    status: AgentHealthStatus;
+    last_seen_at: string | null;
+    last_activity_at: string | null;
+    last_success_at: string | null;
+    last_error_at: string | null;
+    last_error_code: string | null;
+    mcp_status: 'online' | 'recent' | 'offline';
+  }>;
+  next_best_action:
+    | 'run_verification'
+    | 'connect_first_agent'
+    | 'check_inactive_agents'
+    | 'review_errors'
+    | 'none';
+};
+
+export async function getValueHealth() {
+  return request<ValueHealth>('/v1/value/health');
+}
+
+export async function checkWork(input: {
+  agent_id: string;
+  resource_type: 'project' | 'repo';
+  resource_key: string;
+  label?: string;
+  start_at?: string;
+  duration_minutes?: number;
+  reason?: string;
+  metadata?: Record<string, unknown>;
+  apiKey?: string;
+}) {
+  return request<{
+    status: 'available' | 'would_win' | 'would_lose';
+    resource: {
+      id: string | null;
+      resource_type: 'project' | 'repo';
+      resource_key: string;
+      label: string;
+    };
+    winning_claim_id: string | null;
+    losing_claim_ids: string[];
+    rule_applied: string;
+    explanation: string;
+    suggested_retry_at: string | null;
+  }>('/v1/work/check', {
+    method: 'POST',
+    headers: authHeaders(input.apiKey),
+    body: JSON.stringify({
+      agent_id: input.agent_id,
+      resource_type: input.resource_type,
+      resource_key: input.resource_key,
+      label: input.label,
+      start_at: input.start_at,
+      duration_minutes: input.duration_minutes,
+      reason: input.reason,
+      metadata: input.metadata,
+    }),
+  });
+}
+
+export async function claimWork(input: {
+  agent_id: string;
+  resource_type: 'project' | 'repo';
+  resource_key: string;
+  label?: string;
+  start_at?: string;
+  duration_minutes?: number;
+  reason?: string;
+  metadata?: Record<string, unknown>;
+  apiKey?: string;
+  idempotencyKey?: string;
+}) {
+  const response = await request<{
+    claim: unknown;
+    resource: unknown;
+    status: 'available' | 'would_win' | 'would_lose';
+    superseded_claim_ids: string[];
+    idempotent_replay?: boolean;
+  }>('/v1/work/claim', {
+    method: 'POST',
+    headers: {
+      ...authHeaders(input.apiKey),
+      ...(input.idempotencyKey ? { 'Idempotency-Key': input.idempotencyKey } : {}),
+    },
+    body: JSON.stringify({
+      agent_id: input.agent_id,
+      resource_type: input.resource_type,
+      resource_key: input.resource_key,
+      label: input.label,
+      start_at: input.start_at,
+      duration_minutes: input.duration_minutes,
+      reason: input.reason,
+      metadata: input.metadata,
+    }),
+  });
+  return {
+    claim: workClaimSchema.parse(response.claim),
+    resource: workResourceSchema.parse(response.resource),
+    status: response.status,
+    supersededClaimIds: response.superseded_claim_ids,
+    idempotentReplay: Boolean(response.idempotent_replay),
+  };
+}
+
+export async function startWorkRun(input: {
+  agent_id: string;
+  resource_type: 'project' | 'repo';
+  resource_key: string;
+  label?: string;
+  start_at?: string;
+  duration_minutes?: number;
+  reason?: string;
+  metadata?: Record<string, unknown>;
+  idempotencyKey?: string;
+  bodyIdempotencyKey?: string;
+  clientName?: string;
+  apiKey?: string;
+}) {
+  const response = await request<{
+    action: 'proceed' | 'skip_run';
+    claim: unknown | null;
+    resource: unknown;
+    reason: string;
+    retry_after: string | null;
+    blocking_claim: unknown | null;
+    status?: 'available' | 'would_win' | 'would_lose';
+    superseded_claim_ids?: string[];
+    idempotent_replay?: boolean;
+    extend_url?: string;
+    finish_url?: string;
+    shadow_mode?: boolean;
+    would_have_blocked?: boolean;
+    shadow_decision?: {
+      action: 'skip_run';
+      reason?: string;
+      retry_after?: string | null;
+      blocking_claim?: unknown | null;
+      rule_applied?: string | null;
+      winning_claim_id?: string | null;
+    } | null;
+  }>('/v1/work/run/start', {
+    method: 'POST',
+    headers: {
+      ...authHeaders(input.apiKey),
+      ...(input.idempotencyKey ? { 'Idempotency-Key': input.idempotencyKey } : {}),
+    },
+    body: JSON.stringify({
+      agent_id: input.agent_id,
+      resource_type: input.resource_type,
+      resource_key: input.resource_key,
+      label: input.label,
+      start_at: input.start_at,
+      duration_minutes: input.duration_minutes,
+      reason: input.reason,
+      metadata: input.metadata,
+      idempotency_key: input.bodyIdempotencyKey,
+      client_name: input.clientName,
+    }),
+  });
+  return {
+    action: response.action,
+    claim: response.claim ? workClaimSchema.parse(response.claim) : null,
+    resource: workResourceSchema.parse(response.resource),
+    reason: response.reason,
+    retryAfter: response.retry_after,
+    blockingClaim: response.blocking_claim ? workClaimSchema.parse(response.blocking_claim) : null,
+    status: response.status,
+    supersededClaimIds: response.superseded_claim_ids ?? [],
+    idempotentReplay: Boolean(response.idempotent_replay),
+    extendUrl: response.extend_url,
+    finishUrl: response.finish_url,
+    shadowMode: Boolean(response.shadow_mode),
+    wouldHaveBlocked: Boolean(response.would_have_blocked),
+    shadowDecision: response.shadow_decision ?? null,
+  };
+}
+
+export async function extendWorkRun(input: {
+  claimId: string;
+  duration_minutes?: number;
+  clientName?: string;
+  apiKey?: string;
+}) {
+  const response = await request<{
+    action: 'extended';
+    claim: unknown;
+    expires_at: string;
+    seconds_until_expiry: number;
+    last_renewed_at: string;
+    renewal_count: number;
+    max_expires_at: string;
+  }>('/v1/work/run/extend', {
+    method: 'POST',
+    headers: authHeaders(input.apiKey),
+    body: JSON.stringify({
+      claim_id: input.claimId,
+      duration_minutes: input.duration_minutes,
+      client_name: input.clientName,
+    }),
+  });
+  return {
+    action: response.action,
+    claim: workClaimSchema.parse(response.claim),
+    expiresAt: response.expires_at,
+    secondsUntilExpiry: response.seconds_until_expiry,
+    lastRenewedAt: response.last_renewed_at,
+    renewalCount: response.renewal_count,
+    maxExpiresAt: response.max_expires_at,
+  };
+}
+
+export async function finishWorkRun(input: {
+  claimId: string;
+  outcome?: string;
+  reason?: string;
+  metadata?: Record<string, unknown>;
+  clientName?: string;
+  apiKey?: string;
+}) {
+  const response = await request<{
+    action: 'finished' | 'already_finished';
+    claim: unknown | null;
+  }>('/v1/work/run/finish', {
+    method: 'POST',
+    headers: authHeaders(input.apiKey),
+    body: JSON.stringify({
+      claim_id: input.claimId,
+      outcome: input.outcome,
+      reason: input.reason,
+      metadata: input.metadata,
+      client_name: input.clientName,
+    }),
+  });
+  return {
+    action: response.action,
+    claim: response.claim ? workClaimSchema.parse(response.claim) : null,
+  };
+}
+
+export async function extendWorkClaim(input: {
+  claimId: string;
+  duration_minutes?: number;
+  apiKey?: string;
+}) {
+  const response = await request<{
+    claim: unknown;
+    expires_at: string;
+    last_renewed_at: string;
+    renewal_count: number;
+    max_expires_at: string;
+  }>(`/v1/work/claims/${input.claimId}/extend`, {
+    method: 'POST',
+    headers: authHeaders(input.apiKey),
+    body: JSON.stringify({
+      duration_minutes: input.duration_minutes,
+    }),
+  });
+  return {
+    claim: workClaimSchema.parse(response.claim),
+    expiresAt: response.expires_at,
+    lastRenewedAt: response.last_renewed_at,
+    renewalCount: response.renewal_count,
+    maxExpiresAt: response.max_expires_at,
+  };
+}
+
+export async function releaseWorkClaim(claimId: string, apiKey?: string) {
+  const response = await request<{ claim: unknown }>(`/v1/work/claims/${claimId}`, {
+    method: 'DELETE',
+    headers: authHeaders(apiKey),
+  });
+  return workClaimSchema.parse(response.claim);
+}
+
+export async function listWorkClaims(input: {
+  agent_id?: string;
+  resource_type?: 'project' | 'repo';
+  resource_key?: string;
+  status?: 'active' | 'superseded' | 'released' | 'expired' | 'blocked';
+  limit?: number;
+  apiKey?: string;
+} = {}) {
+  const params = new URLSearchParams();
+  if (input.agent_id) params.set('agent_id', input.agent_id);
+  if (input.resource_type) params.set('resource_type', input.resource_type);
+  if (input.resource_key) params.set('resource_key', input.resource_key);
+  if (input.status) params.set('status', input.status);
+  if (input.limit) params.set('limit', String(input.limit));
+  const response = await request<{ claims: unknown[] }>(`/v1/work/claims?${params.toString()}`, {
+    headers: authHeaders(input.apiKey),
+  });
+  return response.claims.map((claim) => workClaimSchema.parse(claim));
+}
+
+export async function listWorkResources() {
+  const response = await request<{ resources: unknown[] }>('/v1/work/resources');
+  return response.resources.map((resource) => workResourceSchema.parse(resource));
+}
+
+export type AdminOverview = {
+  total_workspaces: number;
+  active_workspaces: number;
+  free_workspaces: number;
+  individual_workspaces: number;
+  team_workspaces: number;
+  paid_workspaces: number;
+  total_agents: number;
+  connected_agents: number;
+  api_calls_today: number;
+  api_calls_month: number;
+  errors_today: number;
+  active_workspaces_7d: number;
+  quiet_agents: number;
+  never_connected_agents: number;
+  conflicts_prevented_7d: number;
+  active_work_claims: number;
+  blocked_agent_runs: number;
+  latest_signup_at: string | null;
+  estimated_mrr: number;
+  canceled_workspaces: number;
+  waitlist_leads: number;
+  waitlist_new: number;
+};
+
+export type WaitlistLead = {
+  id: string;
+  org_id: string | null;
+  org_name?: string | null;
+  user_id: string | null;
+  email: string;
+  plan: 'individual' | 'team';
+  source: 'pricing' | 'settings' | 'checkout' | 'plan_limit' | 'other' | string;
+  message: string;
+  status: 'new' | 'contacted' | 'closed';
+  context: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+};
+
+export type SupportTicket = {
+  id: string;
+  org_id: string;
+  org_name?: string;
+  user_id: string | null;
+  email: string;
+  subject: string;
+  category: 'billing' | 'setup' | 'sdk' | 'agent_error' | 'bug' | 'other';
+  message: string;
+  status: 'open' | 'in_review' | 'closed';
+  priority: 'normal' | 'high';
+  plan: 'individual' | 'team' | string;
+  context: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+};
+
+export type AdminOrgRow = {
+  id: string;
+  name: string;
+  owner_email: string | null;
+  plan: 'free' | 'individual' | 'team';
+  agent_limit: number;
+  subscription_status: string;
+  current_period_end: string | null;
+  cancel_at_period_end: boolean;
+  has_stripe_customer: boolean;
+  has_stripe_subscription: boolean;
+  created_at: string;
+  agent_count: number;
+  connected_agent_count: number;
+  active_work_claims: number;
+  protected_resources: number;
+  api_calls_24h: number;
+  api_calls_month: number;
+  errors_24h: number;
+  last_activity_at: string | null;
+};
+
+export type AdminOrgDetail = {
+  org: {
+    id: string;
+    name: string;
+    plan: 'free' | 'individual' | 'team';
+    agent_limit: number;
+    subscription_status: string;
+    current_period_end: string | null;
+    cancel_at_period_end: boolean;
+    has_stripe_customer: boolean;
+    has_stripe_subscription: boolean;
+    created_at: string;
+  };
+  users: Array<{ id: string; email: string; role: string; created_at: string }>;
+  agents: Array<{
+    id: string;
+    name: string;
+    agent_type: string;
+    priority: number;
+    mcp_last_seen_at: string | null;
+    mcp_client_name: string | null;
+    created_at: string;
+    last_activity_at: string | null;
+    last_error_at: string | null;
+  }>;
+  usage: {
+    agents: number;
+    connected_agents: number;
+    protected_resources: number;
+    api_calls_24h: number;
+    api_calls_month: number;
+    errors_24h: number;
+    tokens_24h: number;
+    quiet_agents: number;
+    never_connected_agents: number;
+    conflicts_prevented_7d: number;
+    active_work_claims: number;
+    blocked_agent_runs: number;
+    last_activity_at: string | null;
+  };
+  recent_activity: Array<{
+    id: string;
+    agent_id: string | null;
+    agent_name: string | null;
+    activity_type: string;
+    endpoint: string | null;
+    method: string | null;
+    status_code: number | null;
+    status: 'success' | 'error';
+    error_code: string | null;
+    error_message: string | null;
+    created_at: string;
+  }>;
+  recent_hold_events: Array<{
+    id: string;
+    event_type: string;
+    agent_id: string | null;
+    agent_name: string | null;
+    rule_applied: string | null;
+    actor_type: string | null;
+    actor_label: string | null;
+    created_at: string;
+  }>;
+  recent_work_events: Array<{
+    id: string;
+    event_type: string;
+    agent_id: string | null;
+    agent_name: string | null;
+    resource_type: string | null;
+    resource_key: string | null;
+    rule_applied: string | null;
+    actor_type: string | null;
+    actor_label: string | null;
+    created_at: string;
+  }>;
+};
+
+export type AdminSystem = {
+  status: 'ok' | 'degraded' | 'error';
+  app: {
+    version: string;
+    git_commit: string;
+    node_version: string;
+    uptime_seconds: number;
+  };
+  database: {
+    connected: boolean;
+  };
+  migrations: {
+    total: number;
+    applied: number;
+    failed: number;
+    pending: number;
+    latest: {
+      filename: string;
+      status: string;
+      finished_at: string | null;
+      error_message: string | null;
+    } | null;
+  };
+  env: {
+    mode: string;
+    required: Array<{ name: string; required: boolean; configured: boolean }>;
+    optional: Array<{ name: string; required: boolean; configured: boolean }>;
+    missing: string[];
+    ok: boolean;
+  };
+  stripe: {
+    configured: boolean;
+    webhook_configured: boolean;
+    individual_price_configured: boolean;
+    team_price_configured: boolean;
+  };
+  latest_events: {
+    latest_activity_at: string | null;
+    latest_hold_event_at: string | null;
+    latest_work_event_at: string | null;
+  };
+  timestamp: string;
+};
+
+export async function getAdminOverview() {
+  return request<AdminOverview>('/v1/admin/overview');
+}
+
+export async function listAdminOrgs(input: {
+  plan?: 'free' | 'individual' | 'team';
+  q?: string;
+  active?: 'today' | '7d' | '30d';
+  limit?: number;
+  offset?: number;
+} = {}) {
+  const params = new URLSearchParams();
+  if (input.plan) params.set('plan', input.plan);
+  if (input.q) params.set('q', input.q);
+  if (input.active) params.set('active', input.active);
+  if (input.limit) params.set('limit', String(input.limit));
+  if (input.offset) params.set('offset', String(input.offset));
+
+  return request<{
+    orgs: AdminOrgRow[];
+    limit: number;
+    offset: number;
+    count: number;
+    total: number;
+  }>(`/v1/admin/orgs?${params.toString()}`);
+}
+
+export async function getAdminOrgDetail(orgId: string) {
+  return request<AdminOrgDetail>(`/v1/admin/orgs/${orgId}`);
+}
+
+export async function getAdminSystem() {
+  return request<AdminSystem>('/v1/admin/system');
+}
+
+export async function joinPaidPlanWaitlist(input: {
+  email: string;
+  plan: 'individual' | 'team';
+  source?: WaitlistLead['source'];
+  message?: string;
+  context?: Record<string, unknown>;
+}) {
+  return request<{ lead: WaitlistLead }>('/v1/waitlist', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export async function createSupportTicket(input: {
+  email: string;
+  subject: string;
+  category: SupportTicket['category'];
+  message: string;
+  context?: Record<string, unknown>;
+}) {
+  return request<{ ticket: SupportTicket }>('/v1/support/tickets', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+}
+
+export async function listAdminSupportTickets(input: {
+  status?: SupportTicket['status'];
+  plan?: 'individual' | 'team';
+  q?: string;
+  limit?: number;
+  offset?: number;
+} = {}) {
+  const params = new URLSearchParams();
+  if (input.status) params.set('status', input.status);
+  if (input.plan) params.set('plan', input.plan);
+  if (input.q) params.set('q', input.q);
+  if (input.limit) params.set('limit', String(input.limit));
+  if (input.offset) params.set('offset', String(input.offset));
+
+  return request<{
+    tickets: SupportTicket[];
+    limit: number;
+    offset: number;
+    count: number;
+    total: number;
+  }>(`/v1/admin/support/tickets?${params.toString()}`);
+}
+
+export async function updateAdminSupportTicket(ticketId: string, status: SupportTicket['status']) {
+  return request<{ ticket: SupportTicket }>(`/v1/admin/support/tickets/${ticketId}`, {
+    method: 'PUT',
+    body: JSON.stringify({ status }),
+  });
+}
+
+export async function listAdminWaitlist(input: {
+  status?: WaitlistLead['status'];
+  plan?: 'individual' | 'team';
+  q?: string;
+  limit?: number;
+  offset?: number;
+} = {}) {
+  const params = new URLSearchParams();
+  if (input.status) params.set('status', input.status);
+  if (input.plan) params.set('plan', input.plan);
+  if (input.q) params.set('q', input.q);
+  if (input.limit) params.set('limit', String(input.limit));
+  if (input.offset) params.set('offset', String(input.offset));
+
+  return request<{
+    leads: WaitlistLead[];
+    limit: number;
+    offset: number;
+    count: number;
+    total: number;
+  }>(`/v1/admin/waitlist?${params.toString()}`);
+}
+
+export async function updateAdminWaitlistLead(leadId: string, status: WaitlistLead['status']) {
+  return request<{ lead: WaitlistLead }>(`/v1/admin/waitlist/${leadId}`, {
+    method: 'PUT',
+    body: JSON.stringify({ status }),
+  });
+}
+
+export async function getActivityLog(input: {
+  limit?: number;
+  offset?: number;
+  agent_id?: string;
+  activity_type?: string;
+  status?: 'success' | 'error';
+  from?: string;
+  to?: string;
+} = {}) {
+  const params = new URLSearchParams();
+  if (input.limit) params.set('limit', String(input.limit));
+  if (input.offset) params.set('offset', String(input.offset));
+  if (input.agent_id) params.set('agent_id', input.agent_id);
+  if (input.activity_type) params.set('activity_type', input.activity_type);
+  if (input.status) params.set('status', input.status);
+  if (input.from) params.set('from', input.from);
+  if (input.to) params.set('to', input.to);
+
+  return request<{
+    events: Array<{
+      id: string;
+      org_id: string;
+      agent_id: string | null;
+      agent_name: string | null;
+      activity_type: string;
+      endpoint: string | null;
+      method: string | null;
+      status_code: number | null;
+      status: 'success' | 'error';
+      actor_type: string | null;
+      actor_label: string | null;
+      client_name: string | null;
+      latency_ms: number | null;
+      error_code: string | null;
+      error_message: string | null;
+      provider: string | null;
+      model: string | null;
+      input_tokens: number | null;
+      output_tokens: number | null;
+      total_tokens: number | null;
+      estimated_cost_usd: string | number | null;
+      metadata: Record<string, unknown> | null;
+      created_at: string;
+    }>;
+    limit: number;
+    offset: number;
+    count: number;
+  }>(`/v1/activity?${params.toString()}`);
+}
+
+export async function getAuditLog(input: {
+  limit?: number;
+  offset?: number;
+  agent_id?: string;
+  event_type?: string;
+}) {
+  const params = new URLSearchParams();
+  if (input.limit) params.set('limit', String(input.limit));
+  if (input.offset) params.set('offset', String(input.offset));
+  if (input.agent_id) params.set('agent_id', input.agent_id);
+  if (input.event_type) params.set('event_type', input.event_type);
+
+  return request<{
+    events: Array<{
+      id: string;
+      hold_id: string;
+      event_type: string;
+      agent_id: string;
+      agent_name: string;
+      org_id: string;
+      conflicting_hold_id: string | null;
+      rule_applied: string | null;
+      metadata: Record<string, unknown> | null;
+      actor_type: string | null;
+      actor_id: string | null;
+      actor_label: string | null;
+      created_at: string;
+    }>;
+    limit: number;
+    offset: number;
+    count: number;
+  }>(`/v1/audit?${params.toString()}`);
+}
+
+export async function getAvailabilityWindows(input: {
+  agent_id: string;
+  from?: string;
+  to?: string;
+  apiKey?: string;
+}) {
+  const params = new URLSearchParams({ agent_id: input.agent_id });
+  if (input.from) params.set('from', input.from);
+  if (input.to) params.set('to', input.to);
+
+  const response = await request<{ windows: unknown[] }>(
+    `/v1/availability-windows?${params.toString()}`,
+    { headers: authHeaders(input.apiKey) },
+  );
+  return response.windows.map((w) => availabilityWindowSchema.parse(w));
+}
+
+export async function getPreferences(agentId: string, apiKey?: string) {
+  return request<{
+    preferences: {
+      agent_id: string;
+      buffer_minutes_after: number;
+      buffer_minutes_before: number;
+      focus_blocks: Array<{ weekday: number; start_time: string; end_time: string }>;
+      priority_over_agents: string[];
+      booking_window_days: number;
+      allow_back_to_back: boolean;
+    };
+  }>(`/v1/preferences/${agentId}`, {
+    headers: authHeaders(apiKey),
+  });
+}
+
+export async function updatePreferences(
+  agentId: string,
+  data: Record<string, unknown>,
+  apiKey?: string,
+) {
+  return request<{ preferences: unknown }>(`/v1/preferences/${agentId}`, {
+    method: 'PUT',
+    headers: authHeaders(apiKey),
+    body: JSON.stringify(data),
+  });
+}