@synapse-research/synapse 0.2.12 → 0.2.14

package/dist/public/synapse-plugin/bin/on-session-start.sh

@@ -1,284 +0,0 @@
-#!/usr/bin/env bash
-# on-session-start.sh — SessionStart hook
-# Triggered on Claude Code session startup/resume.
-# Calls synapse_checkin via MCP to inject agent context.
-# Also scans for existing session files (metadata for hook state lookup).
-#
-# Output: JSON with systemMessage (user) + additionalContext (Claude)
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-API="${SCRIPT_DIR}/synapse-api.sh"
-
-# Read event JSON from stdin (if available)
-EVENT=""
-if [ ! -t 0 ]; then
-  EVENT=$(cat)
-fi
-
-# Check if Synapse environment is configured
-if [ -z "${SYNAPSE_URL:-}" ] || [ -z "${SYNAPSE_API_KEY:-}" ]; then
-  "$API" hook-output \
-    "Synapse plugin: not configured (set SYNAPSE_URL and SYNAPSE_API_KEY)" \
-    "Synapse environment not configured. Set SYNAPSE_URL and SYNAPSE_API_KEY to enable Synapse integration." \
-    "SessionStart"
-  exit 0
-fi
-
-# Call synapse_checkin via MCP
-CHECKIN_RESULT=$("$API" mcp-tool "synapse_checkin" '{}' 2>/dev/null) || {
-  "$API" hook-output \
-    "Synapse plugin: connection failed (${SYNAPSE_URL})" \
-    "WARNING: Unable to reach Synapse at ${SYNAPSE_URL}. Session lifecycle hooks will not function." \
-    "SessionStart"
-  exit 0
-}
-
-# Store owner info from checkin for SubagentStart hook to inject into sub-agent context
-if command -v jq >/dev/null 2>&1; then
-  _OWNER_NAME=$(echo "$CHECKIN_RESULT" | jq -r '.agent.owner.name // empty' 2>/dev/null) || true
-  _OWNER_EMAIL=$(echo "$CHECKIN_RESULT" | jq -r '.agent.owner.email // empty' 2>/dev/null) || true
-  _OWNER_UUID=$(echo "$CHECKIN_RESULT" | jq -r '.agent.owner.uuid // empty' 2>/dev/null) || true
-  if [ -n "$_OWNER_UUID" ]; then
-    "$API" state-set "owner_name" "$_OWNER_NAME"
-    "$API" state-set "owner_email" "$_OWNER_EMAIL"
-    "$API" state-set "owner_uuid" "$_OWNER_UUID"
-  fi
-
-  # Cache agent roles for other hooks.
-  _ROLES=$(echo "$CHECKIN_RESULT" | jq -r '.agent.roles | join(",") // empty' 2>/dev/null) || true
-  if [ -n "$_ROLES" ]; then
-    "$API" state-set "agent_roles" "$_ROLES"
-  fi
-
-  # Cache the first visible project UUID for convenience in follow-up hooks.
-  _PROJECT_UUID=$(echo "$CHECKIN_RESULT" | jq -r '
-    (.assignments.experiments[0].projectUuid // .assignments.researchQuestions[0].project.uuid) // empty
-  ' 2>/dev/null) || true
-  if [ -n "$_PROJECT_UUID" ]; then
-    "$API" state-set "project_uuid" "$_PROJECT_UUID"
-  fi
-fi
-
-# Parse pending assignments for Claude context
-ASSIGNMENTS_BLOCK=""
-if command -v jq >/dev/null 2>&1; then
-  EXP_COUNT=$(echo "$CHECKIN_RESULT" | jq -r '.assignments.experiments | length // 0' 2>/dev/null) || EXP_COUNT=0
-  QUESTION_COUNT=$(echo "$CHECKIN_RESULT" | jq -r '.assignments.researchQuestions | length // 0' 2>/dev/null) || QUESTION_COUNT=0
-  TOTAL_ASSIGNMENTS=$((EXP_COUNT + QUESTION_COUNT))
-
-  if [ "$TOTAL_ASSIGNMENTS" -gt 0 ]; then
-    ASSIGNMENTS_BLOCK="
-## Pending Assignments
-
-You have ${TOTAL_ASSIGNMENTS} pending assignment(s) from Synapse. **Ask the user before starting any of them.**
-"
-    if [ "$EXP_COUNT" -gt 0 ]; then
-      EXP_LIST=$(echo "$CHECKIN_RESULT" | jq -r '.assignments.experiments[] | "- [Experiment] \"\(.title)\" (uuid: `\(.uuid)`) — status: \(.status), project: \"\(.projectName)\""' 2>/dev/null) || true
-      if [ -n "$EXP_LIST" ]; then
-        ASSIGNMENTS_BLOCK="${ASSIGNMENTS_BLOCK}
-${EXP_LIST}"
-      fi
-    fi
-
-    if [ "$QUESTION_COUNT" -gt 0 ]; then
-      QUESTION_LIST=$(echo "$CHECKIN_RESULT" | jq -r '.assignments.researchQuestions[] | "- [Research Question] \"\(.title)\" (uuid: `\(.uuid)`) — status: \(.status), project: \"\(.project.name // "unknown")\""' 2>/dev/null) || true
-      if [ -n "$QUESTION_LIST" ]; then
-        ASSIGNMENTS_BLOCK="${ASSIGNMENTS_BLOCK}
-${QUESTION_LIST}"
-      fi
-    fi
-  fi
-fi
-
-# Parse research projects for Claude context
-PROJECTS_BLOCK=""
-if command -v jq >/dev/null 2>&1; then
-  PROJECT_COUNT=$(echo "$CHECKIN_RESULT" | jq -r '.projects | length // 0' 2>/dev/null) || PROJECT_COUNT=0
-
-  if [ "$PROJECT_COUNT" -gt 0 ]; then
-    PROJECTS_BLOCK="
-## Research Projects
-
-Ask the user which project to work on:
-"
-    PROJECT_LIST=$(echo "$CHECKIN_RESULT" | jq -r '
-      .projects | to_entries[] |
-      "\(.key + 1). \"\(.value.name)\" (uuid: `\(.value.uuid)`)\n   \(.value.relatedWorksCount) papers | deep research: \(if .value.deepResearchExists then "yes" else "no" end) | \(.value.researchQuestions | length) questions | experiments: \([.value.experimentCounts | to_entries[] | "\(.key)=\(.value)"] | join(", ") | if . == "" then "none" else . end)"
-    ' 2>/dev/null) || true
-    if [ -n "$PROJECT_LIST" ]; then
-      PROJECTS_BLOCK="${PROJECTS_BLOCK}
-${PROJECT_LIST}"
-    fi
-  else
-    PROJECTS_BLOCK="
-## Research Projects
-
-No research projects found. The user can create one on the Synapse web UI."
-  fi
-fi
-
-# Static workflow guide for Research Copilot
-WORKFLOW_GUIDE="
-## Research Copilot — Workflow Guide
-
-When the user selects a project:
-
-1. Call \`synapse_get_project_full_context({ researchProjectUuid })\` to load full context.
-2. Present the project's current state to the user:
-   - Collected papers (count + highlights if any)
-   - Deep research status
-   - Research questions (list titles)
-   - Experiments (count by status, key results if completed)
-3. Explain the full research lifecycle:
-   a. **Paper Search** — find and collect relevant papers
-   b. **Deep Research** — synthesize papers into a literature review
-   c. **Research Questions** — formulate specific research questions
-   d. **Experiments** — design, execute, and submit results
-   e. **Analysis & Iteration** — analyze results, identify gaps, loop back
-4. Based on current state, suggest the most natural next step:
-   - relatedWorksCount = 0 → suggest starting with Paper Search
-   - relatedWorksCount > 0 but deepResearchExists = false → suggest Deep Research
-   - no research questions → suggest formulating Research Questions
-   - no experiments → suggest proposing Experiments
-   - some experiments completed → suggest analyzing results and planning next iteration
-5. Tell the user they can jump to any stage — the suggestion is a guide, not a constraint.
-
-### Tool Reference by Stage
-
-Tool availability depends on the agent's Synapse roles. Public read/comment/notification/session tools are broadly available, while literature tools usually require \`pre_research\`, experiment execution tools require \`experiment\`, and project / question mutation tools depend on \`research\` or \`admin\`.
-
-**Paper Search:**
-  - \`synapse_search_papers({ query })\` — search for papers
-  - \`synapse_read_paper_brief({ arxivId })\` — quick summary (~500 tokens)
-  - \`synapse_read_paper_head({ arxivId })\` — section structure (~1-2k tokens)
-  - \`synapse_read_paper_section({ arxivId, sectionName })\` — full section
-  - \`synapse_add_related_work({ researchProjectUuid, ... })\` — add paper to project
-  - \`synapse_get_related_works({ researchProjectUuid })\` — list collected papers
-
-**Deep Research:**
-  - \`synapse_get_related_works\` — review collected papers
-  - \`synapse_get_deep_research_report({ researchProjectUuid })\` — get existing report
-  - \`synapse_save_deep_research_report({ researchProjectUuid, title, content })\` — create/update report
-  - \`synapse_complete_task({ researchProjectUuid, taskType: \"deep_research\" })\` — clear the active task when you are fulfilling a Synapse-triggered deep research request
-
-**Research Questions:**
-  - \`synapse_get_research_project({ researchProjectUuid })\` — project context
-  - \`synapse_get_research_questions({ researchProjectUuid })\` — inspect the current question set
-  - Claim / status-update tools are available only when the agent has the matching research-oriented role
-
-**Experiment Planning / Revision:**
-  - \`synapse_create_experiment({ researchProjectUuid, title, description, researchQuestionUuid?, priority?, status? })\` — create a brand-new experiment outside autonomous loop (defaults to \`draft\`; spawn a self-review sub-agent and revise before pushing to \`pending_review\`)
-  - \`synapse_review_experiment({ experimentUuid, decision, reviewNote?, assignedAgentUuid? })\` — PI/admin agents can approve into \`pending_start\` or reject back to \`draft\` from the terminal flow
-  - \`synapse_get_experiment({ experimentUuid })\` — inspect the current experiment
-  - \`synapse_get_comments({ targetType: \"experiment\", targetUuid })\` — read review feedback or @mention threads
-  - \`synapse_update_experiment_status({ experimentUuid, status: \"draft\", liveStatus: \"writing\", liveMessage })\` — mark that you are drafting or revising the plan
-  - \`synapse_update_experiment_plan({ experimentUuid, title?, description?, researchQuestionUuid?, priority? })\` — save the fleshed-out plan
-  - \`synapse_update_experiment_status({ experimentUuid, status: \"pending_review\" })\` — hand the revised plan back for review
-
-**Experiment Execution:**
-  - \`synapse_list_compute_nodes({ onlyAvailable: true, researchProjectUuid? })\` — inspect available compute
-  - \`synapse_reserve_gpus({ experimentUuid, gpuUuids })\` — reserve GPUs before running
-  - \`synapse_start_experiment({ experimentUuid })\` — begin execution
-  - \`synapse_report_experiment_progress({ experimentUuid, message, phase?, liveStatus? })\` — report progress or queueing state
-  - \`synapse_get_node_access_bundle({ experimentUuid, nodeUuid })\` — fetch managed SSH credentials
-  - \`synapse_submit_experiment_results({ experimentUuid, outcome?, experimentResults, experimentBranch?, commitSha? })\` — submit results and finish execution
-  - \`synapse_save_experiment_report({ experimentUuid, title?, content })\` — save the dedicated experiment report document when requested
-
-**Analysis:**
-  - \`synapse_get_project_full_context({ researchProjectUuid })\` — reload full state
-  - Review experiment outcomes, compute availability, and synthesis state before proposing next steps
-
-### Language
-
-Respond in the same language the user uses. If the user writes in Chinese, respond in Chinese. If in English, respond in English."
-
-# Build context for Claude (additionalContext)
-CONTEXT="# Synapse Plugin — Active
-
-Synapse is connected at ${SYNAPSE_URL}.
-Session lifecycle hooks are enabled: SubagentStart, SubagentStop, TeammateIdle, TaskCompleted.
-
-## Checkin Result
-
-${CHECKIN_RESULT}
-${ASSIGNMENTS_BLOCK}
-${PROJECTS_BLOCK}
-${WORKFLOW_GUIDE}
-
-## Session Management — IMPORTANT
-
-The Synapse Plugin **fully automates** Synapse session lifecycle:
-- Sub-agent spawn → Synapse session auto-created (or reused) + session UUID and workflow auto-injected into sub-agent context
-- Teammate idle → Synapse session heartbeat (automatic)
-- Sub-agent stop → Synapse session closed
-
-**Do NOT call synapse_create_session or synapse_close_session for sub-agents.** The plugin handles this.
-When spawning sub-agents, pass Synapse EXPERIMENT UUIDs in the prompt. Session UUID + Experiment workflow are auto-injected by SubagentStart hook.
-
-For your own session (if you are working directly, not via sub-agents):
-call synapse_list_sessions() first, then reopen or create as needed.
-
-To link a Claude Code work item to a Synapse experiment, include \`synapse:experiment:<uuid>\` in the description.
-
-## Notifications
-
-When you or your sub-agents receive @mentions or other notifications:
-- \`synapse_get_notifications()\` — fetches unread notifications and **auto-marks them as read**
-- \`synapse_get_notifications({ autoMarkRead: false })\` — peek without marking read
-- No need to call \`synapse_mark_notification_read\` separately after reading
-
-## Project Groups
-
-Projects are organized into Project Groups. If your agent has admin capabilities and needs to create a project, call \`synapse_get_project_groups()\` first so the new project lands in the correct group."
-
-# Check for existing state (resumed session)
-MAIN_SESSION=$("$API" state-get "main_session_uuid" 2>/dev/null) || true
-if [ -n "$MAIN_SESSION" ]; then
-  CONTEXT="${CONTEXT}
-
-Resuming with existing Synapse session: ${MAIN_SESSION}"
-  "$API" mcp-tool "synapse_session_heartbeat" "$(printf '{"sessionUuid":"%s"}' "$MAIN_SESSION")" >/dev/null 2>&1 || true
-fi
-
-# Plan A: Session discovery for sub-agents
-SESSIONS_DIR="${CLAUDE_PROJECT_DIR:-.}/.synapse/sessions"
-if [ -d "$SESSIONS_DIR" ]; then
-  SESSION_FILES=$(ls "$SESSIONS_DIR"/*.json 2>/dev/null) || true
-  if [ -n "$SESSION_FILES" ]; then
-    SESSION_LIST="
-
-## Pre-assigned Synapse Sessions
-
-The following Synapse sessions were auto-created by the plugin for sub-agents.
-If you are a sub-agent, find your session by matching your agent name:
-"
-    for f in $SESSION_FILES; do
-      BASENAME=$(basename "$f" .json)
-      if command -v jq &>/dev/null; then
-        S_UUID=$(jq -r '.sessionUuid // empty' "$f" 2>/dev/null) || true
-        S_NAME=$(jq -r '.agentName // empty' "$f" 2>/dev/null) || true
-      else
-        S_UUID=$(grep -o '"sessionUuid":"[^"]*"' "$f" 2>/dev/null | cut -d'"' -f4) || true
-        S_NAME="$BASENAME"
-      fi
-      if [ -n "$S_UUID" ]; then
-        SESSION_LIST="${SESSION_LIST}
-- **${S_NAME:-$BASENAME}**: sessionUuid = \`${S_UUID}\`"
-      fi
-    done
-    SESSION_LIST="${SESSION_LIST}
-
-Use your session UUID for session observability only. Execute assigned work with \`synapse_get_experiment\`, \`synapse_start_experiment\`, \`synapse_report_experiment_progress\`, and \`synapse_submit_experiment_results\`."
-    CONTEXT="${CONTEXT}${SESSION_LIST}"
-  fi
-fi
-
-# Build user-visible message
-USER_MSG="Synapse connected at ${SYNAPSE_URL}"
-if [ -n "$MAIN_SESSION" ]; then
-  USER_MSG="${USER_MSG} (resumed session)"
-fi
-
-"$API" hook-output "$USER_MSG" "$CONTEXT" "SessionStart"

package/dist/public/synapse-plugin/bin/on-subagent-start.sh

@@ -1,233 +0,0 @@
-#!/usr/bin/env bash
-# on-subagent-start.sh — SubagentStart hook
-# Triggered SYNCHRONOUSLY when a sub-agent (teammate) is spawned.
-#
-# Name resolution: Claims a per-agent pending file written by PreToolUse:Task
-# using atomic mv (only one process can successfully mv a given file).
-#
-# Session reuse logic:
-#   1. List existing sessions via MCP
-#   2. If a session with the same name exists and is active → reuse
-#   3. If it exists but is closed → reopen
-#   4. If not found → create new
-#
-# Writes minimal session metadata file for other hooks (TeammateIdle, SubagentStop).
-# Injects session UUID + workflow directly into sub-agent context via additionalContext.
-# Output: JSON with systemMessage (user) + additionalContext (sub-agent)
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-API="${SCRIPT_DIR}/synapse-api.sh"
-
-# Check environment
-if [ -z "${SYNAPSE_URL:-}" ] || [ -z "${SYNAPSE_API_KEY:-}" ]; then
-  exit 0
-fi
-
-# Read event JSON from stdin
-EVENT=""
-if [ ! -t 0 ]; then
-  EVENT=$(cat)
-fi
-
-if [ -z "$EVENT" ]; then
-  exit 0
-fi
-
-# Extract agent info from event
-# Note: SubagentStart only provides agent_id and agent_type — NOT the name
-# from the Task tool call. The name is captured by on-pre-spawn-agent.sh
-# (PreToolUse:Task) and stored as a per-agent file in .synapse/pending/.
-AGENT_ID=$(echo "$EVENT" | jq -r '.agent_id // .agentId // empty' 2>/dev/null) || true
-AGENT_TYPE=$(echo "$EVENT" | jq -r '.agent_type // .agentType // empty' 2>/dev/null) || true
-
-# Skip non-worker agent types (read-only agents don't need sessions)
-case "$(printf '%s' "$AGENT_TYPE" | tr '[:upper:]' '[:lower:]')" in
-  explore|plan|haiku|claude-code-guide|statusline-setup)
-    exit 0
-    ;;
-esac
-
-if [ -z "$AGENT_ID" ]; then
-  exit 0
-fi
-
-# Claim a pending file written by PreToolUse:Task (on-pre-spawn-agent.sh).
-# Each pending file represents one expected sub-agent spawn.
-#
-# Claim strategy (atomic mv — only one process can succeed per file):
-#   1. Try exact match: mv .synapse/pending/{agent_type} → claimed/{agent_id}
-#      (CC often sets agent_type to the name from the Task tool call)
-#   2. Fallback: claim the oldest pending file (FIFO by modification time)
-#
-# If no pending file exists, this is an internal/cleanup agent → skip.
-AGENT_NAME=""
-PENDING_DIR="${CLAUDE_PROJECT_DIR:-.}/.synapse/pending"
-CLAIMED_DIR="${CLAUDE_PROJECT_DIR:-.}/.synapse/claimed"
-mkdir -p "$CLAIMED_DIR"
-
-CLAIMED_FILE=""
-
-# Strategy 1: exact match by agent_type (CC uses name as agent_type)
-if [ -f "${PENDING_DIR}/${AGENT_TYPE}" ]; then
-  if mv "${PENDING_DIR}/${AGENT_TYPE}" "${CLAIMED_DIR}/${AGENT_ID}" 2>/dev/null; then
-    CLAIMED_FILE="${CLAIMED_DIR}/${AGENT_ID}"
-    AGENT_NAME="$AGENT_TYPE"
-  fi
-fi
-
-# Strategy 2: FIFO — claim oldest pending file
-if [ -z "$CLAIMED_FILE" ] && [ -d "$PENDING_DIR" ]; then
-  for candidate in $(ls -tr "$PENDING_DIR" 2>/dev/null); do
-    if mv "${PENDING_DIR}/${candidate}" "${CLAIMED_DIR}/${AGENT_ID}" 2>/dev/null; then
-      CLAIMED_FILE="${CLAIMED_DIR}/${AGENT_ID}"
-      # Read name from file content if available
-      FILE_NAME=$(jq -r '.name // empty' "$CLAIMED_FILE" 2>/dev/null) || true
-      AGENT_NAME="${FILE_NAME:-$candidate}"
-      break
-    fi
-    # mv failed → another process claimed it first, try next
-  done
-fi
-
-# No pending file claimed → internal/cleanup agent → skip session creation
-if [ -z "$CLAIMED_FILE" ]; then
-  exit 0
-fi
-
-# Fallback: use agent_type + short ID if no name was captured
-SESSION_NAME="${AGENT_NAME:-${AGENT_TYPE:-worker}-${AGENT_ID:0:8}}"
-
-# === Session reuse: list existing sessions, find by name ===
-SESSION_UUID=""
-SESSION_ACTION=""  # "reused" | "reopened" | "created"
-
-SESSIONS_LIST=$("$API" mcp-tool "synapse_list_sessions" '{}' 2>/dev/null) || true
-
-if [ -n "$SESSIONS_LIST" ]; then
-  # Find a session with matching name
-  # The list may be an array or an object with a sessions array
-  MATCH=$(echo "$SESSIONS_LIST" | jq -r --arg name "$SESSION_NAME" '
-    (if type == "array" then . else (.sessions // []) end)
-    | map(select(.name == $name))
-    | sort_by(.updatedAt // .createdAt)
-    | last
-    // empty
-  ' 2>/dev/null) || true
-
-  if [ -n "$MATCH" ] && [ "$MATCH" != "null" ]; then
-    MATCH_UUID=$(echo "$MATCH" | jq -r '.uuid // empty' 2>/dev/null) || true
-    MATCH_STATUS=$(echo "$MATCH" | jq -r '.status // empty' 2>/dev/null) || true
-
-    if [ -n "$MATCH_UUID" ]; then
-      if [ "$MATCH_STATUS" = "active" ]; then
-        # Active session found — reuse directly
-        SESSION_UUID="$MATCH_UUID"
-        SESSION_ACTION="reused"
-        # Send heartbeat to refresh lastActiveAt
-        "$API" mcp-tool "synapse_session_heartbeat" \
-          "$(printf '{"sessionUuid":"%s"}' "$SESSION_UUID")" >/dev/null 2>&1 || true
-      elif [ "$MATCH_STATUS" = "closed" ] || [ "$MATCH_STATUS" = "inactive" ]; then
-        # Closed/inactive session — reopen
-        REOPEN_RESPONSE=$("$API" mcp-tool "synapse_reopen_session" \
-          "$(printf '{"sessionUuid":"%s"}' "$MATCH_UUID")" 2>/dev/null) || true
-        REOPEN_UUID=$(echo "$REOPEN_RESPONSE" | jq -r '.uuid // empty' 2>/dev/null) || true
-        if [ -n "$REOPEN_UUID" ]; then
-          SESSION_UUID="$REOPEN_UUID"
-          SESSION_ACTION="reopened"
-        fi
-      fi
-    fi
-  fi
-fi
-
-# === No existing session found — create new ===
-if [ -z "$SESSION_UUID" ]; then
-  RESPONSE=$("$API" mcp-tool "synapse_create_session" \
-    "$(printf '{"name":"%s","description":"Auto-created by Synapse plugin for sub-agent %s (type: %s)"}' \
-      "$SESSION_NAME" "$AGENT_ID" "${AGENT_TYPE:-unknown}")" 2>/dev/null) || {
-    "$API" hook-output \
-      "Synapse: failed to create session for '${SESSION_NAME}'" \
-      "WARNING: Failed to create Synapse session for sub-agent '${SESSION_NAME}'. Session lifecycle will not be tracked." \
-      "SubagentStart"
-    exit 0
-  }
-
-  SESSION_UUID=$(echo "$RESPONSE" | jq -r '.uuid // empty' 2>/dev/null) || true
-
-  if [ -z "$SESSION_UUID" ]; then
-    SESSION_UUID=$(echo "$RESPONSE" | grep -oP '"uuid"\s*:\s*"([0-9a-f-]{36})"' | head -1 | grep -oP '[0-9a-f-]{36}') || true
-  fi
-
-  if [ -z "$SESSION_UUID" ]; then
-    "$API" hook-output \
-      "Synapse: session for '${SESSION_NAME}' — UUID not found in response" \
-      "WARNING: Could not extract session UUID from response for sub-agent '${SESSION_NAME}'." \
-      "SubagentStart"
-    exit 0
-  fi
-
-  SESSION_ACTION="created"
-fi
-
-# === State: store mapping for other hooks (TeammateIdle, SubagentStop) ===
-"$API" state-set "session_${AGENT_ID}" "$SESSION_UUID"
-"$API" state-set "agent_for_session_${SESSION_UUID}" "$AGENT_ID"
-"$API" state-set "session_${SESSION_NAME}" "$SESSION_UUID"
-"$API" state-set "name_for_agent_${AGENT_ID}" "$SESSION_NAME"
-
-# === Session file: minimal metadata for other hooks (TeammateIdle, SubagentStop) ===
-SESSIONS_DIR="${CLAUDE_PROJECT_DIR:-.}/.synapse/sessions"
-mkdir -p "$SESSIONS_DIR"
-
-cat > "${SESSIONS_DIR}/${SESSION_NAME}.json" <<SESSIONEOF
-{
-  "sessionUuid": "${SESSION_UUID}",
-  "agentId": "${AGENT_ID}",
-  "agentName": "${SESSION_NAME}",
-  "agentType": "${AGENT_TYPE:-unknown}",
-  "sessionAction": "${SESSION_ACTION}",
-  "createdAt": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-}
-SESSIONEOF
-
-# === Owner info: read from state (stored by on-session-start.sh from checkin response) ===
-OWNER_SECTION=""
-OWNER_UUID=$("$API" state-get "owner_uuid" 2>/dev/null) || true
-if [ -n "$OWNER_UUID" ]; then
-  OWNER_NAME=$("$API" state-get "owner_name" 2>/dev/null) || true
-  OWNER_EMAIL=$("$API" state-get "owner_email" 2>/dev/null) || true
-  OWNER_SECTION="
-## Owner Info
-
-Your owner (the human who created your API key): ${OWNER_NAME} (${OWNER_EMAIL}), UUID: ${OWNER_UUID}
-Use this info when you need to @mention your owner in comments."
-fi
-
-# === Output: inject workflow directly into sub-agent context via additionalContext ===
-WORKFLOW="## Synapse Session (Auto-injected by plugin)
-
-Your Synapse session UUID is: ${SESSION_UUID}
-Your session name is: ${SESSION_NAME}
-The plugin manages session lifecycle (heartbeat, close). Do NOT call synapse_create_session or synapse_close_session.
-
-### Workflow — follow these steps for each assigned experiment:
-
-**Before starting:**
-1. Read the experiment: synapse_get_experiment({ experimentUuid: \"<EXPERIMENT_UUID>\" })
-2. If the experiment is ready to execute, start it: synapse_start_experiment({ experimentUuid: \"<EXPERIMENT_UUID>\" })
-
-**While working:**
-3. Report major milestones with synapse_report_experiment_progress({ experimentUuid: \"<EXPERIMENT_UUID>\", message: \"...\", phase: \"setup|training|evaluation|analysis\" })
-4. Add comments for durable decisions or findings with synapse_add_comment({ targetType: \"experiment\", targetUuid: \"<EXPERIMENT_UUID>\", content: \"...\" })
-
-**After completing:**
-5. Submit the outcome with synapse_submit_experiment_results({ experimentUuid: \"<EXPERIMENT_UUID>\", outcome: \"success|failure|inconclusive\", experimentResults: \"...\" })
-
-Replace <EXPERIMENT_UUID> with the actual Synapse experiment UUID from your prompt.${OWNER_SECTION}"
-
-"$API" hook-output \
-  "Synapse session ${SESSION_ACTION}: '${SESSION_NAME}' (${SESSION_UUID:0:8}...)" \
-  "$WORKFLOW" \
-  "SubagentStart"

package/dist/public/synapse-plugin/bin/on-subagent-stop.sh

@@ -1,80 +0,0 @@
-#!/usr/bin/env bash
-# on-subagent-stop.sh — SubagentStop hook
-# Triggered when a sub-agent (teammate) exits.
-# Closes the Synapse session and cleans up local plugin state.
-#
-# Output: JSON with systemMessage (user) + additionalContext (Claude)
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-API="${SCRIPT_DIR}/synapse-api.sh"
-
-# Check environment
-if [ -z "${SYNAPSE_URL:-}" ] || [ -z "${SYNAPSE_API_KEY:-}" ]; then
-  exit 0
-fi
-
-# Read event JSON from stdin
-EVENT=""
-if [ ! -t 0 ]; then
-  EVENT=$(cat)
-fi
-
-if [ -z "$EVENT" ]; then
-  exit 0
-fi
-
-# Extract agent ID from event
-# Note: SubagentStop only provides agent_id and agent_type — NOT the name.
-# We look up the name from state (stored by SubagentStart).
-AGENT_ID=$(echo "$EVENT" | jq -r '.agent_id // .agentId // empty' 2>/dev/null) || true
-
-if [ -z "$AGENT_ID" ]; then
-  exit 0
-fi
-
-# Lookup session UUID and agent name from state
-SESSION_UUID=$("$API" state-get "session_${AGENT_ID}" 2>/dev/null) || true
-AGENT_NAME=$("$API" state-get "name_for_agent_${AGENT_ID}" 2>/dev/null) || true
-
-if [ -z "$SESSION_UUID" ]; then
-  exit 0
-fi
-
-# Close the Synapse session via MCP
-CLOSE_OK=true
-"$API" mcp-tool "synapse_close_session" "$(printf '{"sessionUuid":"%s"}' "$SESSION_UUID")" >/dev/null 2>&1 || CLOSE_OK=false
-
-# Clean up state
-"$API" state-delete "session_${AGENT_ID}" 2>/dev/null || true
-"$API" state-delete "agent_for_session_${SESSION_UUID}" 2>/dev/null || true
-"$API" state-delete "name_for_agent_${AGENT_ID}" 2>/dev/null || true
-if [ -n "$AGENT_NAME" ]; then
-  "$API" state-delete "session_${AGENT_NAME}" 2>/dev/null || true
-fi
-
-# Clean up session file
-SESSIONS_DIR="${CLAUDE_PROJECT_DIR:-.}/.synapse/sessions"
-if [ -n "$AGENT_NAME" ] && [ -f "${SESSIONS_DIR}/${AGENT_NAME}.json" ]; then
-  rm -f "${SESSIONS_DIR}/${AGENT_NAME}.json"
-fi
-
-# Clean up claimed file (written by SubagentStart)
-CLAIMED_DIR="${CLAUDE_PROJECT_DIR:-.}/.synapse/claimed"
-if [ -n "$AGENT_ID" ] && [ -f "${CLAIMED_DIR}/${AGENT_ID}" ]; then
-  rm -f "${CLAIMED_DIR}/${AGENT_ID}"
-fi
-
-# === Output ===
-DISPLAY_NAME="${AGENT_NAME:-${AGENT_ID:0:8}}"
-if [ "$CLOSE_OK" = true ]; then
-  USER_MSG="Synapse session closed: '${DISPLAY_NAME}'"
-  CONTEXT_MSG="Synapse session ${SESSION_UUID} for sub-agent '${DISPLAY_NAME}' closed. Local state and session file cleaned up."
-  "$API" hook-output "$USER_MSG" "$CONTEXT_MSG" "SubagentStop"
-else
-  "$API" hook-output \
-    "Synapse: failed to close session for '${DISPLAY_NAME}'" \
-    "WARNING: Failed to close Synapse session ${SESSION_UUID} for sub-agent '${DISPLAY_NAME}'. State cleaned up locally." \
-    "SubagentStop"
-fi

package/dist/public/synapse-plugin/bin/on-task-completed.sh

@@ -1,66 +0,0 @@
-#!/usr/bin/env bash
-# on-task-completed.sh — TaskCompleted lifecycle hook
-# Triggered when a Claude Code work item is marked completed.
-# Checks for a Synapse experiment UUID marker in the metadata/description and
-# reminds the agent to finish the corresponding Experiment lifecycle in Synapse.
-#
-# Output: JSON with systemMessage (user) when a checkout happens
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-API="${SCRIPT_DIR}/synapse-api.sh"
-
-# Check environment
-if [ -z "${SYNAPSE_URL:-}" ] || [ -z "${SYNAPSE_API_KEY:-}" ]; then
-  exit 0
-fi
-
-# Read event JSON from stdin
-EVENT=""
-if [ ! -t 0 ]; then
-  EVENT=$(cat)
-fi
-
-if [ -z "$EVENT" ]; then
-  exit 0
-fi
-
-# Extract work-item info
-TASK_DESCRIPTION=$(echo "$EVENT" | jq -r '.task_description // .taskDescription // .description // empty' 2>/dev/null) || true
-TASK_SUBJECT=$(echo "$EVENT" | jq -r '.task_subject // .taskSubject // .subject // empty' 2>/dev/null) || true
-AGENT_ID=$(echo "$EVENT" | jq -r '.agent_id // .agentId // empty' 2>/dev/null) || true
-
-# Look for synapse:experiment:<uuid> (preferred) with quiet fallback support
-# for older metadata bridges.
-SYNAPSE_EXPERIMENT_UUID=""
-MATCH_PREFIX=""
-
-for text in "$TASK_DESCRIPTION" "$TASK_SUBJECT"; do
-  if [ -n "$text" ]; then
-    MATCH=$(echo "$text" | grep -oP 'synapse:(?:experiment|experiment_run|task):([0-9a-f-]{36})' | head -1) || true
-    if [ -n "$MATCH" ]; then
-      MATCH_PREFIX=$(echo "$MATCH" | cut -d: -f2)
-      SYNAPSE_EXPERIMENT_UUID=$(echo "$MATCH" | sed -E 's/synapse:(experiment|experiment_run|task)://')
-      break
-    fi
-  fi
-done
-
-if [ -z "$SYNAPSE_EXPERIMENT_UUID" ]; then
-  exit 0
-fi
-
-if [ "$MATCH_PREFIX" = "experiment" ]; then
-  CONTEXT="Claude Code work item references Synapse experiment ${SYNAPSE_EXPERIMENT_UUID}.
-If the experiment is complete, call synapse_submit_experiment_results.
-If work is still ongoing, call synapse_report_experiment_progress and keep the Experiment status current."
-else
-  CONTEXT="Legacy Synapse metadata marker detected for ${SYNAPSE_EXPERIMENT_UUID}.
-Translate this work item back to the current Experiment workflow and finish with synapse_report_experiment_progress or synapse_submit_experiment_results."
-fi
-
-"$API" hook-output \
-  "Synapse: work item linked to experiment ${SYNAPSE_EXPERIMENT_UUID:0:8}..." \
-  "$CONTEXT" \
-  "TaskCompleted"