@grknbyk/agent-wire 0.8.1 → 0.8.3

package/README.md

@@ -30,14 +30,28 @@ got it, rewriting the report query
 ## Install
 
 ```bash
-npx @grknbyk/agent-wire setup
+npm i -g @grknbyk/agent-wire
+agent-wire setup
 ```
 
+Run `setup` in a real terminal window. It asks questions, so it refuses a pipe, a
+script, and an editor task — an agent that tries to run it from a tool gets a
+one-line refusal and usually tells you the wrong thing about why.
+
 Setup prints the path of the bundled `manifest.json`. You create the app from it
 at [api.slack.com/apps/new](https://api.slack.com/apps/new), install it, and paste
 the Bot User OAuth Token back. Then you create the channel in Slack and type
 `/invite @agent-wire` in it.
 
+**Give every install its own nickname.** The first key seen under a name is pinned
+to it, so a second install answering to the same name is reported as `impostor` by
+everyone who already heard from the first — and a forged sighting stays on the
+record even after a later message verifies.
+
+The whole team shares one Slack app and one bot token. Only the first person
+creates the app; everybody after that pastes the same token and picks their own
+name, and nobody needs to invite the bot again.
+
 Setup never asks which channel. The invite is the answer: whatever the bot has
 been added to, public or private, is what it works in. Invite it somewhere new and
 `agent-wire doctor` picks the channel up on the next run.
@@ -54,19 +68,43 @@ the first unfinished step, because the config file is the progress.
 Then point your client at it:
 
 ```bash
-claude mcp add agent-wire -- npx -y @grknbyk/agent-wire serve
+claude mcp add -s user agent-wire -- agent-wire serve
 ```
 
+`-s user` registers it once for every project. The modes are per session anyway,
+so a per-project registration only means adding it again in the next folder.
+
 Or, for any other MCP client:
 
 ```json
 {
   "mcpServers": {
-    "agent-wire": { "command": "npx", "args": ["-y", "@grknbyk/agent-wire", "serve"] }
+    "agent-wire": { "command": "agent-wire", "args": ["serve"] }
   }
 }
 ```
 
+### Without installing it
+
+Every command works through `npx` instead, which is the way to try it before
+putting a binary on the machine:
+
+```bash
+npx @grknbyk/agent-wire setup
+claude mcp add -s user agent-wire -- npx -y @grknbyk/agent-wire serve
+```
+
+Nothing behaves differently. It is slower: measured at 800 ms against 215 ms for
+the global binary, on a warm cache, and the difference is paid on every call. The
+prompt hook runs on every prompt, so that is where it is felt.
+
+`npx` also serves whatever it has cached. Add `@latest` when a version you just
+published does not show up.
+
+An install that reports an old version after `npm i -g` is reading the same stale
+cache rather than a publish that failed: `npm cache clean --force`, then install
+again.
+
 ## Commands
 
 | Command | What it does |
@@ -83,7 +121,13 @@ Or, for any other MCP client:
 
 ## Tools your agent gets
 
-`send`, `send_file`, `inbox`, `archive`, `peers`, `members`, `channels`, `my_id`.
+`send`, `send_file`, `inbox`, `archive`, `peers`, `members`, `channels`, `my_id`,
+`status`.
+
+`status` returns the same card the CLI draws, already fenced. It exists because a
+shell result gets read, understood and then retyped as prose, and a drawn box does
+not survive that — two installs reporting the same state should not produce two
+different-looking answers.
 
 The mode of a channel is a command the user runs, never a tool. A message
 arriving from the channel must not be able to talk the agent into silencing

package/package.json

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

package/src/inbox.mjs

@@ -38,7 +38,12 @@ export function readInbox() {
 // per appended message is the whole cost of appending a message.
 const inboxKeys = () => derivedFromFile(paths.inbox, 'keys', () => new Set(readInbox().map(logKey)));
 
-export const stateOf = (states, item) => states[storageKey(item)] ?? 'unread';
+// A message this agent sent is kept in the log so the conversation reads back
+// whole, but it was never waiting on anybody. Left as unread it joined the tally
+// of who needs an answer, and the agent was told ten people were waiting when one
+// of them was itself.
+export const stateOf = (states, item) =>
+    (item.authorship === 'self' ? 'read' : states[storageKey(item)] ?? 'unread');
 
 // The Slack timestamp is the idempotency key: a retried poll, an overlapping
 // window, or a re-installed app all replay the same ts, and a duplicate the human

package/src/mcp.mjs

@@ -64,6 +64,11 @@ const TOOLS = [
         description: 'This agent\'s nickname, emoji, key fingerprint and channels.',
         inputSchema: { type: 'object', properties: {} },
     },
+    {
+        name: 'status',
+        description: 'The status card: identity, channels with their modes, who has written, and when the last poll ran. Print what this returns exactly as it arrives, inside a code block. It is a drawn box, so retyping the fields loses it.',
+        inputSchema: { type: 'object', properties: {} },
+    },
     {
         name: 'peers',
         description: 'Agent names seen in the channels so far, with the key pinned to each.',
@@ -154,11 +159,26 @@ const MODE_SUMMARY = {
     read: 'the messages themselves, in every prompt',
 };
 
-const PROMPTS = MODES.map((mode) => ({
-    name: mode,
-    description: `Set a channel to ${mode} for this session — ${MODE_SUMMARY[mode]}`,
-    arguments: [{ name: 'channel', description: 'Channel name. Omit it when only one is configured.', required: false }],
-}));
+const PROMPTS = [
+    ...MODES.map((mode) => ({
+        name: mode,
+        description: `Set a channel to ${mode} for this session — ${MODE_SUMMARY[mode]}`,
+        arguments: [{ name: 'channel', description: 'Channel name. Omit it when only one is configured.', required: false }],
+    })),
+    { name: 'status', description: 'Show the agent-wire status card', arguments: [] },
+];
+
+const STATUS_INSTRUCTION = {
+    description: 'Show the agent-wire status card',
+    messages: [{
+        role: 'user',
+        content: {
+            type: 'text',
+            text: 'Call the agent-wire status tool and print what it returns verbatim, inside a code block.'
+                + ' Do not summarise it, do not retype the fields, do not reformat the box. The drawing is the answer.',
+        },
+    }],
+};
 
 function modeInstruction(mode, channel) {
     const command = `agent-wire ${mode}${channel ? ` ${channel}` : ''}`;
@@ -326,6 +346,15 @@ async function call(name, args, session) {
     // refusal and tells the user the wrong thing.
     if (!config) return 'agent-wire is not configured yet. Tell the user to run `agent-wire setup` in a real terminal window — it asks questions, so it will not run from a tool. Install it first with `npm i -g @grknbyk/agent-wire` if the command is missing.';
 
+    // The card reaches the user through a tool rather than a shell, because a
+    // shell result gets read, understood and then retyped as prose — and the box
+    // does not survive that. Fenced here so it arrives ready to pass on.
+    if (name === 'status') {
+        const { renderStatus } = await import('./status.mjs');
+        return 'Show this to the user exactly as it is, in a code block. Do not summarise it and do not retype the numbers.\n\n'
+            + `\`\`\`\n${renderStatus(config).trim()}\n\`\`\``;
+    }
+
     if (name === 'my_id') {
         const channels = (config.channels ?? []).map((channel) => `#${channel.name}`).join(', ') || 'none';
         return `${config.mark} ${config.nickname} — key ${config.public_key.slice(0, FINGERPRINT_CHARS)}… — channels: ${channels}`;
@@ -430,7 +459,10 @@ export function serve() {
         if (message.method === 'prompts/get') {
             const asked = PROMPTS.find((prompt) => prompt.name === message.params.name);
             if (!asked) return write({ jsonrpc: '2.0', id: message.id, error: { code: -32602, message: `no prompt named ${message.params.name}` } });
-            return write({ jsonrpc: '2.0', id: message.id, result: modeInstruction(asked.name, message.params.arguments?.channel) });
+            const answer = asked.name === 'status'
+                ? STATUS_INSTRUCTION
+                : modeInstruction(asked.name, message.params.arguments?.channel);
+            return write({ jsonrpc: '2.0', id: message.id, result: answer });
         }
         if (message.method === 'ping') return write({ jsonrpc: '2.0', id: message.id, result: {} });
         if (message.method === 'tools/call') {