@theronap/agnoclast-mcp 0.9.241 → 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
@@ -2366,7 +2370,8 @@ function renderNudge(payload) {
       const lines = revs.map((r) => {
         // "Theron via Frack" — the label only ever reaches the token's owner (bdb2339b phase 2).
         const via = r.via_token_label ? ` via ${r.via_token_label}` : ''
-        const who = r.actor_name ? ` · ${r.actor_name}${via}` : (via ? ` ·${via}` : '')
+        const agentOf = r.actor_agent_of ? ` (agent of ${r.actor_agent_of})` : ''
+        const who = r.actor_name ? ` · ${r.actor_name}${agentOf}${via}` : (via ? ` ·${via}` : '')
         // change_kind first and bracketed so a column of [correct] is scannable — the whole point is
         // that a page with repeated corrections looks different at a glance from one that only grew.
         const what = r.change_kind ? ` · [${r.change_kind}]` : ''
@@ -2421,7 +2426,7 @@ function renderNudge(payload) {
         ? `# ${name} — rev ${d.to.revNo} (first version)`
         : `# ${name} — rev ${d.from.revNo} → rev ${d.to.revNo}`
       const meta = []
-      meta.push(`${String(d.to.createdAt).slice(0, 10)} · ${d.to.op}${d.to.changeKind ? ` · [${d.to.changeKind}]` : ''}${d.to.actorName ? ` · ${d.to.actorName}${d.to.viaTokenLabel ? ` via ${d.to.viaTokenLabel}` : ''}` : ''}`)
+      meta.push(`${String(d.to.createdAt).slice(0, 10)} · ${d.to.op}${d.to.changeKind ? ` · [${d.to.changeKind}]` : ''}${d.to.actorName ? ` · ${d.to.actorName}${d.to.actorAgentOf ? ` (agent of ${d.to.actorAgentOf})` : ''}${d.to.viaTokenLabel ? ` via ${d.to.viaTokenLabel}` : ''}` : ''}`)
       if (d.to.reason) meta.push(`reason: ${d.to.reason}`)
       if (d.to.sessionKey) meta.push(`session: ${String(d.to.sessionKey).slice(0, 24)}`)
       const body = []
@@ -4207,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',
     {
@@ -4918,6 +5012,50 @@ function renderNudge(payload) {
     },
   )
 
+  // share_calendar — share YOUR OWN calendar with one person (ADR-0086; Theron, 2026-10-17). Same shape as
+  // share_record: NOT auto-allowed (a disclosure to someone, so it prompts), and only when the person asks.
+  // Nothing is emailed by this tool; it returns the link for the person to send.
+  server.registerTool(
+    'share_calendar',
+    {
+      title: 'Share your calendar with someone',
+      description:
+        'Share the person\'s OWN calendar with one other person by email address. They get their own read-only link ' +
+        '(agnoclast.com/c/…); if they use Agnoclast it also appears on their calendar until revoked. scope "busy" ' +
+        '(default) shows only busy blocks; "titles" also shows event titles (never notes, places or attendees). This does ' +
+        'NOT send anything: give the person the link to send, or they can send it from the Share calendar panel. Only ' +
+        'when the person asks to share their calendar; never on your own initiative. Turn it off on agnoclast.com/calendar.',
+      inputSchema: {
+        email: z.string().describe('the email address of the person to share with'),
+        scope: z.enum(['busy', 'titles']).optional().describe('busy = busy blocks only (default); titles = event titles too'),
+      },
+    },
+    async ({ email, scope }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/calendar/shares`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ action: 'share_with', email, scope: scope ?? 'busy' }),
+        })
+      } catch (e) {
+        return toolError(`Could not share the calendar: ${e.message}`)
+      }
+      if (res.status === 400 || res.status === 409) {
+        const b = await res.json().catch(() => null)
+        return toolError(`Not shared: ${b?.error ?? 'refused'}`)
+      }
+      if (!res.ok) {
+        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
+        return toolError(`Could not share the calendar: ${d.message}`)
+      }
+      const out = await res.json()
+      return { content: [{ type: 'text', text:
+        `Shared your calendar (${out.share.scope === 'titles' ? 'with event titles' : 'busy times only'}) with ${out.share.recipientEmail}:\n${out.url}\n` +
+        `Nothing was sent — give them this link. It is shown only once. If they use Agnoclast it is already on their calendar. share id: ${out.share.id}` }] }
+    },
+  )
+
   // set_record_notes — write the NOTES layer of one of your own transcripts (Theron, 2026-10-08: "two
   // layers … a summary and notes from the transcript … the full transcript"). The server keeps the
   // before-state in record history and refuses anything that is not your own kept transcript.
@@ -6913,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.241",
+  "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": {