@theronap/agnoclast-mcp 0.9.209 → 0.9.211

package/lib/identifier_routes.mjs

@@ -0,0 +1,81 @@
+// WHERE AN IDENTIFIER ROUTES, AND WHAT A FILING SESSION MAY CLAIM — pure renderers (ADR-0075, 2026-10-05).
+//
+// 🔴 THE LINE THIS REPLACES TOLD A SESSION SOMETHING FALSE. `read_page "file:…"` printed "Home: X" for
+// the page whose BODY carried the [[stamp]], and for an unclaimed identifier said "author its page and
+// stamp [[id]] on it (that page becomes the home)". Since ADR-0026 a body stamp routes nothing — the
+// router reads page_routing_identifiers only — so following that advice produced a page the router never
+// sends anything to, and the session was told it worked. That is the 2026-10-04 V4 email-surface
+// incident. The server now answers `homes` from CLAIMS and moves stamp pages to `mentionedOn`; this
+// prints the two apart and gives `set_routing_identifier` as the fix.
+//
+// Pure so CI can execute what each state prints.
+
+const q = (s) => `"${s}"`
+const pageLabel = (h) => `${q(h.title)} (${h.kind}, ${h.tier})`
+
+/**
+ * The read_page identifier view, as lines. Handles the pre-ADR-0075 server too (no `mentionedOn`):
+ * there `homes` are stamp pages, so they are printed as mentions, never as where anything routes.
+ */
+export function renderIdentifierResolution(out, { expand = false } = {}) {
+  const id = out.identifier
+  const lines = [`# ${id} (identifier — a join key, not a page)`]
+  const claimAware = Array.isArray(out.mentionedOn)
+  const homes = claimAware ? (out.homes ?? []) : []
+  const mentions = claimAware ? out.mentionedOn : (out.homes ?? [])
+  const catchAll = claimAware ? (out.catchAll ?? []) : []
+  const hidden = claimAware ? Number(out.hiddenClaims ?? 0) : 0
+
+  if (!claimAware) {
+    lines.push('This server cannot say where it ROUTES (it predates ADR-0075); the pages below only mention it, and a mention routes nothing. `my_routing_claims` lists the claims that do.')
+  } else if (homes.length === 1 && out.status !== 'duplicate') {
+    const h = homes[0]
+    const how = h.via === id ? 'claims it' : `claims the folder \`${h.via}\` above it`
+    lines.push(`Routes to: ${pageLabel(h)} — it ${how}. \`read_page ${q(h.title)}\` for the page.`)
+  } else if (homes.length >= 1) {
+    lines.push(out.status === 'duplicate'
+      ? `⚠ More than one page claims this at the same depth — a record carrying it is filed under all of them (and STAGES if they sit in different brains). Settle which one it belongs to:`
+      : `Routes to ${homes.length} pages, deepest claim first — a record carrying it is filed under each:`)
+    for (const h of homes) lines.push(`  - ${pageLabel(h)} via \`${h.via}\`${h.brain ? ` · ${h.brain}` : ''}`)
+  }
+  if (hidden > 0) {
+    lines.push(`${hidden} claim${hidden === 1 ? '' : 's'} on page${hidden === 1 ? '' : 's'} you cannot open — ${hidden === 1 ? 'it routes' : 'they route'} all the same.`)
+  }
+  if (claimAware && homes.length === 0 && hidden === 0) {
+    const fallback = catchAll.length
+      ? ` Records carrying it are filed only under the repo catch-all: ${catchAll.map((h) => q(h.title)).join(', ')} (via \`${catchAll[0].via}\`).`
+      : ''
+    lines.push(
+      `No page claims this, so it routes nowhere on its own.${fallback} If a page is ABOUT it, claim it there: ` +
+      `\`set_routing_identifier\` with identifier ${q(id)}${id.startsWith('file:') && !id.endsWith('/') ? ' (or the deepest folder above it, with its trailing slash)' : ''}. ` +
+      'A [[stamp]] in a page body does NOT make that page its home.',
+    )
+  } else if (catchAll.length) {
+    lines.push(`Also filed under the repo catch-all: ${catchAll.map((h) => q(h.title)).join(', ')} (via \`${catchAll[0].via}\`).`)
+  }
+  if (mentions.length) {
+    lines.push(`Mentioned on (does not route): ${mentions.map((h) => q(h.title)).join(', ')}`)
+  }
+  const ev = out.events ?? { visibleCount: 0, recent: [] }
+  lines.push(`· ${ev.visibleCount} tagged timeline event${ev.visibleCount === 1 ? '' : 's'} visible to you${ev.recent?.length ? ':' : expand ? '.' : ' — pass expand: true to list recent ones.'}`)
+  for (const e of ev.recent ?? []) lines.push(`  - ${String(e.occurredAt).slice(0, 10)} · ${e.source} · ${e.summary}`)
+  return lines
+}
+
+/** intake_materialize: the folder-claim offers, as lines. [] when the server sent none (or is older). */
+export function renderFolderClaimOffers(offers) {
+  if (!Array.isArray(offers) || offers.length === 0) return []
+  const lines = ['Folder claim offered (nothing was claimed — decide, do not just accept):']
+  for (const o of offers) if (o && typeof o.offer === 'string') lines.push(`  - ${o.offer}`)
+  return lines.length > 1 ? lines : []
+}
+
+/** author / edit_page: [[file:…]] stamps the write left that route nothing to this page, as lines. */
+export function renderUnroutedPathStamps(body) {
+  const stamps = Array.isArray(body?.unroutedPathStamps) ? body.unroutedPathStamps : []
+  if (!stamps.length) return []
+  const lines = [`⚠ ${stamps.length} [[file:…]] stamp${stamps.length === 1 ? '' : 's'} on this page route${stamps.length === 1 ? 's' : ''} nothing here: ${stamps.map((s) => `\`${s.identifier}\``).join(', ')}.`]
+  if (typeof body.unroutedPathStampsNote === 'string') lines.push(body.unroutedPathStampsNote)
+  for (const s of stamps) if (typeof s.fix === 'string') lines.push(`  - ${s.fix}`)
+  return lines
+}

package/lib/imessage_send.mjs

@@ -1,88 +1,78 @@
-// send_imessage — outbound iMessage via Messages.app. This is a personal automation, NOT org
-// intelligence: it writes nothing to Agnoclast. Three layers of safety (eng-review D3/D6/D10):
-//   D6  argv-safe: recipient + body are passed as osascript `on run argv` arguments, NEVER
-//       interpolated into the script source → no AppleScript injection, no quote/newline breakage.
-//   D3  draft-by-default: nothing sends unless the caller explicitly passes send:true.
-//   D10 recipient gating: an MCP send tool is reachable by any agent context (prompt-injection
-//       surface), so a boolean alone is not enough. Allowlisted recipients send on send:true;
-//       OFF-list recipients additionally require an out-of-band confirm secret the agent context
-//       doesn't have (CORTEX_IMESSAGE_SEND_CONFIRM), else the send is BLOCKED.
-import { spawn } from 'child_process'
+// send_imessage — ask to send a text from the user's own Mac, the same way request_send_email asks to
+// send an email (ADR-0076).
+//
+// WHAT CHANGED, AND WHY. This tool used to text directly: osascript → Messages.app on whatever machine
+// the MCP ran on, gated by CORTEX_IMESSAGE_SEND_ALLOWLIST and an out-of-band confirm secret. No
+// approval screen, no history, no "did it go out?", and nothing written to Agnoclast — while email had
+// all of it. Theron, 2026-10-05: "my texts are not being handled in the same way that emails are
+// handled, and that seems like a failure."
+//
+// Now it creates a request on agnoclast.com (POST /api/texts/send-requests). The request waits on
+// /email → Waiting for the user's OK, unless their send rule — the SAME rule email uses, set only on
+// the web — lets it through. Once approved, the user's Mac (the Agnoclast desktop app) sends it through
+// Messages and reports back. So:
+//   * this process never runs osascript and never sends anything itself;
+//   * the env allowlist and the confirm secret are gone — the web send rule replaced both, and an agent
+//     cannot loosen it;
+//   * without send:true it is still a draft preview, exactly as before, so existing callers that rely on
+//     draft-by-default see no change in that path.
+//
+// ⚠ THE POST IS NOT IDEMPOTENT. Never retried: a 5xx may mean the request was created.
 
-// AppleScript reads its inputs from argv — the message text is DATA, never code.
-const SEND_SCRIPT = `on run argv
-  set targetId to item 1 of argv
-  set targetMessage to item 2 of argv
-  tell application "Messages"
-    set targetService to 1st account whose service type = iMessage
-    set targetBuddy to participant targetId of targetService
-    send targetMessage to targetBuddy
-  end tell
-end run`
-
-export function phoneKey(raw) {
-  const d = String(raw).replace(/[^0-9]/g, '')
-  return d.length < 7 ? null : d.slice(-10)
-}
-function handleKey(h) {
-  return h.includes('@') ? h.trim().toLowerCase() : phoneKey(h)
-}
-export function loadSendAllowlist(raw = process.env.CORTEX_IMESSAGE_SEND_ALLOWLIST ?? '') {
-  const set = new Set()
-  for (const item of raw.split(',').map((s) => s.trim()).filter(Boolean)) {
-    set.add(item.includes('@') ? item.toLowerCase() : (phoneKey(item) ?? item))
-  }
-  return set
+/** PURE. The draft preview — unchanged in spirit from the old tool. */
+export function draftText({ recipient, message }) {
+  return `📝 DRAFT (not sent) — to ${recipient}:\n${message}\n\n(Call send_imessage again with send:true to ask the user to approve it.)`
 }
 
-// Pure decision: what should happen, given inputs + config. Testable without Messages.app.
-//   → { action: 'draft' | 'send' | 'blocked', reason }
-export function decideSend({ recipient, message, send, confirm, allowlist, confirmSecret }) {
-  if (!recipient || !String(recipient).trim()) return { action: 'blocked', reason: 'no recipient' }
-  if (!message || !String(message).trim()) return { action: 'blocked', reason: 'empty message' }
-  if (!send) return { action: 'draft', reason: 'draft-by-default — re-call with send:true to actually send' }
-  const key = handleKey(String(recipient))
-  if (key && allowlist.has(key)) return { action: 'send', reason: 'allowlisted recipient' }
-  // off-list: require the out-of-band confirm secret
-  if (confirmSecret && confirm && confirm === confirmSecret) return { action: 'send', reason: 'off-list send authorized by confirm secret' }
-  return {
-    action: 'blocked',
-    reason: confirmSecret
-      ? 'recipient not allowlisted — pass the out-of-band confirm secret to send, or add them to CORTEX_IMESSAGE_SEND_ALLOWLIST'
-      : 'recipient not allowlisted — add them to CORTEX_IMESSAGE_SEND_ALLOWLIST (or set CORTEX_IMESSAGE_SEND_CONFIRM for an out-of-band override)',
-  }
-}
-
-export function sendViaOsascript(recipient, message) {
-  return new Promise((resolve) => {
-    let err = ''
-    let proc
-    try {
-      proc = spawn('osascript', ['-', String(recipient), String(message)], { stdio: ['pipe', 'ignore', 'pipe'] })
-    } catch (e) {
-      resolve({ ok: false, error: String(e) }); return
+/**
+ * PURE. The server's answer → what the agent is told. Mirrors request_send_email's contract exactly:
+ * `reviewUrl` PRESENT means pending, and the hand-off sentence is relayed verbatim; ABSENT means the
+ * user's send rule already approved it, and there is nothing to approve.
+ *
+ * Returns { text, isError }.
+ */
+export function textRequestReply(status, body, recipient) {
+  const msg = typeof body?.error === 'string' ? body.error : null
+  if (status === 201 || (status >= 200 && status < 300)) {
+    const reviewUrl = body?.reviewUrl
+    if (reviewUrl) {
+      return { isError: false, text:
+        `Text request created to ${recipient}. It is NOT sent yet. ` +
+        `Tell the user, in these words: It's waiting for your OK: ${reviewUrl}` }
     }
-    proc.stderr.on('data', (d) => { err += d })
-    proc.on('error', (e) => resolve({ ok: false, error: String(e) }))
-    proc.on('close', (code) => resolve({ ok: code === 0, error: err.trim() }))
-    proc.stdin.write(SEND_SCRIPT)
-    proc.stdin.end()
-  })
+    const state = body?.request?.state ?? 'approved'
+    return { isError: false, text:
+      `Approved by the user's send rule — nothing to approve (state: ${state}). Their Mac sends it through ` +
+      `Messages the next time it checks in, usually within a minute. Do not offer an approval link, and do ` +
+      `not send it again; the user can see how it went on Email → History in Agnoclast.` }
+  }
+  if (body?.code === 'no_text_sender') {
+    return { isError: true, text: `${msg} Nothing was stored, so nothing will be sent.` }
+  }
+  if (status >= 500) {
+    return { isError: true, text:
+      `${msg ?? `Agnoclast could not finish that (${status}).`} ⚠ The request MAY have been created anyway. ` +
+      `Do NOT call send_imessage again — ask the user to check Email in Agnoclast.` }
+  }
+  return { isError: true, text: msg ?? `send_imessage failed (${status}).` }
 }
 
-// Tool entry: decide, then act. Returns MCP content text.
-export async function runSendImessage({ recipient, message, send, confirm }) {
-  const decision = decideSend({
-    recipient, message, send, confirm,
-    allowlist: loadSendAllowlist(),
-    confirmSecret: process.env.CORTEX_IMESSAGE_SEND_CONFIRM ?? null,
-  })
-  if (decision.action === 'draft') {
-    return `📝 DRAFT (not sent) — to ${recipient}:\n${message}\n\n(${decision.reason})`
-  }
-  if (decision.action === 'blocked') {
-    return `🚫 Not sent: ${decision.reason}`
+/**
+ * Tool entry. `request` is the injected POST (fetchCortex with retries off, in server.mjs), so this
+ * stays testable without a network.
+ */
+export async function runSendImessage({ recipient, message, send }, request) {
+  if (!recipient || !String(recipient).trim()) return { isError: true, text: 'Name who to text: a phone number or an iMessage email address.' }
+  if (!message || !String(message).trim()) return { isError: true, text: 'The text is empty.' }
+  if (send !== true) return { isError: false, text: draftText({ recipient, message }) }
+  let res
+  try {
+    res = await request({ to: String(recipient).trim(), text: String(message) })
+  } catch (e) {
+    return { isError: true, text:
+      `Could not confirm the text request: ${e?.message ?? e} ⚠ It may have been created anyway. ` +
+      `Do NOT call send_imessage again — ask the user to check Email in Agnoclast.` }
   }
-  const r = await sendViaOsascript(recipient, message)
-  return r.ok ? `✅ Sent to ${recipient}.` : `❌ Send failed: ${r.error || 'Messages.app returned an error (is it signed in to iMessage? is Automation permission granted?)'}`
+  const body = await res.json().catch(() => null)
+  return textRequestReply(res.status, body, recipient)
 }

package/lib/server.mjs

@@ -9,6 +9,7 @@ import { seatChargeRefusal, seatChargeQuestion } from './seat_charge.mjs'
 import { fetchCortex, classify, resolveBase, resolveEnvToken, setSessionKey, setClientVersion, runWithTool, heartbeatPolicy } from './diagnose.mjs'
 import { REPORT_KINDS, REPORT_ISSUE_DESCRIPTION, fileIssue } from './report_issue.mjs'
 import { folderClaimLine } from './folder_claims.mjs'
+import { renderFolderClaimOffers, renderIdentifierResolution, renderUnroutedPathStamps } from './identifier_routes.mjs'
 import { resolveSessionKey, resolveLogSessionId } from './session_key.mjs'
 import { runSendImessage } from './imessage_send.mjs'
 import { formatGrepHits } from './grep_cli.mjs'
@@ -1343,6 +1344,9 @@ function renderNudge(payload) {
       //   null/undefined  no container was ever requested (say nothing)
       // containerSkipped is the only one that needs a warning: it means a container WAS asked for and
       // did not happen, which is exactly the silence this whole path exists to remove.
+      // ADR-0075 — the deepest unclaimed folder this unit sits in, offered for the feature page it was
+      // filed onto. Never claimed by the server; the session decides.
+      lines.push(...renderFolderClaimOffers(body?.folderClaimOffers))
       if (body?.containerSkipped) {
         lines.push(`⚠ CONTAINER NOT APPLIED — ${body.containerSkipped}. The record exists but is not inside the event you named; place it with contain_record or leave it out.`)
       } else if (body?.contained === true) {
@@ -1874,7 +1878,7 @@ function renderNudge(payload) {
       description:
         'READ the full authored wiki page for one node (project/person/org/you) by its canonical name — every section you can see. This is how you READ a node; `grep` only LOCATES pages (snippets + their [[links]]), it does not read them. Navigate like a researcher: read the page you need, then FOLLOW its inline [[links]] by calling read_page on each linked name — keep following while the linked pages stay relevant, stop when they do not. You decide how deep to go. Returns only what you are permitted to see.',
       inputSchema: {
-        name: z.string().describe('the canonical node name exactly as written (e.g. "Agnoclast", "Ben", or a [[link]] target) — identifier links ([[repo:owner/name]]) resolve to their authored HOME + a visible-event count'),
+        name: z.string().describe('the canonical node name exactly as written (e.g. "Agnoclast", "Ben", or a [[link]] target) — identifier links ([[repo:owner/name]], [[file:owner/name:path]]) resolve to the page(s) that CLAIM them — where the router actually files records — plus the pages that merely mention them, and a visible-event count'),
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind — a PREFERENCE, not a filter. The lookup matches every kind by title and only prefers this one when several share a name, so omitting it never hides a person/org/user page. Pass it to disambiguate a name that exists as more than one kind.'),
         expand: z.boolean().optional().describe('identifier names only: also list recent visible timeline events for this identifier (default: home + count)'),
         history: z.boolean().optional().describe('node names only: return the node\'s TIMELINE (events joined via its [[repo:…]] stamps, reverse-chron, viewer-visible) instead of the page body. The page is the present; this is the history.'),
@@ -1962,18 +1966,8 @@ function renderNudge(payload) {
           const r = await fetchCortex(`${BASE}/api/identifier/resolve?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
           if (r.ok) {
             const out = await r.json()
-            const lines = [`# ${out.identifier} (identifier — a join key, not a page)`]
-            if (out.status === 'unhomed') {
-              lines.push(`No authored home carries this stamp yet — data but no home. If you know what this identifies, author its page and stamp [[${out.identifier}]] on it (that page becomes the home).`)
-            } else if (out.status === 'healthy') {
-              const h = out.homes[0]
-              lines.push(`Home: "${h.title}" (${h.kind}, ${h.tier}) — \`read_page "${h.title}"\` for the full page.`)
-            } else {
-              lines.push(`⚠ ${out.homes.length} pages carry this stamp — possible duplicate homes, consider reconciling:`)
-              for (const h of out.homes) lines.push(`  - "${h.title}" (${h.kind}, ${h.tier})`)
-            }
-            lines.push(`· ${out.events.visibleCount} tagged timeline event${out.events.visibleCount === 1 ? '' : 's'} visible to you${out.events.recent.length ? ':' : expand ? '.' : ' — pass expand: true to list recent ones.'}`)
-            for (const e of out.events.recent) lines.push(`  - ${String(e.occurredAt).slice(0, 10)} · ${e.source} · ${e.summary}`)
+            // ADR-0075: `homes` are CLAIMS (where the router files it); stamp pages are `mentionedOn`.
+            const lines = renderIdentifierResolution(out, { expand })
             // KWA-28 — an identifier node is VIRTUAL: derived per read, zero stored rows, so there is no
             // as_of to fetch. The item says exactly what to do in that case: "where the object is derived
             // per-read, stamp the read itself." Note this as-of means something DIFFERENT from every
@@ -3988,7 +3982,10 @@ function renderNudge(payload) {
       const undatedNote = out?.undated === true
         ? `\n⚠ This section now carries no explicit calendar date. A reader can see WHEN the text was written but not when the claim was TRUE. If it asserts a status, add the date inline — you still hold the context. The edit already landed; this is advisory.`
         : ''
-      return { content: [{ type: 'text', text: `Edited "${name}" (${out.brain} · ${out.tier} tier) § ${out.heading}. Only that passage changed; every other section is byte-identical. New version: ${out.version}${red}${undatedNote}` }] }
+      // ADR-0075 — a [[file:…]] stamp this edit wrote that routes nothing here, with the claim that would.
+      const unroutedLines = renderUnroutedPathStamps(out)
+      const unrouted = unroutedLines.length ? `\n${unroutedLines.join('\n')}` : ''
+      return { content: [{ type: 'text', text: `Edited "${name}" (${out.brain} · ${out.tier} tier) § ${out.heading}. Only that passage changed; every other section is byte-identical. New version: ${out.version}${red}${undatedNote}${unrouted}` }] }
     },
   )
 
@@ -5872,23 +5869,32 @@ function renderNudge(payload) {
     },
   )
 
-  // send_imessage — local outbound texting (NOT org intelligence; writes nothing to Agnoclast). Runs on
-  // this machine via Messages.app. Draft-by-default + recipient allowlist + OOB confirm (D3/D6/D10).
+  // send_imessage — ask to send a text from the user's own Mac (ADR-0076). It no longer texts from this
+  // machine: it creates a request on Agnoclast that waits on /email → Waiting for the user's OK (or their
+  // web send rule approves it), and the user's Mac — the desktop app, through Messages — sends it and
+  // reports back. The same contract as request_send_email: reviewUrl PRESENT = pending, relayed verbatim.
+  //
+  // ⚠ NOT IDEMPOTENT: `idempotent: false, retries: 0`, exactly as request_send_email, so a widened
+  // fetchCortex default can never make sending a text retriable.
   server.registerTool(
     'send_imessage',
     {
-      title: 'Send an iMessage (draft-by-default)',
-      description: 'Compose/send an iMessage via the local Messages app. SAFE BY DEFAULT: without send:true it only returns a draft preview. Sending requires the recipient to be on CORTEX_IMESSAGE_SEND_ALLOWLIST (or an out-of-band confirm). Use this to text someone on the user\'s behalf — always show the draft and get the user\'s OK before sending.',
+      title: 'Ask to send a text (iMessage) from the user\'s Mac',
+      description: 'Text someone from the USER\'S OWN Mac, through Messages. Without send:true this only returns a draft preview. With send:true it creates a request that WAITS for the user to approve it in Agnoclast (Email → Waiting), unless their own send rule allows it; once approved, their Mac sends it within about a minute. The text is frozen when the request is made, so write the final wording, and show the user what you are about to send first. Returns an approval link to relay, or confirmation that their rule approved it. ⚠ NEVER call it twice with send:true for the same text — it is not idempotent.',
       inputSchema: {
-        recipient: z.string().describe('phone number (e.g. +18015551234) or iMessage email'),
-        message: z.string().describe('the message body to send'),
-        send: z.boolean().optional().describe('must be true to actually send; omit/false returns a draft preview only'),
-        confirm: z.string().optional().describe('out-of-band confirm secret, required to send to a recipient not on the allowlist'),
+        recipient: z.string().describe('one phone number (e.g. +18015551234, or (801) 555-1234 for a US number) or iMessage email address'),
+        message: z.string().describe('the text to send'),
+        send: z.boolean().optional().describe('true to ask the user to approve sending it; omit or false for a draft preview only'),
+        confirm: z.string().optional().describe('NO LONGER USED — approval happens in Agnoclast now. Ignored.'),
       },
     },
-    async ({ recipient, message, send, confirm }) => {
-      const text = await runSendImessage({ recipient, message, send, confirm })
-      return { content: [{ type: 'text', text }] }
+    async ({ recipient, message, send }) => {
+      const r = await runSendImessage({ recipient, message, send }, (body) => fetchCortex(`${BASE}/api/texts/send-requests`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      }, { idempotent: false, retries: 0 }))
+      return r.isError ? toolError(r.text) : { content: [{ type: 'text', text: r.text }] }
     },
   )
 
@@ -6067,8 +6073,11 @@ function renderNudge(payload) {
           ` can read the page. Re-send with identity_claim_ack: true only if the subject is publishing` +
           ` their own contact detail; otherwise use a confidential section or set_routing_identifier.`
         : ''
+      // ADR-0075 — [[file:…]] stamps that route nothing here, each with the claim that would. Advisory.
+      const unroutedLines = renderUnroutedPathStamps(out)
+      const unrouted = unroutedLines.length ? `\n${unroutedLines.join('\n')}` : ''
       const verb = out?.created ? 'Created + authored' : 'Authored'
-      const note = out?.built ? `${verb} "${name}" (${out.built} tier${out.built === 1 ? '' : 's'}). Links: ${blue} resolved, ${retired} retired, ${red} red.${corrections}${retiredList}${redList}${stamps}${undated}${identityRefused}`
+      const note = out?.built ? `${verb} "${name}" (${out.built} tier${out.built === 1 ? '' : 's'}). Links: ${blue} resolved, ${retired} retired, ${red} red.${corrections}${retiredList}${redList}${stamps}${undated}${identityRefused}${unrouted}`
         : `No change to "${name}"${out?.skipped?.length ? ` (${out.skipped.join(', ')})` : ''}.${corrections}`
       return { content: [{ type: 'text', text: note }] }
     },

package/package.json

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