agent-bridge-mcp 1.1.0 → 1.4.0

package/README.md

@@ -88,6 +88,8 @@ Data directory:
     1740524430000-x7k2f9.json  # { from, to, content, timestamp }
   context/
     nova-main.json       # { agentName, agentId, project, updatedAt, content }
+  cursors/
+    nova-main.cursor     # timestamp of last delivered message
 ```
 
 ## Example Usage
@@ -154,6 +156,145 @@ Pass env vars through your MCP config:
 }
 ```
 
+## Automatic Context Sharing (Stop Hook)
+
+The `--ingest` flag lets you auto-capture every conversation exchange into the context directory — no manual `share_context` calls needed.
+
+**How it works:** Claude Code fires a [Stop hook](https://docs.anthropic.com/en/docs/claude-code/hooks) after every agent response. The hook pipes `session_id` and `last_assistant_message` via stdin. `agent-bridge-mcp --ingest` reads this, pairs it with the user prompt (saved by a `UserPromptSubmit` hook), strips system tags, and appends the exchange to the agent's context file.
+
+**Setup:**
+
+1. Add a `UserPromptSubmit` hook to save user prompts (required for `--ingest` to capture both sides):
+
+Add to `~/.claude/settings.json`:
+```json
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --capture-prompt",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --ingest",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Set `AGENT_BRIDGE_NAME` in your project's `.mcp.json` so the ingest knows which agent name to write as.
+
+Context is stored as the last 20 exchanges per agent, accessible via `get_context`.
+
+## Automatic Message Delivery (UserPromptSubmit Hook)
+
+The `--check-messages` flag automatically delivers pending messages to an agent before every prompt — no manual `read_messages` calls needed.
+
+**How it works:** Every time you send a prompt to any tab, the hook checks for new messages addressed to that agent. If there are any, they get injected into the conversation as context so Claude sees them immediately. A cursor file tracks what's already been delivered so messages are never repeated.
+
+**Setup:**
+
+Add to the `UserPromptSubmit` hooks in `~/.claude/settings.json`:
+```json
+{
+  "type": "command",
+  "command": "npx agent-bridge-mcp --check-messages",
+  "timeout": 5
+}
+```
+
+The agent name is resolved automatically from the project's `.mcp.json` (reads `AGENT_BRIDGE_NAME` from the agent-bridge MCP config).
+
+## Session Bootstrap (SessionStart Hook)
+
+The `--bootstrap-context` flag loads shared context from all other agents when a new session starts — so new tabs immediately know what everyone else knows.
+
+**How it works:** When a Claude Code session starts or resumes, the hook reads all shared context files and lists active agents, then injects everything into the conversation. The agent starts with full awareness of what other agents have been working on.
+
+**Setup:**
+
+Add a `SessionStart` hook to `~/.claude/settings.json`:
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --bootstrap-context",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## Full Hook Setup
+
+Here's the complete `~/.claude/settings.json` hooks configuration with all agent-bridge features enabled:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --bootstrap-context",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --capture-prompt",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --check-messages",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --ingest",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
 ## Requirements
 
 - Node.js >= 18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bridge-mcp",
-  "version": "1.1.0",
+  "version": "1.4.0",
   "description": "MCP server enabling communication between multiple Claude Code sessions via shared filesystem message bus",
   "type": "module",
   "main": "server.mjs",

package/server.mjs

@@ -35,6 +35,7 @@ const BRIDGE_DIR = process.env.AGENT_BRIDGE_DATA_DIR || getDefaultDataDir();
 const AGENTS_DIR = resolve(BRIDGE_DIR, 'agents');
 const MESSAGES_DIR = resolve(BRIDGE_DIR, 'messages');
 const CONTEXT_DIR = resolve(BRIDGE_DIR, 'context');
+const CURSORS_DIR = resolve(BRIDGE_DIR, 'cursors');
 const HEARTBEAT_INTERVAL_MS = parseInt(process.env.AGENT_BRIDGE_HEARTBEAT_MS || '15000', 10);
 const STALE_THRESHOLD_MS = HEARTBEAT_INTERVAL_MS * 3;
 const DEAD_THRESHOLD_MS = parseInt(process.env.AGENT_BRIDGE_DEAD_MS || '300000', 10);
@@ -46,6 +47,7 @@ const MESSAGE_TTL_MS = parseInt(process.env.AGENT_BRIDGE_MESSAGE_TTL_MS || '3600
 
 const agentId = `agent-${randomBytes(3).toString('hex')}`;
 let agentName = process.env.AGENT_BRIDGE_NAME || null;
+let agentBaseName = process.env.AGENT_BRIDGE_NAME || null; // Original name before auto-suffix
 const startedAt = new Date().toISOString();
 let lastReadTimestamp = Date.now();  // only read messages after we start
 let heartbeatTimer = null;
@@ -58,6 +60,7 @@ function ensureDirs() {
   mkdirSync(AGENTS_DIR, { recursive: true });
   mkdirSync(MESSAGES_DIR, { recursive: true });
   mkdirSync(CONTEXT_DIR, { recursive: true });
+  mkdirSync(CURSORS_DIR, { recursive: true });
 }
 
 // ============================================================
@@ -81,6 +84,7 @@ function getAgentData() {
   return {
     id: agentId,
     name: agentName,
+    baseName: agentBaseName || agentName,
     project: process.cwd().split(/[\\/]/).pop(),
     cwd: process.cwd(),
     pid: process.pid,
@@ -281,17 +285,47 @@ function resolveAgent(nameOrId) {
   const byId = agents.find(a => a.id === nameOrId);
   if (byId) return byId;
 
-  // Exact name match (case-insensitive)
-  const byName = agents.find(a => a.name && a.name.toLowerCase() === nameOrId.toLowerCase());
-  if (byName) return byName;
+  // Exact name match (case-insensitive) — pick most recently active if multiple
+  const nameL = nameOrId.toLowerCase();
+  const byName = agents
+    .filter(a => a.name && a.name.toLowerCase() === nameL)
+    .sort((a, b) => new Date(b.lastHeartbeat) - new Date(a.lastHeartbeat));
+  if (byName.length > 0) return byName[0];
+
+  // Also match by baseName for auto-suffixed agents
+  const byBase = agents
+    .filter(a => a.baseName && a.baseName.toLowerCase() === nameL)
+    .sort((a, b) => new Date(b.lastHeartbeat) - new Date(a.lastHeartbeat));
+  if (byBase.length > 0) return byBase[0];
 
   // Partial name match
-  const partial = agents.filter(a => a.name && a.name.toLowerCase().includes(nameOrId.toLowerCase()));
+  const partial = agents.filter(a => a.name && a.name.toLowerCase().includes(nameL));
   if (partial.length === 1) return partial[0];
 
   return null;
 }
 
+// Resolve ALL agents matching a name (for multi-session messaging)
+function resolveAllAgents(nameOrId) {
+  const agents = getAllAgents().filter(a => !a.isMe && a.status === 'active');
+  const nameL = nameOrId.toLowerCase();
+
+  // Exact ID match — single result
+  const byId = agents.find(a => a.id === nameOrId);
+  if (byId) return [byId];
+
+  // Match by name or baseName
+  const matches = agents.filter(a =>
+    (a.name && a.name.toLowerCase() === nameL) ||
+    (a.baseName && a.baseName.toLowerCase() === nameL)
+  );
+  if (matches.length > 0) return matches;
+
+  // Partial name match
+  const partial = agents.filter(a => a.name && a.name.toLowerCase().includes(nameL));
+  return partial;
+}
+
 // ============================================================
 // Tool Handlers
 // ============================================================
@@ -300,26 +334,32 @@ async function handleRegister(args) {
   const name = args.name?.trim();
   if (!name) return { error: 'Name is required' };
 
-  // Check uniqueness
+  // Allow duplicate base names — auto-suffix if taken
   const agents = getAllAgents().filter(a => !a.isMe && a.status === 'active');
-  const conflict = agents.find(a => a.name && a.name.toLowerCase() === name.toLowerCase());
-  if (conflict) {
-    return {
-      error: `Name "${name}" is already taken by ${conflict.id} (project: ${conflict.project})`,
-      suggestion: `Try "${name}-2" or a different name`
-    };
+  let finalName = name;
+  const nameLower = name.toLowerCase();
+  const conflicts = agents.filter(a => a.name && a.name.toLowerCase() === nameLower);
+  if (conflicts.length > 0) {
+    // Find next available suffix
+    const allNames = agents.map(a => a.name?.toLowerCase()).filter(Boolean);
+    let suffix = 2;
+    while (allNames.includes(`${nameLower}-${suffix}`)) suffix++;
+    finalName = `${name}-${suffix}`;
   }
 
-  agentName = name;
+  agentName = finalName;
+  agentBaseName = name; // Track original base name for context grouping
   writeAgentFile();
 
   return {
     registered: true,
     id: agentId,
     name: agentName,
+    baseName: name,
     project: process.cwd().split(/[\\/]/).pop(),
     cwd: process.cwd(),
-    pid: process.pid
+    pid: process.pid,
+    ...(finalName !== name ? { note: `Name "${name}" was taken, registered as "${finalName}"` } : {})
   };
 }
 
@@ -386,16 +426,18 @@ async function handleBroadcast(args) {
 // Context Operations
 // ============================================================
 
-function writeContextFile(name, content) {
+function writeContextFile(name, content, uniqueId) {
   const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+  const suffix = uniqueId || agentId;
   const data = JSON.stringify({
     agentName: name,
-    agentId,
+    agentId: uniqueId || agentId,
+    baseName: name,
     project: process.cwd().split(/[\\/]/).pop(),
     updatedAt: new Date().toISOString(),
     content
   }, null, 2);
-  const targetPath = resolve(CONTEXT_DIR, `${safeName}.json`);
+  const targetPath = resolve(CONTEXT_DIR, `${safeName}--${suffix}.json`);
   const tmpPath = targetPath + '.tmp';
   try {
     writeFileSync(tmpPath, data);
@@ -444,15 +486,34 @@ async function handleGetContext(args) {
   const { from } = args;
 
   if (from) {
-    // Get context from a specific agent
+    // Get ALL contexts matching this base name (handles multiple sessions)
     const safeName = from.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
-    const filePath = resolve(CONTEXT_DIR, `${safeName}.json`);
+    let files;
     try {
-      const ctx = JSON.parse(readFileSync(filePath, 'utf8'));
-      return { found: true, context: ctx };
+      files = readdirSync(CONTEXT_DIR).filter(f => f.endsWith('.json'));
     } catch {
       return { found: false, error: `No shared context found for "${from}"` };
     }
+
+    const matches = [];
+    for (const file of files) {
+      // Match: exact old-style "{name}.json" OR new-style "{name}--{id}.json"
+      const basePart = file.replace(/\.json$/, '').split('--')[0];
+      if (basePart === safeName) {
+        try {
+          const ctx = JSON.parse(readFileSync(resolve(CONTEXT_DIR, file), 'utf8'));
+          matches.push(ctx);
+        } catch { continue; }
+      }
+    }
+
+    if (matches.length === 0) {
+      return { found: false, error: `No shared context found for "${from}"` };
+    }
+    if (matches.length === 1) {
+      return { found: true, context: matches[0] };
+    }
+    return { found: true, contexts: matches, count: matches.length };
   }
 
   // Get all shared contexts
@@ -463,6 +524,108 @@ async function handleGetContext(args) {
   };
 }
 
+// ============================================================
+// Hook Helpers (used by --check-messages and --bootstrap-context)
+// ============================================================
+
+/**
+ * Figure out the agent name for this project.
+ * Checks: 1) AGENT_BRIDGE_NAME env var, 2) .mcp.json in the cwd, 3) agent files matching cwd
+ */
+function resolveAgentName(cwd) {
+  if (process.env.AGENT_BRIDGE_NAME) return process.env.AGENT_BRIDGE_NAME;
+
+  // Read .mcp.json from the project directory
+  if (cwd) {
+    const mcpPath = resolve(cwd, '.mcp.json');
+    try {
+      const mcp = JSON.parse(readFileSync(mcpPath, 'utf8'));
+      const bridge = mcp.mcpServers?.['agent-bridge'];
+      if (bridge?.env?.AGENT_BRIDGE_NAME) return bridge.env.AGENT_BRIDGE_NAME;
+    } catch {}
+  }
+
+  // Fallback: scan agent files for matching cwd
+  try {
+    const files = readdirSync(AGENTS_DIR).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      const agent = readAgentFile(resolve(AGENTS_DIR, file));
+      if (agent?.name && agent.cwd === cwd) return agent.name;
+    }
+  } catch {}
+
+  return null;
+}
+
+/**
+ * Read messages for a specific agent, starting from a cursor timestamp.
+ * Returns { messages: [...], newCursor: number }
+ */
+function readMessagesForAgent(name, cursorTimestamp) {
+  let files;
+  try {
+    files = readdirSync(MESSAGES_DIR).filter(f => f.endsWith('.json')).sort();
+  } catch {
+    return { messages: [], newCursor: cursorTimestamp };
+  }
+
+  const pending = [];
+  let newCursor = cursorTimestamp;
+  const nameLower = name.toLowerCase();
+
+  for (const file of files) {
+    const timestamp = parseInt(file.split('-')[0], 10);
+    if (isNaN(timestamp) || timestamp <= cursorTimestamp) continue;
+
+    const filePath = resolve(MESSAGES_DIR, file);
+    let msg;
+    try { msg = JSON.parse(readFileSync(filePath, 'utf8')); } catch { continue; }
+
+    // Skip messages FROM this agent
+    if (msg.fromName?.toLowerCase() === nameLower) continue;
+
+    // Check if addressed to this agent or is a broadcast
+    const isForMe = msg.toName?.toLowerCase() === nameLower || msg.to?.toLowerCase() === nameLower;
+    const isBroadcast = msg.broadcast && msg.to === '*';
+
+    if (isForMe || isBroadcast) {
+      pending.push(msg);
+    }
+
+    if (timestamp > newCursor) newCursor = timestamp;
+  }
+
+  return { messages: pending, newCursor };
+}
+
+/**
+ * Read the cursor file for an agent. Returns the timestamp of the last processed message.
+ */
+function readCursor(name) {
+  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+  const cursorPath = resolve(CURSORS_DIR, `${safeName}.cursor`);
+  try {
+    return parseInt(readFileSync(cursorPath, 'utf8').trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Write the cursor file for an agent.
+ */
+function writeCursor(name, timestamp) {
+  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+  const cursorPath = resolve(CURSORS_DIR, `${safeName}.cursor`);
+  const tmpPath = cursorPath + '.tmp';
+  try {
+    writeFileSync(tmpPath, String(timestamp));
+    renameSync(tmpPath, cursorPath);
+  } catch {
+    try { writeFileSync(cursorPath, String(timestamp)); } catch {}
+  }
+}
+
 // ============================================================
 // Tool Definitions
 // ============================================================
@@ -586,7 +749,7 @@ async function handleToolCall(name, args) {
 // ============================================================
 
 const server = new Server(
-  { name: 'agent-bridge', version: '1.1.0' },
+  { name: 'agent-bridge', version: '1.4.0' },
   { capabilities: { tools: {} } }
 );
 
@@ -621,34 +784,365 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 });
 
 // ============================================================
-// Main
+// CLI: --capture-prompt (UserPromptSubmit hook mode)
 // ============================================================
+// Saves user prompt to temp file for --ingest to pair with.
+// Usage: node server.mjs --capture-prompt
+
+async function runCapturePrompt() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString('utf8');
+
+  let data;
+  try { data = JSON.parse(raw); } catch { process.exit(0); }
+
+  const sessionId = data.session_id || '';
+  const prompt = data.prompt || '';
+  if (!sessionId || !prompt) process.exit(0);
+
+  // Strip system tags
+  const tagPatterns = [
+    /<system-reminder>[\s\S]*?<\/system-reminder>/g,
+    /<ide_opened_file>[\s\S]*?<\/ide_opened_file>/g,
+    /<ide_selection>[\s\S]*?<\/ide_selection>/g,
+    /<task-notification>[\s\S]*?<\/task-notification>/g,
+  ];
+  let clean = prompt;
+  for (const pat of tagPatterns) clean = clean.replace(pat, '');
+  clean = clean.replace(/\n\s*\n/g, '\n').trim();
+
+  if (clean.length < 5) process.exit(0);
+
+  const tmp = tmpdir();
+  writeFileSync(resolve(tmp, `agent-bridge-prompt-${sessionId}`), clean, 'utf8');
+  process.exit(0);
+}
 
-async function main() {
+// ============================================================
+// CLI: --ingest (Stop hook mode)
+// ============================================================
+// Called by Claude Code Stop hook. Reads stdin JSON with
+// session_id + last_assistant_message, writes to context dir.
+// Usage: node server.mjs --ingest
+
+async function runIngest() {
   ensureDirs();
-  cleanOldMessages();
-  writeAgentFile();
-  startHeartbeat();
 
-  // Cleanup on exit
-  const cleanup = () => {
-    if (heartbeatTimer) clearInterval(heartbeatTimer);
-    removeAgentFile();
+  // Read stdin
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString('utf8');
+
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  const sessionId = data.session_id || '';
+  const assistantMsg = data.last_assistant_message || '';
+  if (!sessionId || !assistantMsg) process.exit(0);
+
+  // Read user prompt saved by --capture-prompt hook
+  const tmp = tmpdir();
+  const promptPath = resolve(tmp, `agent-bridge-prompt-${sessionId}`);
+  let userMsg = '';
+  try {
+    userMsg = readFileSync(promptPath, 'utf8');
+  } catch {}
+
+  // Strip system tags
+  const tagPatterns = [
+    /<system-reminder>[\s\S]*?<\/system-reminder>/g,
+    /<task-notification>[\s\S]*?<\/task-notification>/g,
+    /<ide_opened_file>[\s\S]*?<\/ide_opened_file>/g,
+    /<ide_selection>[\s\S]*?<\/ide_selection>/g,
+  ];
+  let cleanAssistant = assistantMsg;
+  for (const pat of tagPatterns) cleanAssistant = cleanAssistant.replace(pat, '');
+  cleanAssistant = cleanAssistant.replace(/\n\s*\n/g, '\n').trim();
+
+  if (!cleanAssistant || cleanAssistant.length < 50) process.exit(0);
+
+  // Determine agent name from env or from active agent files
+  const name = process.env.AGENT_BRIDGE_NAME || findAgentNameForSession(sessionId);
+  if (!name) process.exit(0);
+
+  // Read existing context and append new exchange
+  // Use session-specific filename so multiple sessions don't overwrite each other
+  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+  const ctxPath = resolve(CONTEXT_DIR, `${safeName}--${sessionId}.json`);
+
+  // Also check for legacy file (no session suffix) and migrate it
+  const legacyPath = resolve(CONTEXT_DIR, `${safeName}.json`);
+
+  let existing = { exchanges: [] };
+  try {
+    const prev = JSON.parse(readFileSync(ctxPath, 'utf8'));
+    if (prev.exchanges) existing = prev;
+    else if (prev.content) existing = { exchanges: [{ role: 'context', content: prev.content }] };
+  } catch {
+    // If no session-specific file exists, DON'T inherit from legacy file
+    // (it belongs to a different session)
+  }
+
+  // Keep last 20 exchanges to avoid unbounded growth
+  existing.exchanges.push({
+    timestamp: new Date().toISOString(),
+    user: userMsg.slice(0, 2000),
+    assistant: cleanAssistant.slice(0, 5000)
+  });
+  if (existing.exchanges.length > 20) {
+    existing.exchanges = existing.exchanges.slice(-20);
+  }
+
+  const ctxData = JSON.stringify({
+    agentName: name,
+    baseName: name,
+    project: process.cwd().split(/[\\/]/).pop(),
+    updatedAt: new Date().toISOString(),
+    sessionId,
+    exchanges: existing.exchanges
+  }, null, 2);
+
+  const tmpPath = ctxPath + '.tmp';
+  try {
+    writeFileSync(tmpPath, ctxData);
+    renameSync(tmpPath, ctxPath);
+  } catch {
+    try { writeFileSync(ctxPath, ctxData); } catch {}
+  }
+
+  process.exit(0);
+}
+
+function findAgentNameForSession(sessionId) {
+  // Look through agent files to find one from this process's cwd
+  try {
+    const files = readdirSync(AGENTS_DIR).filter(f => f.endsWith('.json'));
+    const cwd = process.cwd();
+    for (const file of files) {
+      const agent = readAgentFile(resolve(AGENTS_DIR, file));
+      if (agent && agent.name && agent.cwd === cwd) return agent.name;
+    }
+  } catch {}
+  return null;
+}
+
+// ============================================================
+// CLI: --check-messages (UserPromptSubmit hook mode)
+// ============================================================
+// Runs on every prompt. Checks for new messages addressed to this agent
+// and outputs them as additionalContext so Claude sees them automatically.
+// Usage: node server.mjs --check-messages
+
+async function runCheckMessages() {
+  ensureDirs();
+
+  // Read stdin for hook context
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString('utf8');
+
+  let data;
+  try { data = JSON.parse(raw); } catch { process.exit(0); }
+
+  const cwd = data.cwd || process.cwd();
+  const name = resolveAgentName(cwd);
+  if (!name) process.exit(0);
+
+  // Read cursor and scan for new messages
+  const cursor = readCursor(name);
+  const { messages, newCursor } = readMessagesForAgent(name, cursor);
+
+  // Update cursor even if no messages (advances past scanned files)
+  if (newCursor > cursor) {
+    writeCursor(name, newCursor);
+  }
+
+  if (messages.length === 0) {
+    process.exit(0); // No output = no context injection
+  }
+
+  // Format messages for Claude
+  const formatted = messages.map(m => {
+    const from = m.fromName || m.from;
+    const age = Math.round((Date.now() - new Date(m.timestamp).getTime()) / 1000);
+    const ageStr = age < 60 ? `${age}s ago` : `${Math.round(age / 60)}min ago`;
+    return `[MESSAGE FROM ${from}]: ${m.content} (${ageStr})`;
+  }).join('\n\n');
+
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: data.hook_event_name || 'UserPromptSubmit',
+      additionalContext: `--- INCOMING AGENT MESSAGES (${messages.length}) ---\n${formatted}\n--- END AGENT MESSAGES ---\nYou received ${messages.length} message(s) from other agents. Read and respond to them. Use send_message to reply if needed.`
+    }
   };
-  process.on('exit', cleanup);
-  process.on('SIGTERM', () => { cleanup(); process.exit(0); });
-  process.on('SIGINT', () => { cleanup(); process.exit(0); });
 
-  // Connect stdio transport
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+  process.stdout.write(JSON.stringify(output));
+  process.exit(0);
+}
+
+// ============================================================
+// CLI: --bootstrap-context (SessionStart hook mode)
+// ============================================================
+// Runs once when a new session starts. Reads all shared contexts
+// from other agents and any pending messages, outputs them so
+// Claude starts the session knowing what everyone else knows.
+// Usage: node server.mjs --bootstrap-context
+
+async function runBootstrapContext() {
+  ensureDirs();
+
+  // Read stdin for hook context
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString('utf8');
+
+  let data;
+  try { data = JSON.parse(raw); } catch { process.exit(0); }
 
-  console.error(`[AgentBridge] Server running`);
-  console.error(`[AgentBridge] Agent ID: ${agentId}`);
-  console.error(`[AgentBridge] Data dir: ${BRIDGE_DIR}`);
+  const cwd = data.cwd || process.cwd();
+  const myName = resolveAgentName(cwd);
+  if (!myName) process.exit(0);
+
+  const myNameLower = myName.toLowerCase();
+
+  // Get active agents (excluding self)
+  let activeAgents = [];
+  try {
+    const agentFiles = readdirSync(AGENTS_DIR).filter(f => f.endsWith('.json'));
+    for (const file of agentFiles) {
+      try {
+        const agent = JSON.parse(readFileSync(resolve(AGENTS_DIR, file), 'utf8'));
+        if (agent.name && agent.name.toLowerCase() !== myNameLower && isProcessAlive(agent.pid)) {
+          activeAgents.push(agent);
+        }
+      } catch {}
+    }
+  } catch {}
+
+  // Get all shared contexts (excluding own session only, NOT all same-name sessions)
+  // Use sessionId to filter — other sessions with the same name should still be visible
+  const mySessionId = data.session_id || '';
+  const contexts = readAllContextFiles().filter(c => {
+    // Exclude our own session's context, but keep other sessions even if same name
+    if (c.sessionId && mySessionId && c.sessionId === mySessionId) return false;
+    // Fallback: if no sessionId, exclude exact agentId match
+    if (c.agentId && c.agentId === myName) return false;
+    return true;
+  });
+
+  // Check for pending messages too
+  const cursor = readCursor(myName);
+  const { messages, newCursor } = readMessagesForAgent(myName, cursor);
+  if (newCursor > cursor) {
+    writeCursor(myName, newCursor);
+  }
+
+  // Nothing to bootstrap
+  if (activeAgents.length === 0 && contexts.length === 0 && messages.length === 0) {
+    process.exit(0);
+  }
+
+  // Build the bootstrap output
+  const parts = [];
+
+  if (activeAgents.length > 0) {
+    parts.push(`ACTIVE AGENTS: ${activeAgents.map(a => `${a.name} (${a.project})`).join(', ')}`);
+  }
+
+  for (const ctx of contexts) {
+    const ageMin = Math.round((Date.now() - new Date(ctx.updatedAt).getTime()) / 1000 / 60);
+    let summary = '';
+    if (ctx.content) {
+      summary = ctx.content.slice(0, 3000);
+    } else if (ctx.exchanges && ctx.exchanges.length > 0) {
+      // Show last 3 exchanges as summary
+      const recent = ctx.exchanges.slice(-3);
+      summary = recent.map(e =>
+        `User: ${(e.user || '').slice(0, 200)}\nAssistant: ${(e.assistant || '').slice(0, 500)}`
+      ).join('\n---\n');
+    }
+    if (summary) {
+      parts.push(`--- CONTEXT FROM ${ctx.agentName} (${ctx.project || 'unknown'}, updated ${ageMin}min ago) ---\n${summary}`);
+    }
+  }
+
+  if (messages.length > 0) {
+    const formatted = messages.map(m => {
+      const from = m.fromName || m.from;
+      const age = Math.round((Date.now() - new Date(m.timestamp).getTime()) / 1000);
+      const ageStr = age < 60 ? `${age}s ago` : `${Math.round(age / 60)}min ago`;
+      return `[MESSAGE FROM ${from}]: ${m.content} (${ageStr})`;
+    }).join('\n\n');
+    parts.push(`--- PENDING MESSAGES (${messages.length}) ---\n${formatted}`);
+  }
+
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: data.hook_event_name || 'SessionStart',
+      additionalContext: `--- AGENT BRIDGE BOOTSTRAP ---\nYou are "${myName}". The agent-bridge connects you with other Claude Code sessions. Messages from other agents are delivered automatically before each prompt.\n\n${parts.join('\n\n')}\n--- END BOOTSTRAP ---`
+    }
+  };
+
+  process.stdout.write(JSON.stringify(output));
+  process.exit(0);
 }
 
-main().catch(err => {
-  console.error(`[AgentBridge] Fatal: ${err.message}`);
-  process.exit(1);
-});
+// ============================================================
+// Main
+// ============================================================
+
+if (process.argv.includes('--capture-prompt')) {
+  runCapturePrompt().catch(() => process.exit(0));
+} else if (process.argv.includes('--ingest')) {
+  runIngest().catch(() => process.exit(0));
+} else if (process.argv.includes('--check-messages')) {
+  runCheckMessages().catch(() => process.exit(0));
+} else if (process.argv.includes('--bootstrap-context')) {
+  runBootstrapContext().catch(() => process.exit(0));
+} else {
+  async function main() {
+    ensureDirs();
+    cleanOldMessages();
+
+    // Auto-suffix name if env var conflicts with an existing active agent
+    if (agentName) {
+      const existing = getAllAgents().filter(a => a.status === 'active' && a.name?.toLowerCase() === agentName.toLowerCase());
+      if (existing.length > 0) {
+        const allNames = getAllAgents().map(a => a.name?.toLowerCase()).filter(Boolean);
+        let suffix = 2;
+        while (allNames.includes(`${agentName.toLowerCase()}-${suffix}`)) suffix++;
+        agentName = `${agentBaseName}-${suffix}`;
+      }
+    }
+
+    writeAgentFile();
+    startHeartbeat();
+
+    // Cleanup on exit
+    const cleanup = () => {
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
+      removeAgentFile();
+    };
+    process.on('exit', cleanup);
+    process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+    process.on('SIGINT', () => { cleanup(); process.exit(0); });
+
+    // Connect stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+
+    console.error(`[AgentBridge] Server running`);
+    console.error(`[AgentBridge] Agent ID: ${agentId}`);
+    console.error(`[AgentBridge] Data dir: ${BRIDGE_DIR}`);
+  }
+
+  main().catch(err => {
+    console.error(`[AgentBridge] Fatal: ${err.message}`);
+    process.exit(1);
+  });
+}