@theronap/cortex-mcp 0.9.82 → 0.9.84

package/lib/server.mjs

@@ -40,7 +40,7 @@ async function redLinkTriage(BASE, TOKEN, name) {
 // file-request tools, and a module-level `fail` would be silently shadowed by it from that point on.
 const toolError = (text) => ({ content: [{ type: 'text', text }], isError: true })
 
-// The Cortex MCP server (stdio). Serves the signed-in employee's scoped org
+// The Agnoclast MCP server (stdio). Serves the signed-in employee's scoped org
 // context to their AI assistant. CORTEX_TOKEN identifies the user + org.
 
 export async function runServer(version) {
@@ -48,7 +48,7 @@ export async function runServer(version) {
   const BASE = resolveBase(process.env.CORTEX_URL)
 
   if (!TOKEN) {
-    process.stderr.write('cortex-mcp: CORTEX_TOKEN is required. Get yours from the Cortex console → Connect your AI.\n')
+    process.stderr.write('cortex-mcp: CORTEX_TOKEN is required. Get yours from the Agnoclast console → Connect your AI.\n')
     process.exit(1)
   }
 
@@ -90,7 +90,7 @@ export async function runServer(version) {
     const now = Date.now()
     if (cache && now - cache.ts < 5 * 60 * 1000) return cache.text
     // fetchCortex retries transient infra/5xx; classify turns a failure into an honest message
-    // (token vs infra-block vs network) instead of a bare "Cortex API 403: unknown".
+    // (token vs infra-block vs network) instead of a bare "Agnoclast API 403: unknown".
     const res = await fetchCortex(`${BASE}/api/mcp-context`, { headers: { Authorization: `Bearer ${TOKEN}` } })
     if (!res.ok) {
       const body = await res.text()
@@ -117,7 +117,7 @@ export async function runServer(version) {
   server.registerTool(
     'my_context',
     {
-      title: 'My Cortex context',
+      title: 'My Agnoclast context',
       description: 'Your current work context from the org. Pass a question to get query-centered session context seeded from the most relevant node and its neighborhood; omit it for the baseline snapshot.',
       inputSchema: { question: z.string().optional().describe('optional opening user question to center the context around') },
     },
@@ -137,6 +137,53 @@ export async function runServer(version) {
     },
   )
 
+  // Where this machine's unattended session captures land. The server half shipped 2026-08-09 with no
+  // client surface at all, so the only way to set it was a hand-written authenticated HTTP call —
+  // which meant three real users whose sessions were silently being held could not fix it themselves.
+  // This is the surface that makes it answerable in conversation: "put my sessions in TTO".
+  server.registerTool(
+    'set_capture_brain',
+    {
+      title: 'Choose where your session captures are saved',
+      description:
+        'Set which brain THIS PERSON\'s unattended session captures (the automatic end-of-session record) land in, or read the current setting by omitting `brain`. WHEN TO USE: whenever the user says their sessions are not being saved, asks where their work is going, or a session-start notice says captures are being HELD. WHY IT IS NEEDED: with more than one brain, a capture that names no brain cannot be routed and is held outside every brain — correct, but invisible, so it accumulates silently. This is per-PERSON and applies to their own captures only; it cannot be set for someone else. ⚠ PASS THE ORG ID when the user has two brains with the SAME NAME (e.g. two called "Personal") — a name matching more than one is REFUSED rather than guessed, and the error lists the ids to choose from. Setting this does NOT file already-held captures; those keep their original dates and may belong in different brains, so sort them deliberately rather than dumping them into the new default.',
+      inputSchema: {
+        brain: z.string().optional().describe('the brain name or org id (from my_brains) where this person\'s session captures should land. Omit to read the current setting instead of changing it.'),
+      },
+    },
+    async ({ brain }) => {
+      const url = `${BASE}/api/brain/capture-default`
+      if (!brain?.trim()) {
+        const res = await fetchCortex(url, { headers: { Authorization: `Bearer ${TOKEN}` } })
+        if (!res.ok) {
+          const body = await res.text()
+          throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
+        }
+        const { defaults } = await res.json()
+        if (!defaults?.length) {
+          return { content: [{ type: 'text', text: 'No capture brain is set. If you belong to more than one brain, your session captures are being HELD outside every brain until you set one. Call this tool again with `brain` to fix it.' }] }
+        }
+        const lines = defaults.map((d) => `${d.sourceType} captures land in "${d.orgName}" (${d.orgId}), set ${String(d.updatedAt).slice(0, 10)}`)
+        return { content: [{ type: 'text', text: lines.join('\n') }] }
+      }
+      const res = await fetchCortex(url, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sourceType: 'claude-code', brain: brain.trim() }),
+      })
+      const body = await res.text()
+      if (!res.ok) {
+        // Prefer the server's own error: a 409 lists the org ids of an ambiguous name, which IS the
+        // remedy, and a generic classification would throw that away.
+        let msg
+        try { msg = JSON.parse(body).error } catch { /* fall through to the classified message */ }
+        throw new Error(msg ?? classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
+      }
+      const j = JSON.parse(body)
+      return { content: [{ type: 'text', text: `✓ Your Claude Code sessions now land in "${j.brain}" (${j.orgId}). Sessions captured before now are still held and keep their original dates — file those deliberately, they may not all belong in this brain.` }] }
+    },
+  )
+
   // T8: cortex-log's authoritative writer. The skill composes a curated summary, then calls this to
   // persist it AS the durable record (capture_source='skill'). The ingest conflict guard ensures the
   // auto-capture hook never clobbers it. Pass the SAME sessionId the hook uses so the two dedupe onto
@@ -144,8 +191,8 @@ export async function runServer(version) {
   server.registerTool(
     'log_session',
     {
-      title: 'Log this session to Cortex',
-      description: 'Persist a CURATED summary of this work session as its durable Cortex record (authoritative — supersedes the auto-capture hook). Call at session close after composing the summary. Pass sessionId (the Claude Code session id) if you have it so this dedupes with the auto-capture of the same session.',
+      title: 'Log this session to Agnoclast',
+      description: 'Persist a CURATED summary of this work session as its durable Agnoclast record (authoritative — supersedes the auto-capture hook). Call at session close after composing the summary. Pass sessionId (the Claude Code session id) if you have it so this dedupes with the auto-capture of the same session.',
       inputSchema: {
         summary: z.string().describe('the curated session summary (what was done, decided, left open) — becomes the durable record'),
         project: z.string().optional().describe('project key/name this session worked in'),
@@ -172,7 +219,7 @@ export async function runServer(version) {
         throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
       }
       const j = await res.json().catch(() => ({}))
-      return { content: [{ type: 'text', text: `Logged to Cortex (authoritative): "${j.title ?? title ?? 'session'}" — ${j.inserted ? 'new record' : 'updated existing'}.` }] }
+      return { content: [{ type: 'text', text: `Logged to Agnoclast (authoritative): "${j.title ?? title ?? 'session'}" — ${j.inserted ? 'new record' : 'updated existing'}.` }] }
     },
   )
 
@@ -286,31 +333,6 @@ export async function runServer(version) {
     },
   )
 
-  server.registerTool(
-    'maintenance_candidates',
-    {
-      title: 'Review recent project-linked maintenance evidence',
-      description: 'Start here when preparing a handoff, status, or next step for a NAMED project. Returns a bounded, RLS-scoped set of recent raw records already linked to that project, before you trust the authored page. These are candidate evidence, not a command to edit: read them, call project_status, then decide whether a material contradiction warrants a minimal accountable correction. When correcting, retain the decisive factual qualifier (for example completion date or state) in the current-status text. Never mutate merely to clear a candidate.',
-      inputSchema: {
-        project: z.string().describe('the project key or exact project name from the task, e.g. "checkout-v2" or "Checkout v2"'),
-        since_days: z.number().optional().describe('how far back to inspect (1-90 days, default 30)'),
-        limit: z.number().optional().describe('max candidate records (1-50, default 20)'),
-      },
-    },
-    async ({ project, since_days, limit }) => {
-      const qs = new URLSearchParams({ project })
-      if (since_days != null) qs.set('since_days', String(since_days))
-      if (limit != null) qs.set('limit', String(limit))
-      const res = await fetchCortex(`${BASE}/api/maintenance/candidates?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
-      if (!res.ok) {
-        const body = await res.text()
-        throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
-      }
-      const { text } = await res.json()
-      return { content: [{ type: 'text', text }] }
-    },
-  )
-
   server.registerTool(
     'search_org',
     {
@@ -379,7 +401,7 @@ export async function runServer(version) {
     {
       title: 'Query the local code structure graph (graphify)',
       description:
-        'Query a structural code graph for the repo at the CURRENT working directory, built locally by graphify (tree-sitter AST — deterministic, no LLM, no server round-trip; this is LOCAL MACHINE data, not org-shared Cortex content, and reflects a snapshot of one commit, not live files). Use for MULTI-HOP questions a single grep cannot answer: what calls/imports/depends on X, how A structurally reaches B, or a repo-wide overview (hub/community files). Do NOT use for single-hop lookups (does file X import Y) — grep is faster and always current. Structure only — it knows what imports/calls what, never WHY; read the actual files or authored Cortex pages for intent.',
+        'Query a structural code graph for the repo at the CURRENT working directory, built locally by graphify (tree-sitter AST — deterministic, no LLM, no server round-trip; this is LOCAL MACHINE data, not org-shared Agnoclast content, and reflects a snapshot of one commit, not live files). Use for MULTI-HOP questions a single grep cannot answer: what calls/imports/depends on X, how A structurally reaches B, or a repo-wide overview (hub/community files). Do NOT use for single-hop lookups (does file X import Y) — grep is faster and always current. Structure only — it knows what imports/calls what, never WHY; read the actual files or authored Agnoclast pages for intent.',
       inputSchema: {
         action: z.enum(['query', 'path', 'explain']).describe('"query" = open-ended natural-language question (graph traversal); "path" = shortest structural path between two named nodes; "explain" = describe one node and list its direct connections'),
         question: z.string().optional().describe('required for action:"query" — the natural-language question'),
@@ -444,7 +466,7 @@ export async function runServer(version) {
       description:
         'READ the full authored wiki page for one node (project/person/org/you) by its canonical name — every section, every tier 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. "Cortex", "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]]) resolve to their authored HOME + a visible-event count'),
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project; pass person/org for people/teams)'),
         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.'),
@@ -618,7 +640,7 @@ export async function runServer(version) {
       title: 'See a wiki page\'s edit history',
       description: 'Show the VERSION history of an authored wiki page — every prior version, who changed it and when, newest first. This is how you see "what changed on this page and by whom", and it includes privacy changes (re-tiers). Then use `read_page` with a version to view an old body, or `rollback_page` to restore one. (Distinct from read_page\'s `history: true`, which is the raw event timeline via [[repo:…]] stamps.) RLS-scoped: you see history only for pages you may read.',
       inputSchema: {
-        name: z.string().describe('the canonical node name exactly as written (e.g. "Cortex", "Ben")'),
+        name: z.string().describe('the canonical node name exactly as written (e.g. "Agnoclast", "Ben")'),
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project)'),
         limit: z.number().int().optional().describe('how many recent versions to show (default 20, max 200)'),
       },
@@ -744,7 +766,14 @@ export async function runServer(version) {
       }
       const out = await res.json().catch(() => null)
       if (!res.ok) return toolError(`Could not roll back "${name}": ${out?.error ?? res.status}`)
-      return { content: [{ type: 'text', text: `Done — "${name}" ${out.note}. \`read_page "${name}"\` to confirm the current content.` }] }
+      // #477: when the target revision had no summary, the page's CURRENT summary was kept rather than
+      // erased. Say it on its own line instead of at the tail of `note` — this is the 2026-08-04 W3
+      // shape, where empty summaries copied over populated ones destroyed 31 of them under a report
+      // that read as success. A rescue the operator does not see is still a silent write.
+      const keptLine = out.summaryKept === 'current'
+        ? `\n\n⚠ That revision had NO summary, so the page's current summary was KEPT rather than erased — check it still describes the restored body, and use set_summary if not.`
+        : ''
+      return { content: [{ type: 'text', text: `Done — "${name}" ${out.note}. \`read_page "${name}"\` to confirm the current content.${keptLine}` }] }
     },
   )
 
@@ -910,13 +939,15 @@ export async function runServer(version) {
     'writing_style',
     {
       title: 'How the user writes (for drafting in their voice)',
-      description: 'Returns the user\'s saved writing-style profile so you can DRAFT in their voice (email, message, doc). Call this right before composing anything on their behalf. Self-only — it is always the calling user\'s own profile. If none is saved, it tells you to derive one and save it with set_writing_style.',
-      inputSchema: {},
+      description: 'Returns the user\'s saved writing-style profile so you can DRAFT in their voice (email, message, doc). Call this right before composing anything on their behalf. Self-only — it is always the calling user\'s own profile. If none is saved, it tells you to derive one and save it with set_writing_style. A profile is stored per (user, BRAIN) — it is injected into authoring IN a brain — so if you hold several, name the one you are drafting in.',
+      inputSchema: {
+        brain: z.string().optional().describe('which brain\'s style profile, by name or org id. Unnecessary when you only have one brain; pass the org id when a name matches more than one of yours'),
+      },
     },
-    async () => {
+    async ({ brain } = {}) => {
       let res
       try {
-        res = await fetchCortex(`${BASE}/api/style`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+        res = await fetchCortex(`${BASE}/api/style${brain ? `?brain=${encodeURIComponent(brain)}` : ''}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
       } catch (e) {
         return toolError(`Could not load writing style: ${e.message}`)
       }
@@ -934,12 +965,15 @@ export async function runServer(version) {
     {
       title: 'Save the user\'s writing-style profile',
       description: 'Save (or update) a description of HOW the user writes — tone, sentence rhythm, structure, formatting habits, signature quirks — derived from prose you have seen them write this session. Store the STYLE, never their private content. Self-only: it always updates the calling user\'s own profile. Pass an empty string to clear it.',
-      inputSchema: { style_md: z.string().describe('a concise markdown description of the user\'s writing voice (tone/structure/quirks), ~1-2 paragraphs') },
+      inputSchema: {
+        style_md: z.string().describe('a concise markdown description of the user\'s writing voice (tone/structure/quirks), ~1-2 paragraphs'),
+        brain: z.string().optional().describe('which brain to save the profile in, by name or org id. A profile is stored per (user, brain), so this is a real choice when you hold several; pass the org id when a name matches more than one of yours'),
+      },
     },
-    async ({ style_md }) => {
+    async ({ style_md, brain }) => {
       let res
       try {
-        res = await fetchCortex(`${BASE}/api/style`, {
+        res = await fetchCortex(`${BASE}/api/style${brain ? `?brain=${encodeURIComponent(brain)}` : ''}`, {
           method: 'PUT',
           headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
           body: JSON.stringify({ style_md }),
@@ -1177,7 +1211,7 @@ export async function runServer(version) {
     'list_brain_pages',
     {
       title: 'List every authored page in one brain',
-      description: 'Enumerate ALL authored pages in ONE brain, by its org id (from my_brains). Unlike my_brains — which ships only a count plus a few sample titles — this returns the FULL page list: one row per node with its kind, validity, tier(s), last-updated date and content hash. Use it to audit a brain, or to VERIFY a brain-to-brain migration — list BOTH brains, diff the page sets, and compare freshness before retiring any original. You can only list a brain you are a member of; reads never widen past your own brains.',
+      description: 'Enumerate ALL authored pages in ONE brain, by its org id (from my_brains). Unlike my_brains — which ships only a count plus a few sample titles — this returns the FULL page list: one row per node with its kind, validity, tier(s), last-updated date and content hash. Use it to audit a brain, or to VERIFY a brain-to-brain migration — list BOTH brains, diff the page sets, and compare freshness before retiring any original. You can only list a brain you are a member of, and within it you see only the pages you are cleared to read — a confidential page owned by someone else is not listed, not even by title.',
       inputSchema: {
         org_id: z.string().describe('the org id of the brain to enumerate (from my_brains)'),
       },
@@ -1213,7 +1247,7 @@ export async function runServer(version) {
     {
       title: 'Create a new brain under your existing account',
       description: 'Create a brand-new brain (org/workspace) — a fully independent knowledge graph — under your EXISTING account. No new login, no new email/password: this adds a second membership to the account you are already using. Reads never cross brains; new pages default to your active brain, so use pass `brain` when an operation needs one named',
-      inputSchema: { name: z.string().describe('display name for the new brain, e.g. "Cortex Codebase"') },
+      inputSchema: { name: z.string().describe('display name for the new brain, e.g. "Design Team"') },
     },
     async ({ name }) => {
       let res
@@ -1304,7 +1338,7 @@ export async function runServer(version) {
     'my_sessions',
     {
       title: 'My active AI sessions',
-      description: "See what all of YOUR OWN active Cortex/AI sessions are doing right now (working directory + how recently each was active), so you can coordinate across windows/devices. Self-only — only your own sessions, never anyone else's.",
+      description: "See what all of YOUR OWN active Agnoclast/AI sessions are doing right now (working directory + how recently each was active), so you can coordinate across windows/devices. Self-only — only your own sessions, never anyone else's.",
       inputSchema: {},
     },
     async () => {
@@ -1494,6 +1528,60 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'replace_variant',
+    {
+      title: 'Move one tier variant\'s body into another, collapsing the node to one page',
+      description: 'DESTRUCTIVE, and the only sanctioned way to fix a FORKED page. When one node exists at two tiers with different bodies, this moves the SOURCE variant\'s body into the TARGET variant\'s slot and DELETES the source, leaving the node with a single page. The source\'s body WINS — this is not `absorb`, where the target survives; in a fork repair the target is usually the damaged page, so mirroring absorb would keep the damage and delete the good copy. Sections are copied as ROWS, never re-derived from text: re-deriving a body from context is exactly what destroyed 258 sections on 2026-07-18 while sincerely reporting "copied verbatim". BEFORE CALLING: read_page the TARGET and pass its version as target_version — it proves you know which body is about to be overwritten, and a stale or guessed value is rejected rather than silently accepted. If the target tier has NO page, do not use this: the slot is free, so set_page_privacy moves the page there cheaply. Both prior bodies are retained in page history and the operation is reversible via page_history/rollback_page. Owner or editor on BOTH variants; an OWNERLESS target may be overwritten only by an org admin.',
+      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.'),
+        source_tier: z.enum(['accessible', 'scoped', 'confidential']).describe('the variant whose BODY WINS and survives. This variant\'s row is then deleted.'),
+        target_tier: z.enum(['accessible', 'scoped', 'confidential']).describe('the OCCUPIED slot the body lands in. This variant\'s current body is DESTROYED (snapshotted to page history first). The surviving page sits at this tier.'),
+        target_version: z.string().describe('REQUIRED — the TARGET page\'s version, from read_page. Proves you know what is being overwritten. Do not retry a rejection blindly; re-read the target and confirm you are replacing what you think you are.'),
+        brain: z.string().optional().describe('only when the same page name exists in more than one of your brains'),
+      },
+    },
+    async ({ kind, name, ref, source_tier, target_tier, target_version, brain }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/replace-variant`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            kind, ...(name ? { name } : {}), ...(ref ? { ref } : {}),
+            source_tier, target_tier, target_version, ...(brain ? { brain } : {}),
+          }),
+        })
+      } catch (e) {
+        return toolError(`Could not replace variant: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        // The engine's rejections carry the remedy in their text (free slot → use set_page_privacy;
+        // hash mismatch → re-read, do not retry blindly). Surface it verbatim rather than paraphrasing.
+        if (out?.error) return toolError(`Could not replace variant: ${out.error}`)
+        const d = classify(res.status, res.headers.get('content-type'), '', res.headers.get('x-vercel-id'))
+        return toolError(`Could not replace variant: ${d.message}`)
+      }
+      if (!out) return { content: [{ type: 'text', text: 'Replace reported success, but the server returned no body — re-read the page before assuming it landed.' }] }
+      // The summary rides along with the body, EXCEPT when the source has none — then the target's is
+      // kept rather than erased. Say so on its own line rather than at the tail of `note`: this is the
+      // 2026-08-04 W3 shape, where an empty summary copied over a populated one destroyed 31 of them
+      // under a report that read as success. A rescue the operator does not see is still a silent write.
+      const rescued = out.summaryRescued
+        ? `\n\n⚠ The ${out.moved.from} variant had NO summary. The ${out.moved.to} page's own summary was KEPT rather than overwritten with an empty one — check it still describes the body that just landed, and set_summary if not.`
+        : ''
+      return {
+        content: [{
+          type: 'text',
+          text: `Done — "${out.moved.title}": the ${out.moved.from} body now occupies the ${out.moved.to} page (${out.sections} section${out.sections === 1 ? '' : 's'}), and the ${out.moved.from} variant was removed. The node now has ONE variant. Both prior bodies are retained in page history.${rescued}`,
+        }],
+      }
+    },
+  )
+
   server.registerTool(
     'grant_page_access',
     {
@@ -1607,6 +1695,78 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'request_person_page_merge',
+    {
+      title: 'Offer one duplicate person page for merge',
+      description: 'Offer YOUR accessible person page to be merged into another current accessible person page in the SAME named brain. Use only when the two pages are unquestionably the same real person. Read both pages first and pass their refs and versions. This never crosses brains and does not use fuzzy matching.',
+      inputSchema: {
+        brain: z.string().describe('the exact brain name or brain id; pass an id if names collide'),
+        source_ref: z.string().describe('ref of YOUR duplicate source person page'),
+        target_ref: z.string().describe('ref of the canonical person page to retain'),
+        source_version: z.string().describe('current version from reading the source page'),
+        target_version: z.string().describe('current version from reading the canonical page'),
+        reason: z.string().describe('why these pages are certainly the same person'),
+      },
+    },
+    async (input) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-node-merge`, {
+          method: 'POST', headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ action: 'request', ...input }),
+        })
+      } catch (e) { return toolError(`Could not request page merge: ${e.message}`) }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not request page merge: ${out?.error ?? res.status}`)
+      return { content: [{ type: 'text', text: `Merge request ${out.request_id} created. The canonical-page owner must review and apply it.` }] }
+    },
+  )
+
+  server.registerTool(
+    'person_page_merge_requests',
+    {
+      title: 'Review duplicate-person page merge requests',
+      description: 'List pending same-brain person-page merges where you own the canonical page. Read both pages before applying. Applying copies every source summary and section verbatim into the canonical page, preserves its links and as-of dates, and supersedes rather than deletes the source page.',
+      inputSchema: {},
+    },
+    async () => {
+      let res
+      try { res = await fetchCortex(`${BASE}/api/brain/page-node-merge`, { headers: { Authorization: `Bearer ${TOKEN}` } }) }
+      catch (e) { return toolError(`Could not list person-page merge requests: ${e.message}`) }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not list person-page merge requests: ${out?.error ?? res.status}`)
+      if (!out?.requests?.length) return { content: [{ type: 'text', text: 'No pending duplicate-person page merge requests.' }] }
+      const lines = out.requests.map((q) => `- [${q.id}] ${q.source_owner_name ?? 'someone'}: "${q.source_title}" → "${q.target_title}" in ${q.brain}. Reason: ${q.reason}`)
+      return { content: [{ type: 'text', text: `Pending person-page merges (${out.requests.length}):\n${lines.join('\n')}` }] }
+    },
+  )
+
+  server.registerTool(
+    'apply_person_page_merge',
+    {
+      title: 'Apply a reviewed duplicate-person page merge',
+      description: 'Apply a pending same-brain person-page merge you own. Re-read the canonical page immediately before applying and pass its version. This is preservation-first: all source summary/sections are retained verbatim in the canonical page, the source page is superseded (not deleted), and its old link target redirects to the canonical page.',
+      inputSchema: {
+        request_id: z.string().describe('id from person_page_merge_requests'),
+        target_version: z.string().describe('current canonical-page version from a fresh read'),
+        reason: z.string().describe('why the merge is approved'),
+      },
+    },
+    async (input) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-node-merge`, {
+          method: 'POST', headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ action: 'apply', ...input }),
+        })
+      } catch (e) { return toolError(`Could not apply page merge: ${e.message}`) }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not apply page merge: ${out?.error ?? res.status}`)
+      return { content: [{ type: 'text', text: `Merged "${out.sourceTitle}" into "${out.targetTitle}". Preserved ${out.preservedSections} source block(s); source page is superseded, not deleted.` }] }
+    },
+  )
+
   server.registerTool(
     'decide_page_merge',
     {
@@ -1688,7 +1848,7 @@ export async function runServer(version) {
     'decide_file_request',
     {
       title: 'Approve or deny a file request',
-      description: 'As the OWNER of a record, approve or deny someone\'s request for its full original. On approve, your Cortex desktop app fetches + shares the file. Get request_id from file_requests.',
+      description: 'As the OWNER of a record, approve or deny someone\'s request for its full original. On approve, your Agnoclast desktop app fetches + shares the file. Get request_id from file_requests.',
       inputSchema: { request_id: z.string(), decision: z.enum(['approve', 'deny']) },
     },
     async ({ request_id, decision }) => {
@@ -1730,7 +1890,7 @@ export async function runServer(version) {
     },
   )
 
-  // send_imessage — local outbound texting (NOT org intelligence; writes nothing to Cortex). Runs on
+  // 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).
   server.registerTool(
     'send_imessage',
@@ -1754,7 +1914,7 @@ export async function runServer(version) {
   // Two tools the working session uses to AUTHOR its understanding into the org wiki while it's hot:
   //   authoring_context → the companion call (§3): fetch the visible NAMESPACE + the node-type connection
   //     rules BEFORE writing, so the page links canonically (the L2 lever).
-  //   author           → the write (§9 step 3/4): hand Cortex a finished page (summary + sections WITH
+  //   author           → the write (§9 step 3/4): hand Agnoclast a finished page (summary + sections WITH
   //     inline [[links]]); the server runs the resolution pass + tier-safe 2B write.
 
   server.registerTool(
@@ -1762,7 +1922,7 @@ export async function runServer(version) {
     {
       title: 'Authoring context (call before author)',
       description:
-        'Fetch the scaffolding to author a Cortex wiki node: the canonical NAMESPACE (current node names — link to these with the EXACT name inside [[ ]]), any deliberately RETIRED page names and their successors, and the node-type CONNECTION RULES. ALWAYS call this BEFORE `author` so the page links to current knowledge rather than minting synonyms or reviving a retired page. Reference a node in the namespace as [[Name]]; if you reference something real that is NOT in the namespace, still write [[Name]] — that is a red-link marking a node worth creating. If the page IS about a specific code repo or chat channel, also stamp it once — [[repo:owner/name]] or [[channel:name]] (lowercase, no #) — identifier join keys, not page links.',
+        'Fetch the scaffolding to author a Agnoclast wiki node: the canonical NAMESPACE (current node names — link to these with the EXACT name inside [[ ]]), any deliberately RETIRED page names and their successors, and the node-type CONNECTION RULES. ALWAYS call this BEFORE `author` so the page links to current knowledge rather than minting synonyms or reviving a retired page. Reference a node in the namespace as [[Name]]; if you reference something real that is NOT in the namespace, still write [[Name]] — that is a red-link marking a node worth creating. If the page IS about a specific code repo or chat channel, also stamp it once — [[repo:owner/name]] or [[channel:name]] (lowercase, no #) — identifier join keys, not page links.',
       inputSchema: {
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('the node type you are about to author (default project)'),
         brain: z.string().optional().describe('which brain\'s namespace to describe — pass the SAME brain you will pass to `author`, so the namespace you plan against is the one your write lands in. Unnecessary when you only have one brain.'),
@@ -1805,7 +1965,7 @@ export async function runServer(version) {
         'Write your CURRENT understanding of a project/person/org/you into the org wiki as a maintained page. Call `authoring_context` FIRST. Author from your own synthesis of the session — the compiled mental model, not a transcript dump: what it IS, where it stands, dated decisions, open threads, key people. Weave inline [[links]] to other nodes (canonical names from the namespace; red-links for wanted-but-absent nodes). The server re-authorizes the tier and resolves links. CREATES the node if it does not exist yet (project/person/org) — the conversation IS the evidence, so a brand-new entity that surfaced only in this session is authorable on the spot; you do NOT need prior records. Because such a node has nothing external to corroborate it, author it DELIBERATELY: only when you genuinely understand it is a real, distinct entity, and use its exact canonical name so it does not duplicate one already in the namespace (`user` nodes are never created). Use this continuously whenever your understanding of a node meaningfully advanced, and at session end (/log). Authoring is PRE-AUTHORIZED — never ask the user "should I update the page?" before calling this (every edit is versioned + reversible via page_history/rollback_page); update, then briefly report what you updated. ⚠ WHICH BRAIN A NEW PAGE GOES IN IS A CONTENT DECISION, SO MAKE IT FROM THE CONTENT. Only a page that exists in NO brain needs this — an update resolves its brain from the page itself. If you hold more than one brain, the server REFUSES a create it cannot attribute (409 `create_needs_brain`) rather than letting the write pointer decide — the pointer is stale out-of-band state that knows nothing about what you are writing. So call `my_brains` (it returns each brain\'s name, page count and sample titles, which is enough to tell what each one is FOR) and pass `brain` up front; that turns a refused round trip into a single call. State which brain you picked and why in one short line, then proceed — do NOT ask when the answer is obvious from the content. DO ask when it is genuinely ambiguous: brains are a confidentiality boundary, so a page born in the wrong one can expose private work to a teammate, and that is not a filing error you can quietly fix later.',
       inputSchema: {
         kind: z.enum(['project', 'person', 'org', 'user']).describe('the node type'),
-        name: z.string().describe('the canonical node name — an EXACT existing name from the namespace to update it, or a new name to create the node (project/person/org). e.g. "Cortex" or "Theron Peterson"'),
+        name: z.string().describe('the canonical node name — an EXACT existing name from the namespace to update it, or a new name to create the node (project/person/org). e.g. "Agnoclast" or "Theron Peterson"'),
         summary: z.string().describe('one-sentence summary of what this is and its current state (may contain [[links]])'),
         sections: z.array(z.object({
           heading: z.string().describe('e.g. Overview, Current state, Decisions, Open threads, People'),

package/lib/setup.mjs

@@ -44,7 +44,7 @@ export async function runSetup(argv, version) {
   if (!token || token.startsWith('-')) {
     process.stderr.write(
       'Usage: npx @theronap/cortex-mcp setup <CORTEX_TOKEN>\n\n' +
-      'Get your token from the Cortex console → Connect your AI.\n'
+      'Get your token from the Agnoclast console → Connect your AI.\n'
     )
     process.exit(1)
   }
@@ -63,7 +63,7 @@ export async function runSetup(argv, version) {
 
   const log = (m) => process.stdout.write(m + '\n')
   log('')
-  log('Cortex setup — wiring your AI assistant…')
+  log('Agnoclast setup — wiring your AI assistant…')
 
   // ── 1. MCP server in ~/.claude.json ──────────────────────────────────────
   try {
@@ -83,7 +83,7 @@ export async function runSetup(argv, version) {
   }
 
   // ── 1b. MCP server in Codex (~/.codex/config.toml), only if Codex is installed ──
-  // Codex gets the same Cortex context tools as Claude Code. Non-fatal: a Codex hiccup must
+  // Codex gets the same Agnoclast context tools as Claude Code. Non-fatal: a Codex hiccup must
   // never block the primary Claude wiring.
   const codexDir = join(home, '.codex')
   if (existsSync(codexDir)) {
@@ -128,8 +128,9 @@ export async function runSetup(argv, version) {
       process.exit(1)
     }
     const bak = backup(settingsJson)
-    // Capture (Stop) + status/skills/snapshot (SessionStart) + precompact (PreCompact), idempotent
-    // merge — the same pure function the `cortex install` Claude adapter uses.
+    // Capture (Stop) + status/skills/snapshot (SessionStart) + hydrate (UserPromptSubmit), idempotent
+    // merge — the same pure function the `cortex install` Claude adapter uses. Also unwires the retired
+    // PreCompact reminder from seats that still carry it.
     s = mergeClaudeSettings(s, spec)
 
     ensureDir(settingsJson)
@@ -157,7 +158,7 @@ export async function runSetup(argv, version) {
   // ── 4. Self-verify — writing config proves "files written", NOT "connection works".
   // Actually call the API so a bad/expired token is caught HERE, not 40 minutes into debugging.
   log('')
-  log('Verifying your token against Cortex…')
+  log('Verifying your token against Agnoclast…')
   const health = await checkToken(token, base)
   if (health.ok) {
     const n = health.projectCount
@@ -169,8 +170,8 @@ export async function runSetup(argv, version) {
   }
 
   log('')
-  log('⟳ IMPORTANT: fully quit and reopen Claude Code to load the Cortex server.')
-  log('   Then your AI sees your Cortex context and your sessions flow into the org.')
+  log('⟳ IMPORTANT: fully quit and reopen Claude Code to load the Agnoclast server.')
+  log('   Then your AI sees your Agnoclast context and your sessions flow into the org.')
   log('   Re-check anytime:  npx -y @theronap/cortex-mcp doctor')
   log(`   Console: ${base}`)
   log('')
@@ -191,11 +192,11 @@ export async function runRepair(version) {
   const token = readWiredToken()
   if (!token) {
     process.stderr.write(
-      'No existing Cortex token found in ~/.claude.json or ~/.codex/config.toml.\n' +
+      'No existing Agnoclast token found in ~/.claude.json or ~/.codex/config.toml.\n' +
       'Run setup once with your token:  npx -y @theronap/cortex-mcp setup <YOUR_TOKEN>\n',
     )
     process.exit(1)
   }
-  process.stdout.write('Cortex repair — re-running setup with your existing token at this version…\n')
+  process.stdout.write('Agnoclast repair — re-running setup with your existing token at this version…\n')
   await runSetup([token], version)
 }