crewly 1.0.0

package/config/skills/orchestrator/record-failure/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "orc-record-failure",
+  "name": "Record Failure",
+  "description": "Record a failed approach or pitfall so the team can avoid repeating it.",
+  "category": "memory",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 15000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["record failure", "failed approach", "what failed", "note failure", "avoid this"],
+  "tags": ["memory", "failure", "pitfalls", "lessons-learned"],
+  "version": "1.0.0"
+}

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

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Quickly record a learning or discovery
+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 '{\"learning\":\"Always check agent status before delegating\",\"teamMemberId\":\"...\"}'"
+
+LEARNING=$(echo "$INPUT" | jq -r '.learning // empty')
+require_param "learning" "$LEARNING"
+
+api_call POST "/memory/record-learning" "$INPUT"

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

@@ -0,0 +1,23 @@
+# Record Learning
+
+Quickly record a learning or discovery. Simpler than `remember` — good for jotting down learnings.
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/record-learning/execute.sh '{"learning":"Always check agent status before delegating","teamMemberId":"crewly-orc"}'
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `learning` | Yes | What you learned |
+| `relatedTask` | No | Task this learning relates to |
+| `relatedFiles` | No | Array of file paths related to the learning |
+| `teamMemberId` | No | Your session name |
+| `projectPath` | No | Current project path |
+
+## Output
+
+JSON confirmation with the stored learning entry ID.

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

@@ -0,0 +1,20 @@
+{
+  "id": "orc-record-learning",
+  "name": "Record Learning",
+  "description": "Quickly record a learning or discovery while working on a task.",
+  "category": "memory",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 15000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["record learning", "learned that", "note discovery"],
+  "tags": ["memory", "learning", "quick-note"],
+  "version": "1.0.0"
+}

package/config/skills/orchestrator/record-success/execute.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Record a successful pattern or approach
+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 '{\"description\":\"...\",\"projectPath\":\"...\",\"teamMemberId\":\"...\",\"context\":\"...\"}'"
+
+DESCRIPTION=$(echo "$INPUT" | jq -r '.description // empty')
+require_param "description" "$DESCRIPTION"
+
+api_call POST "/memory/record-success" "$INPUT"

package/config/skills/orchestrator/record-success/instructions.md

@@ -0,0 +1,22 @@
+# Record Success
+
+Record a successful pattern or approach so the team can replicate it in the future.
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/record-success/execute.sh '{"description":"Breaking large tasks into sub-tasks of 30 min or less reduced errors by 50%","projectPath":"/path/to/project","teamMemberId":"crewly-orc","context":"sprint-12 refactoring"}'
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `description` | Yes | What succeeded and why it worked |
+| `projectPath` | No | Path to the project where this succeeded |
+| `teamMemberId` | No | Your session name |
+| `context` | No | Additional context about when/where this succeeded |
+
+## Output
+
+JSON confirmation with the stored success entry.

package/config/skills/orchestrator/record-success/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "orc-record-success",
+  "name": "Record Success",
+  "description": "Record a successful pattern or approach so the team can replicate it in the future.",
+  "category": "memory",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 15000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["record success", "successful pattern", "what worked", "note success"],
+  "tags": ["memory", "success", "patterns", "best-practices"],
+  "version": "1.0.0"
+}

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

@@ -0,0 +1,24 @@
+#!/bin/bash
+# Register the orchestrator 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\":\"orchestrator\",\"sessionName\":\"crewly-orc\"}'"
+
+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')
+
+BODY=$(jq -n \
+  --arg role "$ROLE" \
+  --arg sessionName "$SESSION_NAME" \
+  --arg claudeSessionId "$CLAUDE_SESSION_ID" \
+  '{role: $role, sessionName: $sessionName} + (if $claudeSessionId != "" then {claudeSessionId: $claudeSessionId} else {} end)')
+
+api_call POST "/teams/members/register" "$BODY"

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

@@ -0,0 +1,21 @@
+# Register Self
+
+Registers the orchestrator as active with the Crewly backend. Call this immediately on startup.
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/register-self/execute.sh '{"role":"orchestrator","sessionName":"crewly-orc"}'
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `role` | Yes | Your role, typically `"orchestrator"` |
+| `sessionName` | Yes | Your PTY session name (use `{{SESSION_ID}}`) |
+| `claudeSessionId` | No | Claude session ID for resume support |
+
+## Output
+
+JSON confirmation of registration status.

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

@@ -0,0 +1,20 @@
+{
+  "id": "orc-register-self",
+  "name": "Register Self",
+  "description": "Register the orchestrator 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": ["orchestrator"],
+  "triggers": ["register", "check in", "go online"],
+  "tags": ["system", "registration", "startup"],
+  "version": "1.0.0"
+}

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

@@ -0,0 +1,15 @@
+#!/bin/bash
+# Store knowledge in agent memory for future reference
+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 '{\"content\":\"...\",\"category\":\"pattern\",\"scope\":\"agent\",\"teamMemberId\":\"...\",\"projectPath\":\"...\"}'"
+
+CONTENT=$(echo "$INPUT" | jq -r '.content // empty')
+CATEGORY=$(echo "$INPUT" | jq -r '.category // empty')
+require_param "content" "$CONTENT"
+require_param "category" "$CATEGORY"
+
+api_call POST "/memory/remember" "$INPUT"

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

@@ -0,0 +1,24 @@
+# Remember
+
+Store knowledge in your persistent memory for future reference.
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/remember/execute.sh '{"content":"TypeScript strict mode is required","category":"pattern","scope":"project","teamMemberId":"crewly-orc","projectPath":"/path/to/project"}'
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `content` | Yes | The knowledge to store |
+| `category` | Yes | Category: `pattern`, `decision`, `gotcha`, `fact`, `preference`, `relationship` |
+| `scope` | No | Scope: `agent` or `project` (default: `agent`) |
+| `title` | No | Optional title for the knowledge |
+| `teamMemberId` | No | Your session name |
+| `projectPath` | No | Current project path |
+
+## Output
+
+JSON with the stored knowledge entry ID.

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

@@ -0,0 +1,20 @@
+{
+  "id": "orc-remember",
+  "name": "Remember",
+  "description": "Store knowledge in memory for future reference. Persists across sessions.",
+  "category": "memory",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 15000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["remember", "store knowledge", "save memory"],
+  "tags": ["memory", "knowledge", "persistence"],
+  "version": "1.0.0"
+}

package/config/skills/orchestrator/reply-slack/execute.sh

@@ -0,0 +1,174 @@
+#!/bin/bash
+# Send a message to a Slack channel or thread via the backend API
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../_common/lib.sh"
+
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  # Legacy JSON argument
+  bash execute.sh '{"channelId":"C0123","text":"Hello"}'
+
+  # Flag-based invocation with multi-line text from stdin
+  cat message.txt | bash execute.sh --channel C0123
+
+  # Upload an image with optional comment
+  bash execute.sh --channel C0123 --image /path/to/screenshot.png --text "Here's the result"
+
+Options:
+  --channel | -c   Slack channel ID (required unless JSON provided)
+  --text    | -t   Message text (optional when piping stdin)
+  --text-file     Read message text from the specified file path
+  --thread  | -r   Slack thread timestamp for replies
+  --image   | -i   Path to image file to upload (uses /api/slack/upload-image)
+  --json    | -j   Raw JSON payload (same as legacy usage)
+  --help    | -h   Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+CHANNEL_ID=""
+TEXT=""
+THREAD_TS=""
+IMAGE_PATH=""
+
+# Detect legacy JSON argument as the first parameter
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+CONVERSATION_ID=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --channel|-c)
+      CHANNEL_ID="$2"
+      shift 2
+      ;;
+    --text|-t)
+      TEXT="$2"
+      shift 2
+      ;;
+    --text-file)
+      TEXT="$(cat "$2")"
+      shift 2
+      ;;
+    --thread|-r)
+      THREAD_TS="$2"
+      shift 2
+      ;;
+    --image|-i)
+      IMAGE_PATH="$2"
+      shift 2
+      ;;
+    --conversation|-C)
+      CONVERSATION_ID="$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"
+      fi
+      ;;
+  esac
+done
+
+# If nothing provided yet, but stdin has data, read it
+if [ -z "$INPUT_JSON" ] && [ -z "$TEXT" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  else
+    TEXT="$STDIN_DATA"
+  fi
+fi
+
+if [ -n "$INPUT_JSON" ]; then
+  CHANNEL_ID=${CHANNEL_ID:-$(echo "$INPUT_JSON" | jq -r '.channelId // empty')}
+  TEXT=${TEXT:-$(echo "$INPUT_JSON" | jq -r '.text // empty')}
+  THREAD_TS=${THREAD_TS:-$(echo "$INPUT_JSON" | jq -r '.threadTs // empty')}
+  CONVERSATION_ID=${CONVERSATION_ID:-$(echo "$INPUT_JSON" | jq -r '.conversationId // empty')}
+fi
+
+require_param "channelId" "$CHANNEL_ID"
+
+# Convert literal \n sequences to real newlines.
+# This fixes a common issue where callers pass text through JSON.stringify()
+# which escapes newlines to literal \n characters that Slack displays as text.
+if [ -n "$TEXT" ]; then
+  _NL=$'\n'
+  TEXT="${TEXT//\\n/$_NL}"
+fi
+
+# When uploading an image, text is optional (serves as initial_comment)
+if [ -z "$IMAGE_PATH" ] && [ -z "$TEXT" ]; then
+  error_exit "Slack message text is required. Pass --text, --text-file, pipe stdin, or include it in the JSON payload."
+fi
+
+if [ -n "$IMAGE_PATH" ]; then
+  # Image upload mode — use /api/slack/upload-image
+  BODY=$(jq -n \
+    --arg channelId "$CHANNEL_ID" \
+    --arg filePath "$IMAGE_PATH" \
+    --arg initialComment "${TEXT:-}" \
+    --arg threadTs "${THREAD_TS:-}" \
+    '{channelId: $channelId, filePath: $filePath} +
+     (if $initialComment != "" then {initialComment: $initialComment} else {} end) +
+     (if $threadTs != "" then {threadTs: $threadTs} else {} end)')
+
+  api_call POST "/slack/upload-image" "$BODY"
+else
+  # Text-only mode — use /api/slack/send
+  if [ -n "$THREAD_TS" ]; then
+    BODY=$(jq -n --arg channelId "$CHANNEL_ID" --arg text "$TEXT" --arg threadTs "$THREAD_TS" \
+      '{channelId: $channelId, text: $text, threadTs: $threadTs}')
+  else
+    BODY=$(jq -n --arg channelId "$CHANNEL_ID" --arg text "$TEXT" \
+      '{channelId: $channelId, text: $text}')
+  fi
+
+  api_call POST "/slack/send" "$BODY"
+fi
+
+# Emit a [NOTIFY] block so the chat service/logs capture this reply and
+# unblock any pending Slack queue items. conversationId is optional –
+# TerminalGateway will fall back to the active conversation when omitted.
+{
+  echo "[NOTIFY]"
+  echo "type: slack_reply"
+  echo "title: Slack Reply"
+  if [ -n "$CONVERSATION_ID" ]; then
+    echo "conversationId: $CONVERSATION_ID"
+  fi
+  echo "channelId: $CHANNEL_ID"
+  if [ -n "$THREAD_TS" ]; then
+    echo "threadTs: $THREAD_TS"
+  fi
+  echo "---"
+  if [ -n "$IMAGE_PATH" ]; then
+    printf 'Image uploaded: %s\n' "$IMAGE_PATH"
+    if [ -n "$TEXT" ]; then
+      printf '%s\n' "$TEXT"
+    fi
+  else
+    printf '%s\n' "$TEXT"
+  fi
+  echo "[/NOTIFY]"
+} >&2

package/config/skills/orchestrator/reply-slack/instructions.md

@@ -0,0 +1,52 @@
+# Reply Slack
+
+Send a message to a Slack channel or thread via the Crewly backend API. This bypasses terminal output parsing and delivers the message directly to Slack, avoiding PTY line-wrapping and ANSI artifacts.
+
+## Usage
+
+```bash
+# Legacy JSON argument (kept for backwards compatibility)
+bash config/skills/orchestrator/reply-slack/execute.sh '{"channelId":"C0123","text":"Task completed successfully!"}'
+
+# Recommended multi-line usage with stdin
+cat <<'EOF' | bash config/skills/orchestrator/reply-slack/execute.sh --channel C0123 --conversation "$CHAT_CONVERSATION"
+Deploy complete ✅
+
+Tests are green and artifacts published.
+EOF
+```
+
+With thread reply (any style):
+
+```bash
+bash config/skills/orchestrator/reply-slack/execute.sh '{"channelId":"C0123","text":"Update: tests passing","threadTs":"1707430000.001234"}'
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `channelId` / `--channel` | Yes | Slack channel ID to send the message to |
+| `text` / `--text` / stdin | Yes* | Message text (supports Slack Markdown). You can pipe multi-line text via stdin with `--channel`. *Optional when `--image` is provided |
+| `threadTs` / `--thread` | No | Thread timestamp for threaded replies |
+| `--image` / `-i` | No | Path to an image file to upload to Slack. When provided, calls `/api/slack/upload-image` instead of `/api/slack/send`. The `--text` becomes an optional comment on the image |
+| `conversationId` / `--conversation` | No | Conversation ID from the `[CHAT:...]` prefix so the queue can resolve instantly (falls back to the active conversation if omitted) |
+
+## Image Upload
+
+To send an image to Slack:
+
+```bash
+bash config/skills/orchestrator/reply-slack/execute.sh \
+  --channel C0123 \
+  --image /path/to/screenshot.png \
+  --text "Here's the test result"
+```
+
+Supported image types: PNG, JPEG, GIF, WebP, SVG. Max file size: 20 MB.
+
+## Output
+
+JSON confirmation with the Slack message timestamp (text) or file ID (image) on success.
+
+> **Heads up:** After a successful API call the script automatically emits a `[NOTIFY]` block so the backend logs the reply and unblocks any pending Slack messages. If you pass `--conversation`, that ID is embedded in the header. Otherwise TerminalGateway will associate the notify block with the active conversation.

package/config/skills/orchestrator/reply-slack/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "orc-reply-slack",
+  "name": "Reply Slack",
+  "description": "Send a message to a Slack channel or thread via the backend API.",
+  "category": "communication",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 30000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["reply slack", "send slack", "slack message"],
+  "tags": ["communication", "slack", "notification"],
+  "version": "1.0.0"
+}

package/config/skills/orchestrator/restart-crewly/execute.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+# Gracefully restart the Crewly backend server
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../_common/lib.sh"
+
+api_call POST "/system/restart"

package/config/skills/orchestrator/restart-crewly/instructions.md

@@ -0,0 +1,23 @@
+# Restart Crewly
+
+Gracefully restart the Crewly backend server. All PTY sessions are saved before shutdown and will be auto-resumed on restart (if the auto-resume setting is enabled).
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/restart-crewly/execute.sh
+```
+
+## Parameters
+
+None required.
+
+## Output
+
+JSON confirming the restart was initiated and how many sessions were saved.
+
+## Notes
+
+- The server process exits with code 0 after saving state
+- The external process manager (nodemon, systemd, ECS) handles restarting
+- Agents will auto-resume their previous sessions on restart if the "Auto-Resume on Restart" setting is enabled

package/config/skills/orchestrator/restart-crewly/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "orc-restart-crewly",
+  "name": "Restart Crewly",
+  "description": "Gracefully restart the Crewly backend server. Sessions are saved and auto-resumed on restart.",
+  "category": "management",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 30000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["restart crewly", "restart backend", "restart server", "reboot server"],
+  "tags": ["system", "management", "restart", "server"],
+  "version": "1.0.0"
+}

package/config/skills/orchestrator/resume-session/execute.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+# Resume a Claude Code agent's most recent conversation session
+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\":\"agent-session\"}'"
+
+SESSION_NAME=$(echo "$INPUT" | jq -r '.sessionName // empty')
+require_param "sessionName" "$SESSION_NAME"
+
+# Step 1: Send /resume command to the agent's session
+BODY=$(jq -n --arg message "/resume" '{message: $message}')
+api_call POST "/terminal/${SESSION_NAME}/deliver" "$BODY"
+
+# Step 2: Wait for Claude Code to render the session picker
+sleep 3
+
+# Step 3: Send Enter to select the most recent (first) session
+KEY_BODY=$(jq -n '{key: "Enter"}')
+api_call POST "/terminal/${SESSION_NAME}/key" "$KEY_BODY"

package/config/skills/orchestrator/resume-session/instructions.md

@@ -0,0 +1,31 @@
+# Resume Session
+
+Resumes a Claude Code agent's most recent conversation using the `/resume` slash command. This preserves the full previous conversation context (tool calls, file reads, history) instead of starting a brand new session with a lossy context dump.
+
+## How It Works
+
+1. Sends `/resume` to the target agent's Claude Code session via the `/deliver` endpoint
+2. Waits for Claude Code to render the session picker (3 seconds)
+3. Sends Enter to select the most recent (first) session in the picker
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/resume-session/execute.sh '{"sessionName":"agent-joe"}'
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `sessionName` | Yes | Target agent's PTY session name |
+
+## Output
+
+JSON confirmation from the deliver and key endpoints.
+
+## Notes
+
+- This skill only works with Claude Code runtimes. On other runtimes, `/resume` is treated as a normal message (harmless but no-op).
+- The agent must have a previous session to resume. If no previous session exists, Claude Code will show an empty picker and Enter will dismiss it.
+- Prefer this over `delegate-task` with full context when you want to restore an agent's prior conversation rather than start fresh.

package/config/skills/orchestrator/resume-session/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "orc-resume-session",
+  "name": "Resume Session",
+  "description": "Resume a Claude Code agent's most recent conversation using /resume.",
+  "category": "management",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 30000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["resume session", "resume conversation", "resume agent"],
+  "tags": ["session", "resume", "management"],
+  "version": "1.0.0"
+}