@theronap/cortex-mcp 0.9.77 → 0.9.79

package/README.md

@@ -1,10 +1,10 @@
 # cortex-mcp
 
-Connect your AI assistant to **Agnoclast** — your org's projects, recent activity, gaps, and directives, scoped to exactly what you're permitted to see.
+Connect your AI assistant to **Cortex** — your org's projects, recent activity, gaps, and directives, scoped to exactly what you're permitted to see.
 
 ## Setup
 
-1. Get your personal token from the Agnoclast console → **Connect your AI**.
+1. Get your personal token from the Cortex console → **Connect your AI**.
 2. Add this to your Claude Code config (`~/.claude.json`, under `mcpServers`):
 
 ```json
@@ -21,7 +21,7 @@ Connect your AI assistant to **Agnoclast** — your org's projects, recent activ
 
 3. Restart Claude Code. Your AI now sees your org context automatically, the managed startup skill
    will prefer query-centered `session_context` on substantive session opens, and each session start
-   will log the exact baseline Agnoclast context to `~/.cortex/context-snapshots/`.
+   will log the exact baseline Cortex context to `~/.cortex/context-snapshots/`.
 
 No clone, no path, no build step — `npx` fetches and runs it.
 

package/bin/cortex-mcp.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * cortex-mcp — connect your AI assistant to Agnoclast.
+ * cortex-mcp — connect your AI assistant to Cortex.
  *
  * Subcommands:
  *   (none)            run the MCP server (stdio) — used by your Claude config
@@ -8,14 +8,14 @@
  *   doctor            live health check — is the token actually working? (no restart needed)
  *   capture           the Stop-hook capturer (invoked by Claude Code, not by hand)
  *   ingest-folder <path>  ingest a local markdown folder as your authored records
- *   snapshot-context  save the exact startup context served by Agnoclast to a local log file
+ *   snapshot-context  save the exact startup context served by Cortex to a local log file
  *   --version | -v
  *   --help | -h
  *
  * Zero-install onboarding:
  *   npx -y @theronap/cortex-mcp setup <your-token>
  *
- * Get your token from the Agnoclast console → Connect your AI.
+ * Get your token from the Cortex console → Connect your AI.
  */
 
 import { readFileSync } from 'node:fs'
@@ -35,31 +35,31 @@ if (cmd === '--version' || cmd === '-v') {
 
 if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
   process.stdout.write(
-    `cortex-mcp ${VERSION} — connect your AI assistant to Agnoclast\n\n` +
+    `cortex-mcp ${VERSION} — connect your AI assistant to Cortex\n\n` +
     `Onboard (one command, no token to copy):\n` +
     `  npx -y @theronap/cortex-mcp login\n\n` +
     `This opens your browser, you click Approve, and it wires everything up. Restart\n` +
-    `Claude Code after, and your AI sees your Agnoclast context while your sessions flow\n` +
+    `Claude Code after, and your AI sees your Cortex context while your sessions flow\n` +
     `into the org automatically.\n\n` +
     `Subcommands:\n` +
     `  login [--label <name>]  browser-approved sign-in — gets a token for you, then runs setup\n` +
     `  setup <token>   wire MCP server + capture hook into ~/.claude config (single editor)\n` +
-    `  install [<token>] [--editor auto|all|<id,...>]  wire Agnoclast into EVERY detected editor + write the capability manifest\n` +
+    `  install [<token>] [--editor auto|all|<id,...>]  wire Cortex into EVERY detected editor + write the capability manifest\n` +
     `  repair          re-run setup at the latest version using your existing token (no token needed)\n` +
-    `  uninstall       remove ALL Agnoclast wiring (MCP, hooks, skills, launchd, cron). --dry-run to preview, --purge to also wipe ~/.cortex + npx cache\n` +
+    `  uninstall       remove ALL Cortex wiring (MCP, hooks, skills, launchd, cron). --dry-run to preview, --purge to also wipe ~/.cortex + npx cache\n` +
     `  doctor          live health check — confirm your token works (no restart needed)\n` +
     `  status          one-line connected/not-connected check (used by the SessionStart hook)\n` +
-    `  skills          install/repair the managed Agnoclast skills — bundled + org-published (also wired by setup)\n` +
+    `  skills          install/repair the managed Cortex skills — bundled + org-published (also wired by setup)\n` +
     `  skills push <file>     publish a SKILL.md to your org (owner/manager/admin)\n` +
-    `  docs-scan       detect new/changed local docs pending Agnoclast authoring (used by /cortex-author-docs)\n` +
-    `  graphify-sync [path] [--brain <name-or-id>]  rebuild the local code graph + log a timeline event\n` +
-    `  snapshot-context save the exact startup context Agnoclast served to a local snapshot\n` +
+    `  docs-scan       detect new/changed local docs pending Cortex authoring (used by /cortex-author-docs)\n` +
+    `  graphify-sync [path]  rebuild the local code graph (graphify) + log an evidence-tier timeline event\n` +
+    `  snapshot-context save the exact startup context Cortex served to a local snapshot\n` +
     `  hydrate         UserPromptSubmit hook — inject query-centered context on the first substantive turn\n` +
     `  statusline      ambient presence line for the Claude Code statusline (local read only)\n` +
     `  capture         Stop-hook capturer (invoked by Claude Code)\n` +
     `  ingest-folder <path>   ingest a local markdown folder as your authored records\n` +
     `  (no args)       run the MCP server (used by your Claude config)\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(0)
 }
@@ -84,14 +84,14 @@ if (cmd === 'login') {
   const { closeFetch } = await import('../lib/diagnose.mjs')
   await closeFetch()
 } else if (cmd === 'install') {
-  // The cross-editor hub installer: wire Agnoclast into every detected editor via the adapter
+  // The cross-editor hub installer: wire Cortex into every detected editor via the adapter
   // registry, then write the capability manifest (~/.cortex/editors.json). Superset of `setup`.
   const { runInstall } = await import('../lib/install.mjs')
   await runInstall(rest, VERSION)
   const { closeFetch } = await import('../lib/diagnose.mjs')
   await closeFetch()
 } else if (cmd === 'uninstall' || cmd === 'remove') {
-  // Full reverse of setup: strip every Agnoclast touch-point (MCP entries, hooks, skills, launchd, cron).
+  // Full reverse of setup: strip every Cortex touch-point (MCP entries, hooks, skills, launchd, cron).
   // --dry-run prints the plan and changes nothing; --purge also removes ~/.cortex, the npx cache, and
   // backups. No network — safe to run even when the token is dead or the server is unreachable.
   const { runUninstall } = await import('../lib/uninstall.mjs')
@@ -122,7 +122,7 @@ if (cmd === 'login') {
 } else if (cmd === 'resolve') {
   // Entity identity dedup: judge the server-flagged fuzzy duplicate pairs locally via `claude -p`.
   const { runResolve } = await import('../lib/resolve.mjs')
-  await runResolve(rest)
+  await runResolve()
   const { closeFetch } = await import('../lib/diagnose.mjs')
   await closeFetch()
 } else if (cmd === 'materialize') {
@@ -153,7 +153,7 @@ if (cmd === 'login') {
   const { closeFetch } = await import('../lib/diagnose.mjs')
   await closeFetch()
 } else if (cmd === 'hydrate') {
-  // UserPromptSubmit hook (① discovery): hydrate the model with query-centered Agnoclast context on the
+  // UserPromptSubmit hook (① discovery): hydrate the model with query-centered Cortex context on the
   // FIRST substantive turn, before it answers — then never again this session (topic-shift refresh stays
   // the cortex-context skill's job). Synchronous by necessity, but once-per-session + 8s + fail-open.
   const { runHydrate } = await import('../lib/hydrate.mjs')
@@ -166,7 +166,7 @@ if (cmd === 'login') {
   const { runStatusline } = await import('../lib/statusline.mjs')
   process.exitCode = runStatusline()
 } else if (cmd === 'skills') {
-  // Install / repair the managed Agnoclast skills — bundled + org-published (`skills push` publishes).
+  // Install / repair the managed Cortex skills — bundled + org-published (`skills push` publishes).
   // Org sync is network-fail-soft so the SessionStart hook stays safe offline.
   const { runSkills } = await import('../lib/skills.mjs')
   process.exitCode = await runSkills(rest)

package/lib/capture.mjs

@@ -35,7 +35,7 @@ export function projectFrom(cwd) {
   return base ?? 'general'
 }
 
-// Claude Code Stop hook → POSTs a session digest to Agnoclast cloud, which
+// Claude Code Stop hook → POSTs a session digest to Cortex cloud, which
 // summarizes server-side and upserts ONE record per session. Node-native
 // SHR-01/T6 — parse a git remote URL into GitHub 'owner/name', or null.
 //

package/lib/code_graph_cli.mjs

@@ -4,7 +4,7 @@ import { join } from 'path'
 
 // Thin local wrapper around the `graphify` CLI's read-only query subcommands. Deliberately NOT a
 // fetchCortex client like grep/read_page: this is LOCAL-MACHINE data (a tree-sitter AST graph of
-// whatever repo the session's cwd happens to be in), not org-shared Agnoclast content, and it never
+// whatever repo the session's cwd happens to be in), not org-shared Cortex content, and it never
 // becomes the wiki graph — see cortex-wiki-primary-spec (structural/extracted data is evidence,
 // never auto-promoted into authored pages). No LLM, no network call; graphify already built the
 // graph on disk, this just queries it.

package/lib/context_log.mjs

@@ -49,7 +49,7 @@ export async function runSnapshotContext() {
   const out = (m) => process.stdout.write(m + '\n')
   const token = resolveToken()
   if (!token) {
-    out('Agnoclast: context snapshot skipped — no token found.')
+    out('Cortex: context snapshot skipped — no token found.')
     return 0
   }
 
@@ -58,13 +58,13 @@ export async function runSnapshotContext() {
   try {
     res = await fetchCortex(`${base}/api/mcp-context`, { headers: { Authorization: `Bearer ${token}` } })
   } catch (e) {
-    out(`Agnoclast: context snapshot failed — ${e?.message ?? String(e)}`)
+    out(`Cortex: context snapshot failed — ${e?.message ?? String(e)}`)
     return 0
   }
 
   if (!res.ok) {
     const body = await res.text()
-    out(`Agnoclast: context snapshot failed — ${classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message}`)
+    out(`Cortex: context snapshot failed — ${classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message}`)
     return 0
   }
 
@@ -76,7 +76,7 @@ export async function runSnapshotContext() {
   const capturedAt = new Date().toISOString()
   const file = join(dir, `${stamp()}.md`)
   const header = [
-    '# Agnoclast startup context snapshot',
+    '# Cortex startup context snapshot',
     `- Captured: ${capturedAt}`,
     `- Source: ${base}/api/mcp-context`,
     '',
@@ -94,6 +94,6 @@ export async function runSnapshotContext() {
 
   pruneSnapshots(dir)
 
-  out(`Agnoclast: logged startup context → ${file}`)
+  out(`Cortex: logged startup context → ${file}`)
   return 0
 }

package/lib/diagnose.mjs

@@ -1,12 +1,12 @@
 // Shared health / diagnosis helpers for the cortex MCP client.
 //
 // The whole reason this file exists: a transient infrastructure block (Vercel firewall / bot
-// protection / deployment protection) once surfaced as a bare "Agnoclast API 403: unknown", which
+// protection / deployment protection) once surfaced as a bare "Cortex API 403: unknown", which
 // read like an auth failure and sent everyone chasing token regeneration for hours. The fix is
 // to tell the truth about WHAT failed.
 //
-// KEY SIGNAL: the Agnoclast app ALWAYS returns JSON ({ error: ... }). So a NON-JSON body on a
-// 4xx/5xx means infrastructure handled the request, not Agnoclast auth — re-running setup or
+// KEY SIGNAL: the Cortex app ALWAYS returns JSON ({ error: ... }). So a NON-JSON body on a
+// 4xx/5xx means infrastructure handled the request, not Cortex auth — re-running setup or
 // regenerating the token will not help; it is usually transient and worth a retry.
 
 import { readFileSync } from 'fs'
@@ -85,24 +85,15 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 // A non-OK response → an actionable diagnosis: { kind, retriable, message }.
 //   kind: 'auth'  → token bad/revoked/wrong-deployment (NOT retriable)
 //         'infra' → blocked by infrastructure, non-JSON body (retriable, usually transient)
-//         'app'   → a real Agnoclast API error with a JSON message (retriable only if 5xx)
+//         'app'   → a real Cortex API error with a JSON message (retriable only if 5xx)
 export function classify(status, contentType, bodyText, requestId) {
   const isJson = (contentType ?? '').includes('application/json')
   let appError = null
   let appHint = null
-  let appMessage = null
-  let appBrains = null
   if (isJson) {
     try {
       const parsed = JSON.parse(bodyText)
       appError = parsed?.error ?? null
-      // Same lesson as `hint`, one layer up. brain_choice_response.ts writes a full explanation to
-      // `message` and every brain's NAME / PAGE COUNT / SAMPLE TITLES to `brains` — its comment says
-      // "THE BODY IS THE ANSWER TO ITS OWN QUESTION", precisely so a model can pick a brain from what
-      // each one HOLDS. Only `error` survived here, so the agent got the bare code `brain_required`
-      // and could not answer it. Measured on the CLI twin of this bug: `✗ brain_required`, full stop.
-      appMessage = typeof parsed?.message === 'string' && parsed.message.trim() ? parsed.message.trim() : null
-      appBrains = Array.isArray(parsed?.brains) ? parsed.brains : null
       // `hint` carries the RECOVERY instruction for the errors an agent is meant to act on, not
       // just report: 409 would_drop ("re-author including the dropped sections…") and 413 too_large
       // ("split the section…"). It used to be dropped here — only `error` survived — so the agent
@@ -118,39 +109,20 @@ export function classify(status, contentType, bodyText, requestId) {
       kind: 'auth', retriable: false,
       message: `Token rejected (HTTP ${status}: ${appError ?? 'unauthorized'}). The token is invalid, ` +
         `revoked, or for a different deployment — not an infrastructure problem. Get a fresh token from ` +
-        `the Agnoclast console → Connect your AI, then re-run setup.${rid}`,
+        `the Cortex console → Connect your AI, then re-run setup.${rid}`,
     }
   }
   if (!isJson) {
     return {
       kind: 'infra', retriable: true,
-      message: `Blocked by infrastructure (HTTP ${status}, non-JSON response) — NOT by Agnoclast auth. This is ` +
+      message: `Blocked by infrastructure (HTTP ${status}, non-JSON response) — NOT by Cortex auth. This is ` +
         `usually a transient firewall / bot-protection hiccup; retrying often clears it. If it persists, check ` +
         `Vercel firewall / deployment protection on the API route. Re-running setup will not help.${rid}`,
     }
   }
-  // A brain-choice refusal is ANSWERABLE, so it must arrive as the question it is rather than as a
-  // code. Deliberately narrow: only these two errors reshape the message, so every other classify()
-  // output keeps its existing wording (and its tests).
-  if (isJson && (appError === 'brain_required' || appError === 'unknown_brain') && (appMessage || appBrains)) {
-    const list = (appBrains ?? []).map((b) => {
-      const pages = typeof b?.pageCount === 'number' ? ` — ${b.pageCount} page${b.pageCount === 1 ? '' : 's'}` : ''
-      const titles = Array.isArray(b?.sampleTitles) && b.sampleTitles.length
-        ? `: ${b.sampleTitles.slice(0, 2).join('; ')}` : ''
-      // Name AND id: brain names are NOT unique (one account holds two called "Personal"), so a name
-      // alone can come back as unknown_brain. The id always resolves.
-      return `  - ${b?.name ?? '(unnamed)'}${pages}${titles}${b?.orgId ? ` [${b.orgId}]` : ''}`
-    })
-    return {
-      kind: 'app', retriable: false,
-      message: `Agnoclast API ${status}: ${appMessage ?? appError}${list.length ? `\n${list.join('\n')}` : ''}` +
-        `\nRe-run this tool with \`brain\` set to one of the names or ids above.${rid}`,
-    }
-  }
-
   return {
     kind: 'app', retriable: status >= 500,
-    message: `Agnoclast API ${status}: ${appError ?? 'unknown error'}.${appHint ? ` ${appHint}` : ''}${rid}`,
+    message: `Cortex API ${status}: ${appError ?? 'unknown error'}.${appHint ? ` ${appHint}` : ''}${rid}`,
   }
 }
 
@@ -204,7 +176,7 @@ export async function fetchCortex(url, opts = {}, { retries = 2, baseDelayMs = 4
     }
   }
   throw new Error(
-    `Could not reach Agnoclast at ${url} — ${lastErr?.message ?? 'network error'}. ` +
+    `Could not reach Cortex at ${url} — ${lastErr?.message ?? 'network error'}. ` +
     `Check your connection (and CORTEX_URL if you set it).`,
   )
 }
@@ -218,7 +190,7 @@ export async function checkToken(token, base) {
   }
   if (!isUuid(token)) {
     return { ok: false, status: 0, diagnosis: { kind: 'config', retriable: false,
-      message: `Token "${String(token).slice(0, 8)}…" is not a valid Agnoclast token (expected a UUID). ` +
+      message: `Token "${String(token).slice(0, 8)}…" is not a valid Cortex token (expected a UUID). ` +
         `Re-run setup with the token from the console.` } }
   }
   const url = `${(base ?? 'https://cortex-console.vercel.app').replace(/\/$/, '')}/api/mcp-context`
@@ -243,41 +215,6 @@ export async function checkToken(token, base) {
   return { ok: true, status: 200, projectCount, requestId }
 }
 
-// Probe the org-skills surface. SEPARATE FROM checkToken ON PURPOSE.
-//
-// WHY THIS EXISTS. `doctor` checked exactly one endpoint — /api/mcp-context — and reported PASS on
-// the strength of it. Meanwhile /api/skills answered 409 to every multi-brain caller for three days
-// (measured 2026-08-08: 14 requests, 14 × 409, zero successes; the local cache sat frozen from Aug 5
-// to Aug 8). Org-published skills silently never installed, the client swallowed the status, and
-// doctor — the tool setup.txt tells people to run FIRST when something is wrong — said everything
-// was fine, every single time. A check that probes one surface is a health check for that surface,
-// not for the system, and must not be reported as the latter.
-//
-// Returns checkToken's shape so the caller renders both the same way. `skillCount` is
-// informational: an org with zero published skills is perfectly healthy, so it is NOT a failure.
-export async function checkSkills(token, base) {
-  if (!token || !isUuid(token)) {
-    return { ok: false, status: 0, diagnosis: { kind: 'config', retriable: false,
-      message: 'no usable token — the context check above already covers this' } }
-  }
-  const url = `${(base ?? CANONICAL_BASE).replace(/\/$/, '')}/api/skills`
-  let res
-  try {
-    res = await fetchCortex(url, { headers: { Authorization: `Bearer ${token}` } })
-  } catch (e) {
-    return { ok: false, status: 0, diagnosis: { kind: 'network', retriable: true, message: e.message } }
-  }
-  const requestId = res.headers.get('x-vercel-id') ?? null
-  const contentType = res.headers.get('content-type')
-  const body = await res.text()
-  if (!res.ok) {
-    return { ok: false, status: res.status, requestId, diagnosis: classify(res.status, contentType, body, requestId) }
-  }
-  let skillCount
-  try { skillCount = (JSON.parse(body)?.skills ?? []).length } catch { /* shape drift — non-fatal */ }
-  return { ok: true, status: 200, skillCount, requestId }
-}
-
 // Release the keep-alive sockets the global fetch (undici) holds, so a short-lived CLI command
 // can tear down cleanly. Without this, calling process.exit() right after a fetch can race a
 // lingering socket handle and trip a libuv assertion on Windows

package/lib/docs_scan.mjs

@@ -6,7 +6,7 @@ import { join, resolve, dirname } from 'path'
 // Documentation ingestion — detection half (D1 of docs/documentation-ingestion-spec.md).
 //
 // Specs/plans/design docs get written to disk (repo docs/, ~/.gstack/projects/…) and never reach
-// Agnoclast as pages. This subcommand DETECTS new/changed markdown under registered roots by content
+// Cortex as pages. This subcommand DETECTS new/changed markdown under registered roots by content
 // hash; the AUTHORING is done by the live session (the cortex-author-docs skill reads each pending
 // doc and calls the `author` MCP tool) — the agent is the pipe, never a raw-markdown dump.
 //
@@ -90,7 +90,7 @@ export function markFiles(state, paths, now = new Date().toISOString()) {
 }
 
 // Heuristic soak guardrail (spec D5): the Robin parity experiment forbids re-syncing the local
-// brain into Agnoclast during the window, so warn when a root looks like the brain repo.
+// brain into Cortex during the window, so warn when a root looks like the brain repo.
 const looksLikeBrain = (dir) => /\/Documents\/brain(\/|$)/.test(dir)
 
 export async function runDocsScan(argv = []) {
@@ -111,7 +111,7 @@ export async function runDocsScan(argv = []) {
     const abs = resolve(dir)
     if (!existsSync(abs)) { process.stderr.write(`Not a directory: ${abs}\n`); return 1 }
     if (looksLikeBrain(abs)) {
-      out(`⚠ ${abs} looks like the local brain repo — the Robin parity soak forbids re-syncing it into Agnoclast.`)
+      out(`⚠ ${abs} looks like the local brain repo — the Robin parity soak forbids re-syncing it into Cortex.`)
       out('  Registering anyway is on you; the cortex-author-docs skill will also warn.')
     }
     if (!state.roots.includes(abs)) state.roots.push(abs)
@@ -163,7 +163,7 @@ export async function runDocsScan(argv = []) {
   }
   if (!pending.length) out(`✓ up to date — ${scanned} doc(s) scanned, nothing pending`)
   else {
-    out(`${pending.length} doc(s) pending Agnoclast authoring (of ${scanned} scanned):`)
+    out(`${pending.length} doc(s) pending Cortex authoring (of ${scanned} scanned):`)
     for (const p of pending) out(`  ${p.status === 'new' ? '+ ' : '~ '}${p.path}`)
     out('Author them via the cortex-author-docs skill, then:  docs-scan --mark <file>...')
   }

package/lib/doctor.mjs

@@ -1,12 +1,12 @@
 import { readFileSync, existsSync } from 'fs'
 import { homedir } from 'os'
 import { join } from 'path'
-import { checkToken, checkSkills, resolveBase } from './diagnose.mjs'
+import { checkToken, resolveBase } from './diagnose.mjs'
 
 // `npx @theronap/cortex-mcp doctor` — a live, one-command health check.
 //
 // This is the "is it ACTUALLY working?" tool that was missing: it reads your token, calls the
-// real Agnoclast API, and prints a clear PASS/FAIL with the actual cause. No Claude Code restart
+// real Cortex API, and prints a clear PASS/FAIL with the actual cause. No Claude Code restart
 // needed — so onboarding can confirm the connection independently of "did the server load."
 
 // Token resolution: env first, then the Claude config the setup command wrote (so `doctor`
@@ -24,7 +24,7 @@ function resolveToken() {
   return { token: null, source: null }
 }
 
-// `status` — the one-line SessionStart variant of doctor: a visible "is Agnoclast capturing?"
+// `status` — the one-line SessionStart variant of doctor: a visible "is Cortex capturing?"
 // signal inside Claude Code itself (three-machine dry-run finding 2026-06-09: with no
 // indicator, a user can't tell whether their sessions are flowing to the org).
 // Always returns 0 — a status line must never break a session start.
@@ -33,19 +33,19 @@ export async function runStatus() {
   const out = (m) => process.stdout.write(m + '\n')
   const { token } = resolveToken()
   if (!token) {
-    out('Agnoclast: NOT connected — no token found. Run: npx -y @theronap/cortex-mcp setup <token>')
+    out('Cortex: NOT connected — no token found. Run: npx -y @theronap/cortex-mcp setup <token>')
     return 0
   }
   try {
     const r = await checkToken(token, base)
     if (r.ok) {
       const n = typeof r.projectCount === 'number' ? ` · ${r.projectCount} project${r.projectCount === 1 ? '' : 's'} visible` : ''
-      out(`Agnoclast: connected — sessions on this machine are captured to your org${n}.`)
+      out(`Cortex: connected — sessions on this machine are captured to your org${n}.`)
     } else {
-      out(`Agnoclast: NOT connected — ${r.diagnosis?.message ?? 'check failed'}. Run: npx -y @theronap/cortex-mcp doctor`)
+      out(`Cortex: NOT connected — ${r.diagnosis?.message ?? 'check failed'}. Run: npx -y @theronap/cortex-mcp doctor`)
     }
   } catch (e) {
-    out(`Agnoclast: status check failed (${e?.message ?? String(e)}) — run doctor.`)
+    out(`Cortex: status check failed (${e?.message ?? String(e)}) — run doctor.`)
   }
   return 0
 }
@@ -55,7 +55,7 @@ export async function runDoctor() {
   const out = (m) => process.stdout.write(m + '\n')
 
   out('')
-  out('Agnoclast doctor — checking your connection…')
+  out('Cortex doctor — checking your connection…')
   const { token, source } = resolveToken()
   out(`  token source: ${source ?? 'NONE FOUND'}`)
   out(`  endpoint:     ${base}`)
@@ -64,35 +64,11 @@ export async function runDoctor() {
   const r = await checkToken(token, base)
 
   if (r.ok) {
-    out('  ✓ context   — your token authenticates and Agnoclast returned your context.')
+    out('  ✓ PASS — your token authenticates and Cortex returned your context.')
     if (typeof r.projectCount === 'number') out(`    You can currently see ${r.projectCount} project(s).`)
     if (r.requestId) out(`    (request id: ${r.requestId})`)
-
-    // A SECOND surface, because one endpoint answering is not "the system is healthy". /api/skills
-    // 409'd every multi-brain caller for three days while this command printed PASS on the strength
-    // of /api/mcp-context alone. See checkSkills' header for the full record.
-    const s = await checkSkills(token, base)
-    if (s.ok) {
-      const n = typeof s.skillCount === 'number'
-        ? ` (${s.skillCount} org skill${s.skillCount === 1 ? '' : 's'} published)` : ''
-      out(`  ✓ skills    — the org-skill surface answers${n}.`)
-    } else {
-      // NOT a total failure — context works, so capture and retrieval are fine. But it must never
-      // again render as PASS, because org skills silently stop updating when this breaks.
-      out(`  ✗ skills    — ${s.diagnosis?.kind ?? 'error'}${s.status ? ` (HTTP ${s.status})` : ''}`)
-      out(`    ${s.diagnosis?.message ?? 'unknown error'}`)
-      out('')
-      out('  ⚠ PARTIAL — your connection is fine and capture/retrieval work, but org-published')
-      out('    skills cannot be fetched, so they will silently stop updating (the client falls')
-      out('    back to its last-good cache). Report this rather than ignoring it.')
-      out('')
-      return 1
-    }
-
-    out('')
-    out('  ✓ PASS — every surface checked is answering.')
     out('')
-    out('  If your AI still does not see Agnoclast, the server just is not loaded yet —')
+    out('  If your AI still does not see Cortex, the server just is not loaded yet —')
     out('  fully quit and reopen Claude Code (the MCP server starts on launch).')
     out('')
     return 0

package/lib/editors/antigravity.mjs

@@ -55,7 +55,7 @@ export function renderAntigravityPlist({ home = homedir() } = {}) {
  *  NOTE the AGENT_DIR line is the portability blocker documented above. */
 export function renderAntigravitySyncSh() {
   return `#!/bin/bash
-# Agnoclast ⇄ Antigravity one-shot sync, triggered by launchd WatchPaths on the Antigravity
+# Cortex ⇄ Antigravity one-shot sync, triggered by launchd WatchPaths on the Antigravity
 # trajectory store. There is no resident daemon — launchd wakes this on change and it exits.
 # Token is resolved from the wired MCP config at runtime (never stored in plist/script).
 # ⚠ AGENT_DIR points at a local dev checkout — see antigravity.mjs BLOCKER note (not coworker-portable).

package/lib/editors/claude.mjs

@@ -6,7 +6,7 @@ import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { readJson, backupFile, ensureDir, writeJson } from './_fsutil.mjs'
 
-/** Merge the Agnoclast MCP server into a ~/.claude.json object. Pure + idempotent: sets only the
+/** Merge the Cortex MCP server into a ~/.claude.json object. Pure + idempotent: sets only the
  *  `cortex` entry (type:'stdio'), preserves every other server. `spec` = the package@dist-tag string. */
 export function mergeClaudeMcp(existing, spec, token) {
   const cfg = existing && typeof existing === 'object' ? { ...existing } : {}
@@ -15,16 +15,14 @@ export function mergeClaudeMcp(existing, spec, token) {
   return cfg
 }
 
-/** The Agnoclast tools every seat may run WITHOUT a permission prompt: the read surface, the live
+/** The Cortex tools every seat may run WITHOUT a permission prompt: the read surface, the live
  *  authoring core, and trivially-reversible maintenance. The contract this enforces: authoring is
  *  EXPECTED agent behavior — a page update must never stall on a yes/no dialog the user won't read
  *  (the ask-permission failure mode is how pages go stale). Safe because every page edit is
  *  CAS-protected + snapshotted (page_revisions → page_history/rollback_page).
  *  Deliberately EXCLUDED — these keep prompting: send_imessage (external side effect),
  *  set_page_privacy / set_record_privacy / grant_page_access (visibility widening — the
- *  unowned-project accessible-default sharp edge, 2026-07-02), replace_variant (destroys a page body
- *  and deletes a variant row — the one write here that is not merely CAS-protected but genuinely
- *  lossy at the row level, so the prompt IS the guard D1 argued for), rollback_page, decide_page_merge /
+ *  unowned-project accessible-default sharp edge, 2026-07-02), rollback_page, decide_page_merge /
  *  decide_file_request / request_file / get_file, create_brain / set_active_brain, alias_page,
  *  set_writing_style. */
 export const CORTEX_ALLOWED_TOOLS = [
@@ -38,7 +36,7 @@ export const CORTEX_ALLOWED_TOOLS = [
   'set_page_validity', 'snooze_red_link', 'attribute_thread',
 ].map((t) => `mcp__cortex__${t}`)
 
-/** Merge Agnoclast's Claude Code hooks into a ~/.claude/settings.json object. Pure + idempotent: drops
+/** Merge Cortex's Claude Code hooks into a ~/.claude/settings.json object. Pure + idempotent: drops
  *  any prior cortex entry (old token/path/version) from each hook array before appending the current
  *  one — capture (Stop), status + skills-repair + snapshot-context (SessionStart), hydrate
  *  (UserPromptSubmit), precompact (PreCompact). Commands carry NO inline token (each subcommand

package/lib/editors/codex.mjs

@@ -6,7 +6,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { readJson, backupFile, ensureDir, writeJson } from './_fsutil.mjs'
 
-/** Merge the Agnoclast MCP server into a Codex config.toml. Pure + idempotent: strips any existing
+/** Merge the Cortex MCP server into a Codex config.toml. Pure + idempotent: strips any existing
  *  [mcp_servers.cortex] / [mcp_servers.cortex.env] tables (so re-runs update in place rather than
  *  duplicating — a duplicate TOML table would break Codex's parser), preserves every other table,
  *  and appends a fresh block. Only touches the cortex tables; never rewrites the user's config. */

package/lib/editors/cursor.mjs

@@ -6,7 +6,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
 import { join } from 'node:path'
 import { backupFile } from './_fsutil.mjs'
 
-/** Merge the Agnoclast MCP server into a Cursor mcp.json object. Pure + idempotent: sets only the
+/** Merge the Cortex MCP server into a Cursor mcp.json object. Pure + idempotent: sets only the
  *  `cortex` entry, preserves every other server. `spec` is the package@dist-tag STRING — the same
  *  convention claude/codex/setup.mjs use, so one install driver can pass a single spec to every adapter. */
 export function mergeCursorMcp(existing, spec, token) {

package/lib/editors/index.mjs

@@ -1,4 +1,4 @@
-// Editor adapter registry (P0-b task 1). One place that knows every editor Agnoclast can wire.
+// Editor adapter registry (P0-b task 1). One place that knows every editor Cortex can wire.
 // Adding an editor = add a module here; the install driver + capability manifest fall out of it.
 //
 // EditorAdapter shape (see the four modules):

package/lib/graphify_sync.mjs

@@ -26,42 +26,8 @@ function repoFullNameFromRemote(cwd) {
   return m ? `${m[1]}/${m[2]}` : null
 }
 
-// `--brain <name-or-org-id>` — which brain an UNROUTED repo's graph event lands in.
-//
-// Deliberately a flag and nothing cleverer. /api/timeline/graphify routes deterministically by repo
-// (resolveSourceRoute) and only asks when the repo has no route; its comment is blunt about why it
-// must not be guessed: this writes a `records` row unique on (org_id, dedupe_key), so "a repo whose
-// graph updates land in two brains becomes two record sets that never reconcile, and re-pointing
-// later converges on nothing (ADR-0020). It is the one write class where a wrong answer is genuinely
-// unrecoverable." So: no sweep (unlike `resolve`, which is a maintenance pass over everything) and
-// no auto-pick.
-//
-// It does NOT create a source route as a side effect, though that would stop the question recurring:
-// routes are append-only precisely because "re-pointing a live source splits its history
-// irreparably", and a near-irreversible write should not fall out of a CLI flag. This command runs
-// from a per-repo cron/launchd job, so the flag lives in that job's definition — answered once,
-// where it is visible. (Route creation currently has NO client on any surface; that is a separate
-// gap, not this command's to paper over.)
-// Split argv into { cwd, brain }. Pure + exported so the ordering trap below is unit-testable
-// without a git repo, a graphify binary or a network.
-//
-// THE TRAP: argv[0] doubles as the optional repo path, and `--brain`'s VALUE has no leading '-'.
-// Parsed naively, `graphify-sync --brain Personal` reads "Personal" as the path and syncs whatever
-// happens to be there. So the flag and its value are stripped BEFORE the positional check.
-export function parseGraphifyArgs(argv = [], fallbackCwd = process.cwd()) {
-  const bIdx = argv.indexOf('--brain')
-  const brain = bIdx === -1 ? null : argv[bIdx + 1]
-  if (bIdx !== -1 && (!brain || brain.startsWith('-'))) {
-    return { error: 'Usage: graphify-sync [path] [--brain <name-or-org-id>]' }
-  }
-  const rest = bIdx === -1 ? argv : argv.filter((_, i) => i !== bIdx && i !== bIdx + 1)
-  return { cwd: rest[0] && !rest[0].startsWith('-') ? rest[0] : fallbackCwd, brain }
-}
-
 export async function runGraphifySync(argv = []) {
-  const parsed = parseGraphifyArgs(argv)
-  if (parsed.error) { process.stderr.write(parsed.error + '\n'); return 1 }
-  const { cwd, brain } = parsed
+  const cwd = argv[0] && !argv[0].startsWith('-') ? argv[0] : process.cwd()
   const TOKEN = process.env.CORTEX_TOKEN
   const BASE = resolveBase(process.env.CORTEX_URL)
   if (!TOKEN) {
@@ -107,27 +73,16 @@ export async function runGraphifySync(argv = []) {
   const res = await fetchCortex(`${BASE}/api/timeline/graphify`, {
     method: 'POST',
     headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify({ repo, commitSha, nodeCount, edgeCount, communityCount, ...(brain ? { brain } : {}) }),
+    body: JSON.stringify({ repo, commitSha, nodeCount, edgeCount, communityCount }),
   })
   if (!res.ok) {
     const body = await res.text()
-    const d = classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id'))
-    process.stderr.write(d.message + '\n')
-    // classify names the brains but speaks in MCP terms ("re-run this tool with `brain`"). Say the
-    // actual flag, and where to put it — this runs unattended from cron, so the person reading this
-    // is looking at a log after the fact, not a prompt.
-    if (res.status === 409 && !brain) {
-      process.stderr.write(
-        `\n${repo} has no routing decision yet, so it cannot be filed without one.\n` +
-        `Re-run with:  cortex-mcp graphify-sync ${cwd === process.cwd() ? '' : `${cwd} `}--brain "<name-or-org-id>"\n` +
-        `and add that flag to this repo's cron/launchd job so it stops asking.\n`,
-      )
-    }
+    process.stderr.write(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message + '\n')
     return 1
   }
   const payload = await res.json()
   process.stdout.write(
-    `Logged to Agnoclast timeline: ${repo}@${commitSha.slice(0, 7)} (${nodeCount} nodes, ${edgeCount} edges, ${communityCount} communities)` +
+    `Logged to Cortex timeline: ${repo}@${commitSha.slice(0, 7)} (${nodeCount} nodes, ${edgeCount} edges, ${communityCount} communities)` +
       `${payload.inserted ? '' : ' (already logged)'}\n`,
   )
   return 0

package/lib/grep_cli.mjs

@@ -56,7 +56,7 @@ export async function runGrep(rest = []) {
   const TOKEN = process.env.CORTEX_TOKEN
   const BASE = resolveBase(process.env.CORTEX_URL)
   if (!TOKEN) {
-    process.stderr.write('cortex grep: CORTEX_TOKEN is required (get yours from the Agnoclast console).\n')
+    process.stderr.write('cortex grep: CORTEX_TOKEN is required (get yours from the Cortex console).\n')
     return 1
   }
   const { query, mode, max } = parseGrepArgs(rest)