@theronap/agnoclast-mcp 0.9.242 → 0.9.243

package/lib/messages_render.mjs

@@ -0,0 +1,48 @@
+// INTERNAL MESSAGING (ADR-0088) — how `my_messages` and `read_conversation` read to an agent.
+// Shapes are web/lib/engine/messages.ts (InboxItem, MessageView), trimmed to what is read.
+
+const REASON = { dm: 'direct message', mention: 'mentioned you', thread: 'reply in your thread', channel: 'channel' }
+
+/** "Builder (agent of Theron Peterson)" / "Ann Lee" / "Deleted account". */
+export function authorLabel(author) {
+  if (!author) return 'Deleted account'
+  if (author.kind === 'agent') return `${author.name} (agent${author.ownerName ? ` of ${author.ownerName}` : ''})`
+  return author.name
+}
+
+function when(iso) {
+  return iso ? iso.replace('T', ' ').slice(0, 16) + 'Z' : ''
+}
+
+/** The inbox, grouped by conversation so an agent answers each one once. */
+export function renderMessageInbox(items) {
+  if (!items.length) return 'No new messages.'
+  const byConv = new Map()
+  for (const it of items) {
+    const key = it.conversation.id
+    if (!byConv.has(key)) byConv.set(key, { conv: it.conversation, items: [] })
+    byConv.get(key).items.push(it)
+  }
+  const lines = [`${items.length} new message${items.length === 1 ? '' : 's'}:`]
+  for (const { conv, items: its } of byConv.values()) {
+    lines.push('', `## ${conv.name} — conversation ${conv.id}`)
+    for (const it of its) {
+      const where = it.threadRootId ? ` · in thread ${it.threadRootId}` : ''
+      lines.push(`- [${when(it.createdAt)}] ${authorLabel(it.author)} (${REASON[it.reason] ?? it.reason}${where}) · message ${it.id}`)
+      for (const l of it.body.split('\n')) lines.push(`  ${l}`)
+    }
+  }
+  lines.push('', 'Reply with send_message. To answer in a thread, pass thread = the thread id shown (or the message id, to start one).')
+  return lines.join('\n')
+}
+
+/** A conversation page or one thread, oldest first. */
+export function renderConversation(messages) {
+  if (!messages.length) return 'No messages yet.'
+  return messages.map((m) => {
+    const head = `[${when(m.createdAt)}] ${authorLabel(m.author)} · message ${m.id}${m.editedAt ? ' · edited' : ''}`
+    const replies = m.replyCount ? `\n  (${m.replyCount} repl${m.replyCount === 1 ? 'y' : 'ies'} in thread ${m.id})` : ''
+    const body = m.deleted ? '  (message deleted)' : m.body.split('\n').map((l) => `  ${l}`).join('\n')
+    return `${head}\n${body}${replies}`
+  }).join('\n')
+}

package/lib/release_gate.mjs

@@ -0,0 +1,44 @@
+// RELEASE COHORTS on the stdio server (Theron, 2026-10-19 — page: Agnoclast — release cohorts and feature flags).
+// The flag registry and the cohort rule live on the server (web/lib/engine/release.ts). This module only asks,
+// once at start-up, which tools this caller must NOT see (GET /api/me/release) and removes them before the
+// first tools/list. Fails CLOSED: no answer within the budget → hide GATED_FALLBACK, a copy of every gated tool
+// that web/lib/engine/release.test.ts pins to the server's registry.
+
+/** Tools any release flag gates — hidden when the server cannot be asked. Mirror of allGatedTools(). */
+export const GATED_FALLBACK = ['my_messages', 'read_conversation', 'send_message']
+
+export const RELEASE_FETCH_TIMEOUT_MS = 2500
+
+/** → { known: true, hidden: string[] } | { known: false }. 404 (server predates cohorts) = nothing hidden. Never throws. */
+export async function fetchReleaseState(base, token, fetchImpl) {
+  try {
+    const res = await fetchImpl(`${base}/api/me/release`, { headers: { Authorization: `Bearer ${token}` } }, { skipAutofile: true })
+    if (res.status === 404) return { known: true, hidden: [] }
+    if (!res.ok) return { known: false }
+    const j = await res.json()
+    if (!Array.isArray(j?.hiddenTools)) return { known: false }
+    return { known: true, hidden: j.hiddenTools.filter((t) => typeof t === 'string') }
+  } catch {
+    return { known: false }
+  }
+}
+
+export async function releaseStateWithin(promise, ms = RELEASE_FETCH_TIMEOUT_MS) {
+  let timer
+  const timeout = new Promise((resolve) => { timer = setTimeout(() => resolve({ known: false }), ms) })
+  try { return await Promise.race([promise, timeout]) } finally { clearTimeout(timer) }
+}
+
+/** Remove hidden tools from the registry. `handles` maps name → { handle }. Returns the names removed. */
+export function applyRelease(handles, state) {
+  const names = state?.known ? state.hidden : GATED_FALLBACK
+  const removed = []
+  for (const name of names) {
+    const h = handles.get(name)
+    if (!h) continue
+    h.handle.remove()
+    handles.delete(name)
+    removed.push(name)
+  }
+  return removed
+}

package/lib/server.mjs

@@ -31,8 +31,10 @@ import { formatCreated, formatDryRun, formatSources, homeFromArgs, pickSource, r
 import { formatSeriesRefusal, formatSeriesUpdated } from './series_render.mjs'
 import { formatSends } from './sends_render.mjs'
 import { applyLock, fetchLockState, lockedAnswerFor, lockStateWithin } from './locked_tools.mjs'
+import { applyRelease, fetchReleaseState, releaseStateWithin } from './release_gate.mjs'
 import { filterUnshownSettling } from './settling_shown.mjs'
 import { renderContactBriefing, renderContactCandidates, renderContactList } from './contacts_render.mjs'
+import { renderConversation, renderMessageInbox } from './messages_render.mjs'
 
 // PAGE tiers (ADR-0071). Six for a PAGE; a RECORD keeps three (`privacy` on log_session and
 // set_record_privacy below) — an owner-relative tier is applied to a page's records when they are read
@@ -394,6 +396,8 @@ export async function runServer(version) {
   // with registering ~120 tools, and awaited (bounded) just before the handshake, so the first tools/list a
   // Lite account's AI sees already marks the Regular-only tools 🔒. Regular accounts: nothing changes.
   const lockP = fetchLockState(BASE, TOKEN, fetchCortex)
+  // RELEASE COHORTS (lib/release_gate.mjs): tools behind a flag this caller's brains lack are removed before the handshake.
+  const releaseP = fetchReleaseState(BASE, TOKEN, fetchCortex)
   const toolHandles = new Map()
   let lockedTools = new Set()
   // ADR-0070: every tool runs with its NAME in async context, so an outage fetchCortex auto-files is
@@ -4208,6 +4212,95 @@ function renderNudge(payload) {
     },
   )
 
+  // 💬 INTERNAL MESSAGING (ADR-0088; Theron, 2026-10-19). Agnoclast's own chat between people AND agents who
+  // share a brain. For an agent, a message is its wake-up: `my_messages` is its inbox.
+  server.registerTool(
+    'send_message',
+    {
+      title: 'Send a message — to a person, an agent, or a #channel',
+      description: 'Send a chat message inside Agnoclast, like Slack. `to` is a person\'s or agent\'s name or email (a DM) or a #channel. You can only message people and agents who share a brain with you. Mention someone with @Name to notify them in a channel. Reply in a thread with `thread` (a message id from my_messages or read_conversation). If a name matches more than one person you get the list back: ask which, then send again with their email. Messages are not email: nothing leaves Agnoclast.',
+      inputSchema: {
+        to: z.string().describe('a name, an email, or a #channel'),
+        body: z.string().describe('the message (at most 8000 characters)'),
+        thread: z.string().optional().describe('reply in this thread: the id of its first message'),
+        brain: z.string().optional().describe('which brain, when a #channel name exists in more than one'),
+      },
+    },
+    async ({ to, body, thread, brain }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/messages/send`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ to, body, threadRootId: thread, brain }),
+        })
+      } catch (e) {
+        return toolError(`Could not send: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (res.status === 404 && !out?.error) return toolError('This Agnoclast server has no messaging yet (it predates ADR-0088).')
+      if (res.status === 409 && out?.error === 'ambiguous') {
+        const lines = (out.candidates ?? []).map((p) => `- ${p.name}${p.kind === 'agent' ? ` (agent${p.ownerName ? ` of ${p.ownerName}` : ''})` : ''}`)
+        return { content: [{ type: 'text', text: `More than one match for "${to}":\n${lines.join('\n')}\nAsk which one, then send again using their email.` }] }
+      }
+      if (!res.ok) return toolError(`Not sent: ${out?.detail ?? out?.error ?? res.status}`)
+      const told = out.notified ? ` ${out.notified} notified.` : ''
+      return { content: [{ type: 'text', text: `Sent to ${to}.${told} (message ${out.message.id}, conversation ${out.conversationId})` }] }
+    },
+  )
+
+  server.registerTool(
+    'my_messages',
+    {
+      title: 'Your messages — what you have been told about and not read',
+      description: 'Your Agnoclast message inbox, oldest first: DMs, @mentions of you, and replies in threads you are in. Call it when you wake up, before anything else. By default it marks what it returns as read, so the next call shows only newer messages; pass mark_read: false to just look. Answer with send_message (same `to` as the conversation, and `thread` to reply in a thread).',
+      inputSchema: {
+        limit: z.number().optional().describe('max messages (default 30, max 100)'),
+        mark_read: z.boolean().optional().describe('mark them read (default true)'),
+      },
+    },
+    async ({ limit, mark_read }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/messages/inbox?${new URLSearchParams({
+          ...(limit ? { limit: String(limit) } : {}), ...(mark_read === false ? {} : { markRead: '1' }),
+        })}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return toolError(`Could not read your messages: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (res.status === 404 && !out?.error) return toolError('This Agnoclast server has no messaging yet (it predates ADR-0088).')
+      if (!res.ok) return toolError(`Could not read your messages: ${out?.detail ?? out?.error ?? res.status}`)
+      return { content: [{ type: 'text', text: renderMessageInbox(out.items ?? []) }] }
+    },
+  )
+
+  server.registerTool(
+    'read_conversation',
+    {
+      title: 'Read a conversation or thread',
+      description: 'Read the recent messages of one conversation (its id comes from my_messages), oldest first, or one thread when you pass `thread`. Reading does not mark anything read; my_messages does.',
+      inputSchema: {
+        conversation: z.string().describe('the conversation id'),
+        thread: z.string().optional().describe('the id of a thread\'s first message, to read just that thread'),
+        limit: z.number().optional().describe('max messages (default 30, max 200)'),
+      },
+    },
+    async ({ conversation, thread, limit }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/messages/conversations/${encodeURIComponent(conversation)}?${new URLSearchParams({
+          ...(thread ? { thread } : {}), limit: String(limit ?? 30),
+        })}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return toolError(`Could not read that conversation: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not read that conversation: ${out?.detail ?? out?.error ?? res.status}`)
+      return { content: [{ type: 'text', text: renderConversation(out.messages ?? []) }] }
+    },
+  )
+
   server.registerTool(
     'contact',
     {
@@ -6958,6 +7051,7 @@ function renderNudge(payload) {
     },
   )
 
+  applyRelease(toolHandles, await releaseStateWithin(releaseP))
   lockedTools = applyLock(toolHandles, await lockStateWithin(lockP))
   await server.connect(new StdioServerTransport())
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theronap/agnoclast-mcp",
-  "version": "0.9.242",
+  "version": "0.9.243",
   "description": "Connect your AI assistant to Cortex — your org's projects, activity, gaps, and directives, scoped to you.",
   "type": "module",
   "bin": {