crewly 1.5.18 → 1.5.19

package/config/skills/agent/core/report-status/execute.sh

@@ -145,6 +145,16 @@ require_param "sessionName (--session)" "$SESSION_NAME"
 require_param "status (--status)" "$STATUS"
 require_param "summary (--summary)" "$SUMMARY"
 
+# Gate: before_mark_done — reject empty or trivially short summaries
+# This prevents agents from marking tasks done without meaningful output.
+if [ "$STATUS" = "done" ]; then
+  SUMMARY_LEN=${#SUMMARY}
+  if [ "$SUMMARY_LEN" -lt 20 ]; then
+    echo "{\"error\":\"before_mark_done gate failed: summary too short (${SUMMARY_LEN} chars, minimum 20). Provide a meaningful summary of what was accomplished.\"}" >&2
+    error_exit "Summary must be at least 20 characters when reporting done (got ${SUMMARY_LEN})"
+  fi
+fi
+
 # Map simple status strings to InProgressTaskStatus values
 map_status_to_state() {
   case "$1" in
@@ -210,3 +220,37 @@ fi
 if [ "$STATUS" = "done" ] && [ -n "$SUMMARY" ]; then
   auto_remember "$SESSION_NAME" "[COMPLETED] Task completed by ${SESSION_NAME}: ${SUMMARY}" "decision" "project" "$PROJECT_PATH"
 fi
+
+# Growth: record learning and extract growth areas on task completion.
+# Uses existing APIs — no additional LLM calls. The agent's own summary
+# is the learning input; keyword extraction identifies growth areas.
+if [ "$STATUS" = "done" ] && [ -n "$SUMMARY" ] && [ -n "$PROJECT_PATH" ]; then
+  # Record as a structured learning entry (appends to what_worked.md)
+  LEARN_BODY=$(jq -n \
+    --arg agentId "$SESSION_NAME" \
+    --arg content "$SUMMARY" \
+    --arg projectPath "$PROJECT_PATH" \
+    --arg type "success" \
+    '{agentId: $agentId, content: $content, projectPath: $projectPath, type: $type}')
+  api_call POST "/memory/record-learning" "$LEARN_BODY" 2>/dev/null || true
+
+  # Extract growth areas from summary (keyword-based, no LLM)
+  GROWTH_BODY=$(jq -n \
+    --arg sessionName "$SESSION_NAME" \
+    --arg text "$SUMMARY" \
+    '{sessionName: $sessionName, text: $text}')
+  api_call POST "/growth/extract-areas" "$GROWTH_BODY" 2>/dev/null || true
+fi
+
+# Growth: record failures for learning when task fails or is blocked.
+if [ "$STATUS" = "failed" ] || [ "$STATUS" = "blocked" ]; then
+  if [ -n "$SUMMARY" ] && [ -n "$PROJECT_PATH" ]; then
+    FAIL_BODY=$(jq -n \
+      --arg agentId "$SESSION_NAME" \
+      --arg content "$SUMMARY" \
+      --arg projectPath "$PROJECT_PATH" \
+      --arg type "failure" \
+      '{agentId: $agentId, content: $content, projectPath: $projectPath, type: $type}')
+    api_call POST "/memory/record-learning" "$FAIL_BODY" 2>/dev/null || true
+  fi
+fi

package/config/skills/agent/core/update-intent-task/execute.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# Update an intent task's status, assigned sessions, intent text, or other fields.
+# Calls PUT /api/intent-tasks/:taskId with the provided update payload.
+#
+# Used by the orchestrator to manage its todo list:
+# - pending → in_progress → completed/failed
+# - Assign agents, update descriptions, etc.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  bash execute.sh '{"taskId":"<id>","status":"in_progress"}'
+  bash execute.sh '{"taskId":"<id>","status":"completed","result":"Deployed successfully"}'
+  bash execute.sh '{"taskId":"<id>","assignedSessions":["dev-leo"]}'
+  bash execute.sh '{"taskId":"<id>","intent":"Updated task description","category":"debugging"}'
+
+Parameters:
+  taskId           - Intent task ID (required)
+  status           - New status: pending, classified, in_progress, paused, completed, failed, cancelled
+  result           - Result summary (when completing/failing)
+  intent           - Updated task description
+  level            - Updated level: L0, L1, L2
+  category         - Updated category: query, code_change, debugging, deployment, research, review, planning, communication, other
+  assignedSessions - Array of agent session names to assign
+  scheduleId       - Schedule ID to associate
+
+Examples:
+  # Start working on a task
+  bash execute.sh '{"taskId":"abc-123","status":"in_progress","assignedSessions":["dev-leo"]}'
+
+  # Complete a task
+  bash execute.sh '{"taskId":"abc-123","status":"completed","result":"Bug fixed and deployed"}'
+
+  # Fail a task
+  bash execute.sh '{"taskId":"abc-123","status":"failed","result":"Build errors in TypeScript"}'
+EOF_USAGE
+}
+
+# ---------------------------------------------------------------------------
+# Parse arguments
+# ---------------------------------------------------------------------------
+if [ $# -eq 0 ] || [[ "${1:-}" == "--help" ]] || [[ "${1:-}" == "-h" ]]; then
+  print_usage
+  exit 0
+fi
+
+JSON_INPUT=$(read_json_input "$1")
+
+TASK_ID=$(echo "$JSON_INPUT" | jq -r '.taskId // empty')
+
+if [ -z "$TASK_ID" ]; then
+  echo '{"success":false,"error":"taskId is required"}'
+  exit 1
+fi
+
+# Build the update body (exclude taskId — it goes in the URL)
+BODY=$(echo "$JSON_INPUT" | jq 'del(.taskId)')
+
+# Verify body has at least one field to update
+FIELD_COUNT=$(echo "$BODY" | jq 'length')
+if [ "$FIELD_COUNT" -eq 0 ]; then
+  echo '{"success":false,"error":"At least one field to update is required (status, result, intent, level, category, assignedSessions)"}'
+  exit 1
+fi
+
+# ---------------------------------------------------------------------------
+# Call backend API
+# ---------------------------------------------------------------------------
+CREWLY_PORT="${CREWLY_PORT:-8787}"
+API_URL="${CREWLY_API_URL:-http://localhost:${CREWLY_PORT}}"
+
+RESPONSE=$(curl -s -w "\n%{http_code}" \
+  -X PUT \
+  -H "Content-Type: application/json" \
+  -d "$BODY" \
+  "${API_URL}/api/intent-tasks/${TASK_ID}" 2>&1) || {
+  echo "{\"success\":false,\"error\":\"Failed to connect to backend at ${API_URL}\"}"
+  exit 1
+}
+
+# Split response body and HTTP status code
+HTTP_CODE=$(echo "$RESPONSE" | tail -1)
+BODY_RESPONSE=$(echo "$RESPONSE" | sed '$d')
+
+if [ "$HTTP_CODE" -ge 200 ] && [ "$HTTP_CODE" -lt 300 ]; then
+  echo "$BODY_RESPONSE"
+else
+  echo "{\"success\":false,\"error\":\"HTTP ${HTTP_CODE}\",\"body\":$(echo "$BODY_RESPONSE" | jq -c '.' 2>/dev/null || echo "\"$BODY_RESPONSE\"")}"
+  exit 1
+fi

package/config/skills/agent/core/work-loop/execute.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+# =============================================================================
+# work-loop — Hybrid pull+push work loop for V3 agents
+#
+# This skill implements the agent's idle-time work acquisition loop.
+# When an agent has no active task, it:
+#   1. Checks for V2 push-mode tasks (get-my-tasks for delegated/assigned work)
+#   2. Polls the V3 Task Pool for claimable work items
+#   3. If a task is claimed, returns it for execution
+#   4. If no work found, returns idle status
+#
+# This is the HYBRID bridge between V2 (push) and V3 (pull). Both
+# mechanisms coexist — the agent tries push first, then pull.
+#
+# Usage:
+#   bash execute.sh '{"sessionName":"agent-1","role":"developer","projectPath":"/path/to/project"}'
+#
+# Parameters:
+#   sessionName  (required) — Agent session name
+#   role         (optional) — Agent role for capability matching
+#   skills       (optional) — JSON array of skill tags
+#   projectPath  (optional) — Project path for task lookup and memory
+#
+# Returns:
+#   Found work: { success: true, hasWork: true, source: "v2"|"v3", task|workItem: {...} }
+#   No work:    { success: true, hasWork: false, message: "..." }
+#   Error:      { error: "..." }
+# =============================================================================
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+INPUT=$(read_json_input "${1:-}")
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"sessionName\":\"agent-1\",\"role\":\"developer\"}'"
+
+SESSION_NAME=$(printf '%s' "$INPUT" | jq -r '.sessionName // empty')
+require_param "sessionName" "$SESSION_NAME"
+
+ROLE=$(printf '%s' "$INPUT" | jq -r '.role // empty')
+SKILLS_JSON=$(printf '%s' "$INPUT" | jq -c '.skills // []')
+PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
+
+# ---------------------------------------------------------------------------
+# Step 1: Check V2 push-mode tasks (delegated tasks assigned to this agent)
+# ---------------------------------------------------------------------------
+
+V2_TASKS_SCRIPT="${SCRIPT_DIR}/../get-my-tasks/execute.sh"
+
+if [ -f "$V2_TASKS_SCRIPT" ]; then
+  V2_PARAMS=$(jq -n \
+    --arg sessionName "$SESSION_NAME" \
+    --arg projectPath "$PROJECT_PATH" \
+    '{sessionName: $sessionName, projectPath: $projectPath}')
+
+  V2_RESULT=$(bash "$V2_TASKS_SCRIPT" "$V2_PARAMS" 2>/dev/null) || V2_RESULT='{"tasks":[]}'
+
+  # Check for in_progress or assigned tasks
+  V2_ACTIVE=$(printf '%s' "$V2_RESULT" | jq -c '
+    [.tasks // [] | .[] | select(.status == "in_progress" or .status == "assigned" or .status == "open")]
+    | first // null
+  ' 2>/dev/null || echo "null")
+
+  if [ "$V2_ACTIVE" != "null" ] && [ -n "$V2_ACTIVE" ]; then
+    TASK_NAME=$(printf '%s' "$V2_ACTIVE" | jq -r '.name // "unknown"')
+    jq -n \
+      --argjson task "$V2_ACTIVE" \
+      --arg taskName "$TASK_NAME" \
+      '{
+        success: true,
+        hasWork: true,
+        source: "v2",
+        message: ("Found V2 push-mode task: " + $taskName),
+        task: $task
+      }'
+    exit 0
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Step 2: Poll V3 Task Pool for claimable work items
+# ---------------------------------------------------------------------------
+
+POLL_SCRIPT="${SCRIPT_DIR}/../poll-tasks/execute.sh"
+
+if [ -f "$POLL_SCRIPT" ]; then
+  POLL_PARAMS=$(jq -n \
+    --arg sessionName "$SESSION_NAME" \
+    --arg role "$ROLE" \
+    --argjson skills "$SKILLS_JSON" \
+    --arg projectPath "$PROJECT_PATH" \
+    '{sessionName: $sessionName, role: $role, skills: $skills, projectPath: $projectPath}')
+
+  POLL_RESULT=$(bash "$POLL_SCRIPT" "$POLL_PARAMS" 2>/dev/null) || POLL_RESULT='{"success":false}'
+
+  CLAIMED=$(printf '%s' "$POLL_RESULT" | jq -r '.claimed // false')
+
+  if [ "$CLAIMED" = "true" ]; then
+    WORK_ITEM=$(printf '%s' "$POLL_RESULT" | jq -c '.workItem // null')
+    CLAIM_OBJ=$(printf '%s' "$POLL_RESULT" | jq -c '.claim // null')
+    WORK_ITEM_ID=$(printf '%s' "$POLL_RESULT" | jq -r '.workItemId // "unknown"')
+    CLAIM_ID=$(printf '%s' "$POLL_RESULT" | jq -r '.claimId // "unknown"')
+
+    jq -n \
+      --argjson workItem "$WORK_ITEM" \
+      --argjson claim "$CLAIM_OBJ" \
+      --arg workItemId "$WORK_ITEM_ID" \
+      --arg claimId "$CLAIM_ID" \
+      '{
+        success: true,
+        hasWork: true,
+        source: "v3",
+        message: "Claimed work item from Task Pool",
+        workItemId: $workItemId,
+        claimId: $claimId,
+        workItem: $workItem,
+        claim: $claim
+      }'
+    exit 0
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Step 3: No work found — report idle
+# ---------------------------------------------------------------------------
+
+jq -n '{
+  success: true,
+  hasWork: false,
+  message: "No work available from V2 push or V3 pull. Agent is idle."
+}'

package/config/skills/agent/core/work-loop/execute.test.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# =============================================================================
+# Tests for work-loop skill
+#
+# Verifies parameter validation, V2/V3 hybrid flow, and output format.
+# =============================================================================
+set -eo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PASS=0
+FAIL=0
+ERRORS=""
+
+assert_contains() {
+  local test_name="$1" needle="$2" haystack="$3"
+  if printf '%s' "$haystack" | grep -q "$needle"; then
+    PASS=$((PASS + 1))
+    echo "  ✓ ${test_name}"
+  else
+    FAIL=$((FAIL + 1))
+    ERRORS="${ERRORS}\n  ✗ ${test_name}\n    expected to contain: ${needle}\n    actual: ${haystack}"
+    echo "  ✗ ${test_name}"
+    echo "    expected to contain: ${needle}"
+  fi
+}
+
+echo "=== work-loop tests ==="
+
+echo ""
+echo "--- Missing parameters ---"
+
+OUTPUT=$(bash "$SCRIPT_DIR/execute.sh" '' 2>&1) || true
+assert_contains "Empty input returns usage error" "Usage" "$OUTPUT"
+
+OUTPUT=$(bash "$SCRIPT_DIR/execute.sh" '{"role":"developer"}' 2>&1) || true
+assert_contains "Missing sessionName returns error" "sessionName" "$OUTPUT"
+
+echo ""
+echo "--- Output format (no server) ---"
+
+# Without a running server, both V2 and V3 checks will fail gracefully
+# and the script should return idle status
+OUTPUT=$(bash "$SCRIPT_DIR/execute.sh" '{"sessionName":"test-agent","role":"developer"}' 2>&1) || true
+# Should get either an error or idle result — not crash
+assert_contains "Returns JSON output" "success" "$OUTPUT"
+
+echo ""
+echo "=== Results: ${PASS} passed, ${FAIL} failed ==="
+if [ $FAIL -gt 0 ]; then
+  echo -e "\nFailures:${ERRORS}"
+  exit 1
+fi

package/config/skills/agent/core/workspace/execute.sh

@@ -0,0 +1,270 @@
+#!/bin/bash
+# Agent Workspace Skill — read, write, create, and list shared workspaces.
+#
+# Actions:
+#   read   — Read a workspace by ID
+#   write  — Write/update workspace data (CAS with expectedVersion)
+#   create — Create a new workspace
+#   list   — List all available workspaces
+#
+# Calls the V2 Workspace API at /api/v2/workspaces.
+#
+# Usage:
+#   # CLI flags (preferred)
+#   bash execute.sh --action read --id ws-123
+#   bash execute.sh --action write --id ws-123 --data '{"key":"val"}' --version 1 --writer agent-1
+#   bash execute.sh --action create --name "Sprint results" --owner-type team --owner-id team-1
+#   bash execute.sh --action list
+#
+#   # Legacy JSON (backward compatible)
+#   bash execute.sh '{"action":"read","id":"ws-123"}'
+#   bash execute.sh '{"action":"write","id":"ws-123","data":{"key":"val"},"expectedVersion":1,"writerId":"agent-1"}'
+#   bash execute.sh '{"action":"create","name":"Sprint results","ownerType":"team","ownerId":"team-1"}'
+#   bash execute.sh '{"action":"list"}'
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  bash execute.sh --action <read|write|create|list> [options]
+
+Actions:
+  read    Read a workspace
+    --id | -i         Workspace ID (required)
+
+  write   Write/update workspace data (CAS)
+    --id | -i         Workspace ID (required)
+    --data | -d       JSON data object (required)
+    --version | -v    Expected version for CAS (required)
+    --writer | -w     Writer ID / session name (required)
+
+  create  Create a new workspace
+    --name | -n       Workspace name (required)
+    --owner-type      Owner type: agent|team|mission|system (required)
+    --owner-id        Owner identifier (required)
+    --access-mode     Access mode: overwrite|append|structured (default: overwrite)
+    --description     Optional description
+    --data | -d       Initial data JSON (default: {})
+    --allowed-writers Comma-separated list of allowed writer IDs
+
+  list    List all workspaces
+    (no options)
+
+General:
+  --json | -j         Raw JSON payload
+  --help | -h         Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+ACTION=""
+WS_ID=""
+WS_NAME=""
+WS_DESCRIPTION=""
+WS_OWNER_TYPE=""
+WS_OWNER_ID=""
+WS_ACCESS_MODE=""
+WS_DATA=""
+WS_VERSION=""
+WS_WRITER=""
+WS_ALLOWED_WRITERS=""
+
+# Detect legacy JSON argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --action|-a)
+      ACTION="$2"
+      shift 2
+      ;;
+    --id|-i)
+      WS_ID="$2"
+      shift 2
+      ;;
+    --name|-n)
+      WS_NAME="$2"
+      shift 2
+      ;;
+    --description)
+      WS_DESCRIPTION="$2"
+      shift 2
+      ;;
+    --owner-type)
+      WS_OWNER_TYPE="$2"
+      shift 2
+      ;;
+    --owner-id)
+      WS_OWNER_ID="$2"
+      shift 2
+      ;;
+    --access-mode)
+      WS_ACCESS_MODE="$2"
+      shift 2
+      ;;
+    --data|-d)
+      WS_DATA="$2"
+      shift 2
+      ;;
+    --version|-v)
+      WS_VERSION="$2"
+      shift 2
+      ;;
+    --writer|-w)
+      WS_WRITER="$2"
+      shift 2
+      ;;
+    --allowed-writers)
+      WS_ALLOWED_WRITERS="$2"
+      shift 2
+      ;;
+    --json|-j)
+      INPUT_JSON="$2"
+      shift 2
+      ;;
+    --help|-h)
+      print_usage
+      exit 0
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then
+        INPUT_JSON="$1"
+        shift
+      else
+        error_exit "Unknown argument: $1. Use --help for usage."
+      fi
+      ;;
+  esac
+done
+
+# Read from stdin if no input yet
+if [ -z "$INPUT_JSON" ] && [ -z "$ACTION" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  fi
+fi
+
+# Parse JSON if provided
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$ACTION" ] && ACTION=$(printf '%s' "$INPUT" | jq -r '.action // empty')
+  [ -z "$WS_ID" ] && WS_ID=$(printf '%s' "$INPUT" | jq -r '.id // empty')
+  [ -z "$WS_NAME" ] && WS_NAME=$(printf '%s' "$INPUT" | jq -r '.name // empty')
+  [ -z "$WS_DESCRIPTION" ] && WS_DESCRIPTION=$(printf '%s' "$INPUT" | jq -r '.description // empty')
+  [ -z "$WS_OWNER_TYPE" ] && WS_OWNER_TYPE=$(printf '%s' "$INPUT" | jq -r '.ownerType // empty')
+  [ -z "$WS_OWNER_ID" ] && WS_OWNER_ID=$(printf '%s' "$INPUT" | jq -r '.ownerId // empty')
+  [ -z "$WS_ACCESS_MODE" ] && WS_ACCESS_MODE=$(printf '%s' "$INPUT" | jq -r '.accessMode // empty')
+  [ -z "$WS_VERSION" ] && WS_VERSION=$(printf '%s' "$INPUT" | jq -r '.expectedVersion // empty')
+  [ -z "$WS_WRITER" ] && WS_WRITER=$(printf '%s' "$INPUT" | jq -r '.writerId // empty')
+  [ -z "$WS_ALLOWED_WRITERS" ] && WS_ALLOWED_WRITERS=$(printf '%s' "$INPUT" | jq -r '.allowedWriters // empty')
+  # Data is special — extract as raw JSON (not string)
+  if [ -z "$WS_DATA" ]; then
+    WS_DATA=$(printf '%s' "$INPUT" | jq -c '.data // empty')
+    # jq outputs "null" or empty string for missing keys
+    [ "$WS_DATA" = "null" ] || [ "$WS_DATA" = '""' ] && WS_DATA=""
+  fi
+fi
+
+require_param "action (--action)" "$ACTION"
+
+# ---------------------------------------------------------------------------
+# Action: list
+# ---------------------------------------------------------------------------
+if [ "$ACTION" = "list" ]; then
+  api_call GET "/v2/workspaces"
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Action: read
+# ---------------------------------------------------------------------------
+if [ "$ACTION" = "read" ]; then
+  require_param "id (--id)" "$WS_ID"
+  api_call GET "/v2/workspaces/${WS_ID}"
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Action: create
+# ---------------------------------------------------------------------------
+if [ "$ACTION" = "create" ]; then
+  require_param "name (--name)" "$WS_NAME"
+  require_param "ownerType (--owner-type)" "$WS_OWNER_TYPE"
+  require_param "ownerId (--owner-id)" "$WS_OWNER_ID"
+
+  # Build JSON body safely using jq + env vars
+  export _WS_NAME="$WS_NAME"
+  export _WS_OWNER_TYPE="$WS_OWNER_TYPE"
+  export _WS_OWNER_ID="$WS_OWNER_ID"
+
+  BODY=$(jq -n '{
+    name: env._WS_NAME,
+    ownerType: env._WS_OWNER_TYPE,
+    ownerId: env._WS_OWNER_ID
+  }')
+
+  [ -n "$WS_DESCRIPTION" ] && {
+    export _WS_DESC="$WS_DESCRIPTION"
+    BODY=$(echo "$BODY" | jq --arg d "$_WS_DESC" '. + {description: $d}')
+    unset _WS_DESC
+  }
+
+  [ -n "$WS_ACCESS_MODE" ] && {
+    export _WS_MODE="$WS_ACCESS_MODE"
+    BODY=$(echo "$BODY" | jq --arg m "$_WS_MODE" '. + {accessMode: $m}')
+    unset _WS_MODE
+  }
+
+  if [ -n "$WS_DATA" ]; then
+    BODY=$(echo "$BODY" | jq --argjson d "$WS_DATA" '. + {data: $d}')
+  fi
+
+  if [ -n "$WS_ALLOWED_WRITERS" ]; then
+    # Convert comma-separated string to JSON array
+    export _WS_AW="$WS_ALLOWED_WRITERS"
+    BODY=$(echo "$BODY" | jq --arg aw "$_WS_AW" '. + {allowedWriters: ($aw | split(",") | map(gsub("^\\s+|\\s+$"; "")))}')
+    unset _WS_AW
+  fi
+
+  unset _WS_NAME _WS_OWNER_TYPE _WS_OWNER_ID
+
+  api_call POST "/v2/workspaces" "$BODY"
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Action: write
+# ---------------------------------------------------------------------------
+if [ "$ACTION" = "write" ]; then
+  require_param "id (--id)" "$WS_ID"
+  require_param "expectedVersion (--version)" "$WS_VERSION"
+  require_param "writerId (--writer)" "$WS_WRITER"
+  require_param "data (--data)" "$WS_DATA"
+
+  export _WS_VER="$WS_VERSION"
+  export _WS_WRT="$WS_WRITER"
+
+  BODY=$(jq -n --argjson data "$WS_DATA" '{
+    expectedVersion: (env._WS_VER | tonumber),
+    writerId: env._WS_WRT,
+    data: $data
+  }')
+
+  unset _WS_VER _WS_WRT
+
+  api_call PUT "/v2/workspaces/${WS_ID}" "$BODY"
+  exit 0
+fi
+
+# Unknown action
+error_exit "Unknown action: $ACTION. Valid actions: read, write, create, list"