@grknbyk/agent-wire 0.8.0 → 0.8.2

package/README.md

@@ -83,7 +83,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
@@ -136,7 +142,7 @@ to the machine:
 `ask` looks like this, and is what a prompt hook prints:
 
 ```
-Unread messages : Huso(5), Sinan(2)
+Unread messages : mira(5), kai(2)
 ```
 
 Loudest sender first, because five messages from one person is a conversation

package/bin/agent-wire.mjs

@@ -20,6 +20,7 @@ const USAGE = `agent-wire — message other AI coding agents through Slack
   agent-wire ask <name>  name who is waiting and how many; open nothing (default)
   agent-wire read <name> put the messages themselves into every prompt
   agent-wire off <name>  say nothing about it in this session
+  agent-wire version     print the installed version, which is what a bug report needs
 
 The three modes belong to one session, identified by the client's session id when
 it publishes one and by the working directory otherwise. The token, the nickname
@@ -113,6 +114,19 @@ function switchChannel(name, mode) {
 
 const showStatus = async () => (await import('../src/status.mjs')).runStatus();
 
+// Everybody types one of these three before they report anything, so all three
+// answer. package.json is read here rather than imported at the top because
+// `drain` runs on every prompt and never needs it.
+async function showVersion() {
+    const { readFileSync } = await import('node:fs');
+    const { fileURLToPath } = await import('node:url');
+    const { dirname, join } = await import('node:path');
+
+    const packageJson = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+    console.log(JSON.parse(readFileSync(packageJson, 'utf8')).version);
+    return 0;
+}
+
 const commands = {
     status: async () => await showStatus() ?? notConfigured(),
     setup: async () => (await import('../src/setup.mjs')).runSetup(),
@@ -125,6 +139,9 @@ const commands = {
     // `on` was the only way to undo `off` before there were three modes, and it
     // meant "announce it without opening it". That is ask.
     on: () => switchChannel(process.argv[3], 'ask'),
+    version: showVersion,
+    '--version': showVersion,
+    '-v': showVersion,
 };
 
 function notConfigured() {

package/package.json

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

package/src/drain.mjs

@@ -9,7 +9,7 @@ import { renderEnvelope } from './protocol.mjs';
 // has to scroll is a hook line the user stops reading.
 const SENDERS_SHOWN = 5;
 
-// "Huso(5), Sinan(2)", loudest first, so the name that matters is the first thing
+// "mira(5), kai(2)", loudest first, so the name that matters is the first thing
 // on the line. The count per person is the whole point: five messages from one
 // person is a conversation waiting, one each from five people is a standup.
 export function senderTally(items) {

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
@@ -80,10 +85,65 @@ export function selectMessages({ state = 'unread', count = DEFAULT_COUNT, channe
     return picked.reverse();
 }
 
+// A session id is minted per client session, so read state stored under one is
+// unreachable the moment that session ends — no later process ever asks under
+// that key again. Left alone the file grows by one key per message per session:
+// measured at 14 MB and 79 ms per mark after a thousand sessions, and marking is
+// something a `read` session does on every prompt.
+//
+// Whole scopes go, oldest first, ranked by the newest message each one has seen.
+// A session still running has recent timestamps and survives; only the dead ones
+// are cheap enough to lose. The current scope is never a candidate.
+const STATE_KEYS_MAX = 8000;
+const STATE_KEYS_KEEP = 6000;
+
+const scopeOfKey = (key) => {
+    const bar = key.indexOf('|');
+    return bar === -1 ? '' : key.slice(0, bar); // written before scopes existed
+};
+
+function prunedStates(states) {
+    const keys = Object.keys(states);
+    if (keys.length <= STATE_KEYS_MAX) return states;
+
+    // One session that has simply read a lot owns every key here, and none of them
+    // can be dropped. Counting them costs a startsWith per key and no allocation,
+    // where grouping by scope costs a substring per key: 20k keys went from 0.7 ms
+    // to 13 ms of scanning that always freed nothing.
+    const mine = `${scopeId()}|`;
+    let foreign = 0;
+    for (const key of keys) if (!key.startsWith(mine)) foreign++;
+    if (foreign === 0) return states;
+
+    const keysByScope = new Map();
+    const newestByScope = new Map();
+    for (const key of keys) {
+        const scope = scopeOfKey(key);
+        const timestamp = Number(key.slice(key.lastIndexOf(':') + 1)) || 0;
+        if (!keysByScope.has(scope)) keysByScope.set(scope, []);
+        keysByScope.get(scope).push(key);
+        if (timestamp > (newestByScope.get(scope) ?? 0)) newestByScope.set(scope, timestamp);
+    }
+
+    const stale = [...newestByScope]
+        .filter(([scope]) => scope !== scopeId())
+        .sort(([, left], [, right]) => left - right);
+
+    // Down to the low mark rather than to the cap, or the next write is over it
+    // again and pays for the whole scan a second time.
+    let remaining = keys.length;
+    for (const [scope] of stale) {
+        if (remaining <= STATE_KEYS_KEEP) break;
+        for (const key of keysByScope.get(scope)) delete states[key];
+        remaining -= keysByScope.get(scope).length;
+    }
+    return states;
+}
+
 export function markRead(items) {
     const states = readJsonCached(paths.states, {});
     for (const item of items) states[storageKey(item)] = 'read';
-    writeJson(paths.states, states);
+    writeJson(paths.states, prunedStates(states));
 }
 
 export function archive(ts) {
@@ -92,7 +152,7 @@ export function archive(ts) {
         ? readInbox().filter((item) => item.ts === ts)
         : readInbox().filter((item) => stateOf(states, item) === 'read');
     for (const item of targets) states[storageKey(item)] = 'archived';
-    writeJson(paths.states, states);
+    writeJson(paths.states, prunedStates(states));
     return targets.length;
 }
 

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}` : ''}`;
@@ -321,7 +341,19 @@ async function call(name, args, session) {
     if (missing.length) return `missing or empty: ${missing.join(', ')}`;
 
     const config = loadConfig();
-    if (!config) return 'agent-wire is not configured yet — run `npx @grknbyk/agent-wire setup`';
+    // Said to an agent, which will pass it on. Naming the terminal matters: setup
+    // refuses a pipe, so an agent that tries to run it from a tool gets a bare
+    // 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';
@@ -427,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') {

package/src/setup.mjs

@@ -169,7 +169,7 @@ export async function runSetup() {
 export async function runDoctor() {
     const config = loadConfig();
     if (!config?.bot_token) {
-        console.log('not configured — run `npx @grknbyk/agent-wire setup`');
+        console.log('not configured yet — run `agent-wire setup`');
         return 1;
     }