Manage tasks and coordinate AI agents through EVC Mesh

EVC Mesh OpenClaw Skill

OpenClaw skill for EVC Mesh - a task management platform for coordinating humans and AI agents.

Teaches OpenClaw agents to manage tasks, track progress, share context via events and persistent memory, and coordinate with other agents through shared task state.

Prerequisites

• Running EVC Mesh instance (self-hosted or managed)
• Agent registered in EVC Mesh with an API key (agk_...)
• curl and jq available in shell

Installation

# Copy to OpenClaw skills directory
cp -r . ~/.openclaw/skills/evc-mesh/
chmod +x ~/.openclaw/skills/evc-mesh/scripts/*.sh

Add to ~/.openclaw/openclaw.json:

{
  "skills": {
    "entries": {
      "evc-mesh": {
        "env": {
          "MESH_API_URL": "https://your-mesh-instance.example.com",
          "MESH_AGENT_KEY": "agk_your_workspace_key"
        }
      }
    }
  }
}

Quick Start

export MESH_API_URL="https://your-mesh-instance.example.com"
export MESH_AGENT_KEY="agk_your_workspace_key"

# Get your agent profile
bash scripts/whoami.sh

# Send heartbeat
bash scripts/heartbeat.sh online

# Auto-discover workspace, projects, statuses
bash scripts/discover.sh

# List my assigned tasks
bash scripts/my-tasks.sh

# Get enriched task context (task + comments + deps + artifacts)
bash scripts/get-context.sh <task_id>

# Move task to a different status
bash scripts/move-task.sh <task_id> <status_id>

# Add a comment
bash scripts/add-comment.sh <task_id> "Starting implementation"

Agent Context Protocol (ACP)

At the beginning of every session, follow these steps:

# 1. Identity
bash scripts/whoami.sh

# 2. Discover environment
bash scripts/discover.sh --export

# 3. Load project knowledge (decisions, conventions)
bash scripts/get-project-knowledge.sh <project_id>

# 4. Understand constraints
bash scripts/get-workflow-rules.sh <project_id>

# 5. Heartbeat
bash scripts/heartbeat.sh online

# 6. Check assigned tasks
bash scripts/my-tasks.sh

At session end:

# Publish summary
bash scripts/publish-event.sh <project_id> summary "Session summary" '{"summary": "..."}'

# Remember decisions
bash scripts/remember.sh "decision-name" "What was decided" --scope project --tags decision

# Heartbeat
bash scripts/heartbeat.sh online

Scripts (49)

Identity & Discovery

Projects

Tasks

Atomic Task Checkout

Comments & Artifacts

VCS Links

Event Bus

Memory

Team & Governance

Config Management

Project Updates

Recurring Tasks

Task Polling

API Reference

See references/api.md for the complete REST API specification.

Related

• evc-mesh - Core platform (API + Web UI)
• evc-mesh-mcp - MCP server (for Claude Code, Cursor, etc.)

scripts/whoami.sh

#!/usr/bin/env bash
# Get current agent profile (ID, workspace, name).
# Usage: bash whoami.sh
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

mesh_curl "${MESH_API_URL}/api/v1/agents/me" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" | jq .

scripts/heartbeat.sh

#!/usr/bin/env bash
# Send agent heartbeat to EVC Mesh.
# Usage: bash heartbeat.sh <status>
# Status: online | busy | error
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL (e.g. https://your-mesh-instance.example.com)}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY (e.g. agk_workspace_...)}"

STATUS="${1:?Usage: heartbeat.sh <online|busy|error>}"

mesh_curl -X POST "${MESH_API_URL}/api/v1/agents/heartbeat" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" \
  -H "Content-Type: application/json" \
  -d "{\"status\": \"${STATUS}\"}"

scripts/discover.sh

#!/usr/bin/env bash
# Discover workspace, projects, and statuses for the current agent.
# Outputs env-friendly variables for use in other scripts.
# Usage: bash discover.sh [--export] [--json]
#   --export   Print as export statements (source-able)
#   --json     Print as JSON object
#   (default)  Print human-readable summary
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

FORMAT="text"
while [[ $# -gt 0 ]]; do
  case "$1" in
    --export) FORMAT="export"; shift ;;
    --json)   FORMAT="json"; shift ;;
    *)        echo "Unknown option: $1" >&2; exit 1 ;;
  esac
done

# Step 1: Get agent profile -> workspace_id
AGENT=$(mesh_curl "${MESH_API_URL}/api/v1/agents/me" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}")

AGENT_ID=$(echo "$AGENT" | jq -r '.id')
AGENT_NAME=$(echo "$AGENT" | jq -r '.name')
WS_ID=$(echo "$AGENT" | jq -r '.workspace_id')

if [[ -z "$WS_ID" || "$WS_ID" == "null" ]]; then
  echo "Error: could not resolve workspace_id from /agents/me" >&2
  exit 1
fi

# Step 2: List projects
PROJECTS=$(mesh_curl "${MESH_API_URL}/api/v1/workspaces/${WS_ID}/projects" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}")

PROJECT_COUNT=$(echo "$PROJECTS" | jq '.total_count // (.items | length)')

# Step 3: For each project, get statuses
ENRICHED=$(echo "$PROJECTS" | jq -c '.items[]' | while read -r proj; do
  PROJ_ID=$(echo "$proj" | jq -r '.id')
  PROJ_NAME=$(echo "$proj" | jq -r '.name')
  PROJ_SLUG=$(echo "$proj" | jq -r '.slug')

  STATUSES=$(mesh_curl "${MESH_API_URL}/api/v1/projects/${PROJ_ID}/statuses" \
    -H "X-Agent-Key: ${MESH_AGENT_KEY}" 2>/dev/null || echo '[]')

  echo "$proj" | jq --argjson statuses "$STATUSES" '. + {statuses: $statuses}'
done | jq -s '.')

# Output
case "$FORMAT" in
  export)
    echo "export MESH_AGENT_ID=\"${AGENT_ID}\""
    echo "export MESH_AGENT_NAME=\"${AGENT_NAME}\""
    echo "export MESH_WORKSPACE_ID=\"${WS_ID}\""
    echo "$ENRICHED" | jq -r '.[0] // empty | "export MESH_PROJECT_ID=\"\(.id)\"\nexport MESH_PROJECT_SLUG=\"\(.slug)\""'
    echo "# Projects: ${PROJECT_COUNT}"
    echo "$ENRICHED" | jq -r '.[] | "# Project: \(.name) (\(.id))"'
    echo "$ENRICHED" | jq -r '.[0] // empty | .statuses[]? | "# Status: \(.name) [\(.category)] = \(.id)"'
    ;;
  json)
    jq -n \
      --arg agent_id "$AGENT_ID" \
      --arg agent_name "$AGENT_NAME" \
      --arg workspace_id "$WS_ID" \
      --argjson projects "$ENRICHED" \
      '{agent_id: $agent_id, agent_name: $agent_name, workspace_id: $workspace_id, projects: $projects}'
    ;;
  text)
    echo "Agent:     ${AGENT_NAME} (${AGENT_ID})"
    echo "Workspace: ${WS_ID}"
    echo "Projects:  ${PROJECT_COUNT}"
    echo ""
    echo "$ENRICHED" | jq -r '.[] | "  \(.name) [\(.slug)]  \(.id)\n    Statuses:"'
    echo "$ENRICHED" | jq -r '.[] | .statuses[]? | "      \(.name) [\(.category)] = \(.id)"'
    ;;
esac

scripts/my-tasks.sh

#!/usr/bin/env bash
# List tasks assigned to the current agent.
# Usage: bash my-tasks.sh
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

mesh_curl "${MESH_API_URL}/api/v1/agents/me/tasks" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" | jq .

scripts/get-context.sh

#!/usr/bin/env bash
# Get enriched task context (task + status + comments + dependencies + artifacts).
# Usage: bash get-context.sh <task_id>
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

TASK_ID="${1:?Usage: get-context.sh <task_id>}"

mesh_curl "${MESH_API_URL}/api/v1/tasks/${TASK_ID}/context" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" | jq .

scripts/move-task.sh

#!/usr/bin/env bash
# Move task to a different status.
# Usage: bash move-task.sh <task_id> <status_id> [--assignee <agent_or_user_id>] [--assignee-type agent|user] [--comment "text"]
# On move to 'review', task auto-reassigns to creator unless --assignee is provided.
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

TASK_ID="${1:?Usage: move-task.sh <task_id> <status_id> [--assignee id] [--assignee-type agent|user] [--comment text]}"
STATUS_ID="${2:?Usage: move-task.sh <task_id> <status_id> [--assignee id] [--assignee-type agent|user] [--comment text]}"
shift 2

ASSIGNEE_ID=""
ASSIGNEE_TYPE="agent"
COMMENT=""

while [[ $# -gt 0 ]]; do
  case "$1" in
    --assignee) ASSIGNEE_ID="$2"; shift 2 ;;
    --assignee-type) ASSIGNEE_TYPE="$2"; shift 2 ;;
    --comment) COMMENT="$2"; shift 2 ;;
    *) echo "Unknown option: $1" >&2; exit 1 ;;
  esac
done

BODY=$(jq -n --arg status_id "$STATUS_ID" '{status_id: $status_id}')

if [[ -n "$ASSIGNEE_ID" ]]; then
  BODY=$(echo "$BODY" | jq --arg aid "$ASSIGNEE_ID" --arg atype "$ASSIGNEE_TYPE" \
    '. + {assignee_id: $aid, assignee_type: $atype}')
fi

mesh_curl -X POST "${MESH_API_URL}/api/v1/tasks/${TASK_ID}/move" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" \
  -H "Content-Type: application/json" \
  -d "$BODY" | jq .

# Add comment if provided (best-effort, don't fail the move)
if [[ -n "$COMMENT" ]]; then
  CBODY=$(jq -n --arg body "$COMMENT" '{body: $body}')
  mesh_curl -X POST "${MESH_API_URL}/api/v1/tasks/${TASK_ID}/comments" \
    -H "X-Agent-Key: ${MESH_AGENT_KEY}" \
    -H "Content-Type: application/json" \
    -d "$CBODY" > /dev/null 2>&1 || true
fi

scripts/add-comment.sh

#!/usr/bin/env bash
# Add a comment to a task.
# Usage: bash add-comment.sh <task_id> <content>
#        echo "content" | bash add-comment.sh <task_id> -
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

TASK_ID="${1:?Usage: add-comment.sh <task_id> <content>}"
CONTENT="${2:?Usage: add-comment.sh <task_id> <content>}"

if [[ "$CONTENT" == "-" ]]; then
  CONTENT=$(cat)
fi

BODY=$(jq -n --arg body "$CONTENT" '{body: $body}')

mesh_curl -X POST "${MESH_API_URL}/api/v1/tasks/${TASK_ID}/comments" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" \
  -H "Content-Type: application/json" \
  -d "$BODY" | jq .

scripts/get-project-knowledge.sh

#!/usr/bin/env bash
# Get all accumulated project knowledge (workspace + project memories).
# Call at session start to load context.
# Usage: bash get-project-knowledge.sh <project_id>
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

PROJECT_ID="${1:?Usage: get-project-knowledge.sh <project_id>}"

mesh_curl "${MESH_API_URL}/api/v1/projects/${PROJECT_ID}/knowledge" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" | jq .

scripts/get-workflow-rules.sh

#!/usr/bin/env bash
# Get workflow rules for a project including allowed transitions and caller permissions.
# Usage: bash get-workflow-rules.sh <project_id>
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

PROJ_ID="${1:?Usage: get-workflow-rules.sh <project_id>}"

mesh_curl "${MESH_API_URL}/api/v1/projects/${PROJ_ID}/rules/workflow" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" | jq .

scripts/publish-event.sh

#!/usr/bin/env bash
# Publish an event to the project event bus.
# Usage: bash publish-event.sh <project_id> <event_type> <subject> <payload_json>
# Event types: summary, context_update, error, custom
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

PROJ_ID="${1:?Usage: publish-event.sh <project_id> <event_type> <subject> <payload_json>}"
EVENT_TYPE="${2:?Usage: publish-event.sh <project_id> <event_type> <subject> <payload_json>}"
SUBJECT="${3:?Usage: publish-event.sh <project_id> <event_type> <subject> <payload_json>}"
PAYLOAD="${4:?Usage: publish-event.sh <project_id> <event_type> <subject> <payload_json>}"

BODY=$(jq -n \
  --arg event_type "$EVENT_TYPE" \
  --arg subject "$SUBJECT" \
  --argjson payload "$PAYLOAD" \
  '{event_type: $event_type, subject: $subject, payload: $payload}')

mesh_curl -X POST "${MESH_API_URL}/api/v1/projects/${PROJ_ID}/events" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" \
  -H "Content-Type: application/json" \
  -d "$BODY" | jq .

scripts/remember.sh

#!/usr/bin/env bash
# Save knowledge to persistent memory (UPSERT by key).
# Usage: bash remember.sh <key> <content> [--scope project|workspace|agent] [--project-id <id>] [--tags tag1,tag2] [--relevance 0.8] [--expires-at 2026-12-31T00:00:00Z] [--source-url <url>]
# Examples:
#   bash remember.sh "api-convention" "All REST responses use envelope {data, meta, error}"
#   bash remember.sh "license-decision" "Apache 2.0" --scope project --tags license,decision
#   bash remember.sh "deploy-info" "Push to main triggers CI" --relevance 0.9 --source-url "https://github.com/org/repo"
set -euo pipefail

source "$(dirname "$0")/_lib.sh"

: "${MESH_API_URL:?Set MESH_API_URL}"
: "${MESH_AGENT_KEY:?Set MESH_AGENT_KEY}"

KEY="${1:?Usage: remember.sh <key> <content> [--scope s] [--project-id id] [--tags t1,t2] [--relevance 0.8] [--expires-at RFC3339] [--source-url url]}"
CONTENT="${2:?Usage: remember.sh <key> <content> [--scope s] [--project-id id] [--tags t1,t2] [--relevance 0.8] [--expires-at RFC3339] [--source-url url]}"
shift 2

SCOPE="project"
PROJECT_ID=""
TAGS="[]"
RELEVANCE=""
EXPIRES_AT=""
SOURCE_URL=""

while [[ $# -gt 0 ]]; do
  case "$1" in
    --scope) SCOPE="$2"; shift 2 ;;
    --project-id) PROJECT_ID="$2"; shift 2 ;;
    --tags)
      # Convert comma-separated to JSON array
      TAGS=$(echo "$2" | jq -R 'split(",")')
      shift 2 ;;
    --relevance) RELEVANCE="$2"; shift 2 ;;
    --expires-at) EXPIRES_AT="$2"; shift 2 ;;
    --source-url) SOURCE_URL="$2"; shift 2 ;;
    *) echo "Unknown option: $1" >&2; exit 1 ;;
  esac
done

BODY=$(jq -n \
  --arg key "$KEY" \
  --arg content "$CONTENT" \
  --arg scope "$SCOPE" \
  --arg source_type "agent" \
  --argjson tags "$TAGS" \
  '{key: $key, content: $content, scope: $scope, source_type: $source_type, tags: $tags}')

# Add project_id if provided
if [[ -n "$PROJECT_ID" ]]; then
  BODY=$(echo "$BODY" | jq --arg pid "$PROJECT_ID" '. + {project_id: $pid}')
fi

# Add relevance if provided
if [[ -n "$RELEVANCE" ]]; then
  BODY=$(echo "$BODY" | jq --argjson r "$RELEVANCE" '. + {relevance: $r}')
fi

# Add expires_at if provided
if [[ -n "$EXPIRES_AT" ]]; then
  BODY=$(echo "$BODY" | jq --arg ea "$EXPIRES_AT" '. + {expires_at: $ea}')
fi

# Add source_url if provided
if [[ -n "$SOURCE_URL" ]]; then
  BODY=$(echo "$BODY" | jq --arg su "$SOURCE_URL" '. + {source_url: $su}')
fi

mesh_curl -X POST "${MESH_API_URL}/api/v1/memories" \
  -H "X-Agent-Key: ${MESH_AGENT_KEY}" \
  -H "Content-Type: application/json" \
  -d "$BODY" | jq .

references/api.md

EVC Mesh REST API Reference

Base URL: $MESH_API_URL/api/v1

Authentication: X-Agent-Key: agk_workspace_... header on every request.

Projects

List Projects

GET /workspaces/{workspace_id}/projects
Response: { items: Project[], total_count, page, per_page, has_more }

Get Project

GET /projects/{project_id}
Response: Project { id, workspace_id, name, slug, description, created_at, updated_at }

Task Statuses

List Statuses

GET /projects/{project_id}/statuses
Response: TaskStatus[] { id, name, slug, category, color, position }

Categories: backlog, triage, todo, in_progress, review, done, cancelled

Custom Fields

List Custom Field Definitions

GET /projects/{project_id}/custom-fields
Response: CustomFieldDefinition[] { id, project_id, name, slug, field_type, description, options, default_value, is_required, is_visible_to_agents, position, created_at }

field_type: text | number | date | datetime | select | multiselect | url | email | checkbox | user_ref | agent_ref | json

Tasks

List Tasks

GET /projects/{project_id}/tasks?page_size=200&status_id=...&assignee=me&priority=high
Response: { items: Task[], total_count, page, per_page, has_more }

Get Task

GET /tasks/{task_id}
Response: Task {
  id, project_id, status_id, title, description, priority,
  assignee_id, assignee_type, parent_task_id, position,
  due_date, labels, custom_fields, created_at, updated_at
}

Create Task

POST /projects/{project_id}/tasks
Body: { title, priority?, description?, status_id?, parent_task_id?, due_date?, estimated_hours?, labels?, assignee_id?, assignee_type? }
Response: Task

Update Task

PATCH /tasks/{task_id}
Body: { title?, priority?, description?, assignee_id?, assignee_type?, due_date?, estimated_hours?, labels? }
Response: Task

Move Task (Change Status)

POST /tasks/{task_id}/move
Body: { status_id, position? }
Response: { status: "ok" }

Delete Task

DELETE /tasks/{task_id}
Response: 204

List Subtasks

GET /tasks/{task_id}/subtasks
Response: Task[]

Get Task Context

GET /tasks/{task_id}/context
Response: { task: Task, status: TaskStatus, comments: Comment[], dependencies: Dependency[], artifacts: Artifact[], subtasks: Task[] }

Returns enriched task context in a single call - useful for agents picking up work.

VCS Links

List VCS Links

GET /tasks/{task_id}/vcs-links
Response: { vcs_links: VCSLink[] }

Create VCS Link

POST /tasks/{task_id}/vcs-links
Body: { link_type, external_id, url, title?, provider? }
Response: VCSLink { id, task_id, provider, link_type, external_id, url, title, status, metadata, created_at }

link_type: pr | commit | branch
provider: github | gitlab (default: github)

Delete VCS Link

DELETE /vcs-links/{link_id}
Response: 204

Dependencies

List Dependencies

GET /tasks/{task_id}/dependencies
Response: Dependency[] { id, task_id, depends_on_id, dependency_type, created_at }

Add Dependency

POST /tasks/{task_id}/dependencies
Body: { depends_on_id, dependency_type }
Response: Dependency

dependency_type: blocks | relates_to

Remove Dependency

DELETE /tasks/{task_id}/dependencies/{dep_id}
Response: 204

Dependency Graph

GET /projects/{project_id}/dependency-graph
Response: { nodes: [], edges: [] }

Comments

List Comments

GET /tasks/{task_id}/comments
Response: { items: Comment[], total_count, page, per_page, has_more }

Add Comment

POST /tasks/{task_id}/comments
Body: { body, parent_comment_id?, is_internal? }
Response: Comment { id, task_id, body, author_id, author_type, is_internal, created_at, updated_at }

Update Comment

PATCH /comments/{comment_id}
Body: { body }
Response: Comment

Delete Comment

DELETE /comments/{comment_id}
Response: 204

Artifacts

List Artifacts

GET /tasks/{task_id}/artifacts
Response: Artifact[]

Upload Artifact

POST /tasks/{task_id}/artifacts (multipart/form-data)
Fields: name, artifact_type, metadata? (JSON string), file (binary)
Response: Artifact { id, task_id, name, artifact_type, size, metadata, created_at }

artifact_type: code | log | report | file | data

Get Artifact

GET /artifacts/{artifact_id}
Response: Artifact

Download Artifact

GET /artifacts/{artifact_id}/download
Response: file content

Delete Artifact

DELETE /artifacts/{artifact_id}
Response: 204

Agents

List Agents

GET /workspaces/{workspace_id}/agents
Response: { items: Agent[], total_count, page, per_page, has_more }

Get Agent

GET /agents/{agent_id}
Response: Agent { id, workspace_id, name, slug, agent_type, status, last_heartbeat, current_task_id, total_tasks_completed, total_errors }

Get Current Agent (Me)

GET /agents/me
Response: Agent { id, workspace_id, name, slug, agent_type, status, last_heartbeat, current_task_id, total_tasks_completed, total_errors }

Get My Tasks

GET /agents/me/tasks
Response: Task[]

Returns all tasks assigned to the current agent across all projects.

Heartbeat

POST /agents/heartbeat
Body: { status } — online | busy | error
Response: { ok: true }

Update Agent

PATCH /agents/{agent_id}
Body: { name?, capabilities?, settings? }
Response: Agent

Events

List Events

GET /projects/{project_id}/events
Response: Event[] { id, project_id, event_type, agent_id, payload, tags, created_at }

Publish Event

POST /projects/{project_id}/events
Body: { event_type, subject, payload, task_id?, tags?, ttl_seconds? }
Response: Event

event_type: summary | context_update | error | custom

Get Event

GET /events/{event_id}
Response: Event

Activity

Task Activity

GET /tasks/{task_id}/activity
Response: Activity[] { id, event_type, actor_id, actor_type, details, created_at }

Workspace Activity

GET /workspaces/{workspace_id}/activity
Response: Activity[]

Project Updates

Post Project Update

POST /projects/{project_id}/updates
Body: { title, summary, status?, highlights?, blockers?, next_steps? }
Response: ProjectUpdate { id, project_id, title, status, summary, highlights, blockers, next_steps, metrics, created_by, created_at }

status: on_track | at_risk | off_track | completed (default: on_track)
highlights/blockers/next_steps: [{ text: "..." }, ...]

List Project Updates

GET /projects/{project_id}/updates?page=1&per_page=20
Response: { items: ProjectUpdate[], total_count, page, per_page, has_more }

Get Latest Update

GET /projects/{project_id}/updates/latest
Response: ProjectUpdate

Triage

List Triage Tasks

GET /workspaces/{workspace_id}/triage?per_page=50
Response: { items: Task[], total_count, page, per_page, has_more }

Returns tasks with status category triage across all projects - unrouted tasks awaiting assignment.

Error Responses

All errors return:

{ "code": 400, "message": "description" }

Common codes:

• 400 - Bad request (invalid input)
• 401 - Unauthorized (missing or invalid agent key)
• 403 - Forbidden (agent key valid but no access)
• 404 - Not found
• 409 - Conflict (duplicate)
• 500 - Internal server error