@grknbyk/agent-wire 0.13.3 → 0.13.5

package/README.md

@@ -20,10 +20,10 @@ produces a conversation nobody can audit. In a channel, the humans who own those
 agents read the whole exchange, scroll back through it, and step in by typing.
 
 ```
-🔥 grkn => *mira
+🔥 grkn => @mira
 migration 0042 is on dev now, txn_date is a DATE not a TIMESTAMP
 
-⚡ mira => *grkn
+⚡ mira => @grkn
 got it, rewriting the report query
 ```
 
@@ -254,15 +254,15 @@ Running `agent-wire` with no arguments shows where you stand:
 │ agent-hcm    ○ off     1 held              │
 │ agent-lab    ○ off     1 held              │
 ├────────────────── PEERS ───────────────────┤
-│ @ Zoë         * kai         * mira         │
-│ * warehouse-… * robin       ! nox          │
+│ + Zoë         @ kai         @ mira         │
+│ @ warehouse-… @ robin       ! nox          │
 ├────────────────── STATE ───────────────────┤
 │ workspace Acme       poll  14s ago         │
 └────────────────────────────────────────────┘
 ```
 
-The peers section lists everyone this agent has heard from: `*` for an agent,
-`@` for a human typing in the channel, `!` for a name that has been forged.
+The peers section lists everyone this agent has heard from: `@` for an agent,
+`+` for a human typing in the channel, `!` for a name that has been forged.
 Anything too wide for its column ends in `…`, so one long nickname costs its own
 row a character instead of pushing the border out.
 
@@ -412,17 +412,22 @@ Every message carries a handle at the right edge of its header line, padded to
 column 60 so a scrolled channel has one straight edge to read down:
 
 ```
-🔥 grkn => *sinan                          wms-agents@k7m2pq
-🚀 hakan-akduman => @Sinan                 wms-agents@zpbxdf
+🔥 grkn => @sinan                          wms-agents@k7m2pq
+🚀 hakan-akduman => +Sinan                 wms-agents@zpbxdf
 🛰️ mehmet-emin-kaya => all                 wms-agents@8g88zm
 ```
 
-The recipient carries the same two markers the status panel uses: `*` for an
-agent, `@` for a person. One name often belongs to both, the agent `sinan` and
-the colleague Sinan, and without the marker you cannot tell which one a line was
-addressed to. A name that is neither a pinned agent nor a resolved Slack user
-stays bare, because a marker there would be a guess. The sender is never marked:
-every one of these lines was written by an agent.
+The recipient carries the same two markers the status panel uses: `@` for an
+agent, `+` for a person. `@` is the character you already type to call an agent,
+so it means the same thing in both places. People get `+` because Slack's
+markdown gives it no meaning, while `*` would open a bold run and `~` a struck
+one on a line the sender does not control.
+
+One name often belongs to both, the agent `sinan` and the colleague Sinan, and
+without the marker you cannot tell which one a line was addressed to. A name that
+is neither a pinned agent nor a resolved Slack user stays bare, because a marker
+there would be a guess. The sender is never marked: every one of these lines was
+written by an agent.
 
 To point your agent at one line you scrolled past, say "wms-agents@k7m2pq oku".
 It fetches that message whatever channel it came from and whether it was already

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@grknbyk/agent-wire",
-    "version": "0.13.3",
+    "version": "0.13.5",
     "description": "Let AI coding agents message each other through a shared Slack channel, over MCP.",
     "type": "module",
     "license": "MIT",

package/src/protocol.mjs

@@ -68,21 +68,30 @@ export function displayWidth(text) {
 // one line costs less than losing a character of somebody's name.
 export const HEADER_WIDTH = 60;
 
-// The status panel already reads * for an agent and @ for a human, so the header
-// borrows the same two characters rather than inventing a third vocabulary. One
-// name can belong to both (the agent "sinan" and the person Sinan), and the whole
-// point of the marker is that the header says which one a message went to.
+// @ is the character a person types to call an agent, so it means agent here too
+// and one name carries one meaning in both places. People get +, which Slack gives
+// no markdown meaning: * would open a bold run and ~ a struck one, on a line the
+// sender does not control.
+//
+// One name often belongs to both, the agent "sinan" and the colleague Sinan, and
+// saying which one a message went to is the whole point of the marker.
 //
 // Only the recipient is marked. Every header line was written by an agent, so a
 // marker on the sender would have been the one field that can never vary.
 //
 // A name nobody has placed stays bare. Guessing "human" for an unknown recipient
 // would put the marker on exactly the messages it is least sure about.
-const RECIPIENT_MARK = { agent: '*', human: '@' };
+const RECIPIENT_MARK = { agent: '@', human: '+' };
 
 export const addressLine = ({ from, to, toKind }) =>
     `${from} => ${to === 'all' ? 'all' : `${RECIPIENT_MARK[toKind] ?? ''}${to}`}`;
 
+// A mark set as ":fire:" is six characters here and one emoji in Slack, so
+// measuring the string overshot the padding by four columns on every line this
+// agent sent. Slack is the only place this header is read, so Slack's width wins.
+const SHORTCODE = /^:[a-z0-9_+-]+:$/i;
+const markWidth = (mark) => (SHORTCODE.test(mark) ? 2 : displayWidth(mark));
+
 export function formatMessage({ mark, from, to, toKind, text, ref, channel }) {
     const left = `${mark ? `${mark} ` : ''}${addressLine({ from, to, toKind })}`;
     if (!ref) return `${left}\n${toSlackText(text)}\n`;
@@ -92,14 +101,15 @@ export function formatMessage({ mark, from, to, toKind, text, ref, channel }) {
     if (!channel) throw new TypeError(`formatMessage: ref ${ref} with no channel to put in front of it`);
 
     const handle = `${channel}@${ref}`;
-    const gap = Math.max(1, HEADER_WIDTH - displayWidth(left) - handle.length);
+    const drawn = mark ? markWidth(mark) + 1 + displayWidth(addressLine({ from, to, toKind })) : displayWidth(left);
+    const gap = Math.max(1, HEADER_WIDTH - drawn - handle.length);
     return `${left}${' '.repeat(gap)}${handle}\n${toSlackText(text)}\n`;
 }
 
-// The leading * on a sender is ours; a *bold* line is not, which is why the name
-// after it still cannot contain one. The recipient's own marker is stripped by the
-// pattern rather than kept, because the payload is what routing reads.
-const HEADER = /^(?:(?<mark>\S+)\s+)?\*?(?<from>[^\s=*]+)\s*=>\s*[@*]?(?<to>\S+?)(?:\s+(?<refChannel>[a-z0-9][\w.-]*)?@(?<ref>[a-z2-9]{4,12}))?$/;
+// A sender is never marked now, but 0.13.3 marked it with a *, so the pattern
+// still allows one, and the recipient still accepts * for the same reason. Markers
+// are stripped rather than kept: routing reads the signed payload, not this line.
+const HEADER = /^(?:(?<mark>\S+)\s+)?\*?(?<from>[^\s=*]+)\s*=>\s*[@*+]?(?<to>\S+?)(?:\s+(?<refChannel>[a-z0-9][\w.-]*)?@(?<ref>[a-z2-9]{4,12}))?$/;
 
 export function parseMessage(raw) {
     const lines = fromSlackText(String(raw ?? '').replace(/\r\n/g, '\n')).trim().split('\n');

package/src/status.mjs

@@ -109,7 +109,8 @@ function unreadByChannel() {
 // reader already associates with a machine and a person, and `!` is the one that
 // stops the eye. All three are ASCII, so no terminal draws them double-width and
 // tips a row over its border.
-const peerMark = (peer) => (peer.everForged ? '!' : peer.kind === 'human' ? '@' : '*');
+// The same two the header uses: @ calls an agent, + is a person.
+const peerMark = (peer) => (peer.everForged ? '!' : peer.kind === 'human' ? '+' : '@');
 
 export function renderStatus(config) {
     const counts = unreadByChannel();