@spoons-and-mirrors/iam 0.1.6 → 0.1.8

package/README.md

@@ -1,13 +1,11 @@
 # IAM (Inter-Agent Messaging)
 
-Enable parallel agents communication for opencode
+### Enable parallel agents communication for opencode
 
-`@spoons-and-mirrors/iam@latest`
+![header](./header2.webp)
 
 ## How It Works
 
-Parallel agents they can send messages to each other using the `broadcast` tool. Messages are relayed to the proper agent's context.
-
 ```mermaid
 sequenceDiagram
     participant Parent as Parent Session
@@ -17,62 +15,105 @@ sequenceDiagram
     Parent->>A: spawn task
     Parent->>B: spawn task
 
-    Note over A,B: Both agents auto-register on first LLM call
+    Note over A,B: Attention mechanism activation
+
+    A->>B: broadcast(message="Doing X") notifies all parallel agents
+    Note over A: Tool result shows agentB is available
+
+    B->>A: broadcast(message="Doing Y") notifies all parallel agents
+    Note over B: Tool result shows agentA is available
+
+    Note over A,B: Attention mechanism activated
 
     A->>B: broadcast(recipient="agentB", message="Question?")
+    A->>B: broadcast(recipient="agentB", message="Other question?")
 
-    Note over B: Receives message
-    Note over B: Responds
+    Note over B: Receive messages in context
 
-    B->>A: broadcast(recipient="agentA", reply_to=[1], message="Answer!")
+    B->>A: broadcast(reply_to=1, message="Answer!")
+    Note over B: Tool result shows source message
+    Note over B: Message 1 removed from context
+    Note over B: Audit trace persists in tool result
 
     Note over A: Receives reply
-    Note over B: Tool output shows both reply and handled message
-    Note over B: Remove message from inbox
+```
+
+## Installation
+
+Add to your OpenCode config:
+
+```
+"plugin": ["@spoons-and-mirrors/iam@latest"]
 ```
 
 ## The `broadcast` Tool
 
 ```
-broadcast(message="...")                                 # Send to all agents
-broadcast(recipient="agentB", message="...")             # Send to specific agent
-broadcast(reply_to=[1, 2], message="...")                # Mark messages as handled
-broadcast(recipient="agentA", reply_to=[1], message="...") # Reply and mark handled
+broadcast(message="...")                     # Send to all agents
+broadcast(recipient="agentB", message="...") # Send to specific agent
+broadcast(reply_to=1, message="...")         # Reply to message #1 (auto-wires recipient)
 ```
 
 ### Parameters
 
-| Parameter   | Required | Description                                                          |
-| ----------- | -------- | -------------------------------------------------------------------- |
-| `message`   | Yes      | Your message content                                                 |
-| `recipient` | No       | Target agent(s), comma-separated. Omit to send to all                |
-| `reply_to`  | No       | Array of message IDs to mark as handled (e.g., `[1]` or `[1, 2, 3]`) |
+| Parameter   | Required | Description                                                     |
+| ----------- | -------- | --------------------------------------------------------------- |
+| `message`   | Yes      | Your message content                                            |
+| `recipient` | No       | Target agent (single agent only)                                |
+| `reply_to`  | No       | Message ID to reply to - auto-wires recipient to message sender |
 
 ## Receiving Messages
 
-Messages appear as a `broadcast` tool result with structured data:
+Messages are injected as a synthetic `broadcast` tool result. Here's the complete structure:
 
 ```json
 {
-  "messages": [
-    { "id": 1, "from": "agentA", "body": "What's the status on the API?" },
-    { "id": 2, "from": "agentA", "body": "Also, can you check the tests?" }
-  ],
-  "agents": ["agentA", "agentC: Working on backend"]
+  "tool": "broadcast",
+  "state": {
+    "status": "completed",
+    "input": { "synthetic": true },
+    "output": {
+      "agents": [
+        { "name": "agentA", "status": "Working on frontend components" }
+      ],
+      "messages": [
+        {
+          "id": 1,
+          "from": "agentA",
+          "content": "What's the status on the API?"
+        },
+        {
+          "id": 2,
+          "from": "agentA",
+          "content": "Also, can you check the tests?"
+        }
+      ]
+    },
+    "title": "1 agent(s), 2 message(s)"
+  }
 }
 ```
 
-The `agents` array always shows available agents to message. This is injected even when there are no incoming messages.
+- **`input.synthetic`**: Indicates this was injected by IAM, not a real agent call
+- **`output.agents`**: Status announcements from other agents (not replyable)
+- **`output.messages`**: Actual messages you can reply to using `reply_to`
 
 Messages persist in the inbox until the agent marks them as handled using `reply_to`.
 
-## Installation
+**Discovery:** Agents discover each other by calling `broadcast` which activates the attention mechanism.
 
-Add to your OpenCode config:
+## Attention Layer
 
-```
-"plugin": ["@spoons-and-mirrors/iam@latest"]
-```
+On every LLM fetch, pending inbox messages are injected as a synthetic `broadcast` tool result at the end of the message chain. The synthetic call has `input: { synthetic: true }` to indicate it was injected by IAM, not a real agent call.
+
+After injection, the message chain looks like:
+
+1. system prompt
+2. user message
+3. assistant response
+4. tool calls...
+5. user message
+6. **`[broadcast]` 1 agent(s), 2 message(s)** ← injected at end
 
 ## Example Workflow
 
@@ -80,21 +121,21 @@ Add to your OpenCode config:
 # Parent spawns two agents to work on different parts of a feature
 
 AgentA (working on frontend):
-  → broadcast(message="Starting frontend work")
-  → ... does work ...
-  → broadcast(recipient="agentB", message="Need the API schema")
+  -> broadcast(message="Starting frontend work")
+     # Tool result shows: "Available agents: agentB"
+  -> ... does work ...
+  -> broadcast(recipient="agentB", message="Need the API schema")
 
 AgentB (working on backend):
-  → broadcast(message="Starting backend work")
-  → ... sees AgentA's question in inbox ...
-  → broadcast(recipient="agentA", reply_to=[1], message="Here's the schema: {...}")
+  -> broadcast(message="Starting backend work")
+     # Tool result shows: "Available agents: agentA"
+  -> ... sees AgentA's question in inbox ...
+  -> broadcast(reply_to=1, message="Here's the schema: {...}")
+     # Tool result shows: Marked as handled: #1 from agentA
+     # Recipient auto-wired to agentA
 
 AgentA:
-  → ... sees AgentB's response in inbox ...
-  → broadcast(reply_to=[1], message="Got it, thanks!")
+  -> ... sees AgentB's response in inbox ...
+  -> broadcast(reply_to=1, message="Got it, thanks!")
+     # Recipient auto-wired to agentB
 ```
-
-## Notes
-
-- Agents are assigned aliases automatically: `agentA`, `agentB`, `agentC`, etc.
-- Logs are written to `.logs/iam.log` for debugging

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAijBlD,QAAA,MAAM,MAAM,EAAE,MAwTb,CAAC;AAEF,eAAe,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAkmBlD,QAAA,MAAM,MAAM,EAAE,MAyXb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -2,13 +2,13 @@
 import { tool } from "@opencode-ai/plugin";
 
 // prompt.ts
-var BROADCAST_DESCRIPTION = `Communicate with other parallel agents. Use 'recipient' for specific agent(s), or omit to message all. Use 'reply_to' to mark messages as handled.`;
-function broadcastResult(alias, recipients, parallelAgents, handledMessages) {
+var BROADCAST_DESCRIPTION = `Communicate with other parallel agents. Use 'recipient' for a specific agent, or omit to message all. Use 'reply_to' to reply (auto-wires recipient to sender).`;
+function broadcastResult(alias, recipients, parallelAgents, handledMessage) {
   const lines = [];
   lines.push(`You are: ${alias}`);
   lines.push(``);
   if (parallelAgents.length > 0) {
-    lines.push(`Available agents to message:`);
+    lines.push(`Available agents:`);
     for (const agent of parallelAgents) {
       if (agent.description) {
         lines.push(`  - ${agent.alias}: ${agent.description}`);
@@ -19,27 +19,21 @@ function broadcastResult(alias, recipients, parallelAgents, handledMessages) {
   } else {
     lines.push(`No other agents available yet.`);
   }
-  if (recipients.length > 0) {
+  if (handledMessage) {
+    lines.push(``);
+    const preview = handledMessage.body.length > 80 ? handledMessage.body.substring(0, 80) + "..." : handledMessage.body;
+    lines.push(`Replied to #${handledMessage.id} from ${handledMessage.from}:`);
+    lines.push(`  "${preview}"`);
+  } else if (recipients.length > 0) {
     lines.push(``);
     const recipientStr = recipients.length === 1 ? recipients[0] : recipients.join(", ");
     lines.push(`Message sent to: ${recipientStr}`);
   }
-  if (handledMessages.length > 0) {
-    lines.push(``);
-    lines.push(`Marked as handled: ${handledMessages.length} message(s)`);
-    for (const msg of handledMessages) {
-      const preview = msg.body.length > 80 ? msg.body.substring(0, 80) + "..." : msg.body;
-      lines.push(`  #${msg.id} from ${msg.from}: "${preview}"`);
-    }
-  }
   return lines.join(`
 `);
 }
 var BROADCAST_MISSING_MESSAGE = `Error: 'message' parameter is required.`;
 var BROADCAST_SELF_MESSAGE = `Warning: You cannot send a message to yourself. The target alias is your own alias. Choose a different recipient.`;
-function broadcastMessageTooLong(length, maxLength) {
-  return `Error: Message too long (${length} chars). Maximum allowed: ${maxLength} chars.`;
-}
 function broadcastUnknownRecipient(recipient, known) {
   const list = known.length > 0 ? `Known agents: ${known.join(", ")}` : "No agents available yet.";
   return `Error: Unknown recipient "${recipient}". ${list}`;
@@ -58,31 +52,39 @@ Call \`broadcast(message="...")\` as your FIRST action to announce yourself and
 - \`broadcast(recipient="agentB", message="...")\` → send to specific agent
 
 ## Receiving Messages
-Incoming messages appear as \`broadcast\` tool results with a \`messages\` array:
+Incoming messages appear as synthetic \`broadcast\` tool results:
 \`\`\`
-{ messages: [{ id: 1, from: "agentA", body: "..." }, ...] }
+{
+  agents: [{ name: "agentA", status: "Working on X" }],
+  messages: [{ id: 1, from: "agentA", content: "..." }]
+}
 \`\`\`
 
-Use \`reply_to\` to mark messages as handled (they persist until you do):
-- \`broadcast(recipient="agentA", reply_to=[1], message="...")\`
-- \`broadcast(recipient="agentA", reply_to=[1, 2, 3], message="...")\`
+- **agents**: Status announcements (not replyable)
+- **messages**: Messages you can reply to using \`reply_to\`
+
+Use \`reply_to\` to reply to a message (auto-wires recipient):
+- \`broadcast(reply_to=1, message="...")\` → replies to message #1
 </instructions>
 `;
 
 // logger.ts
 import * as fs from "fs";
 import * as path from "path";
+var DEBUG_ENABLED = process.env.OPENCODE_IAM_DEBUG_LOGS === "1";
 var LOG_DIR = path.join(process.cwd(), ".logs");
 var LOG_FILE = path.join(LOG_DIR, "iam.log");
 var WRITE_INTERVAL_MS = 100;
 var logBuffer = [];
 var writeScheduled = false;
-try {
-  if (!fs.existsSync(LOG_DIR)) {
-    fs.mkdirSync(LOG_DIR, { recursive: true });
-  }
-  fs.writeFileSync(LOG_FILE, "");
-} catch {}
+if (DEBUG_ENABLED) {
+  try {
+    if (!fs.existsSync(LOG_DIR)) {
+      fs.mkdirSync(LOG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(LOG_FILE, "");
+  } catch {}
+}
 function formatTimestamp() {
   return new Date().toISOString();
 }
@@ -105,6 +107,9 @@ function scheduleFlush() {
   }
 }
 function writeLog(level, category, message, data) {
+  if (!DEBUG_ENABLED) {
+    return;
+  }
   const timestamp = formatTimestamp();
   const dataStr = data !== undefined ? ` | ${JSON.stringify(data)}` : "";
   const logLine = `[${timestamp}] [${level}] [${category}] ${message}${dataStr}
@@ -130,7 +135,7 @@ var LOG = {
 // index.ts
 var CHAR_CODE_A = 65;
 var ALPHABET_SIZE = 26;
-var MAX_DESCRIPTION_LENGTH = 100;
+var MAX_DESCRIPTION_LENGTH = 300;
 var MESSAGE_TTL_MS = 30 * 60 * 1000;
 var UNHANDLED_TTL_MS = 2 * 60 * 60 * 1000;
 var MAX_INBOX_SIZE = 100;
@@ -142,6 +147,7 @@ var MAX_MESSAGE_LENGTH = 1e4;
 var inboxes = new Map;
 var sessionMsgCounter = new Map;
 var activeSessions = new Set;
+var announcedSessions = new Set;
 var sessionToAlias = new Map;
 var aliasToSession = new Map;
 var agentDescriptions = new Map;
@@ -233,15 +239,17 @@ function getInbox(sessionId) {
   }
   return inboxes.get(sessionId);
 }
-function sendMessage(from, to, body) {
+function sendMessage(from, to, body, isStatusAnnouncement = false) {
+  const msgIndex = isStatusAnnouncement ? 0 : getNextMsgIndex(to);
   const message = {
     id: generateId(),
-    msgIndex: getNextMsgIndex(to),
+    msgIndex,
     from,
     to,
     body,
     timestamp: Date.now(),
-    handled: false
+    handled: false,
+    isStatusAnnouncement
   };
   const queue = getInbox(to);
   if (queue.length >= MAX_INBOX_SIZE) {
@@ -259,7 +267,8 @@ function sendMessage(from, to, body) {
     msgIndex: message.msgIndex,
     from,
     to,
-    bodyLength: body.length
+    bodyLength: body.length,
+    isStatusAnnouncement
   });
   return message;
 }
@@ -360,18 +369,39 @@ async function getParentId(client, sessionId) {
 function createInboxMessage(sessionId, messages, baseUserMessage) {
   const now = Date.now();
   const userInfo = baseUserMessage.info;
-  const inboxMsgs = messages.map((m) => ({
-    id: m.msgIndex,
-    from: m.from,
-    body: m.body
-  }));
+  const statusAnnouncements = messages.filter((m) => m.isStatusAnnouncement);
+  const regularMessages = messages.filter((m) => !m.isStatusAnnouncement);
+  const outputData = {};
+  if (statusAnnouncements.length > 0) {
+    outputData.agents = statusAnnouncements.map((m) => ({
+      name: m.from,
+      status: m.body
+    }));
+  }
+  if (regularMessages.length > 0) {
+    outputData.messages = regularMessages.map((m) => ({
+      id: m.msgIndex,
+      from: m.from,
+      content: m.body
+    }));
+  }
   const assistantMessageId = `msg_broadcast_${now}`;
   const partId = `prt_broadcast_${now}`;
   const callId = `call_broadcast_${now}`;
+  const titleParts = [];
+  if (statusAnnouncements.length > 0) {
+    titleParts.push(`${statusAnnouncements.length} agent(s)`);
+  }
+  if (regularMessages.length > 0) {
+    titleParts.push(`${regularMessages.length} message(s)`);
+  }
+  const title = titleParts.length > 0 ? titleParts.join(", ") : "Inbox";
+  const output = JSON.stringify(outputData);
   log.debug(LOG.MESSAGE, `Creating bundled inbox message`, {
     sessionId,
-    messageCount: messages.length,
-    msgIndices: messages.map((m) => m.msgIndex)
+    totalCount: messages.length,
+    statusCount: statusAnnouncements.length,
+    messageCount: regularMessages.length
   });
   const result = {
     info: {
@@ -403,12 +433,13 @@ function createInboxMessage(sessionId, messages, baseUserMessage) {
         tool: "broadcast",
         state: {
           status: "completed",
-          input: { messages: inboxMsgs },
-          output: `${messages.length} message(s)`,
-          title: `Inbox (${messages.length} messages)`,
+          input: { synthetic: true },
+          output,
+          title,
           metadata: {
-            incoming_message: true,
-            message_count: messages.length
+            incoming_message: regularMessages.length > 0,
+            message_count: regularMessages.length,
+            status_count: statusAnnouncements.length
           },
           time: { start: now, end: now }
         }
@@ -428,59 +459,96 @@ var plugin = async (ctx) => {
       broadcast: tool({
         description: BROADCAST_DESCRIPTION,
         args: {
-          recipient: tool.schema.string().optional().describe("Target agent(s), comma-separated. Omit to send to all."),
+          recipient: tool.schema.string().optional().describe("Target agent (single agent only). Omit to send to all."),
           message: tool.schema.string().describe("Your message"),
-          reply_to: tool.schema.array(tool.schema.number()).optional().describe("Message IDs to mark as handled (e.g., [1, 2, 3])")
+          reply_to: tool.schema.number().optional().describe("Message ID to mark as handled")
         },
         async execute(args, context) {
           const sessionId = context.sessionID;
-          const isFirstCall = !activeSessions.has(sessionId);
+          const isFirstCall = !announcedSessions.has(sessionId);
           registerSession(sessionId);
           const alias = getAlias(sessionId);
           if (!args.message) {
             log.warn(LOG.TOOL, `broadcast missing 'message'`, { alias });
             return BROADCAST_MISSING_MESSAGE;
           }
-          if (args.message.length > MAX_MESSAGE_LENGTH) {
-            log.warn(LOG.TOOL, `broadcast message too long`, {
+          let messageContent = args.message;
+          if (messageContent.length > MAX_MESSAGE_LENGTH) {
+            log.warn(LOG.TOOL, `broadcast message truncated`, {
               alias,
-              length: args.message.length
+              originalLength: messageContent.length,
+              truncatedTo: MAX_MESSAGE_LENGTH
             });
-            return broadcastMessageTooLong(args.message.length, MAX_MESSAGE_LENGTH);
-          }
-          if (isFirstCall) {
-            setDescription(sessionId, args.message);
+            messageContent = messageContent.substring(0, MAX_MESSAGE_LENGTH) + "... [truncated]";
           }
+          const parallelAgents = getParallelAgents(sessionId);
           log.debug(LOG.TOOL, `broadcast called`, {
             sessionId,
             alias,
             recipient: args.recipient,
             reply_to: args.reply_to,
-            messageLength: args.message.length,
+            messageLength: messageContent.length,
             isFirstCall
           });
-          let handledMessages = [];
-          if (args.reply_to && args.reply_to.length > 0) {
-            handledMessages = markMessagesAsHandled(sessionId, args.reply_to);
-            log.info(LOG.TOOL, `Handled messages via reply_to`, {
+          if (isFirstCall && args.reply_to === undefined) {
+            announcedSessions.add(sessionId);
+            setDescription(sessionId, messageContent);
+            const knownAgents2 = getKnownAliases(sessionId);
+            for (const targetAlias of knownAgents2) {
+              const recipientSessionId = aliasToSession.get(targetAlias);
+              if (recipientSessionId) {
+                sendMessage(alias, recipientSessionId, messageContent, true);
+              }
+            }
+            log.info(LOG.TOOL, `First broadcast - sent status announcement`, {
               alias,
-              requested: args.reply_to,
-              actuallyHandled: handledMessages.length
+              status: messageContent,
+              sentTo: knownAgents2
             });
+            return broadcastResult(alias, knownAgents2, parallelAgents, undefined);
+          }
+          if (isFirstCall) {
+            announcedSessions.add(sessionId);
+            log.info(LOG.TOOL, `First broadcast with reply_to - treating as normal reply`, {
+              alias,
+              reply_to: args.reply_to
+            });
+          }
+          let handledMessage;
+          let autoRecipient;
+          if (args.reply_to !== undefined) {
+            const handled = markMessagesAsHandled(sessionId, [args.reply_to]);
+            if (handled.length > 0) {
+              handledMessage = handled[0];
+              autoRecipient = handledMessage.from;
+              if (args.recipient && args.recipient !== autoRecipient) {
+                log.warn(LOG.TOOL, `reply_to provided - ignoring recipient param`, {
+                  alias,
+                  providedRecipient: args.recipient,
+                  autoWiredRecipient: autoRecipient
+                });
+              }
+              log.info(LOG.TOOL, `Handled message via reply_to`, {
+                alias,
+                msgId: args.reply_to,
+                autoRecipient
+              });
+            }
           }
           const knownAgents = getKnownAliases(sessionId);
-          const parallelAgents = getParallelAgents(sessionId);
           let targetAliases;
-          if (!args.recipient) {
+          if (autoRecipient) {
+            targetAliases = [autoRecipient];
+          } else if (!args.recipient) {
             targetAliases = knownAgents;
           } else {
-            targetAliases = args.recipient.split(",").map((s) => s.trim()).filter(Boolean);
+            targetAliases = [args.recipient.trim()];
           }
           if (targetAliases.length === 0) {
             log.info(LOG.TOOL, `No recipients, returning agent info`, {
               alias
             });
-            return broadcastResult(alias, [], parallelAgents, handledMessages);
+            return broadcastResult(alias, [], parallelAgents, handledMessage);
           }
           const parentId = await getParentId(client, sessionId);
           const recipientSessions = [];
@@ -511,11 +579,11 @@ var plugin = async (ctx) => {
             log.info(LOG.TOOL, `No valid recipients after filtering`, {
               alias
             });
-            return broadcastResult(alias, [], parallelAgents, handledMessages);
+            return broadcastResult(alias, [], parallelAgents, handledMessage);
           }
           const isTargetingParent = parentId && recipientSessions.includes(parentId);
           for (const recipientSessionId of recipientSessions) {
-            sendMessage(alias, recipientSessionId, args.message);
+            sendMessage(alias, recipientSessionId, messageContent, false);
           }
           if (isTargetingParent) {
             log.info(LOG.MESSAGE, `Broadcasting to parent session, calling notify_once`, { sessionId, parentId });
@@ -539,7 +607,7 @@ var plugin = async (ctx) => {
               });
             }
           }
-          return broadcastResult(alias, validTargets, parallelAgents, handledMessages);
+          return broadcastResult(alias, validTargets, parallelAgents, handledMessage);
         }
       })
     },

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../logger.ts"],"names":[],"mappings":"AAkCA;;GAEG;AACH,iBAAe,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAexC;AA0BD,eAAO,MAAM,GAAG;sBACI,MAAM,WAAW,MAAM,SAAS,OAAO;qBAGxC,MAAM,WAAW,MAAM,SAAS,OAAO;qBAGvC,MAAM,WAAW,MAAM,SAAS,OAAO;sBAGtC,MAAM,WAAW,MAAM,SAAS,OAAO;IAGzD,yDAAyD;;CAE1D,CAAC;AAGF,eAAO,MAAM,GAAG;;;;;;CAMN,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../logger.ts"],"names":[],"mappings":"AAuCA;;GAEG;AACH,iBAAe,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAexC;AA+BD,eAAO,MAAM,GAAG;sBACI,MAAM,WAAW,MAAM,SAAS,OAAO;qBAGxC,MAAM,WAAW,MAAM,SAAS,OAAO;qBAGvC,MAAM,WAAW,MAAM,SAAS,OAAO;sBAGtC,MAAM,WAAW,MAAM,SAAS,OAAO;IAGzD,yDAAyD;;CAE1D,CAAC;AAGF,eAAO,MAAM,GAAG;;;;;;CAMN,CAAC"}

package/dist/prompt.d.ts

@@ -1,4 +1,4 @@
-export declare const BROADCAST_DESCRIPTION = "Communicate with other parallel agents. Use 'recipient' for specific agent(s), or omit to message all. Use 'reply_to' to mark messages as handled.";
+export declare const BROADCAST_DESCRIPTION = "Communicate with other parallel agents. Use 'recipient' for a specific agent, or omit to message all. Use 'reply_to' to reply (auto-wires recipient to sender).";
 export interface ParallelAgent {
     alias: string;
     description?: string;
@@ -8,10 +8,9 @@ export interface HandledMessage {
     from: string;
     body: string;
 }
-export declare function broadcastResult(alias: string, recipients: string[], parallelAgents: ParallelAgent[], handledMessages: HandledMessage[]): string;
+export declare function broadcastResult(alias: string, recipients: string[], parallelAgents: ParallelAgent[], handledMessage?: HandledMessage): string;
 export declare const BROADCAST_MISSING_MESSAGE = "Error: 'message' parameter is required.";
 export declare const BROADCAST_SELF_MESSAGE = "Warning: You cannot send a message to yourself. The target alias is your own alias. Choose a different recipient.";
-export declare function broadcastMessageTooLong(length: number, maxLength: number): string;
 export declare function broadcastUnknownRecipient(recipient: string, known: string[]): string;
-export declare const SYSTEM_PROMPT = "\n<instructions tool=\"iam\">\n# Inter-Agent Messaging\n\nUse `broadcast` to communicate with other parallel agents.\n\n## IMPORTANT: Broadcast Immediately on Start\nCall `broadcast(message=\"...\")` as your FIRST action to announce yourself and discover other agents. The tool result will show all available agents you can message.\n\n## Sending Messages\n- `broadcast(message=\"...\")` \u2192 send to all agents\n- `broadcast(recipient=\"agentB\", message=\"...\")` \u2192 send to specific agent\n\n## Receiving Messages\nIncoming messages appear as `broadcast` tool results with a `messages` array:\n```\n{ messages: [{ id: 1, from: \"agentA\", body: \"...\" }, ...] }\n```\n\nUse `reply_to` to mark messages as handled (they persist until you do):\n- `broadcast(recipient=\"agentA\", reply_to=[1], message=\"...\")`\n- `broadcast(recipient=\"agentA\", reply_to=[1, 2, 3], message=\"...\")`\n</instructions>\n";
+export declare const SYSTEM_PROMPT = "\n<instructions tool=\"iam\">\n# Inter-Agent Messaging\n\nUse `broadcast` to communicate with other parallel agents.\n\n## IMPORTANT: Broadcast Immediately on Start\nCall `broadcast(message=\"...\")` as your FIRST action to announce yourself and discover other agents. The tool result will show all available agents you can message.\n\n## Sending Messages\n- `broadcast(message=\"...\")` \u2192 send to all agents\n- `broadcast(recipient=\"agentB\", message=\"...\")` \u2192 send to specific agent\n\n## Receiving Messages\nIncoming messages appear as synthetic `broadcast` tool results:\n```\n{\n  agents: [{ name: \"agentA\", status: \"Working on X\" }],\n  messages: [{ id: 1, from: \"agentA\", content: \"...\" }]\n}\n```\n\n- **agents**: Status announcements (not replyable)\n- **messages**: Messages you can reply to using `reply_to`\n\nUse `reply_to` to reply to a message (auto-wires recipient):\n- `broadcast(reply_to=1, message=\"...\")` \u2192 replies to message #1\n</instructions>\n";
 //# sourceMappingURL=prompt.d.ts.map

package/dist/prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../prompt.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB,uJAAuJ,CAAC;AAM1L,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAMD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAAE,EACpB,cAAc,EAAE,aAAa,EAAE,EAC/B,eAAe,EAAE,cAAc,EAAE,GAChC,MAAM,CAyCR;AAED,eAAO,MAAM,yBAAyB,4CAA4C,CAAC;AAEnF,eAAO,MAAM,sBAAsB,sHAAsH,CAAC;AAE1J,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,MAAM,CAER;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,CAMR;AAMD,eAAO,MAAM,aAAa,q5BAuBzB,CAAC"}
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../prompt.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB,oKAAoK,CAAC;AAMvM,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAMD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAAE,EACpB,cAAc,EAAE,aAAa,EAAE,EAC/B,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAuCR;AAED,eAAO,MAAM,yBAAyB,4CAA4C,CAAC;AAEnF,eAAO,MAAM,sBAAsB,sHAAsH,CAAC;AAE1J,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,CAMR;AAMD,eAAO,MAAM,aAAa,w+BA4BzB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spoons-and-mirrors/iam",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Inter-agent messaging for OpenCode parallel subagents",
   "type": "module",
   "main": "dist/index.js",