@theronap/cortex-mcp 0.9.156 → 0.9.158

package/lib/server.mjs

@@ -193,7 +193,16 @@ export async function runServer(version) {
         // seat runs — session-ping carried liveness only. That is why every version gate in this
         // ADR was unobservable. Additive and forward-compatible: the route destructures sessionKey
         // and cwd and ignores the rest, so this is inert until a column exists to store it.
-        body: JSON.stringify({ sessionKey: SESSION_KEY, cwd: process.cwd(), mcpVersion: version }),
+        // repo (ADR-0066 §7): the repo this session is WORKING IN, so it holds more than what it
+        // has read. Same detector the context cache is keyed on, so no new failure mode — a
+        // non-GitHub or non-repo cwd yields null and the field is simply omitted. The server drops
+        // anything malformed; this is attention data, never routing.
+        body: JSON.stringify({
+          sessionKey: SESSION_KEY,
+          cwd: process.cwd(),
+          mcpVersion: version,
+          repo: repoFullNameFrom(process.cwd()) ?? undefined,
+        }),
       })
     } catch { /* best-effort heartbeat — never disrupt the session */ }
   }
@@ -2741,6 +2750,100 @@ function renderNudge(payload) {
     },
   )
 
+  server.registerTool(
+    'my_source_routes',
+    {
+      title: 'Where a source lands — the routes you declared, and what is waiting for one',
+      description: 'Show the DECLARED landings: (account, source type, key) -> brain, with who decided each one. ⚠ THIS IS A DIFFERENT TABLE FROM my_routing_claims AND ANSWERS A DIFFERENT QUESTION. A claim says which PAGE a record attaches to (and the brain falls out of that); a route says which BRAIN a source\'s raw lands in when nothing else decides. Both can be right and disagree, which is exactly when mail piles up. ⚠ A route settles a claim TIE only when `decided_by` is `explicit` — a person decided it; a `triage` route was an agent unblocking a queue and does not overrule live ambiguity (ADR-0066 §5d). ⚠ APPEND-ONLY BY DESIGN: a route is never updated, because re-pointing a live source splits its stream irreparably — records are unique on the org-scoped (org_id, dedupe_key), so the two halves never reconcile. Creating one is a decision you do not get to take back cheaply. Also lists what is STAGED per source — those are exactly the routes worth creating.',
+      inputSchema: {},
+    },
+    async () => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/source-routes`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return toolError(`Could not read source routes: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not read source routes: ${out?.error ?? res.status}`)
+
+      const routes = Array.isArray(out?.routes) ? out.routes : []
+      const pending = Array.isArray(out?.pendingStaged) ? out.pendingStaged : []
+      const lines = []
+
+      if (routes.length === 0) {
+        lines.push('No declared routes. Every source resolves by claims alone, and a claim tie has nothing to fall back on.')
+      } else {
+        lines.push(`${routes.length} declared route(s):`)
+        for (const r of routes) {
+          // `account`/`sourceKey` are empty when the route means "any" at that position — say so
+          // rather than printing a blank, because a blank reads as missing data.
+          const acct = r.account || '(any account)'
+          const key = r.sourceKey || '(any key)'
+          const mark = r.decidedBy === 'explicit' ? '✓' : '·'
+          lines.push(`  ${mark} ${r.sourceType} · ${acct} · ${key}  →  ${r.brain}   [${r.decidedBy}${r.decidedNote ? `: ${r.decidedNote}` : ''}]`)
+        }
+        lines.push('  ✓ = decided by a person, and therefore able to settle a claim tie. · = decided by triage, which cannot.')
+      }
+
+      if (pending.length) {
+        lines.push('')
+        lines.push('Waiting on a routing decision:')
+        for (const p of pending) {
+          lines.push(`  ${p.sourceType} · ${p.account || '(any account)'} — ${p.count} staged, oldest ${String(p.oldest).slice(0, 10)}`)
+        }
+      }
+      return { content: [{ type: 'text', text: lines.join('\n') }] }
+    },
+  )
+
+  server.registerTool(
+    'my_routing_claims',
+    {
+      title: 'What you have claimed — and therefore where your mail goes',
+      description: 'Show the routing claims you can see: which pages claim which identifiers, in which brains, and WHAT THE ROUTER WILL DO with a message carrying each one. ⚠ THE COUNT IS THE WHOLE POINT: a message routes only when EXACTLY ONE brain claims something on it — zero or several both STAGE, which is why mail piles up in the staged queue while every individual claim looks correct. Pass `identifier` to ask about one exact key ("who claims notifications@github.com?"); a zero answer is a verdict, not an empty result. ⚠ NOTHING ELSE SHOWS THIS. read_page on an identifier greps page BODIES for the literal stamp, and a body mention does not drive routing (ADR-0026) — so the surface that looks like the answer reads a different table from the one the router reads. ⚠ CHECK BEFORE YOU CLAIM: adding a claim to a second brain turns "routes" into "stages", and replacing a stale one turns a silent misroute into a different silent misroute (ADR-0066 §5b). `email:`/`thread:` claims are private to whoever made them and attach only that person\'s own units — so for YOUR records, your own claims are exactly the set the router consults, not a redacted view of a larger truth.',
+      inputSchema: {
+        identifier: z.string().optional().describe('one canonical identifier to ask about, e.g. email:support@npmjs.com or repo:owner/name. Omit to list everything you can see, ambiguous identifiers first.'),
+        limit: z.number().optional().describe('max claim rows (default 200, capped at 500)'),
+      },
+    },
+    async ({ identifier, limit }) => {
+      const qs = new URLSearchParams()
+      if (identifier) qs.set('identifier', identifier)
+      if (limit) qs.set('limit', String(limit))
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/routing-claims${qs.toString() ? `?${qs}` : ''}`, {
+          headers: { Authorization: `Bearer ${TOKEN}` },
+        })
+      } catch (e) {
+        return toolError(`Could not read routing claims: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not read routing claims: ${out?.error ?? res.status}${out?.hint ? `\n${out.hint}` : ''}`)
+
+      const groups = Array.isArray(out?.identifiers) ? out.identifiers : []
+      if (groups.length === 0) {
+        return { content: [{ type: 'text', text: 'No routing claims you can see. Nothing you own decides a brain for any identifier, so inbound mail resolves by nothing and stages.' }] }
+      }
+      const lines = []
+      for (const g of groups) {
+        const mark = g.brains > 1 ? '⚠ ' : g.brains === 0 ? '· ' : '✓ '
+        lines.push(`${mark}${g.identifier}  —  ${g.brains} brain(s) → ${g.verdict}`)
+        for (const c of g.claims ?? []) {
+          // A page the caller cannot open still claims the identifier and still decides routing, so it
+          // is listed; only its title is withheld. Dropping the row would under-report the count.
+          const page = c.page ?? '(a page you cannot open)'
+          lines.push(`    ${c.brain} · ${page}${c.mine ? '' : ' · claimed by someone else'} · ${c.source} · ${String(c.createdAt).slice(0, 10)}`)
+        }
+      }
+      lines.push('')
+      lines.push('— Exactly one brain routes. Zero or several STAGE, and a real message carries several identifiers, so one clean sender can still stage on another key it carries.')
+      lines.push('— Before adding a claim: a second brain on the same identifier converts routing into staging. Claim the NARROWEST key the message carries (a repo or package), not the account it came from.')
+      return { content: [{ type: 'text', text: lines.join('\n') }] }
+    },
+  )
+
   server.registerTool(
     'set_summary',
     {
@@ -4004,6 +4107,54 @@ function renderNudge(payload) {
     },
   )
 
+  // THE CUSTODIAL HALF OF OWNERSHIP. `transferPageOwnership` and its route have existed since
+  // 2026-08-24 and had NEVER run in production (0 of 4,280 page revisions as of 2026-09-18) for the
+  // simple reason that no agent could reach them — the endpoint was HTTP-only, and ownership is a
+  // thing people ask their agent about ("put Dana in charge of this"), not a thing they open a
+  // console for. Added 2026-09-18 on Theron's ask, as the first piece of the member-removal design
+  // on [[Member removal and org shape]]: rehoming a departing person's pages is impossible without it.
+  server.registerTool(
+    'transfer_page_ownership',
+    {
+      title: 'Hand a page over to someone else',
+      description: 'Make another org member the owner of a wiki page — "put Dana in charge of the Northwind page". Ownership decides who may re-tier it, who may set its edit policy, and (for scoped/confidential pages) who can read it, so this is a real handover, not a label. Allowed for the page\'s owner, or for a manager-ancestor who can already read it; pass yourself as `to` to TAKE ownership, which is the documented path for a manager who then needs to change policy. Recorded in page history with you as the actor. The page keeps its tier — transferring does not re-tier, so a scoped page handed to someone outside the new owner\'s chain can become unreadable to its previous audience; re-tier separately if that matters.',
+      inputSchema: {
+        kind: z.enum(['project', 'person', 'org', 'user']).describe('the page kind'),
+        name: z.string().optional().describe('the exact page name (or pass `ref` instead — one of the two is required)'),
+        ref: z.string().optional().describe('the page\'s stable id, printed as `ref:` by read_page. PREFER THIS over name when you have it: a ref is unique across brains, so it addresses exactly one page and never needs a brain to disambiguate it.'),
+        to: z.string().describe('who becomes the owner — an org member\'s email, or their user id. Must be an ACTIVE member of the same brain as the page. Pass your own address to take ownership yourself.'),
+      },
+    },
+    async ({ kind, name, ref, to }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/node-policy`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          // No `tier`: a node has exactly one page (ADR-0064 §4), and the route resolves it. Sending a
+          // guessed tier is how this used to 404 on precisely the scoped/confidential pages it matters for.
+          body: JSON.stringify({ kind, ...(name ? { name } : {}), ...(ref ? { ref } : {}), transfer_to: to }),
+        })
+      } catch (e) {
+        return toolError(`Could not transfer ownership: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        // The route's refusals name their own remedy (not permitted / not an active member / no page
+        // yet) — surface them verbatim rather than flattening them to a status code.
+        if (out?.error) return toolError(`Could not transfer ownership: ${out.error}`)
+        const d = classify(res.status, res.headers.get('content-type'), '', res.headers.get('x-vercel-id'))
+        return toolError(`Could not transfer ownership: ${d.message}`)
+      }
+      return {
+        content: [{
+          type: 'text',
+          text: `Done — ${name ?? out.ref} now belongs to ${to}. The page is still ${out.tier}; transferring never re-tiers, so check that its audience is still right.`,
+        }],
+      }
+    },
+  )
+
   server.registerTool(
     'my_retier_notices',
     {

package/package.json

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