@critical-path/client 0.20.4 → 0.20.6

package/src/index.ts

@@ -1,888 +0,0 @@
-import type {
-  CreateWorkflowBody,
-  UpdateWorkflowBody,
-  CreateProjectBody,
-  UpdateProjectBody,
-  CreateTaskBody,
-  UpdateTaskBody,
-  CreateDependencyBody,
-  CreateTeamBody,
-  UpdateTeamBody,
-  CreateContainerBody,
-  UpdateContainerBody,
-  CreateDeliverableBody,
-  UpdateDeliverableBody,
-  CreateIterationBody,
-  UpdateIterationBody,
-  CreateCommentBody,
-  UpdateCommentBody,
-  CommentReactionBody,
-  CreateAttachmentBody,
-  UploadAttachmentBody,
-  PresignAttachmentBody,
-  LogTimeBody,
-  CreateWebhookBody,
-  UpdateWebhookBody
-} from '@critical-path/core/schemas';
-import type {
-  ActivityQuery,
-  Page,
-  TaskQuery,
-  PublicWebhook,
-  TaskDependency,
-  Project,
-  Task,
-  TaskTodoItem,
-  TaskStatus,
-  Priority,
-  TaskDependencyGraph,
-  Team,
-  TaskContainer,
-  Iteration,
-  Activity,
-  Comment,
-  CommentReaction,
-  Attachment,
-  PresignedUrlOptions,
-  PresignedUploadResult,
-  TimeEntry,
-  Workflow,
-  Deliverable,
-  DeliverableSummary,
-  CreateDeliverableInput,
-  SemanticStatus,
-  StatusDefinition,
-  TaskDerivedStatus,
-  TaskLifecycleState,
-  CriticalPathAnalysis,
-  TimelineLadder,
-  TimelineLadderOptions,
-  TaskLadderView,
-  MacroTimelineSummary,
-  MacroPhaseRollup,
-  StandardTaskTimelineItem,
-  ConcreteTaskEvidence,
-  RealityDelta,
-  TaskMetrics,
-  TaskProgressHistory,
-  TaskProgressInference,
-  TaskEVM,
-  TaskInferredActuals,
-  ProgressInferenceSource,
-  ProgressCurveProfile,
-  WorkloadDistribution,
-  WorkloadBucket,
-  WorkloadDistributionOptions,
-  WorkloadInterval,
-  WorkloadGroupBy,
-  WorkloadMetric
-} from '@critical-path/core';
-
-export type {
-  TaskTodoItem,
-  TaskStatus,
-  Priority,
-  SemanticStatus,
-  StatusDefinition,
-  TaskDerivedStatus,
-  TaskLifecycleState,
-  CriticalPathAnalysis,
-  TimelineLadder,
-  TimelineLadderOptions,
-  TaskLadderView,
-  MacroTimelineSummary,
-  MacroPhaseRollup,
-  StandardTaskTimelineItem,
-  ConcreteTaskEvidence,
-  RealityDelta,
-  TaskMetrics,
-  TaskProgressHistory,
-  TaskProgressInference,
-  TaskEVM,
-  TaskInferredActuals,
-  ProgressInferenceSource,
-  ProgressCurveProfile,
-  WorkloadDistribution,
-  WorkloadBucket,
-  WorkloadDistributionOptions,
-  WorkloadInterval,
-  WorkloadGroupBy,
-  WorkloadMetric
-};
-
-export interface UpdateStatusOptions {
-  taskId?: string;
-  projectId?: string;
-  details?: string;
-  isEngaged?: boolean;
-}
-
-export interface UpdateStatusResult {
-  success: boolean;
-  status: string;
-  timestamp: number;
-}
-
-type HeaderMap = Record<string, string>;
-
-export interface ClientOptions {
-  /** API base URL, e.g. `http://localhost:3000/api/critical-path`. */
-  baseUrl: string;
-  /**
-   * Headers sent with every request. Pass a function to compute them per request, e.g. to attach
-   * a freshly refreshed access token: `headers: async () => ({ Authorization: `Bearer ${await getToken()}` })`.
-   */
-  headers?: HeaderMap | (() => HeaderMap | Promise<HeaderMap>);
-  fetch?: typeof fetch;
-  /** Abort requests that take longer than this. Default: no timeout. */
-  timeoutMs?: number;
-  /**
-   * Retry GET requests that fail with a network error, 429, 502, 503 or 504. Default: no retries.
-   * Delays double from `baseDelayMs` (default 250 ms) and honour `Retry-After` on 429/503.
-   */
-  retry?: { retries: number; baseDelayMs?: number };
-}
-
-/** Per-call options for a scoped client (see `CriticalPathClient.with`). */
-export interface RequestOptions {
-  signal?: AbortSignal;
-  headers?: HeaderMap;
-  timeoutMs?: number;
-}
-
-/**
- * Error thrown for non-2xx responses. Carries the HTTP status and the server's error details
- * (`issues` for validation errors, `cyclePath` for dependency cycles, and so on).
- */
-export class CriticalPathError extends Error {
-  /** HTTP status code. */
-  readonly status: number;
-  /** Field-level validation problems for 400 responses. */
-  readonly issues?: Array<{ path: string; message: string }>;
-  /** The parsed JSON error body, if any (e.g. `fromStatus`, `toStatus`, `cyclePath`, `fieldKey`). */
-  readonly body?: Record<string, unknown>;
-
-  constructor(message: string, status: number, body?: Record<string, unknown>) {
-    super(message);
-    this.name = 'CriticalPathError';
-    this.status = status;
-    this.body = body;
-    this.issues = Array.isArray(body?.issues) ? (body!.issues as CriticalPathError['issues']) : undefined;
-  }
-
-  get isNotFound(): boolean {
-    return this.status === 404;
-  }
-}
-
-const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
-const sleep = (ms: number, signal?: AbortSignal | null) =>
-  new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(resolve, ms);
-    signal?.addEventListener('abort', () => {
-      clearTimeout(timer);
-      reject(signal.reason);
-    }, { once: true });
-  });
-
-function toBase64(data: Uint8Array | ArrayBuffer): string {
-  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-  let binary = '';
-  for (let i = 0; i < bytes.length; i += 0x8000) {
-    binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
-  }
-  return btoa(binary);
-}
-
-export class CriticalPathClient {
-  private readonly baseUrl: string;
-  private readonly options: ClientOptions;
-  private readonly customFetch: typeof fetch;
-  /** Set on scoped clients created by `with()`. */
-  private readonly requestOptions?: RequestOptions;
-
-  constructor(options: ClientOptions) {
-    this.options = options;
-    this.baseUrl = options.baseUrl.replace(/\/+$/, '');
-    this.customFetch = options.fetch || ((...args) => globalThis.fetch(...args));
-  }
-
-  /**
-   * Returns a client that applies `options` to every call, e.g. to cancel requests when a
-   * component unmounts: `client.with({ signal: controller.signal }).getTasks(projectId)`.
-   */
-  with(options: RequestOptions): CriticalPathClient {
-    const scoped = Object.create(this) as CriticalPathClient;
-    const merged: RequestOptions = {
-      ...this.requestOptions,
-      ...options,
-      headers: { ...this.requestOptions?.headers, ...options.headers }
-    };
-    Object.defineProperty(scoped, 'requestOptions', { value: merged });
-    return scoped;
-  }
-
-  /**
-   * Sends a DELETE and resolves to `false` when the resource does not exist (HTTP 404),
-   * so delete methods keep their boolean contract instead of throwing.
-   */
-  private async deleteRequest(endpoint: string): Promise<boolean> {
-    try {
-      const res = await this.request<{ success: boolean }>(endpoint, { method: 'DELETE' });
-      return res.success;
-    } catch (err) {
-      if (err instanceof CriticalPathError && err.isNotFound) return false;
-      throw err;
-    }
-  }
-
-  private async request<T>(endpoint: string, init: RequestInit = {}): Promise<T> {
-    const url = `${this.baseUrl}${endpoint.startsWith('/') ? endpoint : `/${endpoint}`}`;
-    const method = (init.method ?? 'GET').toUpperCase();
-    const configured = typeof this.options.headers === 'function' ? await this.options.headers() : this.options.headers;
-    const headers: HeaderMap = {
-      ...(init.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
-      ...configured,
-      ...this.requestOptions?.headers
-    };
-    const timeoutMs = this.requestOptions?.timeoutMs ?? this.options.timeoutMs;
-    const signals = [this.requestOptions?.signal, timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined].filter(
-      (s): s is AbortSignal => !!s
-    );
-    const signal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
-    const retries = method === 'GET' ? this.options.retry?.retries ?? 0 : 0;
-    const baseDelay = this.options.retry?.baseDelayMs ?? 250;
-
-    for (let attempt = 0; ; attempt++) {
-      let response: Response;
-      try {
-        response = await this.customFetch(url, { ...init, method, headers, signal });
-      } catch (err) {
-        // Network failure; never retry after an abort or timeout.
-        if (attempt < retries && !signal?.aborted) {
-          await sleep(baseDelay * 2 ** attempt, signal);
-          continue;
-        }
-        throw err;
-      }
-
-      if (response.ok) return response.json() as Promise<T>;
-
-      if (attempt < retries && RETRYABLE_STATUSES.has(response.status)) {
-        const retryAfter = Number(response.headers.get('Retry-After'));
-        await sleep(Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1000 : baseDelay * 2 ** attempt, signal);
-        continue;
-      }
-
-      let body: Record<string, unknown> | undefined;
-      try {
-        body = await response.json();
-      } catch {
-        // Non-JSON error body
-      }
-      const message = typeof body?.error === 'string' ? body.error : `HTTP Error ${response.status}: ${response.statusText}`;
-      throw new CriticalPathError(message, response.status, body);
-    }
-  }
-
-
-  // Workflows
-  async getWorkflows(): Promise<Workflow[]> {
-    const res = await this.request<{ workflows: Workflow[] }>('/workflows');
-    return res.workflows;
-  }
-
-  async getWorkflow(id: string): Promise<Workflow> {
-    const res = await this.request<{ workflow: Workflow }>(`/workflows/${encodeURIComponent(id)}`);
-    return res.workflow;
-  }
-
-  async createWorkflow(data: CreateWorkflowBody): Promise<Workflow> {
-    const res = await this.request<{ workflow: Workflow }>('/workflows', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.workflow;
-  }
-
-  async updateWorkflow(id: string, updates: UpdateWorkflowBody): Promise<Workflow> {
-    const res = await this.request<{ workflow: Workflow }>(`/workflows/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      body: JSON.stringify(updates)
-    });
-    return res.workflow;
-  }
-
-  async deleteWorkflow(id: string): Promise<boolean> {
-    return this.deleteRequest(`/workflows/${encodeURIComponent(id)}`);
-  }
-
-  // Projects
-  async getProjects(): Promise<Project[]> {
-    const res = await this.request<{ projects: Project[] }>('/projects');
-    return res.projects;
-  }
-
-  async getProject(id: string): Promise<Project> {
-    const res = await this.request<{ project: Project }>(`/projects/${encodeURIComponent(id)}`);
-    return res.project;
-  }
-
-  async createProject(data: CreateProjectBody): Promise<Project> {
-    const res = await this.request<{ project: Project }>('/projects', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.project;
-  }
-
-  async updateProject(id: string, updates: UpdateProjectBody): Promise<Project> {
-    const res = await this.request<{ project: Project }>(`/projects/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      body: JSON.stringify(updates)
-    });
-    return res.project;
-  }
-
-  /** Deletes a project and its tasks. Resolves to `false` if it does not exist. */
-  async deleteProject(id: string): Promise<boolean> {
-    return this.deleteRequest(`/projects/${encodeURIComponent(id)}`);
-  }
-
-  async calculateCriticalPath(projectId: string): Promise<CriticalPathAnalysis> {
-    const res = await this.request<{ analysis: CriticalPathAnalysis }>(
-      `/projects/${encodeURIComponent(projectId)}/critical-path`
-    );
-    return res.analysis;
-  }
-
-  async getTimelineLadder(
-    projectId: string,
-    options: TimelineLadderOptions = {}
-  ): Promise<TimelineLadder> {
-    const params = new URLSearchParams();
-    if (options.level) params.set('level', options.level);
-    if (options.containerId) params.set('containerId', options.containerId);
-    if (options.iterationId) params.set('iterationId', options.iterationId);
-    const qs = params.toString();
-    const query = qs ? `?${qs}` : '';
-    const res = await this.request<{ ladder: TimelineLadder }>(
-      `/projects/${encodeURIComponent(projectId)}/ladder${query}`
-    );
-    return res.ladder;
-  }
-
-  async getWorkloadDistribution(
-    projectId?: string,
-    options: WorkloadDistributionOptions = {}
-  ): Promise<WorkloadDistribution> {
-    const params = new URLSearchParams();
-    if (options.startDate) params.set('startDate', options.startDate);
-    if (options.endDate) params.set('endDate', options.endDate);
-    if (options.interval) params.set('interval', options.interval);
-    if (options.groupBy) params.set('groupBy', options.groupBy);
-    if (options.metric) params.set('metric', options.metric);
-    if (typeof options.defaultWeeklyCapacityHours === 'number') {
-      params.set('defaultWeeklyCapacityHours', options.defaultWeeklyCapacityHours.toString());
-    }
-
-    const path = projectId
-      ? `/projects/${encodeURIComponent(projectId)}/workload`
-      : '/workload';
-    const qs = params.toString();
-    const query = qs ? `?${qs}` : '';
-
-    const res = await this.request<{ workload: WorkloadDistribution }>(`${path}${query}`);
-    return res.workload;
-  }
-
-  // Tasks
-  /** All tasks (optionally in one project), following pagination. Prefer `queryTasks` for large lists. */
-  async getTasks(projectId?: string): Promise<Task[]> {
-    return this.collectPages((cursor) => this.queryTasks({ projectId, cursor, limit: 500 }));
-  }
-
-  /**
-   * One page of tasks, oldest first. Filters: `status` and `priority` (arrays), `assigneeId`,
-   * `iterationId`, `deliverableId`, `containerId`, `parentId` (`null` for top-level tasks).
-   */
-  async queryTasks(query: TaskQuery = {}): Promise<Page<Task>> {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(query)) {
-      if (value === undefined || key === 'projectIds') continue;
-      if (key === 'parentId' && value === null) params.set('parentId', 'none');
-      else params.set(key, Array.isArray(value) ? value.join(',') : String(value));
-    }
-    const qs = params.size ? `?${params}` : '';
-    const res = await this.request<{ tasks: Task[]; nextCursor?: string }>(`/tasks${qs}`);
-    return { items: res.tasks, nextCursor: res.nextCursor };
-  }
-
-  private async collectPages<T>(fetchPage: (cursor?: string) => Promise<Page<T>>): Promise<T[]> {
-    const items: T[] = [];
-    let cursor: string | undefined;
-    do {
-      const page = await fetchPage(cursor);
-      items.push(...page.items);
-      cursor = page.nextCursor;
-    } while (cursor);
-    return items;
-  }
-
-  async getTask(id: string): Promise<Task> {
-    const res = await this.request<{ task: Task }>(`/tasks/${encodeURIComponent(id)}`);
-    return res.task;
-  }
-
-  async getTaskLadder(taskId: string): Promise<TaskLadderView> {
-    const res = await this.request<{ taskLadder: TaskLadderView }>(
-      `/tasks/${encodeURIComponent(taskId)}/ladder`
-    );
-    return res.taskLadder;
-  }
-
-  async getTaskMetrics(taskId: string): Promise<TaskMetrics> {
-    const res = await this.request<{ metrics: TaskMetrics }>(
-      `/tasks/${encodeURIComponent(taskId)}/metrics`
-    );
-    return res.metrics;
-  }
-
-  async getTaskProgressHistory(taskId: string): Promise<TaskProgressHistory> {
-    const res = await this.request<{ progressHistory: TaskProgressHistory }>(
-      `/tasks/${encodeURIComponent(taskId)}/progress-history`
-    );
-    return res.progressHistory;
-  }
-
-  async createTask(data: CreateTaskBody): Promise<Task> {
-    const res = await this.request<{ task: Task }>('/tasks', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.task;
-  }
-
-  async updateTask(id: string, updates: UpdateTaskBody): Promise<Task> {
-    const res = await this.request<{ task: Task }>(`/tasks/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      body: JSON.stringify(updates)
-    });
-    return res.task;
-  }
-
-  async createSubtask(
-    parentTaskId: string,
-    data: {
-      title: string;
-      description?: string;
-      status?: TaskStatus;
-      priority?: Priority;
-      projectId?: string;
-      assigneeId?: string;
-      customFields?: Record<string, unknown>;
-    }
-  ): Promise<Task> {
-    let projectId = data.projectId;
-    if (!projectId) {
-      const parentTask = await this.getTask(parentTaskId);
-      projectId = parentTask.projectId;
-    }
-    return this.createTask({
-      projectId,
-      title: data.title,
-      description: data.description,
-      parentId: parentTaskId,
-      status: data.status || 'todo',
-      priority: data.priority || 'medium',
-      assigneeId: data.assigneeId,
-      customFields: data.customFields
-    });
-  }
-
-  async addTodo(
-    taskId: string,
-    title: string
-  ): Promise<TaskTodoItem> {
-    const task = await this.getTask(taskId);
-    const item: TaskTodoItem = {
-      id: `todo_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`,
-      title,
-      completed: false,
-      createdAt: new Date().toISOString()
-    };
-    const todos = [...(task.todos || []), item];
-    await this.updateTask(taskId, { todos });
-    return item;
-  }
-
-  async toggleTodo(
-    taskId: string,
-    todoIdOrTitle: string,
-    completed?: boolean
-  ): Promise<Task> {
-    const task = await this.getTask(taskId);
-    if (!task.todos || task.todos.length === 0) {
-      throw new Error(`Task ${taskId} has no checklist items.`);
-    }
-    const item = task.todos.find(
-      (t) => t.id === todoIdOrTitle || t.title.toLowerCase() === todoIdOrTitle.toLowerCase()
-    );
-    if (!item) {
-      throw new Error(`Checklist item "${todoIdOrTitle}" not found on task ${taskId}.`);
-    }
-    item.completed = completed !== undefined ? completed : !item.completed;
-    item.completedAt = item.completed ? new Date().toISOString() : undefined;
-    return this.updateTask(taskId, { todos: task.todos });
-  }
-
-  // Webhooks
-  async getWebhooks(): Promise<PublicWebhook[]> {
-    return (await this.request<{ webhooks: PublicWebhook[] }>('/webhooks')).webhooks;
-  }
-
-  async getWebhook(id: string): Promise<PublicWebhook> {
-    return (await this.request<{ webhook: PublicWebhook }>(`/webhooks/${encodeURIComponent(id)}`)).webhook;
-  }
-
-  /** Registers a webhook. The returned `secret` is shown only once; store it to verify deliveries. */
-  async createWebhook(data: CreateWebhookBody): Promise<{ webhook: PublicWebhook; secret: string }> {
-    return this.request<{ webhook: PublicWebhook; secret: string }>('/webhooks', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-  }
-
-  async updateWebhook(id: string, updates: UpdateWebhookBody): Promise<PublicWebhook> {
-    const res = await this.request<{ webhook: PublicWebhook }>(`/webhooks/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      body: JSON.stringify(updates)
-    });
-    return res.webhook;
-  }
-
-  async deleteWebhook(id: string): Promise<boolean> {
-    return this.deleteRequest(`/webhooks/${encodeURIComponent(id)}`);
-  }
-
-  /** Declares that `taskId` depends on another task. Rejects with a 409 error on cycles. */
-  async addDependency(taskId: string, data: CreateDependencyBody): Promise<TaskDependency> {
-    const res = await this.request<{ dependency: TaskDependency }>(`/tasks/${encodeURIComponent(taskId)}/dependencies`, {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.dependency;
-  }
-
-  /**
-   * Deletes a task with its subtasks, dependencies, comments, attachments and time entries.
-   * Pass `{ subtasks: 'detach' }` to keep subtasks (their parent link is cleared).
-   */
-  async deleteTask(id: string, options: { subtasks?: 'delete' | 'detach' } = {}): Promise<boolean> {
-    const query = options.subtasks ? `?subtasks=${options.subtasks}` : '';
-    return this.deleteRequest(`/tasks/${encodeURIComponent(id)}${query}`);
-  }
-
-  async removeDependency(taskId: string, dependencyId: string): Promise<boolean> {
-    return this.deleteRequest(`/tasks/${encodeURIComponent(taskId)}/dependencies/${encodeURIComponent(dependencyId)}`);
-  }
-
-  async getTaskDependencies(taskId: string): Promise<TaskDependencyGraph> {
-    const res = await this.request<{ graph: TaskDependencyGraph }>(`/tasks/${encodeURIComponent(taskId)}/dependencies`);
-    return res.graph;
-  }
-
-  async getTaskLifecycleState(taskId: string): Promise<TaskDerivedStatus> {
-    const res = await this.request<{ state: TaskDerivedStatus }>(`/tasks/${encodeURIComponent(taskId)}/lifecycle`);
-    return res.state;
-  }
-
-  async getAllowedTaskTransitions(taskId: string): Promise<string[]> {
-    const res = await this.request<{ allowedNextStatuses: string[]; allowedPreviousStatuses?: string[] }>(`/tasks/${encodeURIComponent(taskId)}/transitions`);
-    return res.allowedNextStatuses;
-  }
-
-  async getAllowedPreviousTaskTransitions(taskId: string): Promise<string[]> {
-    const res = await this.request<{ allowedNextStatuses: string[]; allowedPreviousStatuses?: string[] }>(`/tasks/${encodeURIComponent(taskId)}/transitions`);
-    return res.allowedPreviousStatuses || [];
-  }
-
-  // Teams
-  async getTeams(): Promise<Team[]> {
-    const res = await this.request<{ teams: Team[] }>('/teams');
-    return res.teams;
-  }
-
-  async getTeam(id: string): Promise<Team> {
-    const res = await this.request<{ team: Team }>(`/teams/${encodeURIComponent(id)}`);
-    return res.team;
-  }
-
-  async createTeam(data: CreateTeamBody): Promise<Team> {
-    const res = await this.request<{ team: Team }>('/teams', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.team;
-  }
-
-  async updateTeam(id: string, updates: UpdateTeamBody): Promise<Team> {
-    const res = await this.request<{ team: Team }>(`/teams/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      body: JSON.stringify(updates)
-    });
-    return res.team;
-  }
-
-  async deleteTeam(id: string): Promise<boolean> {
-    return this.deleteRequest(`/teams/${encodeURIComponent(id)}`);
-  }
-
-  // Containers
-  async getContainers(projectId: string): Promise<TaskContainer[]> {
-    const res = await this.request<{ containers: TaskContainer[] }>(`/containers?projectId=${encodeURIComponent(projectId)}`);
-    return res.containers;
-  }
-
-  async getContainer(id: string): Promise<TaskContainer> {
-    return (await this.request<{ container: TaskContainer }>(`/containers/${encodeURIComponent(id)}`)).container;
-  }
-
-  async createContainer(data: CreateContainerBody): Promise<TaskContainer> {
-    const res = await this.request<{ container: TaskContainer }>('/containers', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.container;
-  }
-
-  async updateContainer(id: string, updates: UpdateContainerBody): Promise<TaskContainer> {
-    const res = await this.request<{ container: TaskContainer }>(`/containers/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      body: JSON.stringify(updates)
-    });
-    return res.container;
-  }
-
-  async deleteContainer(id: string): Promise<boolean> {
-    return this.deleteRequest(`/containers/${encodeURIComponent(id)}`);
-  }
-
-  // Deliverables
-  async getDeliverables(projectId: string): Promise<Deliverable[]> {
-    const res = await this.request<{ deliverables: Deliverable[] }>(`/deliverables?projectId=${encodeURIComponent(projectId)}`);
-    return res.deliverables;
-  }
-
-  async getDeliverable(id: string): Promise<Deliverable> {
-    const res = await this.request<{ deliverable: Deliverable }>(`/deliverables/${encodeURIComponent(id)}`);
-    return res.deliverable;
-  }
-
-  async getDeliverableSummary(id: string): Promise<DeliverableSummary> {
-    const res = await this.request<{ summary: DeliverableSummary }>(`/deliverables/${encodeURIComponent(id)}/summary`);
-    return res.summary;
-  }
-
-  async createDeliverable(data: CreateDeliverableBody): Promise<Deliverable> {
-    const res = await this.request<{ deliverable: Deliverable }>('/deliverables', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.deliverable;
-  }
-
-  async updateDeliverable(id: string, updates: UpdateDeliverableBody): Promise<Deliverable> {
-    const res = await this.request<{ deliverable: Deliverable }>(`/deliverables/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      body: JSON.stringify(updates)
-    });
-    return res.deliverable;
-  }
-
-  async deleteDeliverable(id: string): Promise<boolean> {
-    return this.deleteRequest(`/deliverables/${encodeURIComponent(id)}`);
-  }
-
-  // Iterations
-  async getIterations(projectId: string): Promise<Iteration[]> {
-    const res = await this.request<{ iterations: Iteration[] }>(`/iterations?projectId=${encodeURIComponent(projectId)}`);
-    return res.iterations;
-  }
-
-  async getIteration(id: string): Promise<Iteration> {
-    return (await this.request<{ iteration: Iteration }>(`/iterations/${encodeURIComponent(id)}`)).iteration;
-  }
-
-  async createIteration(data: CreateIterationBody): Promise<Iteration> {
-    const res = await this.request<{ iteration: Iteration }>('/iterations', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.iteration;
-  }
-
-  async updateIteration(id: string, updates: UpdateIterationBody): Promise<Iteration> {
-    const res = await this.request<{ iteration: Iteration }>(`/iterations/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      body: JSON.stringify(updates)
-    });
-    return res.iteration;
-  }
-
-  async deleteIteration(id: string): Promise<boolean> {
-    return this.deleteRequest(`/iterations/${encodeURIComponent(id)}`);
-  }
-
-  // Activity Stream
-  /** The whole activity feed (newest first), following pagination. Prefer `queryActivities` for feeds. */
-  async getActivities(filter?: { projectId?: string; taskId?: string }): Promise<Activity[]> {
-    return this.collectPages((cursor) => this.queryActivities({ ...filter, cursor, limit: 500 }));
-  }
-
-  /** One page of the activity feed, newest first. */
-  async queryActivities(query: ActivityQuery = {}): Promise<Page<Activity>> {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(query)) {
-      if (value !== undefined && key !== 'projectIds') params.set(key, String(value));
-    }
-    const qs = params.size ? `?${params}` : '';
-    const res = await this.request<{ activities: Activity[]; nextCursor?: string }>(`/activities${qs}`);
-    return { items: res.activities, nextCursor: res.nextCursor };
-  }
-
-  // Comments
-  async getComments(taskId: string): Promise<Comment[]> {
-    const res = await this.request<{ comments: Comment[] }>(`/comments?taskId=${encodeURIComponent(taskId)}`);
-    return res.comments;
-  }
-
-  async getComment(id: string): Promise<Comment> {
-    const res = await this.request<{ comment: Comment }>(`/comments/${encodeURIComponent(id)}`);
-    return res.comment;
-  }
-
-  async addComment(data: CreateCommentBody): Promise<Comment> {
-    const res = await this.request<{ comment: Comment }>('/comments', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.comment;
-  }
-
-  async updateComment(id: string, updates: UpdateCommentBody): Promise<Comment> {
-    const res = await this.request<{ comment: Comment }>(`/comments/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      body: JSON.stringify(updates)
-    });
-    return res.comment;
-  }
-
-  async deleteComment(id: string): Promise<boolean> {
-    return this.deleteRequest(`/comments/${encodeURIComponent(id)}`);
-  }
-
-  async addCommentReaction(commentId: string, reaction: CommentReactionBody): Promise<Comment> {
-    const res = await this.request<{ comment: Comment }>(`/comments/${encodeURIComponent(commentId)}/reactions`, {
-      method: 'POST',
-      body: JSON.stringify(reaction)
-    });
-    return res.comment;
-  }
-
-  async removeCommentReaction(commentId: string, reaction: CommentReactionBody): Promise<Comment> {
-    const query = new URLSearchParams({ emoji: reaction.emoji });
-    const res = await this.request<{ comment: Comment }>(
-      `/comments/${encodeURIComponent(commentId)}/reactions?${query}`,
-      { method: 'DELETE' }
-    );
-    return res.comment;
-  }
-
-  // Attachments
-  async getAttachments(filter?: { taskId?: string; projectId?: string; commentId?: string }): Promise<Attachment[]> {
-    const params = new URLSearchParams();
-    if (filter?.taskId) params.set('taskId', filter.taskId);
-    if (filter?.projectId) params.set('projectId', filter.projectId);
-    if (filter?.commentId) params.set('commentId', filter.commentId);
-    const query = params.toString() ? `?${params.toString()}` : '';
-    const res = await this.request<{ attachments: Attachment[] }>(`/attachments${query}`);
-    return res.attachments;
-  }
-
-  async getAttachment(id: string): Promise<Attachment> {
-    const res = await this.request<{ attachment: Attachment }>(`/attachments/${encodeURIComponent(id)}`);
-    return res.attachment;
-  }
-
-  async createAttachment(data: CreateAttachmentBody): Promise<Attachment> {
-    const res = await this.request<{ attachment: Attachment }>('/attachments', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.attachment;
-  }
-
-  /**
-   * Uploads a file through the server's FileStorageAdapter. Binary data is sent base64-encoded.
-   */
-  async uploadAttachmentFile(
-    data: Omit<UploadAttachmentBody, 'data'> & { data: string | Uint8Array | ArrayBuffer }
-  ): Promise<Attachment> {
-    const body: UploadAttachmentBody =
-      typeof data.data === 'string'
-        ? { ...data, data: data.data }
-        : { ...data, data: toBase64(data.data), encoding: 'base64' };
-    const res = await this.request<{ attachment: Attachment }>('/attachments/upload', {
-      method: 'POST',
-      body: JSON.stringify(body)
-    });
-    return res.attachment;
-  }
-
-  async deleteAttachment(id: string): Promise<boolean> {
-    return this.deleteRequest(`/attachments/${encodeURIComponent(id)}`);
-  }
-
-  async getPresignedAttachmentUploadUrl(options: PresignAttachmentBody): Promise<PresignedUploadResult> {
-    const res = await this.request<{ presigned: PresignedUploadResult }>('/attachments/presign', {
-      method: 'POST',
-      body: JSON.stringify(options)
-    });
-    return res.presigned;
-  }
-
-  // Time Entries
-  async getTimeEntries(taskId: string): Promise<TimeEntry[]> {
-    const res = await this.request<{ timeEntries: TimeEntry[] }>(`/time-entries?taskId=${encodeURIComponent(taskId)}`);
-    return res.timeEntries;
-  }
-
-  async logTime(data: LogTimeBody): Promise<TimeEntry> {
-    const res = await this.request<{ timeEntry: TimeEntry }>('/time-entries', {
-      method: 'POST',
-      body: JSON.stringify(data)
-    });
-    return res.timeEntry;
-  }
-
-  // Agent Status / Telemetry
-  async updateStatus(
-    status: string,
-    options?: UpdateStatusOptions
-  ): Promise<UpdateStatusResult> {
-    const res = await this.request<UpdateStatusResult>('/status', {
-      method: 'POST',
-      body: JSON.stringify({
-        status,
-        taskId: options?.taskId,
-        projectId: options?.projectId,
-        details: options?.details,
-        isEngaged: options?.isEngaged ?? true
-      })
-    });
-    return res;
-  }
-}
-
-export type { CommentReaction };