claude-code-swarm 0.3.12 → 0.3.16

package/.claude-plugin/marketplace.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-swarm",
-  "version": "0.3.12",
+  "version": "0.3.16",
   "description": "Launch Claude Code with swarmkit capabilities, including team orchestration, MAP observability, and session tracking.",
   "owner": {
     "name": "alexngai"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-code-swarm",
   "description": "Spin up Claude Code agent teams from openteams YAML topologies with optional MAP (Multi-Agent Protocol) observability and coordination. Provides hooks for session lifecycle, agent spawn/complete tracking, and a /swarm skill to launch team configurations.",
-  "version": "0.3.12",
+  "version": "0.3.16",
   "author": {
     "name": "alexngai"
   },

package/hooks/hooks.json

@@ -10,7 +10,7 @@
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch session-start; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch session-start"
           }
         ]
       }
@@ -21,7 +21,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch session-end; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch session-end"
           }
         ]
       }
@@ -32,11 +32,11 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" inject; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" inject"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch user-prompt-submit; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch user-prompt-submit"
           }
         ]
       }
@@ -47,7 +47,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch pre-task; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch pre-task"
           }
         ]
       }
@@ -58,7 +58,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit((c.opentasks?.enabled||process.env.SWARM_OPENTASKS_ENABLED)&&(c.map?.enabled||c.map?.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED)?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" opentasks-mcp-used; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit((c.opentasks?.enabled||process.env.SWARM_OPENTASKS_ENABLED)&&(c.map?.enabled||c.map?.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED)?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" opentasks-mcp-used"
           }
         ]
       },
@@ -67,7 +67,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task"
           }
         ]
       },
@@ -76,11 +76,11 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" native-task-created; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" native-task-created"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task-create; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task-create"
           }
         ]
       },
@@ -89,11 +89,11 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" native-task-updated; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" native-task-updated"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task-update; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task-update"
           }
         ]
       },
@@ -102,7 +102,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-todo; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-todo"
           }
         ]
       },
@@ -111,7 +111,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-plan-enter; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-plan-enter"
           }
         ]
       },
@@ -120,7 +120,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-plan-exit; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-plan-exit"
           }
         ]
       },
@@ -129,7 +129,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-skill; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-skill"
           }
         ]
       }
@@ -140,15 +140,15 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" turn-completed; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" turn-completed"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));const m=c.map||{};process.exit((m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED)&&c.sessionlog?.sync&&c.sessionlog.sync!=='off'?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-sync; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit((m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED)&&c.sessionlog?.sync&&c.sessionlog.sync!=='off'?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-sync"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch stop; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch stop"
           }
         ]
       }
@@ -159,7 +159,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" subagent-start; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" subagent-start"
           }
         ]
       }
@@ -170,7 +170,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" subagent-stop; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" subagent-stop"
           }
         ]
       }
@@ -181,7 +181,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" teammate-idle; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" teammate-idle"
           }
         ]
       }
@@ -192,7 +192,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" task-completed; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" task-completed"
           }
         ]
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-swarm",
-  "version": "0.3.12",
+  "version": "0.3.16",
   "description": "Claude Code plugin for launching agent teams from openteams topologies with MAP observability",
   "type": "module",
   "exports": {
@@ -18,7 +18,7 @@
     "swarm-generate-agents": "./scripts/generate-agents.mjs"
   },
   "dependencies": {
-    "@multi-agent-protocol/sdk": "^0.1.4",
+    "@multi-agent-protocol/sdk": "^0.1.8",
     "agentic-mesh": "^0.2.0",
     "js-yaml": "^4.1.0"
   },
@@ -55,7 +55,7 @@
   "devDependencies": {
     "agent-inbox": "^0.1.9",
     "minimem": "^0.1.0",
-    "opentasks": "^0.0.6",
+    "opentasks": "^0.0.8",
     "skill-tree": "^0.1.5",
     "vitest": "^4.0.18",
     "ws": "^8.0.0"

package/scripts/map-sidecar.mjs

@@ -24,6 +24,7 @@ import { SOCKET_PATH, PID_PATH, INBOX_SOCKET_PATH, sessionPaths, pluginDir } fro
 import { connectToMAP } from "../src/map-connection.mjs";
 import { createMeshPeer, createMeshInbox } from "../src/mesh-connection.mjs";
 import { createSocketServer, createCommandHandler } from "../src/sidecar-server.mjs";
+import { createContentProvider } from "../src/content-provider.mjs";
 import { readConfig } from "../src/config.mjs";
 import { createLogger, init as initLog } from "../src/log.mjs";
 import { configureNodePath, resolvePackage } from "../src/swarmkit-resolver.mjs";
@@ -50,6 +51,38 @@ const RECONNECT_INTERVAL_MS = parseInt(getArg("reconnect-interval", ""), 10) ||
 // Auth credential for server-driven auth negotiation (opaque — type determined by server)
 const AUTH_CREDENTIAL = getArg("credential", "");
 
+// Project context for swarm identification (sent as agent metadata)
+import { execSync } from "child_process";
+function getProjectContext() {
+  const context = {};
+  try { context.project = path.basename(process.cwd()); } catch {}
+  try {
+    context.branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {}
+  try {
+    const config = readConfig();
+    if (config.template) context.template = config.template;
+
+    // Include task_graph metadata when opentasks is enabled
+    if (config.opentasks?.enabled) {
+      try {
+        const opentasksDir = path.resolve(".opentasks");
+        const configPath = path.join(opentasksDir, "config.json");
+        const taskGraph = { path: opentasksDir };
+        if (fs.existsSync(configPath)) {
+          const otConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+          if (otConfig.location?.hash) taskGraph.location_hash = otConfig.location.hash;
+        }
+        context.task_graph = taskGraph;
+      } catch { /* opentasks config not available */ }
+    }
+  } catch {}
+  return context;
+}
+const PROJECT_CONTEXT = getProjectContext();
+
 // Configure NODE_PATH so dynamic imports of globally-installed packages
 // (@multi-agent-protocol/sdk, agent-inbox, agentic-mesh) resolve correctly.
 // Must happen before any dynamic import() calls.
@@ -186,6 +219,7 @@ function startSlowReconnectLoop() {
         scope: MAP_SCOPE,
         systemId: SYSTEM_ID,
         credential: AUTH_CREDENTIAL || undefined,
+        projectContext: PROJECT_CONTEXT,
         onMessage: () => resetInactivityTimer(),
       });
 
@@ -300,15 +334,77 @@ async function tryMeshTransport() {
   return true;
 }
 
+/**
+ * Register opentasks notification handlers on a MAP connection.
+ * Delegates to the extracted opentasks-connector module for testability.
+ */
+async function registerOpenTasksHandler(conn) {
+  const { registerOpenTasksHandler: _register } = await import("../src/opentasks-connector.mjs");
+  return _register(conn, {
+    scope: MAP_SCOPE,
+    onActivity: resetInactivityTimer,
+  });
+}
+
 /**
  * Start with direct MAP SDK WebSocket transport (fallback).
  */
+/**
+ * Register the trajectory/content.request notification handler on a connection.
+ * When the hub sends a content request, the sidecar reads the transcript
+ * from sessionlog and responds with a trajectory/content.response notification.
+ */
+function registerContentHandler(conn) {
+  if (!conn || typeof conn.onNotification !== "function") return;
+
+  const contentProvider = createContentProvider();
+
+  conn.onNotification("trajectory/content.request", async (params) => {
+    const requestId = params?.request_id;
+    const checkpointId = params?.checkpoint_id;
+    if (!requestId) return;
+
+    log.info("content request received", { requestId, checkpointId });
+    resetInactivityTimer();
+
+    try {
+      const content = checkpointId ? await contentProvider(checkpointId) : null;
+
+      if (content) {
+        conn.sendNotification("trajectory/content.response", {
+          request_id: requestId,
+          transcript: content.transcript,
+          metadata: content.metadata,
+          prompts: content.prompts,
+          context: content.context,
+        });
+        log.info("content response sent", { requestId, size: content.transcript.length });
+      } else {
+        conn.sendNotification("trajectory/content.response", {
+          request_id: requestId,
+          error: "Content not found",
+        });
+        log.warn("content not found", { requestId, checkpointId });
+      }
+    } catch (err) {
+      log.error("content provider error", { requestId, error: err.message });
+      try {
+        conn.sendNotification("trajectory/content.response", {
+          request_id: requestId,
+          error: err.message,
+        });
+      } catch { /* ignore */ }
+    }
+  });
+}
+
 async function startWebSocketTransport() {
   connection = await connectToMAP({
     server: MAP_SERVER,
     scope: MAP_SCOPE,
     systemId: SYSTEM_ID,
     credential: AUTH_CREDENTIAL || undefined,
+    projectContext: PROJECT_CONTEXT,
     onMessage: () => {
       resetInactivityTimer();
     },
@@ -316,6 +412,16 @@ async function startWebSocketTransport() {
 
   transportMode = "websocket";
 
+  // Register trajectory content handler for on-demand transcript serving
+  if (connection) {
+    registerContentHandler(connection);
+  }
+
+  // Register opentasks connector for remote graph queries (only when opentasks is enabled)
+  if (connection && PROJECT_CONTEXT.task_graph) {
+    await registerOpenTasksHandler(connection);
+  }
+
   // Start agent-inbox with MAP connection (legacy mode)
   if (INBOX_CONFIG && connection) {
     inboxInstance = await startLegacyAgentInbox(connection);

package/src/__tests__/opentasks-connector.test.mjs

@@ -0,0 +1,216 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { registerOpenTasksHandler } from "../opentasks-connector.mjs";
+
+// ── Mock factories ──────────────────────────────────────────────────────────
+
+const MOCK_METHODS = {
+  QUERY_REQUEST: "opentasks/query.request",
+  LINK_REQUEST: "opentasks/link.request",
+  ANNOTATE_REQUEST: "opentasks/annotate.request",
+  TASK_REQUEST: "opentasks/task.request",
+};
+
+function createMockConnection() {
+  const handlers = new Map();
+  return {
+    onNotification: vi.fn((method, handler) => {
+      handlers.set(method, handler);
+    }),
+    sendNotification: vi.fn(),
+    // Test helper: fire a notification as if the hub sent it
+    _fireNotification(method, params) {
+      const handler = handlers.get(method);
+      if (handler) return handler(params);
+    },
+    _handlers: handlers,
+  };
+}
+
+function createMockOpentasks() {
+  const connector = {
+    handleNotification: vi.fn(),
+  };
+  return {
+    createClient: vi.fn(() => ({ /* mock client */ })),
+    createMAPConnector: vi.fn(() => connector),
+    MAP_CONNECTOR_METHODS: { ...MOCK_METHODS },
+    _connector: connector,
+  };
+}
+
+function createMockOpentasksClient(socketPath = "/tmp/opentasks/daemon.sock") {
+  return {
+    findSocketPath: vi.fn(() => socketPath),
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("registerOpenTasksHandler", () => {
+  let mockConn;
+  let mockOpentasks;
+  let mockOtClient;
+
+  beforeEach(() => {
+    mockConn = createMockConnection();
+    mockOpentasks = createMockOpentasks();
+    mockOtClient = createMockOpentasksClient();
+  });
+
+  const callRegister = (connOverride, optsOverride = {}) =>
+    registerOpenTasksHandler(connOverride ?? mockConn, {
+      scope: "swarm:test",
+      importOpentasks: async () => mockOpentasks,
+      importOpentasksClient: async () => mockOtClient,
+      ...optsOverride,
+    });
+
+  it("creates a client with the socket path from findSocketPath", async () => {
+    await callRegister();
+
+    expect(mockOtClient.findSocketPath).toHaveBeenCalled();
+    expect(mockOpentasks.createClient).toHaveBeenCalledWith({
+      socketPath: "/tmp/opentasks/daemon.sock",
+      autoConnect: true,
+    });
+  });
+
+  it("creates a MAP connector with the client and a send function", async () => {
+    await callRegister();
+
+    expect(mockOpentasks.createMAPConnector).toHaveBeenCalledTimes(1);
+    const callArgs = mockOpentasks.createMAPConnector.mock.calls[0][0];
+
+    // Should pass the client returned by createClient
+    expect(callArgs.client).toBeDefined();
+    // Should pass a send function
+    expect(typeof callArgs.send).toBe("function");
+    // Should pass agentId derived from scope
+    expect(callArgs.agentId).toBe("swarm:test-sidecar");
+  });
+
+  it("registers onNotification for all 4 request methods", async () => {
+    await callRegister();
+
+    expect(mockConn.onNotification).toHaveBeenCalledTimes(4);
+
+    const registeredMethods = mockConn.onNotification.mock.calls.map((c) => c[0]);
+    expect(registeredMethods).toContain(MOCK_METHODS.QUERY_REQUEST);
+    expect(registeredMethods).toContain(MOCK_METHODS.LINK_REQUEST);
+    expect(registeredMethods).toContain(MOCK_METHODS.ANNOTATE_REQUEST);
+    expect(registeredMethods).toContain(MOCK_METHODS.TASK_REQUEST);
+  });
+
+  it("forwards notifications to connector.handleNotification", async () => {
+    await callRegister();
+
+    const params = { request_id: "req-1", query: "status:open" };
+    await mockConn._fireNotification(MOCK_METHODS.QUERY_REQUEST, params);
+
+    expect(mockOpentasks._connector.handleNotification).toHaveBeenCalledWith(
+      MOCK_METHODS.QUERY_REQUEST,
+      params,
+    );
+  });
+
+  it("passes empty object when notification params are missing", async () => {
+    await callRegister();
+
+    await mockConn._fireNotification(MOCK_METHODS.TASK_REQUEST, undefined);
+
+    expect(mockOpentasks._connector.handleNotification).toHaveBeenCalledWith(
+      MOCK_METHODS.TASK_REQUEST,
+      {},
+    );
+  });
+
+  it("calls the send function on the connector via sendNotification", async () => {
+    await callRegister();
+
+    // Get the send function that was passed to createMAPConnector
+    const sendFn = mockOpentasks.createMAPConnector.mock.calls[0][0].send;
+    sendFn("opentasks/query.response", { data: "result" });
+
+    expect(mockConn.sendNotification).toHaveBeenCalledWith(
+      "opentasks/query.response",
+      { data: "result" },
+    );
+  });
+
+  it("does not throw when sendNotification fails in the send callback", async () => {
+    mockConn.sendNotification.mockImplementation(() => {
+      throw new Error("connection closed");
+    });
+
+    await callRegister();
+
+    const sendFn = mockOpentasks.createMAPConnector.mock.calls[0][0].send;
+    // Should not throw
+    expect(() => sendFn("method", {})).not.toThrow();
+  });
+
+  it("calls onActivity callback when a notification fires", async () => {
+    const onActivity = vi.fn();
+    await callRegister(undefined, { onActivity });
+
+    await mockConn._fireNotification(MOCK_METHODS.LINK_REQUEST, { request_id: "r1" });
+
+    expect(onActivity).toHaveBeenCalledTimes(1);
+  });
+
+  it("does nothing when conn is null", async () => {
+    // Should not throw
+    await registerOpenTasksHandler(null, {
+      scope: "swarm:test",
+      importOpentasks: async () => mockOpentasks,
+      importOpentasksClient: async () => mockOtClient,
+    });
+
+    expect(mockOpentasks.createClient).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when conn lacks onNotification", async () => {
+    await registerOpenTasksHandler({ sendNotification: vi.fn() }, {
+      scope: "swarm:test",
+      importOpentasks: async () => mockOpentasks,
+      importOpentasksClient: async () => mockOtClient,
+    });
+
+    expect(mockOpentasks.createClient).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when opentasks module is missing createMAPConnector", async () => {
+    const brokenModule = { createClient: vi.fn() }; // no createMAPConnector
+
+    await registerOpenTasksHandler(mockConn, {
+      scope: "swarm:test",
+      importOpentasks: async () => brokenModule,
+      importOpentasksClient: async () => mockOtClient,
+    });
+
+    expect(mockConn.onNotification).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when opentasks import throws", async () => {
+    await registerOpenTasksHandler(mockConn, {
+      scope: "swarm:test",
+      importOpentasks: async () => { throw new Error("module not found"); },
+      importOpentasksClient: async () => mockOtClient,
+    });
+
+    expect(mockConn.onNotification).not.toHaveBeenCalled();
+  });
+
+  it("uses custom socket path from findSocketPath", async () => {
+    const customClient = createMockOpentasksClient("/custom/path/daemon.sock");
+
+    await callRegister(undefined, {
+      importOpentasksClient: async () => customClient,
+    });
+
+    expect(mockOpentasks.createClient).toHaveBeenCalledWith({
+      socketPath: "/custom/path/daemon.sock",
+      autoConnect: true,
+    });
+  });
+});

package/src/__tests__/sessionlog.test.mjs

@@ -188,6 +188,46 @@ describe("sessionlog", () => {
       expect(cp.token_usage.input_tokens).toBe(800);
       expect(cp.token_usage.output_tokens).toBe(400);
     });
+
+    it("includes project name from cwd in metadata", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
+      expect(cp.metadata.project).toBeDefined();
+      expect(typeof cp.metadata.project).toBe("string");
+      expect(cp.metadata.project.length).toBeGreaterThan(0);
+    });
+
+    it("includes git branch as top-level wire format field", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
+      // branch may be null in CI/non-git environments, but should be defined
+      expect("branch" in cp).toBe(true);
+    });
+
+    it("includes firstPrompt from session state when available", () => {
+      const state = { ...baseState, firstPrompt: "fix the bug in server.ts" };
+      const cp = buildTrajectoryCheckpoint(state, "lifecycle", makeConfig());
+      expect(cp.metadata.firstPrompt).toBe("fix the bug in server.ts");
+    });
+
+    it("truncates long firstPrompt to 200 chars", () => {
+      const state = { ...baseState, firstPrompt: "x".repeat(300) };
+      const cp = buildTrajectoryCheckpoint(state, "lifecycle", makeConfig());
+      expect(cp.metadata.firstPrompt.length).toBe(200);
+    });
+
+    it("omits firstPrompt when not in session state", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
+      expect(cp.metadata.firstPrompt).toBeUndefined();
+    });
+
+    it("includes template from config when configured", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig({ template: "gsd" }));
+      expect(cp.metadata.template).toBe("gsd");
+    });
+
+    it("omits template when not configured", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig({ template: "" }));
+      expect(cp.metadata.template).toBeUndefined();
+    });
   });
 
   describe("ensureSessionlogEnabled", () => {

package/src/__tests__/sidecar-server.test.mjs

@@ -229,13 +229,13 @@ describe("sidecar-server", () => {
 
       it("falls back to broadcast with trajectory.checkpoint payload when callExtension throws", async () => {
         mockConnection.callExtension.mockRejectedValueOnce(new Error("not supported"));
-        const cp = { id: "cp1", agentId: "a", sessionId: "s", label: "l", metadata: { phase: "active" } };
+        const cp = { id: "cp1", agent: "a", session_id: "s", files_touched: [], token_usage: null, metadata: { phase: "active" } };
         await handler({ action: "trajectory-checkpoint", checkpoint: cp }, mockClient);
         expect(mockConnection.send).toHaveBeenCalled();
         const [, payload] = mockConnection.send.mock.calls[0];
         expect(payload.type).toBe("trajectory.checkpoint");
         expect(payload.checkpoint.id).toBe("cp1");
-        expect(payload.checkpoint.agentId).toBe("a");
+        expect(payload.checkpoint.agent).toBe("a");
         expect(payload.checkpoint.metadata).toEqual({ phase: "active" });
       });
 

package/src/content-provider.mjs

@@ -0,0 +1,176 @@
+/**
+ * content-provider.mjs — Trajectory content provider for claude-code-swarm
+ *
+ * Provides session transcript content for on-demand trajectory/content requests
+ * from the hub. Reads from sessionlog's session state to find the transcript,
+ * then serves the raw Claude Code JSONL.
+ *
+ * Two content sources:
+ * 1. Live session: reads directly from state.transcriptPath (active JSONL file)
+ * 2. Committed checkpoint: reads from sessionlog's checkpoint store (full.jsonl)
+ *
+ * Returns { metadata, transcript, prompts, context } matching the
+ * SessionContentProvider type from @multi-agent-protocol/sdk.
+ */
+
+import fs from "fs";
+import path from "path";
+import { SESSIONLOG_DIR } from "./paths.mjs";
+import { resolvePackage } from "./swarmkit-resolver.mjs";
+import { createLogger } from "./log.mjs";
+
+const log = createLogger("content-provider");
+
+/**
+ * Create a content provider function for the sidecar.
+ * The provider receives a checkpointId and returns transcript content.
+ *
+ * For live sessions, checkpointId may be the session ID or a checkpoint ID.
+ * We search sessionlog state to find the transcript path.
+ *
+ * @returns {Function} SessionContentProvider-compatible async function
+ */
+export function createContentProvider() {
+  return async function provideContent(checkpointId) {
+    try {
+      // 1. Try to find a live session with this checkpoint or session ID
+      const liveContent = await readLiveSessionContent(checkpointId);
+      if (liveContent) return liveContent;
+
+      // 2. Try to read from committed checkpoint store
+      const committedContent = await readCommittedContent(checkpointId);
+      if (committedContent) return committedContent;
+
+      log.warn("content not found for checkpoint", { checkpointId });
+      return null;
+    } catch (err) {
+      log.warn("content provider error", { checkpointId, error: err.message });
+      return null;
+    }
+  };
+}
+
+/**
+ * Read transcript content from a live (non-ended) sessionlog session.
+ * Searches all session state files for one that matches the checkpoint ID
+ * or has a matching session ID, then reads the transcript from disk.
+ */
+async function readLiveSessionContent(checkpointId) {
+  if (!fs.existsSync(SESSIONLOG_DIR)) return null;
+
+  let files;
+  try {
+    files = fs.readdirSync(SESSIONLOG_DIR).filter(f => f.endsWith(".json"));
+  } catch {
+    return null;
+  }
+
+  for (const f of files) {
+    try {
+      const statePath = path.join(SESSIONLOG_DIR, f);
+      const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+
+      // Match by session ID, checkpoint ID, or checkpoint in turnCheckpointIDs
+      const isMatch =
+        state.sessionID === checkpointId ||
+        state.lastCheckpointID === checkpointId ||
+        (state.turnCheckpointIDs || []).includes(checkpointId);
+
+      if (!isMatch) continue;
+
+      // Read the transcript from the path stored in session state
+      const transcriptPath = state.transcriptPath;
+      if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+        log.warn("transcript path not found", { sessionID: state.sessionID, transcriptPath });
+        continue;
+      }
+
+      const transcript = fs.readFileSync(transcriptPath, "utf-8");
+
+      // Extract prompts from transcript (user messages)
+      const prompts = extractPrompts(transcript);
+
+      return {
+        metadata: {
+          sessionID: state.sessionID,
+          phase: state.phase,
+          stepCount: state.stepCount || 0,
+          filesTouched: state.filesTouched || [],
+          tokenUsage: state.tokenUsage || {},
+          startedAt: state.startedAt,
+          endedAt: state.endedAt,
+          source: "live",
+        },
+        transcript,
+        prompts,
+        context: `Session ${state.sessionID} (${state.phase})`,
+      };
+    } catch {
+      // Skip malformed files
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Read transcript content from sessionlog's committed checkpoint store.
+ * Uses sessionlog's library API via resolvePackage.
+ */
+async function readCommittedContent(checkpointId) {
+  try {
+    const sessionlogMod = await resolvePackage("sessionlog");
+    if (!sessionlogMod?.createCheckpointStore) return null;
+
+    const store = sessionlogMod.createCheckpointStore();
+    if (!store?.readSessionContent) return null;
+
+    // Try reading committed content (session index 0)
+    const content = await store.readSessionContent(checkpointId, 0);
+    if (!content) return null;
+
+    return {
+      metadata: {
+        ...content.metadata,
+        source: "committed",
+      },
+      transcript: content.transcript,
+      prompts: content.prompts,
+      context: content.context,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract user prompts from a Claude Code JSONL transcript.
+ */
+function extractPrompts(transcript) {
+  const prompts = [];
+  for (const line of transcript.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "user") {
+        const msg = entry.message;
+        if (typeof msg === "string") {
+          prompts.push(msg);
+        } else if (msg?.content) {
+          if (typeof msg.content === "string") {
+            prompts.push(msg.content);
+          } else if (Array.isArray(msg.content)) {
+            const text = msg.content
+              .filter(b => b.type === "text" && b.text)
+              .map(b => b.text)
+              .join("\n");
+            if (text) prompts.push(text);
+          }
+        }
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+  return prompts.join("\n---\n");
+}

package/src/map-connection.mjs

@@ -24,7 +24,7 @@ const log = createLogger("map");
  *   authRequired challenge with the server's preferred method + this credential.
  *   When absent, uses the standard SDK connect() for open mode servers.
  */
-export async function connectToMAP({ server, scope, systemId, onMessage, credential }) {
+export async function connectToMAP({ server, scope, systemId, onMessage, credential, projectContext }) {
   try {
     const mapSdk = await resolvePackage("@multi-agent-protocol/sdk");
     if (!mapSdk) throw new Error("@multi-agent-protocol/sdk not available");
@@ -38,12 +38,16 @@ export async function connectToMAP({ server, scope, systemId, onMessage, credent
       role: "sidecar",
       scopes: [scope],
       capabilities: {
-        trajectory: { canReport: true },
+        trajectory: { canReport: true, canServeContent: true },
         tasks: { canCreate: true, canAssign: true, canUpdate: true, canList: true },
+        ...(projectContext?.task_graph ? {
+          opentasks: { canQuery: true, canLink: true, canAnnotate: true, canTask: true },
+        } : {}),
       },
       metadata: {
         systemId,
         type: "claude-code-swarm-sidecar",
+        ...(projectContext || {}),
       },
       reconnection: {
         enabled: true,

package/src/opentasks-connector.mjs

@@ -0,0 +1,86 @@
+/**
+ * opentasks-connector.mjs — MAP connector registration for opentasks
+ *
+ * Extracted from map-sidecar.mjs for testability.
+ * Registers notification handlers on a MAP connection so that when the hub
+ * (or another agent) sends opentasks/*.request notifications, the connector
+ * queries the local daemon and sends back opentasks/*.response.
+ */
+
+import { createLogger } from "./log.mjs";
+
+const log = createLogger("opentasks-connector");
+
+/**
+ * Register opentasks notification handlers on a MAP connection.
+ *
+ * @param {object} conn - MAP connection with onNotification/sendNotification
+ * @param {object} options
+ * @param {string} options.scope - MAP scope (e.g. "swarm:gsd")
+ * @param {() => void} [options.onActivity] - Called on each notification (for inactivity timer reset)
+ * @param {() => Promise<object>} [options.importOpentasks] - Override for dynamic import("opentasks")
+ * @param {() => Promise<object>} [options.importOpentasksClient] - Override for dynamic import of opentasks-client
+ */
+export async function registerOpenTasksHandler(conn, options = {}) {
+  if (!conn || typeof conn.onNotification !== "function") return;
+
+  const {
+    scope = "swarm:default",
+    onActivity,
+    importOpentasks,
+    importOpentasksClient,
+  } = options;
+
+  try {
+    const opentasks = importOpentasks
+      ? await importOpentasks()
+      : await import("opentasks");
+
+    if (!opentasks?.createMAPConnector || !opentasks?.createClient) {
+      log.debug("opentasks MAP connector not available (missing exports)");
+      return;
+    }
+
+    const { createMAPConnector, createClient, MAP_CONNECTOR_METHODS } = opentasks;
+
+    const opentasksClient = importOpentasksClient
+      ? await importOpentasksClient()
+      : await import("./opentasks-client.mjs");
+
+    const { findSocketPath } = opentasksClient;
+    const socketPath = findSocketPath();
+    const client = createClient({ socketPath, autoConnect: true });
+
+    const connector = createMAPConnector({
+      client,
+      send: (method, params) => {
+        try {
+          conn.sendNotification(method, params);
+        } catch {
+          log.debug("failed to send opentasks response", { method });
+        }
+      },
+      agentId: `${scope}-sidecar`,
+    });
+
+    // Register handlers for all 4 request methods
+    const requestMethods = [
+      MAP_CONNECTOR_METHODS.QUERY_REQUEST,
+      MAP_CONNECTOR_METHODS.LINK_REQUEST,
+      MAP_CONNECTOR_METHODS.ANNOTATE_REQUEST,
+      MAP_CONNECTOR_METHODS.TASK_REQUEST,
+    ];
+
+    for (const method of requestMethods) {
+      conn.onNotification(method, async (params) => {
+        log.debug("opentasks request received", { method, requestId: params?.request_id });
+        if (onActivity) onActivity();
+        connector.handleNotification(method, params || {});
+      });
+    }
+
+    log.info("opentasks connector registered", { methods: requestMethods.length });
+  } catch (err) {
+    log.debug("opentasks connector not available", { error: err.message });
+  }
+}

package/src/sessionlog.mjs

@@ -16,6 +16,20 @@ import { sendToSidecar, ensureSidecar } from "./sidecar-client.mjs";
 import { fireAndForgetTrajectory } from "./map-connection.mjs";
 import { resolvePackage } from "./swarmkit-resolver.mjs";
 
+/**
+ * Get the current git branch name. Returns null if not in a git repo.
+ */
+function getGitBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Check if sessionlog is installed and active.
  * Returns 'active', 'installed but not enabled', or 'not installed'.
@@ -151,6 +165,7 @@ export function buildTrajectoryCheckpoint(state, syncLevel, config) {
     id,
     session_id: state.sessionID,
     agent: `${teamName}-sidecar`,
+    branch: getGitBranch(),
     files_touched: [],
     checkpoints_count: 0,
   };
@@ -161,6 +176,10 @@ export function buildTrajectoryCheckpoint(state, syncLevel, config) {
     turnId: state.turnID,
     startedAt: state.startedAt,
     label: `Turn ${state.turnID || "?"} (step ${state.stepCount || 0}, ${state.phase || "unknown"})`,
+    // Project context for display
+    project: path.basename(process.cwd()),
+    firstPrompt: state.firstPrompt ? state.firstPrompt.slice(0, 200) : undefined,
+    template: config.template || undefined,
   };
   if (state.endedAt) metadata.endedAt = state.endedAt;
 

package/src/sidecar-server.mjs

@@ -94,6 +94,7 @@ export function createSocketServer(socketPath, onCommand) {
 export function createCommandHandler(connection, scope, registeredAgents, opts = {}) {
   // Use a getter pattern so the connection ref can be updated
   let conn = connection;
+  let _trajectoryResourceId = null; // Cached resource_id from server response
   const { inboxInstance, meshPeer, transportMode = "websocket" } = opts;
   const useMeshRegistry = transportMode === "mesh" && inboxInstance;
 
@@ -291,10 +292,17 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
           const c = conn || await waitForConn();
           if (c) {
             try {
-              await c.callExtension("trajectory/checkpoint", {
-                checkpoint: command.checkpoint,
-              });
-              respond(client, { ok: true, method: "trajectory" });
+              // Include cached resource_id if available from a previous response
+              const payload = { checkpoint: command.checkpoint };
+              if (_trajectoryResourceId) {
+                payload.resource_id = _trajectoryResourceId;
+              }
+              const result = await c.callExtension("trajectory/checkpoint", payload);
+              // Cache resource_id from server response for subsequent calls
+              if (result?.resource_id) {
+                _trajectoryResourceId = result.resource_id;
+              }
+              respond(client, { ok: true, method: "trajectory", resource_id: result?.resource_id });
             } catch (err) {
               log.warn("trajectory/checkpoint not supported, falling back to broadcast", { error: err.message });
               await c.send(
@@ -303,9 +311,10 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
                   type: "trajectory.checkpoint",
                   checkpoint: {
                     id: command.checkpoint.id,
-                    agentId: command.checkpoint.agentId,
-                    sessionId: command.checkpoint.sessionId,
-                    label: command.checkpoint.label,
+                    agent: command.checkpoint.agent,
+                    session_id: command.checkpoint.session_id,
+                    files_touched: command.checkpoint.files_touched,
+                    token_usage: command.checkpoint.token_usage,
                     metadata: command.checkpoint.metadata,
                   },
                 },