@spoons-and-mirrors/iam 0.1.7 → 0.1.9

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 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,67 +15,102 @@ sequenceDiagram
     Parent->>A: spawn task
     Parent->>B: spawn task
 
-    Note over A,B: Registration
+    Note over A,B: Attention mechanism activation
 
-    A->>A: broadcast(message="Doing X")
-    Note over A: Tool result shows agentB is available
+    A->>B: broadcast(message="Doing X")
+    Note over B: Get announcement in synthetic tool result
 
-    B->>B: broadcast(message="Doing Y")
-    Note over B: Tool result shows agentA is available
 
     A->>B: broadcast(recipient="agentB", message="Question?")
+    A->>B: broadcast(recipient="agentB", message="Other question?")
 
-    Note over B: Receives message in inbox
+    Note over B: Get messages in synthetic tool result
 
-    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: Clear message 1 from synthetic
 
     Note over A: Receives reply
-    Note over B: Message removed from inbox
-    Note over B: Audit trace persists in tool result
+```
+
+## 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, message="...")                      # Mark message 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          |
-| `reply_to`  | No       | Message ID to mark as handled (e.g., `1`) |
+| 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?"}
-  ]
+  "tool": "broadcast",
+  "state": {
+    "status": "completed",
+    "input": { "synthetic": true },
+    "output": {
+      "hint": "ACTION REQUIRED: Announce yourself...",
+      "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)"
+  }
 }
 ```
 
+- **`input.synthetic`**: Indicates this was injected by IAM, not a real agent call
+- **`output.hint`**: Shown only if agent hasn't announced yet (disappears after first broadcast)
+- **`output.agents`**: Other agents and their status (not replyable)
+- **`output.messages`**: Messages you can reply to using `reply_to`
+
 Messages persist in the inbox until the agent marks them as handled using `reply_to`.
 
-**Discovery:** Agents discover each other by calling `broadcast` - the tool result shows all available agents.
+**Discovery:** Agents discover each other through synthetic injection. The first `broadcast` call sets the agent's status, which other agents see in the `agents` array.
 
-## Installation
+## Attention Layer
 
-Add to your OpenCode config:
+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.
 
-```
-"plugin": ["@spoons-and-mirrors/iam@latest"]
-```
+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
 
@@ -94,10 +127,12 @@ AgentB (working on backend):
   -> broadcast(message="Starting backend work")
      # Tool result shows: "Available agents: agentA"
   -> ... sees AgentA's question in inbox ...
-  -> broadcast(recipient="agentA", reply_to=1, message="Here's the schema: {...}")
+  -> 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!")
+     # Recipient auto-wired to agentB
 ```

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,MA0Tb,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;AAsnBlD,QAAA,MAAM,MAAM,EAAE,MA6Xb,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.`;
+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,25 +19,21 @@ function broadcastResult(alias, recipients, parallelAgents, handledMessage) {
   } else {
     lines.push(`No other agents available yet.`);
   }
-  if (recipients.length > 0) {
-    lines.push(``);
-    const recipientStr = recipients.length === 1 ? recipients[0] : recipients.join(", ");
-    lines.push(`Message sent to: ${recipientStr}`);
-  }
   if (handledMessage) {
     lines.push(``);
     const preview = handledMessage.body.length > 80 ? handledMessage.body.substring(0, 80) + "..." : handledMessage.body;
-    lines.push(`Marked as handled: #${handledMessage.id} from ${handledMessage.from}`);
+    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}`);
   }
   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}`;
@@ -48,38 +44,49 @@ var SYSTEM_PROMPT = `
 
 Use \`broadcast\` to communicate with other parallel agents.
 
-## IMPORTANT: Broadcast Immediately on Start
-Call \`broadcast(message="...")\` as your FIRST action to announce yourself and discover other agents. The tool result will show all available agents you can message.
+## IMPORTANT: Announce Yourself First
+Your first action should be calling \`broadcast(message="what you're working on")\` to announce yourself. Until you do, other agents won't know your purpose. The synthetic tool result will show a hint reminding you to announce.
 
 ## Sending Messages
-- \`broadcast(message="...")\` → send to all agents
+- \`broadcast(message="...")\` → announce yourself or send to all agents
 - \`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: "..." }, ...] }
+{
+  hint: "ACTION REQUIRED: Announce yourself...",  // only if you haven't announced
+  agents: [{ name: "agentA", status: "Working on X" }],
+  messages: [{ id: 1, from: "agentA", content: "..." }]
+}
 \`\`\`
 
-Use \`reply_to\` to mark a message as handled (they persist until you do):
-- \`broadcast(recipient="agentA", reply_to=1, message="...")\`
+- **hint**: Disappears after you announce yourself
+- **agents**: Other agents and their status (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();
 }
@@ -102,6 +109,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}
@@ -127,7 +137,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;
@@ -139,12 +149,14 @@ 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;
 var nextAgentIndex = 0;
 var registeringSessionsLock = new Set;
 var sessionParentCache = new Map;
+var childSessionCache = new Set;
 function cleanupExpiredMessages() {
   const now = Date.now();
   let totalRemoved = 0;
@@ -354,21 +366,55 @@ async function getParentId(client, sessionId) {
     return null;
   }
 }
-function createInboxMessage(sessionId, messages, baseUserMessage) {
+async function isChildSession(client, sessionId) {
+  if (childSessionCache.has(sessionId)) {
+    return true;
+  }
+  const parentId = await getParentId(client, sessionId);
+  if (parentId) {
+    childSessionCache.add(sessionId);
+    return true;
+  }
+  return false;
+}
+function createInboxMessage(sessionId, messages, baseUserMessage, parallelAgents, hasAnnounced) {
   const now = Date.now();
   const userInfo = baseUserMessage.info;
-  const inboxMsgs = messages.map((m) => ({
-    id: m.msgIndex,
-    from: m.from,
-    body: m.body
-  }));
+  const outputData = {};
+  if (!hasAnnounced) {
+    outputData.hint = `ACTION REQUIRED: Announce yourself to other agents by calling broadcast(message="what you're working on")`;
+  }
+  if (parallelAgents.length > 0) {
+    outputData.agents = parallelAgents.map((agent) => ({
+      name: agent.alias,
+      status: agent.description
+    }));
+  }
+  if (messages.length > 0) {
+    outputData.messages = messages.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}`;
-  log.debug(LOG.MESSAGE, `Creating bundled inbox message`, {
+  const titleParts = [];
+  if (parallelAgents.length > 0) {
+    titleParts.push(`${parallelAgents.length} agent(s)`);
+  }
+  if (messages.length > 0) {
+    titleParts.push(`${messages.length} message(s)`);
+  }
+  const title = titleParts.length > 0 ? titleParts.join(", ") : "Inbox";
+  const output = JSON.stringify(outputData);
+  log.info(LOG.MESSAGE, `Creating inbox injection`, {
     sessionId,
-    messageCount: messages.length,
-    msgIndices: messages.map((m) => m.msgIndex)
+    agents: parallelAgents.map((a) => a.alias),
+    agentStatuses: parallelAgents.map((a) => a.description?.substring(0, 50)),
+    messageIds: messages.map((m) => m.msgIndex),
+    messageFroms: messages.map((m) => m.from)
   });
   const result = {
     info: {
@@ -400,12 +446,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: messages.length > 0,
+            message_count: messages.length,
+            agent_count: parallelAgents.length
           },
           time: { start: now, end: now }
         }
@@ -425,55 +472,83 @@ 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.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);
+            messageContent = messageContent.substring(0, MAX_MESSAGE_LENGTH) + "... [truncated]";
           }
-          if (isFirstCall) {
-            setDescription(sessionId, args.message);
-          }
-          log.debug(LOG.TOOL, `broadcast called`, {
-            sessionId,
+          const parallelAgents = getParallelAgents(sessionId);
+          log.info(LOG.TOOL, `broadcast called`, {
             alias,
             recipient: args.recipient,
             reply_to: args.reply_to,
-            messageLength: args.message.length,
+            messageLength: messageContent.length,
             isFirstCall
           });
+          if (isFirstCall && args.reply_to === undefined) {
+            announcedSessions.add(sessionId);
+            setDescription(sessionId, messageContent);
+            const knownAgents2 = getKnownAliases(sessionId);
+            log.info(LOG.TOOL, `First broadcast - status announcement`, {
+              alias,
+              status: messageContent.substring(0, 80),
+              discoveredAgents: 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
+                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`, {
@@ -514,7 +589,7 @@ var plugin = async (ctx) => {
           }
           const isTargetingParent = parentId && recipientSessions.includes(parentId);
           for (const recipientSessionId of recipientSessions) {
-            sendMessage(alias, recipientSessionId, args.message);
+            sendMessage(alias, recipientSessionId, messageContent);
           }
           if (isTargetingParent) {
             log.info(LOG.MESSAGE, `Broadcasting to parent session, calling notify_once`, { sessionId, parentId });
@@ -564,19 +639,8 @@ var plugin = async (ctx) => {
         log.debug(LOG.INJECT, `No sessionID in system.transform input, skipping`);
         return;
       }
-      try {
-        const result = await client.session.get({ path: { id: sessionId } });
-        if (!result.data?.parentID) {
-          log.debug(LOG.INJECT, `Session has no parentID (main session), skipping IAM`, {
-            sessionId
-          });
-          return;
-        }
-      } catch (e) {
-        log.debug(LOG.INJECT, `Failed to get session info, skipping IAM`, {
-          sessionId,
-          error: String(e)
-        });
+      if (!await isChildSession(client, sessionId)) {
+        log.debug(LOG.INJECT, `Session has no parentID (main session), skipping IAM`, { sessionId });
         return;
       }
       registerSession(sessionId);
@@ -593,25 +657,37 @@ var plugin = async (ctx) => {
         return;
       }
       const sessionId = lastUserMsg.info.sessionID;
+      if (!await isChildSession(client, sessionId)) {
+        log.debug(LOG.INJECT, `Skipping messages.transform for main session`, {
+          sessionId
+        });
+        return;
+      }
       const unhandled = getUnhandledMessages(sessionId);
+      const parallelAgents = getParallelAgents(sessionId);
       log.debug(LOG.INJECT, `Checking for messages in transform`, {
         sessionId,
-        unhandledCount: unhandled.length
+        unhandledCount: unhandled.length,
+        parallelAgentCount: parallelAgents.length
       });
-      if (unhandled.length === 0) {
+      if (unhandled.length === 0 && parallelAgents.length === 0) {
+        log.info(LOG.INJECT, `No agents or messages to inject`, {
+          sessionId,
+          alias: getAlias(sessionId)
+        });
         return;
       }
-      log.info(LOG.INJECT, `Injecting bundled inbox message`, {
+      log.info(LOG.INJECT, `Injecting synthetic broadcast`, {
         sessionId,
-        unhandledCount: unhandled.length,
-        msgIndices: unhandled.map((m) => m.msgIndex)
+        alias: getAlias(sessionId),
+        agentCount: parallelAgents.length,
+        agents: parallelAgents.map((a) => a.alias),
+        messageCount: unhandled.length,
+        messageIds: unhandled.map((m) => m.msgIndex)
       });
-      const inboxMsg = createInboxMessage(sessionId, unhandled, lastUserMsg);
+      const hasAnnounced = announcedSessions.has(sessionId);
+      const inboxMsg = createInboxMessage(sessionId, unhandled, lastUserMsg, parallelAgents, hasAnnounced);
       output.messages.push(inboxMsg);
-      log.info(LOG.INJECT, `Injected inbox at end of message chain`, {
-        sessionId,
-        messageCount: unhandled.length
-      });
     },
     "experimental.config.transform": async (_input, output) => {
       const experimental = output.experimental ?? {};

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;
@@ -11,7 +11,6 @@ export interface HandledMessage {
 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 a message as handled (they persist until you do):\n- `broadcast(recipient=\"agentA\", reply_to=1, 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: Announce Yourself First\nYour first action should be calling `broadcast(message=\"what you're working on\")` to announce yourself. Until you do, other agents won't know your purpose. The synthetic tool result will show a hint reminding you to announce.\n\n## Sending Messages\n- `broadcast(message=\"...\")` \u2192 announce yourself or 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  hint: \"ACTION REQUIRED: Announce yourself...\",  // only if you haven't announced\n  agents: [{ name: \"agentA\", status: \"Working on X\" }],\n  messages: [{ id: 1, from: \"agentA\", content: \"...\" }]\n}\n```\n\n- **hint**: Disappears after you announce yourself\n- **agents**: Other agents and their status (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,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CA2CR;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,00BAsBzB,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,ssCA8BzB,CAAC"}

package/package.json

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