@theronap/cortex-mcp 0.9.77 → 0.9.79

package/lib/hydrate.mjs

@@ -7,7 +7,7 @@ import { formatReceipt, renderUncounted, subjectOf } from './presence.mjs'
 import { writePresence } from './statusline.mjs'
 
 // UserPromptSubmit hook (① discovery): on the FIRST substantive turn of a session, hydrate the model
-// with query-centered Agnoclast context BEFORE it answers — then never again this session. It closes the
+// with query-centered Cortex context BEFORE it answers — then never again this session. It closes the
 // gap that read-triggered authoring can't: an agent that never READS the wiki (works from code + memory)
 // never triggers a currency update, and re-derives already-authored truth. cortex-context is a SKILL the
 // model may forget to invoke; this makes the first hydration non-discretionary (the same move that made

package/lib/imessage_send.mjs

@@ -1,5 +1,5 @@
 // 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):
+// intelligence: it writes nothing to Cortex. 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.

package/lib/ingest_folder.mjs

@@ -3,7 +3,7 @@ import { join, relative, basename, extname } from 'node:path'
 import { fetchCortex, classify, resolveBase } from './diagnose.mjs'
 
 // `cortex-mcp ingest-folder <path>` — walk a local markdown folder and upsert each file as an
-// AUTHORED record in Agnoclast (source='brain'), so a user's personal digest is built from THEIR
+// AUTHORED record in Cortex (source='brain'), so a user's personal digest is built from THEIR
 // notes (Robin parity). Only an EXCERPT of each file leaves the machine (frontmatter + first
 // ~800 chars), never the full body. The server clamps privacy for source='brain' and treats
 // sessionId (the file's relative path) as the stable dedupe key, so re-running updates in place.
@@ -100,7 +100,7 @@ export async function runIngestFolder(argv) {
   if (!path) {
     process.stderr.write(
       'usage: cortex-mcp ingest-folder <path>\n' +
-      '  Ingest a local markdown folder as your authored Agnoclast records.\n',
+      '  Ingest a local markdown folder as your authored Cortex records.\n',
     )
     return
   }

package/lib/install.mjs

@@ -1,4 +1,4 @@
-// `cortex install` — the cross-editor hub installer (P0-b). One command that wires the Agnoclast MCP
+// `cortex install` — the cross-editor hub installer (P0-b). One command that wires the Cortex MCP
 // server + client shim into EVERY detected editor via the adapter registry, then writes a capability
 // manifest so later pillars (session sync, skill sync, doc sync) know which channels each editor
 // supports. `setup <token>` stays as the single-editor path the console prints; `install` is the
@@ -78,7 +78,7 @@ export async function runInstall(argv, version) {
     process.stderr.write(
       'Usage: npx @theronap/cortex-mcp install [<CORTEX_TOKEN>] [--editor auto|all|<id,...>]\n\n' +
       'No token was given and none is already wired.\n' +
-      'Get your token from the Agnoclast console → Connect your AI.\n',
+      'Get your token from the Cortex console → Connect your AI.\n',
     )
     process.exit(1)
   }
@@ -92,7 +92,7 @@ export async function runInstall(argv, version) {
   }
 
   log('')
-  log('Agnoclast install — wiring your AI editors…')
+  log('Cortex install — wiring your AI editors…')
   if (editor === 'auto' && targets.length === 0) {
     log('  (no supported editors detected — pass --editor all to force, or install an editor first)')
   }
@@ -135,7 +135,7 @@ export async function runInstall(argv, version) {
   // Verify the token against the live API — writing config proves "files written", not "it works".
   const base = resolveBase(process.env.CORTEX_URL)
   log('')
-  log('Verifying your token against Agnoclast…')
+  log('Verifying your token against Cortex…')
   try {
     const health = await checkToken(token, base)
     if (health.ok) {
@@ -147,13 +147,13 @@ export async function runInstall(argv, version) {
       log('     The files are in place; fix the above, then re-check with `doctor`.')
     }
   } catch (e) {
-    log(`  ⚠ Could not reach Agnoclast to verify (${e.message}). Config is written; re-check with 'doctor'.`)
+    log(`  ⚠ Could not reach Cortex to verify (${e.message}). Config is written; re-check with 'doctor'.`)
   }
 
   const wired = entries.filter((e) => targetIds.has(e.adapter.id) && e.wired).map((e) => e.adapter.displayName)
   log('')
   log(`⟳ Wired ${wired.length} editor(s): ${wired.join(', ') || '(none)'}`)
-  log('   Fully quit and reopen each editor to load the Agnoclast server.')
+  log('   Fully quit and reopen each editor to load the Cortex server.')
   log(`   Console: ${base}`)
   log('')
 }

package/lib/precompact.mjs

@@ -8,7 +8,7 @@
 // Output goes to stdout, which the Claude Code harness surfaces as additional context for the next turn.
 export function runPrecompactReminder() {
   process.stdout.write(
-    'Agnoclast: context is about to compact. If your understanding of any node (the project(s) you worked ' +
+    'Cortex: context is about to compact. If your understanding of any node (the project(s) you worked ' +
     'on, people you coordinated with, or yourself) advanced this session, AUTHOR it into the wiki NOW ' +
     'before it is lost: call `authoring_context` then `author` for each. This is a synthesis of your ' +
     'compiled understanding with inline [[links]], not a transcript dump. Skip nodes you did not advance.\n',

package/lib/redact.mjs

@@ -21,7 +21,7 @@ const PATTERNS = [
   [/xox[baprs]-[A-Za-z0-9-]{10,}/g, '[REDACTED:slack]'],
   [/eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, '[REDACTED:jwt]'],
   [/(Bearer\s+)[A-Za-z0-9._-]{20,}/g, '$1[REDACTED]'],
-  // Agnoclast's own login token wherever it appears in KEY=value / KEY: value form (hooks.json,
+  // Cortex's own login token wherever it appears in KEY=value / KEY: value form (hooks.json,
   // config.toml, shell commands — the 2026-07-02 finding: a grep of hooks.json put the live token
   // in a transcript and nothing below caught it). Specific pattern first for the accurate label.
   [/(CORTEX_TOKEN["']?\s*[=:]\s*["']?)[0-9a-fA-F][0-9a-fA-F-]{30,}/g, '$1[REDACTED:cortex-token]'],

package/lib/resolve.mjs

@@ -8,97 +8,47 @@ import { edgeSafeEnv } from './edge_extract.mjs'
 // and pushes decisions back (POST /api/resolve-apply): confident-same → entity_merges, else → rejected
 // so the pair never re-flags. Conservative by construction. Always exits cleanly.
 
-// Which brains to sweep. BOTH endpoints require the brain to be NAMED (ADR-0022 requireBrain —
-// answering a scoped read out of an ARBITRARY brain is the defect that whole class exists to
-// prevent). Until 2026-08-09 this command named none, so a multi-brain caller got 409 on step 1 and
-// the dedup sweep did nothing at all, silently, forever.
-//
-// Naming ONE brain would have been the smaller fix and the wrong one: `resolve` is a MAINTENANCE
-// SWEEP over the user's entities, so doing one brain and reporting success is ADR-0022's other
-// failure — "silently truncating a result set and presenting it as complete". With no --brain we
-// enumerate the caller's brains and sweep EACH, naming it explicitly. Not a guess: every request
-// still names exactly one brain, and all of them actually get done.
-//
-// A sole-brain caller sees today's behaviour: one pass, no flag, no prompt.
-export async function brainsToSweep(base, token, wanted, deps = {}) {
-  const fetchFn = deps.fetchCortex ?? fetchCortex
-  if (wanted) return [{ orgId: wanted, name: wanted }] // explicit: pass through (name or org id)
-  const res = await fetchFn(`${base}/api/brains`, { headers: { Authorization: `Bearer ${token}` } })
-  if (!res.ok) {
-    const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-    throw new Error(`could not list your brains — ${d.message}`)
-  }
-  const j = await res.json().catch(() => ({}))
-  const brains = Array.isArray(j.brains) ? j.brains : []
-  // Carry the ORG ID, never the name: brain names are NOT unique (this account holds two called
-  // "Personal"), and a duplicate name comes back as unknown_brain.
-  return brains.filter((b) => b?.orgId).map((b) => ({ orgId: b.orgId, name: b.name ?? b.orgId }))
-}
-
-export async function runResolve(argv = []) {
+export async function runResolve() {
   // recursion guard (we spawn `claude --print`; if its Stop hook fires capture, that no-ops on this flag)
   if (process.env.CORTEX_SUMMARIZING) { process.stderr.write('cortex: summarizer subprocess, skipping\n'); return }
   const token = process.env.CORTEX_TOKEN
   if (!token) { process.stderr.write('cortex: CORTEX_TOKEN not set, skipping\n'); return }
   const base = resolveBase(process.env.CORTEX_URL)
 
-  const bIdx = argv.indexOf('--brain')
-  const wanted = bIdx === -1 ? null : argv[bIdx + 1]
-  if (bIdx !== -1 && (!wanted || wanted.startsWith('-'))) {
-    process.stderr.write('Usage: resolve [--brain <name-or-org-id>]\n'); return
-  }
-
-  let targets
-  try {
-    targets = await brainsToSweep(base, token, wanted)
-  } catch (e) { process.stderr.write(`cortex: resolve — ${e.message}\n`); return }
-  if (!targets.length) { process.stderr.write('cortex: no brains to sweep\n'); return }
-
-  for (const t of targets) {
-    // Label each line with the brain when sweeping several: an unlabelled "merged 3" cannot be acted
-    // on, because you cannot tell WHERE three entities just merged.
-    await resolveOneBrain(base, token, t, targets.length > 1)
-  }
-}
-
-async function resolveOneBrain(base, token, brain, labelled) {
-  const tag = labelled ? `[${brain.name}] ` : ''
-  const qs = `?brain=${encodeURIComponent(brain.orgId)}`
-
   // 1. pull the flagged candidate pairs
   let candidates = []
   try {
-    const res = await fetchCortex(`${base}/api/resolve-candidates${qs}`, { headers: { Authorization: `Bearer ${token}` } })
+    const res = await fetchCortex(`${base}/api/resolve-candidates`, { headers: { Authorization: `Bearer ${token}` } })
     if (!res.ok) {
       const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-      process.stderr.write(`cortex: ${tag}resolve-candidates failed — ${d.message}\n`); return
+      process.stderr.write(`cortex: resolve-candidates failed — ${d.message}\n`); return
     }
     const j = await res.json().catch(() => ({}))
     candidates = Array.isArray(j.candidates) ? j.candidates : []
-  } catch (e) { process.stderr.write(`cortex: ${tag}resolve fetch failed — ${e.message}\n`); return }
+  } catch (e) { process.stderr.write(`cortex: resolve fetch failed — ${e.message}\n`); return }
 
-  if (!candidates.length) { process.stderr.write(`cortex: ${tag}no duplicate candidates to judge\n`); return }
-  process.stderr.write(`cortex: ${tag}judging ${candidates.length} candidate pair(s) locally…\n`)
+  if (!candidates.length) { process.stderr.write('cortex: no duplicate candidates to judge\n'); return }
+  process.stderr.write(`cortex: judging ${candidates.length} candidate pair(s) locally…\n`)
 
   // 2. judge locally on the subscription
   const decisions = judgeCandidates(candidates)
-  if (decisions === null) { process.stderr.write(`cortex: ${tag}judge unavailable (is \`claude\` on PATH?) — skipping\n`); return }
+  if (decisions === null) { process.stderr.write('cortex: judge unavailable (is `claude` on PATH?) — skipping\n'); return }
 
-  // 3. apply — SAME brain the candidates came from, or the merges land in the wrong graph
+  // 3. apply judged decisions
   try {
-    const res = await fetchCortex(`${base}/api/resolve-apply${qs}`, {
+    const res = await fetchCortex(`${base}/api/resolve-apply`, {
       method: 'POST',
       headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
       body: JSON.stringify({ decisions }),
     })
     if (res.ok) {
       const j = await res.json().catch(() => ({}))
-      process.stderr.write(`cortex: ${tag}dedup — merged ${j.merged ?? 0}, rejected ${j.rejected ?? 0}, skipped ${j.skipped ?? 0}\n`)
+      process.stderr.write(`cortex: dedup — merged ${j.merged ?? 0}, rejected ${j.rejected ?? 0}, skipped ${j.skipped ?? 0}\n`)
     } else {
       const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-      process.stderr.write(`cortex: ${tag}resolve-apply failed — ${d.message}\n`)
+      process.stderr.write(`cortex: resolve-apply failed — ${d.message}\n`)
     }
-  } catch (e) { process.stderr.write(`cortex: ${tag}resolve-apply failed — ${e.message}\n`) }
+  } catch (e) { process.stderr.write(`cortex: resolve-apply failed — ${e.message}\n`) }
 }
 
 // ONE `claude --print` call judges every pair. Returns DedupDecision[] for the apply endpoint, or null

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 Agnoclast MCP server (stdio). Serves the signed-in employee's scoped org
+// The Cortex 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 Agnoclast console → Connect your AI.\n')
+    process.stderr.write('cortex-mcp: CORTEX_TOKEN is required. Get yours from the Cortex 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 "Agnoclast API 403: unknown".
+    // (token vs infra-block vs network) instead of a bare "Cortex 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 Agnoclast context',
+      title: 'My Cortex 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') },
     },
@@ -144,8 +144,8 @@ export async function runServer(version) {
   server.registerTool(
     'log_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.',
+      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.',
       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 +172,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 Agnoclast (authoritative): "${j.title ?? title ?? 'session'}" — ${j.inserted ? 'new record' : 'updated existing'}.` }] }
+      return { content: [{ type: 'text', text: `Logged to Cortex (authoritative): "${j.title ?? title ?? 'session'}" — ${j.inserted ? 'new record' : 'updated existing'}.` }] }
     },
   )
 
@@ -286,6 +286,31 @@ 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. Never mutate merely to clear a candidate.',
+      inputSchema: {
+        project: z.string().describe('the project key from the task, e.g. "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',
     {
@@ -354,7 +379,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 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.',
+        '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.',
       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'),
@@ -419,7 +444,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. "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. "Cortex", "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.'),
@@ -593,7 +618,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. "Agnoclast", "Ben")'),
+        name: z.string().describe('the canonical node name exactly as written (e.g. "Cortex", "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)'),
       },
@@ -719,14 +744,7 @@ 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}`)
-      // #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}` }] }
+      return { content: [{ type: 'text', text: `Done — "${name}" ${out.note}. \`read_page "${name}"\` to confirm the current content.` }] }
     },
   )
 
@@ -892,15 +910,13 @@ 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. 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'),
-      },
+      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: {},
     },
-    async ({ brain } = {}) => {
+    async () => {
       let res
       try {
-        res = await fetchCortex(`${BASE}/api/style${brain ? `?brain=${encodeURIComponent(brain)}` : ''}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+        res = await fetchCortex(`${BASE}/api/style`, { headers: { Authorization: `Bearer ${TOKEN}` } })
       } catch (e) {
         return toolError(`Could not load writing style: ${e.message}`)
       }
@@ -918,15 +934,12 @@ 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'),
-        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'),
-      },
+      inputSchema: { style_md: z.string().describe('a concise markdown description of the user\'s writing voice (tone/structure/quirks), ~1-2 paragraphs') },
     },
-    async ({ style_md, brain }) => {
+    async ({ style_md }) => {
       let res
       try {
-        res = await fetchCortex(`${BASE}/api/style${brain ? `?brain=${encodeURIComponent(brain)}` : ''}`, {
+        res = await fetchCortex(`${BASE}/api/style`, {
           method: 'PUT',
           headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
           body: JSON.stringify({ style_md }),
@@ -1164,7 +1177,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, 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.',
+      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.',
       inputSchema: {
         org_id: z.string().describe('the org id of the brain to enumerate (from my_brains)'),
       },
@@ -1200,7 +1213,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. "Design Team"') },
+      inputSchema: { name: z.string().describe('display name for the new brain, e.g. "Cortex Codebase"') },
     },
     async ({ name }) => {
       let res
@@ -1291,7 +1304,7 @@ export async function runServer(version) {
     'my_sessions',
     {
       title: 'My active AI sessions',
-      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.",
+      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.",
       inputSchema: {},
     },
     async () => {
@@ -1481,60 +1494,6 @@ 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',
     {
@@ -1729,7 +1688,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 Agnoclast 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 Cortex 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 }) => {
@@ -1771,7 +1730,7 @@ export async function runServer(version) {
     },
   )
 
-  // send_imessage — local outbound texting (NOT org intelligence; writes nothing to Agnoclast). Runs on
+  // send_imessage — local outbound texting (NOT org intelligence; writes nothing to Cortex). Runs on
   // this machine via Messages.app. Draft-by-default + recipient allowlist + OOB confirm (D3/D6/D10).
   server.registerTool(
     'send_imessage',
@@ -1795,7 +1754,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 Agnoclast a finished page (summary + sections WITH
+  //   author           → the write (§9 step 3/4): hand Cortex a finished page (summary + sections WITH
   //     inline [[links]]); the server runs the resolution pass + tier-safe 2B write.
 
   server.registerTool(
@@ -1803,7 +1762,7 @@ export async function runServer(version) {
     {
       title: 'Authoring context (call before author)',
       description:
-        '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.',
+        '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.',
       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.'),
@@ -1846,7 +1805,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. "Agnoclast" 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. "Cortex" 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 Agnoclast console → Connect your AI.\n'
+      'Get your token from the Cortex 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('Agnoclast setup — wiring your AI assistant…')
+  log('Cortex 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 Agnoclast context tools as Claude Code. Non-fatal: a Codex hiccup must
+  // Codex gets the same Cortex 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)) {
@@ -157,7 +157,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 Agnoclast…')
+  log('Verifying your token against Cortex…')
   const health = await checkToken(token, base)
   if (health.ok) {
     const n = health.projectCount
@@ -169,8 +169,8 @@ export async function runSetup(argv, version) {
   }
 
   log('')
-  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('⟳ 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('   Re-check anytime:  npx -y @theronap/cortex-mcp doctor')
   log(`   Console: ${base}`)
   log('')
@@ -191,11 +191,11 @@ export async function runRepair(version) {
   const token = readWiredToken()
   if (!token) {
     process.stderr.write(
-      'No existing Agnoclast token found in ~/.claude.json or ~/.codex/config.toml.\n' +
+      'No existing Cortex 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('Agnoclast repair — re-running setup with your existing token at this version…\n')
+  process.stdout.write('Cortex repair — re-running setup with your existing token at this version…\n')
   await runSetup([token], version)
 }