@theronap/cortex-mcp 0.9.79 → 0.9.80

package/README.md

@@ -1,10 +1,10 @@
 # cortex-mcp
 
-Connect your AI assistant to **Cortex** — your org's projects, recent activity, gaps, and directives, scoped to exactly what you're permitted to see.
+Connect your AI assistant to **Agnoclast** — 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 Cortex console → **Connect your AI**.
+1. Get your personal token from the Agnoclast 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 **Cortex** — your org's projects, recent activity
 
 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 Cortex context to `~/.cortex/context-snapshots/`.
+   will log the exact baseline Agnoclast 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 Cortex.
+ * cortex-mcp — connect your AI assistant to Agnoclast.
  *
  * 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 Cortex to a local log file
+ *   snapshot-context  save the exact startup context served by Agnoclast 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 Cortex console → Connect your AI.
+ * Get your token from the Agnoclast console → Connect your AI.
  */
 
 import { readFileSync } from 'node:fs'
@@ -35,31 +35,32 @@ if (cmd === '--version' || cmd === '-v') {
 
 if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
   process.stdout.write(
-    `cortex-mcp ${VERSION} — connect your AI assistant to Cortex\n\n` +
+    `cortex-mcp ${VERSION} — connect your AI assistant to Agnoclast\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 Cortex context while your sessions flow\n` +
+    `Claude Code after, and your AI sees your Agnoclast 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 Cortex into EVERY detected editor + write the capability manifest\n` +
+    `  install [<token>] [--editor auto|all|<id,...>]  wire Agnoclast 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 Cortex wiring (MCP, hooks, skills, launchd, cron). --dry-run to preview, --purge to also wipe ~/.cortex + npx cache\n` +
+    `  uninstall       remove ALL Agnoclast 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 Cortex skills — bundled + org-published (also wired by setup)\n` +
+    `  use-brain [<brain>]    where your session captures are saved — no arg shows the current setting\n` +
+    `  skills          install/repair the managed Agnoclast 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 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` +
+    `  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` +
     `  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 Cortex console → Connect your AI.\n`,
+    `Get your token from the Agnoclast console → Connect your AI.\n`,
   )
   process.exit(0)
 }
@@ -84,14 +85,14 @@ if (cmd === 'login') {
   const { closeFetch } = await import('../lib/diagnose.mjs')
   await closeFetch()
 } else if (cmd === 'install') {
-  // The cross-editor hub installer: wire Cortex into every detected editor via the adapter
+  // The cross-editor hub installer: wire Agnoclast 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 Cortex touch-point (MCP entries, hooks, skills, launchd, cron).
+  // Full reverse of setup: strip every Agnoclast 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 +123,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()
+  await runResolve(rest)
   const { closeFetch } = await import('../lib/diagnose.mjs')
   await closeFetch()
 } else if (cmd === 'materialize') {
@@ -153,7 +154,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 Cortex context on the
+  // UserPromptSubmit hook (① discovery): hydrate the model with query-centered Agnoclast 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 +167,7 @@ if (cmd === 'login') {
   const { runStatusline } = await import('../lib/statusline.mjs')
   process.exitCode = runStatusline()
 } else if (cmd === 'skills') {
-  // Install / repair the managed Cortex skills — bundled + org-published (`skills push` publishes).
+  // Install / repair the managed Agnoclast 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)
@@ -177,12 +178,27 @@ if (cmd === 'login') {
   // The cortex-author-docs skill authors the pending docs into wiki pages. No network.
   const { runDocsScan } = await import('../lib/docs_scan.mjs')
   process.exitCode = await runDocsScan(rest)
+} else if (cmd === 'use-brain') {
+  // Set (or show) which brain this machine's unattended session captures land in. Registered here,
+  // BEFORE the default branch — an unrecognised subcommand falls through to "start the MCP server",
+  // which is how `connect-calendar` once silently became the file-watching daemon on a pilot user's
+  // machine and reported that daemon's errors instead of its own.
+  const { runUseBrain } = await import('../lib/use_brain.mjs')
+  process.exitCode = await runUseBrain(rest)
+  const { closeFetch } = await import('../lib/diagnose.mjs')
+  await closeFetch()
 } else if (cmd === 'precompact') {
-  // PreCompact hook (③ live wiki authoring, best-effort): print an "author now" reminder so the session
-  // sweeps its understanding into the wiki BEFORE compaction drops it. A hook cannot force a model turn
-  // (D2) — this is the documented fallback; /log is the hard backstop. No network; prints + exits.
-  const { runPrecompactReminder } = await import('../lib/precompact.mjs')
-  runPrecompactReminder()
+  // RETIRED — deliberately kept as a silent no-op, do not delete yet.
+  //
+  // The reminder it used to print never reached a model: PreCompact takes a blocking `decision` and has
+  // no additionalContext channel, so its stdout went nowhere (verified 2026-08-10 against 7,232 local
+  // transcripts — see the PreCompact block in lib/editors/claude.mjs for the measurement and control).
+  //
+  // Why this branch survives the removal: seats installed before this release still have
+  // `PreCompact: npx -y @theronap/cortex-mcp@latest precompact` in ~/.claude/settings.json, and @latest
+  // resolves to THIS build. Deleting the branch would turn a harmless no-op into an unknown-command
+  // error on every compaction for anyone who has not re-run install. mergeClaudeSettings unwires them
+  // on their next install/repair; drop this branch a release after that has had time to propagate.
 } else {
   // Default: run the MCP server (stays alive; never exits).
   const { runServer } = await import('../lib/server.mjs')

package/lib/capture.mjs

@@ -35,7 +35,7 @@ export function projectFrom(cwd) {
   return base ?? 'general'
 }
 
-// Claude Code Stop hook → POSTs a session digest to Cortex cloud, which
+// Claude Code Stop hook → POSTs a session digest to Agnoclast 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 Cortex content, and it never
+// whatever repo the session's cwd happens to be in), not org-shared Agnoclast 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('Cortex: context snapshot skipped — no token found.')
+    out('Agnoclast: 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(`Cortex: context snapshot failed — ${e?.message ?? String(e)}`)
+    out(`Agnoclast: context snapshot failed — ${e?.message ?? String(e)}`)
     return 0
   }
 
   if (!res.ok) {
     const body = await res.text()
-    out(`Cortex: context snapshot failed — ${classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message}`)
+    out(`Agnoclast: 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 = [
-    '# Cortex startup context snapshot',
+    '# Agnoclast startup context snapshot',
     `- Captured: ${capturedAt}`,
     `- Source: ${base}/api/mcp-context`,
     '',
@@ -94,6 +94,6 @@ export async function runSnapshotContext() {
 
   pruneSnapshots(dir)
 
-  out(`Cortex: logged startup context → ${file}`)
+  out(`Agnoclast: 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 "Cortex API 403: unknown", which
+// protection / deployment protection) once surfaced as a bare "Agnoclast 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 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
+// 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
 // regenerating the token will not help; it is usually transient and worth a retry.
 
 import { readFileSync } from 'fs'
@@ -85,15 +85,24 @@ 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 Cortex API error with a JSON message (retriable only if 5xx)
+//         'app'   → a real Agnoclast 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
@@ -109,20 +118,39 @@ 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 Cortex console → Connect your AI, then re-run setup.${rid}`,
+        `the Agnoclast 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 Cortex auth. This is ` +
+      message: `Blocked by infrastructure (HTTP ${status}, non-JSON response) — NOT by Agnoclast 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: `Cortex API ${status}: ${appError ?? 'unknown error'}.${appHint ? ` ${appHint}` : ''}${rid}`,
+    message: `Agnoclast API ${status}: ${appError ?? 'unknown error'}.${appHint ? ` ${appHint}` : ''}${rid}`,
   }
 }
 
@@ -176,7 +204,7 @@ export async function fetchCortex(url, opts = {}, { retries = 2, baseDelayMs = 4
     }
   }
   throw new Error(
-    `Could not reach Cortex at ${url} — ${lastErr?.message ?? 'network error'}. ` +
+    `Could not reach Agnoclast at ${url} — ${lastErr?.message ?? 'network error'}. ` +
     `Check your connection (and CORTEX_URL if you set it).`,
   )
 }
@@ -190,7 +218,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 Cortex token (expected a UUID). ` +
+      message: `Token "${String(token).slice(0, 8)}…" is not a valid Agnoclast 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`
@@ -207,12 +235,54 @@ export async function checkToken(token, base) {
     return { ok: false, status: res.status, requestId, diagnosis: classify(res.status, contentType, body, requestId) }
   }
   let projectCount
+  let captureNotice = null
   try {
-    const ctx = JSON.parse(body).context ?? ''
+    const parsed = JSON.parse(body)
+    const ctx = parsed.context ?? ''
     const m = ctx.match(/## Projects \((\d+)\)/)
     if (m) projectCount = Number(m[1])
+    // The server's "your work is not landing" advisory. Optional by design: an older server does not
+    // send it and this must stay a health check, so a missing field is simply no notice.
+    if (parsed.captureNotice && typeof parsed.captureNotice.message === 'string') {
+      captureNotice = parsed.captureNotice
+    }
   } catch { /* context shape changed — non-fatal for a health check */ }
-  return { ok: true, status: 200, projectCount, requestId }
+  return { ok: true, status: 200, projectCount, requestId, captureNotice }
+}
+
+// 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

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
-// Cortex as pages. This subcommand DETECTS new/changed markdown under registered roots by content
+// Agnoclast 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 Cortex during the window, so warn when a root looks like the brain repo.
+// brain into Agnoclast 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 Cortex.`)
+      out(`⚠ ${abs} looks like the local brain repo — the Robin parity soak forbids re-syncing it into Agnoclast.`)
       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 Cortex authoring (of ${scanned} scanned):`)
+    out(`${pending.length} doc(s) pending Agnoclast 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,17 +1,20 @@
 import { readFileSync, existsSync } from 'fs'
 import { homedir } from 'os'
 import { join } from 'path'
-import { checkToken, resolveBase } from './diagnose.mjs'
+import { checkToken, checkSkills, 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 Cortex API, and prints a clear PASS/FAIL with the actual cause. No Claude Code restart
+// real Agnoclast 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`
 // works the moment after `setup`, before any restart). Returns { token, source }.
-function resolveToken() {
+// Exported so `use-brain` resolves the token EXACTLY as doctor/status do. There is already a second,
+// subtly different copy of this in context_log.mjs (returns a bare token, not {token, source}); a
+// third copy is how a machine ends up "connected" to one command and "no token found" to another.
+export function resolveToken() {
   if (process.env.CORTEX_TOKEN) return { token: process.env.CORTEX_TOKEN, source: 'CORTEX_TOKEN env' }
   const claudeJson = join(homedir(), '.claude.json')
   if (existsSync(claudeJson)) {
@@ -24,7 +27,7 @@ function resolveToken() {
   return { token: null, source: null }
 }
 
-// `status` — the one-line SessionStart variant of doctor: a visible "is Cortex capturing?"
+// `status` — the one-line SessionStart variant of doctor: a visible "is Agnoclast 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 +36,29 @@ export async function runStatus() {
   const out = (m) => process.stdout.write(m + '\n')
   const { token } = resolveToken()
   if (!token) {
-    out('Cortex: NOT connected — no token found. Run: npx -y @theronap/cortex-mcp setup <token>')
+    out('Agnoclast: 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) {
+      // ⚠ THE NOTICE REPLACES THE HAPPY LINE RATHER THAN FOLLOWING IT.
+      // "connected — sessions on this machine are captured to your org" was printed truthfully to
+      // three people whose sessions were, at that moment, landing in NO brain: connected is a fact
+      // about the TOKEN, and every reader takes it as a fact about their WORK. Printing both would
+      // leave the reassurance that caused four days of silent loss sitting directly above the
+      // warning that contradicts it.
+      if (r.captureNotice?.message) {
+        out(`Agnoclast: ⚠ ${r.captureNotice.message}`)
+        return 0
+      }
       const n = typeof r.projectCount === 'number' ? ` · ${r.projectCount} project${r.projectCount === 1 ? '' : 's'} visible` : ''
-      out(`Cortex: connected — sessions on this machine are captured to your org${n}.`)
+      out(`Agnoclast: connected — sessions on this machine are captured to your org${n}.`)
     } else {
-      out(`Cortex: NOT connected — ${r.diagnosis?.message ?? 'check failed'}. Run: npx -y @theronap/cortex-mcp doctor`)
+      out(`Agnoclast: NOT connected — ${r.diagnosis?.message ?? 'check failed'}. Run: npx -y @theronap/cortex-mcp doctor`)
     }
   } catch (e) {
-    out(`Cortex: status check failed (${e?.message ?? String(e)}) — run doctor.`)
+    out(`Agnoclast: status check failed (${e?.message ?? String(e)}) — run doctor.`)
   }
   return 0
 }
@@ -55,7 +68,7 @@ export async function runDoctor() {
   const out = (m) => process.stdout.write(m + '\n')
 
   out('')
-  out('Cortex doctor — checking your connection…')
+  out('Agnoclast doctor — checking your connection…')
   const { token, source } = resolveToken()
   out(`  token source: ${source ?? 'NONE FOUND'}`)
   out(`  endpoint:     ${base}`)
@@ -64,11 +77,35 @@ export async function runDoctor() {
   const r = await checkToken(token, base)
 
   if (r.ok) {
-    out('  ✓ PASS — your token authenticates and Cortex returned your context.')
+    out('  ✓ context   — your token authenticates and Agnoclast 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 Cortex, the server just is not loaded yet —')
+    out('  If your AI still does not see Agnoclast, 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
-# Cortex ⇄ Antigravity one-shot sync, triggered by launchd WatchPaths on the Antigravity
+# Agnoclast ⇄ 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 Cortex MCP server into a ~/.claude.json object. Pure + idempotent: sets only the
+/** Merge the Agnoclast 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,14 +15,16 @@ export function mergeClaudeMcp(existing, spec, token) {
   return cfg
 }
 
-/** The Cortex tools every seat may run WITHOUT a permission prompt: the read surface, the live
+/** The Agnoclast 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), rollback_page, decide_page_merge /
+ *  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 /
  *  decide_file_request / request_file / get_file, create_brain / set_active_brain, alias_page,
  *  set_writing_style. */
 export const CORTEX_ALLOWED_TOOLS = [
@@ -36,10 +38,11 @@ export const CORTEX_ALLOWED_TOOLS = [
   'set_page_validity', 'snooze_red_link', 'attribute_thread',
 ].map((t) => `mcp__cortex__${t}`)
 
-/** Merge Cortex's Claude Code hooks into a ~/.claude/settings.json object. Pure + idempotent: drops
+/** Merge Agnoclast'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
+ *  (UserPromptSubmit). Also UNWIRES the retired PreCompact reminder from seats that still carry it.
+ *  Commands carry NO inline token (each subcommand
  *  self-resolves it). Mirrors setup.mjs
  *  step 2 exactly; foreign hooks are never touched. Also merges the CORTEX_ALLOWED_TOOLS permission
  *  allowlist — additive-only: a user's own allow entries (even extra mcp__cortex__* ones) are never
@@ -103,16 +106,28 @@ export function mergeClaudeSettings(existing, spec) {
   hgrp.hooks = hgrp.hooks ?? []
   hgrp.hooks.push({ type: 'command', command: hydrateCmd })
 
-  // PreCompact — "author now" reminder.
-  s.hooks.PreCompact = Array.isArray(s.hooks.PreCompact) ? s.hooks.PreCompact : []
-  const precompactCmd = `npx -y ${spec} precompact`
-  for (const pg of s.hooks.PreCompact) {
-    if (Array.isArray(pg.hooks)) pg.hooks = pg.hooks.filter((h) => !/cortex-mcp(@[^ ]*)? precompact/.test(h.command ?? ''))
+  // PreCompact — REMOVED, and this block is the migration that unwires existing seats.
+  //
+  // The "author now" reminder wrote to stdout on the assumption the harness surfaced it as context for
+  // the next turn. It does not: PreCompact accepts a blocking `decision` and nothing else — it has no
+  // additionalContext channel — so the reminder never reached a model. Measured 2026-08-10 across 7,232
+  // local transcripts: the reminder text appears 5 times, every one of them a tool_result from someone
+  // READING the file, assistant prose about it, or a compaction summary that absorbed such prose. Zero
+  // injections, against >=13 transcripts that demonstrably compacted. The control is what makes that
+  // conclusive rather than merely absent: SessionStart's hook output, on a channel that IS injected,
+  // appears in 912 transcripts of the same corpus.
+  //
+  // So: filter, never append. Every install/repair strips the stale entry from seats that already have
+  // it, which is why this runs unconditionally instead of shipping as a separate migration.
+  if (Array.isArray(s.hooks.PreCompact)) {
+    for (const pg of s.hooks.PreCompact) {
+      if (Array.isArray(pg.hooks)) pg.hooks = pg.hooks.filter((h) => !/cortex-mcp(@[^ ]*)? precompact/.test(h.command ?? ''))
+    }
+    // Drop groups we just emptied, then the key itself if no foreign hook remains — a bare
+    // `PreCompact: []` reads as "cortex wires this event" to the next person to open settings.json.
+    s.hooks.PreCompact = s.hooks.PreCompact.filter((pg) => (pg.hooks ?? []).length > 0)
+    if (s.hooks.PreCompact.length === 0) delete s.hooks.PreCompact
   }
-  let pgrp = s.hooks.PreCompact.find((g) => (g.matcher ?? '') === '')
-  if (!pgrp) { pgrp = { matcher: '', hooks: [] }; s.hooks.PreCompact.push(pgrp) }
-  pgrp.hooks = pgrp.hooks ?? []
-  pgrp.hooks.push({ type: 'command', command: precompactCmd })
 
   // Permissions — pre-authorize the read + authoring core so a page update never stalls on a
   // permission prompt. Append-missing only (no filter-and-rebuild like the hooks above): removals