crewly 1.0.1 → 1.0.2

package/config/skills/agent/nano-banana-image/generate.sh

@@ -1,73 +0,0 @@
-#!/bin/bash
-# Nano Banana Image Generation Script
-# This script calls the Gemini API to generate images
-# Supports both standard (flash) and pro models
-
-set -e
-
-# Check for required environment variable
-if [ -z "$GEMINI_API_KEY" ]; then
-    echo "Error: GEMINI_API_KEY environment variable is not set"
-    exit 1
-fi
-
-# Model selection
-# Usage: generate.sh [prompt] [--pro]
-#   --pro    Use gemini-3-pro-image-preview (higher quality)
-#   default  Use gemini-2.0-flash-exp-image-generation (faster)
-MODEL="gemini-2.0-flash-exp-image-generation"
-PROMPT=""
-
-for arg in "$@"; do
-    if [ "$arg" = "--pro" ]; then
-        MODEL="gemini-3-pro-image-preview"
-    elif [ -z "$PROMPT" ]; then
-        PROMPT="$arg"
-    fi
-done
-
-if [ -z "$PROMPT" ]; then
-    read -r PROMPT
-fi
-
-if [ -z "$PROMPT" ]; then
-    echo "Error: No prompt provided"
-    exit 1
-fi
-
-# API endpoint
-API_URL="https://generativelanguage.googleapis.com/v1beta/models/${MODEL}:generateContent"
-
-# Create the request payload
-PAYLOAD=$(cat <<EOF
-{
-  "contents": [
-    {
-      "parts": [
-        {
-          "text": "Generate an image: $PROMPT"
-        }
-      ]
-    }
-  ],
-  "generationConfig": {
-    "responseModalities": ["Text", "Image"]
-  }
-}
-EOF
-)
-
-# Make the API call
-RESPONSE=$(curl -s -X POST "$API_URL?key=$GEMINI_API_KEY" \
-    -H "Content-Type: application/json" \
-    -d "$PAYLOAD")
-
-# Check for errors
-if echo "$RESPONSE" | grep -q '"error"'; then
-    echo "API Error:"
-    echo "$RESPONSE" | jq -r '.error.message // .error'
-    exit 1
-fi
-
-# Output the response
-echo "$RESPONSE"

package/config/skills/agent/nano-banana-image/instructions.md

@@ -1,50 +0,0 @@
-# Nano Banana Image Generation
-
-This skill enables AI image generation through Google's Gemini API.
-
-## Overview
-
-The Nano Banana Image Generation skill allows agents to create images from text descriptions using Google's Gemini model. This is useful for:
-
-- Creating concept art and visualizations
-- Generating placeholder images for designs
-- Producing custom graphics based on descriptions
-- Rapid prototyping of visual content
-
-## Usage
-
-To generate an image, provide a detailed text description of what you want to create.
-
-### Example Prompts
-
-- "A futuristic cityscape at sunset with flying cars"
-- "A cozy coffee shop interior with warm lighting"
-- "An abstract representation of music and sound waves"
-
-## API Configuration
-
-This skill requires a Gemini API key to function. The API key should be stored in the skill's `.env` file:
-
-```
-GEMINI_API_KEY=your_api_key_here
-```
-
-### Getting an API Key
-
-1. Visit [Google AI Studio](https://aistudio.google.com/apikey)
-2. Sign in with your Google account
-3. Create a new API key
-4. Copy the key and add it to the skill configuration
-
-## Best Practices
-
-- Be specific and detailed in your image descriptions
-- Include style preferences (realistic, artistic, minimalist, etc.)
-- Specify desired colors, lighting, and mood
-- Mention any specific elements that must be included
-
-## Limitations
-
-- Image generation may take 30-60 seconds
-- Some content types may be restricted by the API
-- Results may vary based on prompt complexity

package/config/skills/agent/nano-banana-image/skill.json

@@ -1,39 +0,0 @@
-{
-  "id": "nano-banana-image",
-  "name": "Nano Banana Image Generation",
-  "description": "Generate images using Google's Gemini Nano Banana API. Supports standard (flash) and pro models. Use --pro flag for higher quality output with gemini-3-pro-image-preview.",
-  "category": "design",
-  "skillType": "claude-skill",
-  "promptFile": "instructions.md",
-  "execution": {
-    "type": "script",
-    "script": {
-      "file": "generate.sh",
-      "interpreter": "bash",
-      "timeoutMs": 120000
-    }
-  },
-  "environment": {
-    "file": ".env",
-    "required": ["GEMINI_API_KEY"]
-  },
-  "notices": [
-    {
-      "type": "requirement",
-      "title": "API Key Required",
-      "message": "This skill requires a Gemini API key. Add your API key in the skill settings.",
-      "link": "https://aistudio.google.com/apikey",
-      "linkText": "Get API Key"
-    }
-  ],
-  "triggers": ["generate image", "create image", "nano banana", "gemini image", "ai image"],
-  "models": {
-    "standard": "gemini-2.0-flash-exp-image-generation",
-    "pro": "gemini-3-pro-image-preview"
-  },
-  "tags": ["image", "generation", "ai", "gemini", "api", "pro"],
-  "assignableRoles": ["designer"],
-  "version": "1.1.0",
-  "createdAt": "2024-01-01T00:00:00.000Z",
-  "updatedAt": "2024-01-01T00:00:00.000Z"
-}

package/config/skills/agent/query-knowledge/execute.sh

@@ -1,30 +0,0 @@
-#!/bin/bash
-# Query Knowledge Documents - search company knowledge base
-set -euo pipefail
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../_common/lib.sh"
-
-INPUT="${1:-}"
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"query\":\"deployment\",\"scope\":\"global\"}'"
-
-QUERY=$(echo "$INPUT" | jq -r '.query // empty')
-SCOPE=$(echo "$INPUT" | jq -r '.scope // "global"')
-CATEGORY=$(echo "$INPUT" | jq -r '.category // empty')
-PROJECT_PATH=$(echo "$INPUT" | jq -r '.projectPath // empty')
-require_param "query" "$QUERY"
-
-# URL-encode the query parameters
-ENCODED_QUERY=$(printf '%s' "$QUERY" | jq -sRr @uri)
-ENDPOINT="/knowledge/documents?scope=${SCOPE}&search=${ENCODED_QUERY}"
-
-if [ -n "$CATEGORY" ]; then
-  ENCODED_CATEGORY=$(printf '%s' "$CATEGORY" | jq -sRr @uri)
-  ENDPOINT="${ENDPOINT}&category=${ENCODED_CATEGORY}"
-fi
-
-if [ -n "$PROJECT_PATH" ]; then
-  ENCODED_PATH=$(printf '%s' "$PROJECT_PATH" | jq -sRr @uri)
-  ENDPOINT="${ENDPOINT}&projectPath=${ENCODED_PATH}"
-fi
-
-api_call GET "$ENDPOINT"

package/config/skills/agent/query-knowledge/instructions.md

@@ -1,47 +0,0 @@
-# Query Knowledge
-
-Search the company knowledge base for relevant documents. Use this to find SOPs, runbooks, architecture docs, team norms, and other documentation before starting process-oriented tasks.
-
-Knowledge documents are stored at two scopes:
-- **global** (`~/.crewly/docs/`) — company-wide documents accessible to all agents
-- **project** (`{projectPath}/.crewly/docs/`) — project-specific documents
-
-## Parameters
-
-| Parameter | Required | Description |
-|-----------|----------|-------------|
-| `query` | Yes | Search text to match against document titles, tags, and content |
-| `scope` | No | `global` (default) or `project` |
-| `category` | No | Filter by category: `SOPs`, `Team Norms`, `Architecture`, `Onboarding`, `Runbooks`, `General` |
-| `projectPath` | Conditional | Required when scope is `project` |
-
-## Examples
-
-### Search global knowledge for deployment docs
-
-```bash
-bash {{AGENT_SKILLS_PATH}}/query-knowledge/execute.sh '{"query":"deployment","scope":"global"}'
-```
-
-### Search project-specific architecture docs
-
-```bash
-bash {{AGENT_SKILLS_PATH}}/query-knowledge/execute.sh '{"query":"API design","scope":"project","projectPath":"{{PROJECT_PATH}}","category":"Architecture"}'
-```
-
-### Search for runbooks
-
-```bash
-bash {{AGENT_SKILLS_PATH}}/query-knowledge/execute.sh '{"query":"incident response","scope":"global","category":"Runbooks"}'
-```
-
-## When to Use
-
-- **Before process-oriented tasks** — search for SOPs and runbooks that describe how to do things
-- **Before architecture work** — check for existing architecture docs and design decisions
-- **When onboarding to a project** — search for onboarding guides and team norms
-- **Before answering questions** about processes, conventions, or infrastructure
-
-## Output
-
-JSON response with `success: true` and a `data` array of matching document summaries (id, title, category, tags, preview).

package/config/skills/agent/query-knowledge/skill.json

@@ -1,20 +0,0 @@
-{
-  "id": "agent-query-knowledge",
-  "name": "Query Knowledge",
-  "description": "Search the company knowledge base for SOPs, runbooks, architecture docs, and other documentation.",
-  "category": "memory",
-  "skillType": "claude-skill",
-  "promptFile": "instructions.md",
-  "execution": {
-    "type": "script",
-    "script": {
-      "file": "execute.sh",
-      "interpreter": "bash",
-      "timeoutMs": 15000
-    }
-  },
-  "assignableRoles": ["developer", "qa", "tpm", "designer", "frontend-developer", "backend-developer", "fullstack-dev", "qa-engineer", "product-manager", "architect", "generalist", "sales", "support"],
-  "triggers": ["query knowledge", "search knowledge", "find docs", "search docs", "find runbook", "find SOP"],
-  "tags": ["memory", "knowledge", "search", "documentation"],
-  "version": "1.0.0"
-}

package/config/skills/agent/read-task/execute.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-# Read the full details of a task file by its absolute path
-set -euo pipefail
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../_common/lib.sh"
-
-INPUT="${1:-}"
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"absoluteTaskPath\":\"/path/to/task\"}'"
-
-ABSOLUTE_TASK_PATH=$(echo "$INPUT" | jq -r '.absoluteTaskPath // empty')
-require_param "absoluteTaskPath" "$ABSOLUTE_TASK_PATH"
-
-BODY=$(jq -n --arg absoluteTaskPath "$ABSOLUTE_TASK_PATH" '{absoluteTaskPath: $absoluteTaskPath}')
-
-api_call POST "/task-management/read-task" "$BODY"

package/config/skills/agent/read-task/instructions.md

@@ -1,19 +0,0 @@
-# Read Task
-
-Read the full details of a task file by its absolute path. Returns the task content, metadata, status, and any subtasks.
-
-## Parameters
-
-| Parameter | Required | Description |
-|-----------|----------|-------------|
-| `absoluteTaskPath` | Yes | Absolute filesystem path to the task file |
-
-## Example
-
-```bash
-bash config/skills/agent/read-task/execute.sh '{"absoluteTaskPath":"/projects/app/tasks/implement-login.md"}'
-```
-
-## Output
-
-JSON with full task details including description, acceptance criteria, priority, status, and related files.

package/config/skills/agent/read-task/skill.json

@@ -1,20 +0,0 @@
-{
-  "id": "agent-read-task",
-  "name": "Read Task",
-  "description": "Read the full details of a task file by its absolute path.",
-  "category": "task-management",
-  "skillType": "claude-skill",
-  "promptFile": "instructions.md",
-  "execution": {
-    "type": "script",
-    "script": {
-      "file": "execute.sh",
-      "interpreter": "bash",
-      "timeoutMs": 15000
-    }
-  },
-  "assignableRoles": ["developer", "qa", "tpm", "designer", "frontend-developer", "backend-developer", "fullstack-dev", "qa-engineer", "product-manager", "architect", "generalist", "sales", "support"],
-  "triggers": ["read task", "view task", "show task", "task details"],
-  "tags": ["task", "read", "details"],
-  "version": "1.0.0"
-}

package/config/skills/agent/recall/execute.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-# Retrieve stored memories relevant to a given context
-set -euo pipefail
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../_common/lib.sh"
-
-INPUT="${1:-}"
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"agentId\":\"dev-1\",\"context\":\"authentication patterns\"}'"
-
-AGENT_ID=$(echo "$INPUT" | jq -r '.agentId // empty')
-CONTEXT=$(echo "$INPUT" | jq -r '.context // empty')
-require_param "agentId" "$AGENT_ID"
-require_param "context" "$CONTEXT"
-
-# Build body with required and optional fields
-BODY=$(echo "$INPUT" | jq '{
-  agentId: .agentId,
-  context: .context
-} +
-  (if .scope then {scope: .scope} else {} end) +
-  (if .limit then {limit: (.limit | tonumber)} else {} end) +
-  (if .projectPath then {projectPath: .projectPath} else {} end)')
-
-api_call POST "/memory/recall" "$BODY"

package/config/skills/agent/recall/instructions.md

@@ -1,23 +0,0 @@
-# Recall
-
-Retrieve stored memories relevant to a given context or query. Use this to look up past decisions, architectural patterns, or findings before starting related work.
-
-## Parameters
-
-| Parameter | Required | Description |
-|-----------|----------|-------------|
-| `agentId` | Yes | Your agent ID |
-| `context` | Yes | Search context or query describing what you want to recall |
-| `scope` | No | Filter by scope: `"project"`, `"team"`, or `"global"` |
-| `limit` | No | Maximum number of results to return |
-| `projectPath` | No | Filter by project path |
-
-## Example
-
-```bash
-bash config/skills/agent/recall/execute.sh '{"agentId":"dev-1","context":"authentication implementation patterns","scope":"project","limit":5}'
-```
-
-## Output
-
-JSON array of matching memory entries with content, category, scope, and timestamps.

package/config/skills/agent/recall/skill.json

@@ -1,20 +0,0 @@
-{
-  "id": "agent-recall",
-  "name": "Recall",
-  "description": "Retrieve stored memories relevant to a given context or query.",
-  "category": "memory",
-  "skillType": "claude-skill",
-  "promptFile": "instructions.md",
-  "execution": {
-    "type": "script",
-    "script": {
-      "file": "execute.sh",
-      "interpreter": "bash",
-      "timeoutMs": 15000
-    }
-  },
-  "assignableRoles": ["developer", "qa", "tpm", "designer", "frontend-developer", "backend-developer", "fullstack-dev", "qa-engineer", "product-manager", "architect", "generalist", "sales", "support"],
-  "triggers": ["recall", "search memory", "remember what", "look up"],
-  "tags": ["memory", "recall", "search", "context"],
-  "version": "1.0.0"
-}

package/config/skills/agent/record-learning/execute.sh

@@ -1,29 +0,0 @@
-#!/bin/bash
-# Record a learning or insight for team knowledge sharing
-set -euo pipefail
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../_common/lib.sh"
-
-INPUT="${1:-}"
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"agentId\":\"dev-1\",\"agentRole\":\"developer\",\"projectPath\":\"/projects/app\",\"learning\":\"Jest mock resets are needed between tests\"}'"
-
-AGENT_ID=$(echo "$INPUT" | jq -r '.agentId // empty')
-AGENT_ROLE=$(echo "$INPUT" | jq -r '.agentRole // empty')
-PROJECT_PATH=$(echo "$INPUT" | jq -r '.projectPath // empty')
-LEARNING=$(echo "$INPUT" | jq -r '.learning // empty')
-require_param "agentId" "$AGENT_ID"
-require_param "agentRole" "$AGENT_ROLE"
-require_param "projectPath" "$PROJECT_PATH"
-require_param "learning" "$LEARNING"
-
-# Build body with required and optional fields
-BODY=$(echo "$INPUT" | jq '{
-  agentId: .agentId,
-  agentRole: .agentRole,
-  projectPath: .projectPath,
-  learning: .learning
-} +
-  (if .relatedTask then {relatedTask: .relatedTask} else {} end) +
-  (if .relatedFiles then {relatedFiles: .relatedFiles} else {} end)')
-
-api_call POST "/memory/record-learning" "$BODY"

package/config/skills/agent/record-learning/instructions.md

@@ -1,24 +0,0 @@
-# Record Learning
-
-Record a learning or insight gained during task execution. These learnings are shared with the team and accumulated over time to improve future work.
-
-## Parameters
-
-| Parameter | Required | Description |
-|-----------|----------|-------------|
-| `agentId` | Yes | Your agent ID |
-| `agentRole` | Yes | Your role (e.g., `"developer"`, `"qa"`) |
-| `projectPath` | Yes | Absolute path to the project |
-| `learning` | Yes | Description of the learning or insight |
-| `relatedTask` | No | Path or ID of the task that triggered this learning |
-| `relatedFiles` | No | Array of file paths related to the learning |
-
-## Example
-
-```bash
-bash config/skills/agent/record-learning/execute.sh '{"agentId":"dev-1","agentRole":"developer","projectPath":"/projects/app","learning":"Jest mock resets are required between tests when using shared module mocks","relatedTask":"implement-auth-tests","relatedFiles":["src/auth.service.test.ts"]}'
-```
-
-## Output
-
-JSON confirmation that the learning was recorded.

package/config/skills/agent/record-learning/skill.json

@@ -1,20 +0,0 @@
-{
-  "id": "agent-record-learning",
-  "name": "Record Learning",
-  "description": "Record a learning or insight gained during task execution for team knowledge sharing.",
-  "category": "memory",
-  "skillType": "claude-skill",
-  "promptFile": "instructions.md",
-  "execution": {
-    "type": "script",
-    "script": {
-      "file": "execute.sh",
-      "interpreter": "bash",
-      "timeoutMs": 15000
-    }
-  },
-  "assignableRoles": ["developer", "qa", "tpm", "designer", "frontend-developer", "backend-developer", "fullstack-dev", "qa-engineer", "product-manager", "architect", "generalist", "sales", "support"],
-  "triggers": ["record learning", "learned that", "new insight", "knowledge share"],
-  "tags": ["memory", "learning", "knowledge", "insight"],
-  "version": "1.0.0"
-}

package/config/skills/agent/register-self/execute.sh

@@ -1,28 +0,0 @@
-#!/bin/bash
-# Register an agent with the Crewly backend
-set -euo pipefail
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../_common/lib.sh"
-
-INPUT="${1:-}"
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"role\":\"developer\",\"sessionName\":\"dev-1\"}'"
-
-ROLE=$(echo "$INPUT" | jq -r '.role // empty')
-SESSION_NAME=$(echo "$INPUT" | jq -r '.sessionName // empty')
-require_param "role" "$ROLE"
-require_param "sessionName" "$SESSION_NAME"
-
-# Optional: claudeSessionId for resume support
-CLAUDE_SESSION_ID=$(echo "$INPUT" | jq -r '.claudeSessionId // empty')
-TEAM_MEMBER_ID=$(echo "$INPUT" | jq -r '.teamMemberId // empty')
-
-BODY=$(jq -n \
-  --arg role "$ROLE" \
-  --arg sessionName "$SESSION_NAME" \
-  --arg claudeSessionId "$CLAUDE_SESSION_ID" \
-  --arg teamMemberId "$TEAM_MEMBER_ID" \
-  '{role: $role, sessionName: $sessionName} +
-   (if $claudeSessionId != "" then {claudeSessionId: $claudeSessionId} else {} end) +
-   (if $teamMemberId != "" then {teamMemberId: $teamMemberId} else {} end)')
-
-api_call POST "/teams/members/register" "$BODY"

package/config/skills/agent/register-self/instructions.md

@@ -1,18 +0,0 @@
-# Register Self
-
-Register this agent as active with the Crewly backend. This must be the first skill you run on startup.
-
-## Parameters
-
-| Parameter | Required | Description |
-|-----------|----------|-------------|
-| `role` | Yes | Agent role (e.g., "developer", "qa", "tpm") |
-| `sessionName` | Yes | Your session name (from your identity) |
-| `teamMemberId` | No | Your team member ID |
-| `claudeSessionId` | No | Claude session ID for resume support |
-
-## Example
-
-```bash
-bash config/skills/agent/register-self/execute.sh '{"role":"developer","sessionName":"dev-1"}'
-```

package/config/skills/agent/register-self/skill.json

@@ -1,20 +0,0 @@
-{
-  "id": "agent-register-self",
-  "name": "Register Self",
-  "description": "Register the agent as active with the Crewly backend. Must be called on startup.",
-  "category": "system",
-  "skillType": "claude-skill",
-  "promptFile": "instructions.md",
-  "execution": {
-    "type": "script",
-    "script": {
-      "file": "execute.sh",
-      "interpreter": "bash",
-      "timeoutMs": 15000
-    }
-  },
-  "assignableRoles": ["developer", "qa", "tpm", "designer", "frontend-developer", "backend-developer", "fullstack-dev", "qa-engineer", "product-manager", "architect", "generalist", "sales", "support"],
-  "triggers": ["register", "check in", "go online"],
-  "tags": ["system", "registration", "startup"],
-  "version": "1.0.0"
-}

package/config/skills/agent/remember/execute.sh

@@ -1,29 +0,0 @@
-#!/bin/bash
-# Store a memory entry for future recall
-set -euo pipefail
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../_common/lib.sh"
-
-INPUT="${1:-}"
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"agentId\":\"dev-1\",\"content\":\"The auth module uses JWT\",\"category\":\"architecture\",\"scope\":\"project\"}'"
-
-AGENT_ID=$(echo "$INPUT" | jq -r '.agentId // empty')
-CONTENT=$(echo "$INPUT" | jq -r '.content // empty')
-CATEGORY=$(echo "$INPUT" | jq -r '.category // empty')
-SCOPE=$(echo "$INPUT" | jq -r '.scope // empty')
-require_param "agentId" "$AGENT_ID"
-require_param "content" "$CONTENT"
-require_param "category" "$CATEGORY"
-require_param "scope" "$SCOPE"
-
-# Build body with required and optional fields
-BODY=$(echo "$INPUT" | jq '{
-  agentId: .agentId,
-  content: .content,
-  category: .category,
-  scope: .scope
-} +
-  (if .projectPath then {projectPath: .projectPath} else {} end) +
-  (if .metadata then {metadata: .metadata} else {} end)')
-
-api_call POST "/memory/remember" "$BODY"

package/config/skills/agent/remember/instructions.md

@@ -1,24 +0,0 @@
-# Remember
-
-Store a memory entry for future recall. Use this to persist important context, decisions, architectural findings, or patterns you discover during work.
-
-## Parameters
-
-| Parameter | Required | Description |
-|-----------|----------|-------------|
-| `agentId` | Yes | Your agent ID |
-| `content` | Yes | The content to remember |
-| `category` | Yes | Memory category (e.g., `"architecture"`, `"decision"`, `"pattern"`, `"bug"`) |
-| `scope` | Yes | Memory scope: `"project"`, `"team"`, or `"global"` |
-| `projectPath` | No | Associated project path |
-| `metadata` | No | Additional metadata object |
-
-## Example
-
-```bash
-bash config/skills/agent/remember/execute.sh '{"agentId":"dev-1","content":"Auth module uses JWT with 24h expiry. Refresh tokens stored in httpOnly cookies.","category":"architecture","scope":"project","projectPath":"/projects/app"}'
-```
-
-## Output
-
-JSON confirmation that the memory entry was stored.

package/config/skills/agent/remember/skill.json

@@ -1,20 +0,0 @@
-{
-  "id": "agent-remember",
-  "name": "Remember",
-  "description": "Store a memory entry for future recall. Use this to persist important context, decisions, or findings.",
-  "category": "memory",
-  "skillType": "claude-skill",
-  "promptFile": "instructions.md",
-  "execution": {
-    "type": "script",
-    "script": {
-      "file": "execute.sh",
-      "interpreter": "bash",
-      "timeoutMs": 15000
-    }
-  },
-  "assignableRoles": ["developer", "qa", "tpm", "designer", "frontend-developer", "backend-developer", "fullstack-dev", "qa-engineer", "product-manager", "architect", "generalist", "sales", "support"],
-  "triggers": ["remember", "save memory", "store context", "note this"],
-  "tags": ["memory", "persistence", "context"],
-  "version": "1.0.0"
-}

package/config/skills/agent/report-progress/execute.sh

@@ -1,28 +0,0 @@
-#!/bin/bash
-# Report progress on the current task
-set -euo pipefail
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/../_common/lib.sh"
-
-INPUT="${1:-}"
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"sessionName\":\"dev-1\",\"progress\":50,\"current\":\"Implementing tests\"}'"
-
-SESSION_NAME=$(echo "$INPUT" | jq -r '.sessionName // empty')
-PROGRESS=$(echo "$INPUT" | jq -r '.progress // empty')
-CURRENT=$(echo "$INPUT" | jq -r '.current // empty')
-require_param "sessionName" "$SESSION_NAME"
-require_param "progress" "$PROGRESS"
-require_param "current" "$CURRENT"
-
-# Build body with required and optional fields
-BODY=$(echo "$INPUT" | jq '{
-  sessionName: .sessionName,
-  progress: (.progress | tonumber),
-  current: .current
-} +
-  (if .completed then {completed: .completed} else {} end) +
-  (if .nextSteps then {nextSteps: .nextSteps} else {} end) +
-  (if .blockers then {blockers: .blockers} else {} end) +
-  (if .ticketId then {ticketId: .ticketId} else {} end)')
-
-api_call POST "/task-management/sync" "$BODY"