@theronap/cortex-mcp 0.9.83 → 0.9.85

package/lib/skills.mjs

@@ -3,9 +3,9 @@ import { homedir } from 'os'
 import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
 
-// Managed Cortex skills.
+// Managed Agnoclast skills.
 //
-// Two sources, one install pipeline:
+// Three sources, one install pipeline:
 //   1. BUNDLED — shipped inside this package (cortex-log, cortex-context, cortex-author-docs).
 //      Inalterable: canonical content always wins; user edits are backed up + restored.
 //   2. ORG-PUBLISHED — rows in the org's `org_skills` table (documentation-ingestion-spec.md
@@ -13,6 +13,9 @@ import { fileURLToPath } from 'url'
 //      SessionStart `skills --repair` hook pulls + installs it here. Bundled names WIN collisions,
 //      so an org can never shadow a core skill. The pull is fail-soft (offline → last-good cache
 //      at ~/.cortex/org-skills-cache.json → skip), because SessionStart must never break.
+//   3. PERSONAL — rows in `personal_skills`, keyed by auth_id. These are private to one person and
+//      are projected into every compatible editor on their machines. Personal wins an org collision
+//      on that person's machine; bundled core still wins every collision.
 //
 // Installed into EVERY agent CLI present on the machine, at the flat layout each one discovers:
 //   ~/.claude/skills/<name>/SKILL.md   (Claude Code)
@@ -30,13 +33,16 @@ import { fileURLToPath } from 'url'
 const HERE = dirname(fileURLToPath(import.meta.url))
 const BUNDLED = join(HERE, '..', 'skills') // packages/cortex-mcp/skills/<name>/SKILL.md
 const ORG_CACHE = join(homedir(), '.cortex', 'org-skills-cache.json')
+const PERSONAL_CACHE = join(homedir(), '.cortex', 'personal-skills-cache.json')
 const NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/ // mirrors the org_skills check; also blocks path tricks
 
-// Agent CLIs we install skills into. Claude is primary; Codex is included whenever it's present.
-// Both use the same flat <cli>/skills/<name>/SKILL.md discovery layout.
+// Editor skill roots with the compatible flat SKILL.md discovery layout. Cursor's path was verified
+// on-machine before declaring it supported; Antigravity has no documented skill surface yet, so we
+// deliberately do not fabricate one.
 const CLIS = [
   { id: 'Claude Code', dir: join(homedir(), '.claude') },
   { id: 'Codex', dir: join(homedir(), '.codex') },
+  { id: 'Cursor', dir: join(homedir(), '.cursor') },
 ]
 
 // djb2 — tiny, dependency-free content fingerprint for the manifest (drift detection, not security).
@@ -155,21 +161,61 @@ export function installSkills(opts = {}) {
 
   if (quiet && (summary.installed.length || summary.repaired.length)) {
     // SessionStart surfaces one line in Claude Code so a silent self-heal isn't invisible.
-    process.stdout.write(`Cortex: synced managed skill(s) into ${summary.targets.join(' + ')}.\n`)
+    process.stdout.write(`Agnoclast: synced managed skill(s) into ${summary.targets.join(' + ')}.\n`)
   }
   return summary
 }
 
-// Decide what to install from a served org-skill list: drop invalid names and bundled collisions
-// (bundled wins — core skills are inalterable). Pure, so it's unit-testable without a network.
+// Decide what to install from a served org-skill list: drop invalid names, bundled collisions
+// (bundled wins — core skills are inalterable) and cross-brain collisions. Pure, so it's
+// unit-testable without a network.
 export function planOrgInstall(served, bundledNames) {
   const bundled = new Set(bundledNames)
   const install = []
   const skipped = []
+
+  // /api/skills now fans out across EVERY brain the caller belongs to (ADR-0022 acrossMyBrains), so
+  // for the first time two brains can serve the SAME skill name. Installing both would write one
+  // file twice and silently leave whichever landed last — an executable body from a brain the user
+  // never chose. There is no principled winner, so a cross-brain collision installs NEITHER and says
+  // so, matching how a bundled collision already resolves: when in doubt, do not install.
+  const byName = new Map()
+  for (const s of served ?? []) {
+    const n = (s?.name ?? '').trim()
+    if (!byName.has(n)) byName.set(n, [])
+    byName.get(n).push(s)
+  }
+
+  for (const s of served ?? []) {
+    const name = (s?.name ?? '').trim()
+    if (!NAME_RE.test(name) || typeof s?.body_md !== 'string' || !s.body_md.trim()) { skipped.push({ name: name || '(unnamed)', why: 'invalid' }); continue }
+    if (bundled.has(name)) { skipped.push({ name, why: 'collides with a bundled core skill' }); continue }
+    const dupes = byName.get(name) ?? []
+    if (dupes.length > 1) {
+      // Name the brains so the owner knows which to rename. `brain` is the tag acrossMyBrains adds.
+      const brains = [...new Set(dupes.map((d) => d?.brain).filter(Boolean))]
+      skipped.push({ name, why: `published by ${dupes.length} brains (${brains.join(', ') || 'unknown'}) — rename one; installing neither` })
+      continue
+    }
+    install.push({ name, source: s.body_md })
+  }
+  return { install, skipped }
+}
+
+// Personal skills share the same validation and bundled-collision rule as org skills, but never use
+// the cross-brain collision rule: their auth_id uniqueness means only one personal body can exist per
+// name. Keeping this pure makes the precedence contract testable without touching a real home dir.
+export function planPersonalInstall(served, bundledNames) {
+  const bundled = new Set(bundledNames)
+  const install = []
+  const skipped = []
+  const seen = new Set()
   for (const s of served ?? []) {
     const name = (s?.name ?? '').trim()
     if (!NAME_RE.test(name) || typeof s?.body_md !== 'string' || !s.body_md.trim()) { skipped.push({ name: name || '(unnamed)', why: 'invalid' }); continue }
     if (bundled.has(name)) { skipped.push({ name, why: 'collides with a bundled core skill' }); continue }
+    if (seen.has(name)) { skipped.push({ name, why: 'duplicate personal skill' }); continue }
+    seen.add(name)
     install.push({ name, source: s.body_md })
   }
   return { install, skipped }
@@ -201,6 +247,13 @@ export async function syncOrgSkills(opts = {}) {
     if (res.ok) {
       served = (await res.json())?.skills ?? []
       summary.source = 'server'
+    } else {
+      // ⚠ DO NOT MAKE THIS SILENT AGAIN. `if (res.ok)` alone is how a 100% failure hid for weeks:
+      // /api/skills answered 409 to every multi-brain caller, this fell through to the cache below,
+      // and the only log line ('unreachable and no cache') does NOT print when a cache exists. So
+      // org skills silently stopped updating and nothing anywhere said so. Fail-soft is right —
+      // SessionStart must not break — but fail-soft is not fail-quiet.
+      log(`  · org skills: server said ${res.status} — using last-good cache. Run \`doctor\` if this persists.`)
     }
   } catch { /* fall through to cache */ }
   if (!served && Array.isArray(cache?.skills)) { served = cache.skills; summary.source = 'cache' }
@@ -230,29 +283,142 @@ export async function syncOrgSkills(opts = {}) {
     const bits = []
     if (changed.length) bits.push(`synced ${changed.join(', ')}`)
     if (summary.removed.length) bits.push(`removed ${summary.removed.join(', ')}`)
-    process.stdout.write(`Cortex: org skills — ${bits.join('; ')}${summary.source === 'cache' ? ' (offline cache)' : ''}.\n`)
+    process.stdout.write(`Agnoclast: org skills — ${bits.join('; ')}${summary.source === 'cache' ? ' (offline cache)' : ''}.\n`)
   } else if (!quiet) {
     log(`  ✓ org skills up to date (${currentNames.length} published${skipped.length ? `, ${skipped.length} skipped` : ''})`)
   }
   return summary
 }
 
-// `skills push <file>` / `skills push --disable <name>` / `skills push --enable <name>` —
-// publish or toggle an org skill (owner/manager/admin; the server enforces the role).
-async function runSkillsPush(argv) {
+/**
+ * Pull the caller's personal skill library and project it into every compatible local editor.
+ * It is deliberately fail-soft for the same reason as org sync: a network outage must not break a
+ * session start. A personal skill wins an unpinned org skill by being installed after org sync.
+ */
+export async function syncPersonalSkills(opts = {}) {
+  const quiet = !!opts.quiet
+  const log = (m) => { if (!quiet) process.stdout.write(m + '\n') }
+  const summary = { installed: [], repaired: [], removed: [], skipped: [], source: 'none' }
+  const { resolveBase, readWiredToken, fetchCortex } = await import('./diagnose.mjs')
+  const token = process.env.CORTEX_TOKEN || readWiredToken()
+  if (!token) { log('  · personal skills: no token wired — skipped'); return summary }
+
+  let cache = null
+  try { cache = JSON.parse(readFileSync(PERSONAL_CACHE, 'utf8')) } catch { /* none */ }
+  let served = null
+  try {
+    const res = await fetchCortex(`${resolveBase(process.env.CORTEX_URL)}/api/personal-skills`, {
+      headers: { Authorization: `Bearer ${token}` },
+    })
+    if (res.ok) {
+      served = (await res.json())?.skills ?? []
+      summary.source = 'server'
+    } else {
+      log(`  · personal skills: server said ${res.status} — using last-good cache. Run \`doctor\` if this persists.`)
+    }
+  } catch { /* fall through to cache */ }
+  if (!served && Array.isArray(cache?.skills)) { served = cache.skills; summary.source = 'cache' }
+  if (!served) { log('  · personal skills: unreachable and no cache — skipped'); return summary }
+
+  const bundledNames = bundledSkills().map((s) => s.name)
+  const { install, skipped } = planPersonalInstall(served, bundledNames)
+  summary.skipped = skipped
+  const prevNames = Array.isArray(cache?.installed) ? cache.installed : []
+  const currentNames = install.map((s) => s.name)
+  const retiredNames = prevNames.filter((n) => !currentNames.includes(n))
+
+  // If a personal override was disabled, put back a cached org skill of that name rather than
+  // deleting it. The normal sync sequence has already refreshed ORG_CACHE before this function.
+  let orgCache = null
+  try { orgCache = JSON.parse(readFileSync(ORG_CACHE, 'utf8')) } catch { /* no org fallback */ }
+  const { install: orgInstall } = planOrgInstall(orgCache?.skills, bundledNames)
+  const orgByName = new Map(orgInstall.map((s) => [s.name, s]))
+  const fallback = retiredNames.map((name) => orgByName.get(name)).filter(Boolean)
+  const removeNames = retiredNames.filter((name) => !orgByName.has(name))
+
+  for (const cli of CLIS.filter((c) => existsSync(c.dir))) {
+    // Fallbacks first, personal second: personal > org, but bundled was installed before either.
+    const r = installInto(join(cli.dir, 'skills'), [...fallback, ...install], { removeNames })
+    summary.installed.push(...r.installed)
+    summary.repaired.push(...r.repaired)
+    summary.removed.push(...r.removed)
+  }
+  if (summary.source === 'server') {
+    ensureDir(dirname(PERSONAL_CACHE))
+    writeFileSync(PERSONAL_CACHE, JSON.stringify({ fetchedAt: new Date().toISOString(), skills: served, installed: currentNames }, null, 2))
+  }
+
+  const changed = [...new Set([...summary.installed, ...summary.repaired])]
+  if (changed.length || summary.removed.length) {
+    const bits = []
+    if (changed.length) bits.push(`synced ${changed.join(', ')}`)
+    if (summary.removed.length) bits.push(`removed ${summary.removed.join(', ')}`)
+    process.stdout.write(`Agnoclast: personal skills — ${bits.join('; ')}${summary.source === 'cache' ? ' (offline cache)' : ''}.\n`)
+  } else if (!quiet) {
+    log(`  ✓ personal skills up to date (${currentNames.length} private${skipped.length ? `, ${skipped.length} skipped` : ''})`)
+  }
+  return summary
+}
+
+// Render a failed push. THE SERVER ALREADY ANSWERED THE QUESTION — brain_choice_response.ts builds a
+// body carrying a full `message` plus every brain's NAME, PAGE COUNT and SAMPLE TITLES, explicitly so
+// the caller can choose "by what each one HOLDS, not by which name sounds related". This function
+// existed as `body.error ?? HTTP ${status}`, which printed the bare code `brain_required` and threw
+// all of that away — the user saw a two-word error with no notion of what a brain is, which ones they
+// have, or what to type next. Pure + exported so the shape is unit-testable without a network.
+export function renderPushError(body, status) {
+  const lines = [body?.message ?? body?.error ?? `HTTP ${status}`]
+  const brains = Array.isArray(body?.brains) ? body.brains : []
+  if (brains.length) {
+    lines.push('', '  Your brains:')
+    for (const b of brains) {
+      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('; ')}` : ''
+      lines.push(`    ${b?.name ?? b?.orgId ?? '(unnamed)'}${pages}${titles}`)
+    }
+    lines.push('', '  Re-run with --brain "<name>".')
+  }
+  return lines.join('\n')
+}
+
+// `skills push <file> [--brain <name>]` / `skills push --disable <name> [--brain <name>]` /
+// `skills push --enable <name> [--brain <name>]` — publish or toggle an org skill
+// (owner/manager/admin; the server enforces the role).
+//
+// ⚠ --brain IS NOT OPTIONAL FOR A MULTI-BRAIN CALLER, and until 2026-08-08 there was no way to pass
+// it. Publishing MODIFIES one brain, so the server correctly uses ADR-0022's `requireBrain` half and
+// refuses to guess — but this command sent no `brain`, so every push and every --disable from a
+// multi-brain account died on `brain_required` with no way forward. Confirmed against production:
+// `skills push --disable cortex-author-docs` → `✗ brain_required`, full stop.
+//
+// This is the WRITE twin of the GET bug fixed in #467. The read was miscategorised and now fans out;
+// the write was categorised correctly and simply had no input for the answer it demanded.
+export async function runSkillsPush(argv) {
   const { resolveBase, readWiredToken, fetchCortex } = await import('./diagnose.mjs')
   const token = process.env.CORTEX_TOKEN || readWiredToken()
-  if (!token) { process.stderr.write('No Cortex token wired — run setup first.\n'); return 1 }
+  if (!token) { process.stderr.write('No Agnoclast token wired — run setup first.\n'); return 1 }
   const base = resolveBase(process.env.CORTEX_URL)
 
+  const brainIdx = argv.findIndex((a) => a === '--brain')
+  const brain = brainIdx === -1 ? null : argv[brainIdx + 1]
+  if (brainIdx !== -1 && (!brain || brain.startsWith('-'))) {
+    process.stderr.write('Usage: skills push … --brain <name>  (missing brain name)\n')
+    return 1
+  }
+  // Strip --brain AND its value before any positional parsing below. The value does not start with
+  // '-', so the `argv.find(a => !a.startsWith('-'))` file lookup would otherwise take it as the
+  // SKILL.md path and push the wrong thing.
+  const rest = brainIdx === -1 ? argv : argv.filter((_, i) => i !== brainIdx && i !== brainIdx + 1)
+
   let payload
-  const toggleIdx = argv.findIndex((a) => a === '--disable' || a === '--enable')
+  const toggleIdx = rest.findIndex((a) => a === '--disable' || a === '--enable')
   if (toggleIdx !== -1) {
-    const name = argv[toggleIdx + 1]
-    if (!name) { process.stderr.write(`Usage: skills push ${argv[toggleIdx]} <name>\n`); return 1 }
-    payload = { name, enabled: argv[toggleIdx] === '--enable' }
+    const name = rest[toggleIdx + 1]
+    if (!name) { process.stderr.write(`Usage: skills push ${rest[toggleIdx]} <name>\n`); return 1 }
+    payload = { name, enabled: rest[toggleIdx] === '--enable' }
   } else {
-    const file = argv.find((a) => !a.startsWith('-'))
+    const file = rest.find((a) => !a.startsWith('-'))
     if (!file || !existsSync(file)) { process.stderr.write('Usage: skills push <SKILL.md>  (file not found)\n'); return 1 }
     const body_md = readFileSync(file, 'utf8')
     const name = frontmatterName(body_md, '').toLowerCase()
@@ -264,13 +430,14 @@ async function runSkillsPush(argv) {
   }
 
   try {
-    const res = await fetchCortex(`${base}/api/skills`, {
+    const qs = brain ? `?brain=${encodeURIComponent(brain)}` : ''
+    const res = await fetchCortex(`${base}/api/skills${qs}`, {
       method: 'POST',
       headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
       body: JSON.stringify(payload),
     })
     const body = await res.json().catch(() => ({}))
-    if (!res.ok) { process.stderr.write(`✗ ${body.error ?? `HTTP ${res.status}`}\n`); return 1 }
+    if (!res.ok) { process.stderr.write(`✗ ${renderPushError(body, res.status)}\n`); return 1 }
     process.stdout.write(
       payload.body_md
         ? `✓ published "${payload.name}" to your org — every seat installs it on next session start.\n`
@@ -283,13 +450,72 @@ async function runSkillsPush(argv) {
   }
 }
 
+export function discoverSkillFiles(root) {
+  if (!root || !existsSync(root)) return []
+  return readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, 'SKILL.md')))
+    .map((entry) => join(root, entry.name, 'SKILL.md'))
+}
+
+// `skills import --from claude` is the deliberate migration command. It uploads only the user's
+// skill bodies to their private library, then projects the served result; it never publishes to an
+// organization and it never treats a local copy as proof that server sync worked.
+export async function runSkillsImport(argv) {
+  if (argv.length !== 2 || argv[0] !== '--from' || argv[1] !== 'claude') {
+    process.stderr.write('Usage: skills import --from claude\n')
+    return 1
+  }
+  const { resolveBase, readWiredToken, fetchCortex } = await import('./diagnose.mjs')
+  const token = process.env.CORTEX_TOKEN || readWiredToken()
+  if (!token) { process.stderr.write('No Agnoclast token wired — run setup first.\n'); return 1 }
+  const files = discoverSkillFiles(join(homedir(), '.claude', 'skills'))
+  if (!files.length) { process.stderr.write('No Claude Code SKILL.md files found.\n'); return 1 }
+
+  const base = resolveBase(process.env.CORTEX_URL)
+  let imported = 0
+  const skipped = []
+  const seen = new Set()
+  for (const file of files) {
+    const body_md = readFileSync(file, 'utf8')
+    const name = frontmatterName(body_md, '').toLowerCase()
+    if (!NAME_RE.test(name)) { skipped.push(`${file}: invalid frontmatter name`); continue }
+    if (seen.has(name)) { skipped.push(`${file}: duplicate name ${name}`); continue }
+    seen.add(name)
+    try {
+      const res = await fetchCortex(`${base}/api/personal-skills`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name, body_md, enabled: true }),
+      })
+      if (!res.ok) {
+        const response = await res.json().catch(() => ({}))
+        skipped.push(`${file}: ${response.error ?? `HTTP ${res.status}`}`)
+        continue
+      }
+      imported++
+    } catch (e) {
+      skipped.push(`${file}: network error: ${e.message}`)
+    }
+  }
+  process.stdout.write(`Agnoclast: imported ${imported}/${files.length} Claude Code skills into your private library.\n`)
+  for (const reason of skipped) process.stdout.write(`  · skipped ${reason}\n`)
+  if (imported) await syncPersonalSkills({ quiet: false })
+  return skipped.length ? 1 : 0
+}
+
 // CLI entry: `cortex-mcp skills [--repair] [--quiet] | skills push …`. (--repair and plain install
 // are the same idempotent operation; --repair is just the name the SessionStart hook uses for intent.)
 export async function runSkills(argv = []) {
   if (argv[0] === 'push') return runSkillsPush(argv.slice(1))
+  if (argv[0] === 'import') return runSkillsImport(argv.slice(1))
+  const syncing = argv[0] === 'sync'
+  if (argv[0] && !syncing && argv[0] !== '--repair' && argv[0] !== '--quiet') {
+    process.stderr.write('Usage: skills [sync|--repair] | skills import --from claude | skills push <SKILL.md> [--brain <name>]\n')
+    return 1
+  }
 
   const quiet = argv.includes('--quiet')
-  if (!quiet) process.stdout.write('\nCortex skills — installing managed skills…\n')
+  if (!quiet) process.stdout.write('\nAgnoclast skills — installing managed skills…\n')
   const r = installSkills({ quiet })
   if (!quiet) {
     if (!r.targets.length) process.stdout.write('  ! No agent CLI found (~/.claude or ~/.codex). Nothing to install.\n')
@@ -297,6 +523,9 @@ export async function runSkills(argv = []) {
       process.stdout.write(`  ✓ Up to date in ${r.targets.join(' + ')} (${[...new Set(r.unchanged)].join(', ') || 'none'}).\n`)
     }
   }
-  if (r.targets.length) await syncOrgSkills({ quiet })
+  if (r.targets.length) {
+    await syncOrgSkills({ quiet })
+    await syncPersonalSkills({ quiet })
+  }
   return 0
 }

package/lib/uninstall.mjs

@@ -3,7 +3,7 @@ import { homedir } from 'os'
 import { join } from 'path'
 import { execFileSync } from 'child_process'
 
-// Full uninstall — the reverse of setup.mjs. Removes EVERY touch-point Cortex writes onto a machine:
+// Full uninstall — the reverse of setup.mjs. Removes EVERY touch-point Agnoclast writes onto a machine:
 //   1. ~/.claude.json          → mcpServers.cortex
 //   2. ~/.claude/settings.json → Stop/SessionStart/PreCompact cortex hooks
 //   3. ~/.codex/config.toml    → [mcp_servers.cortex] + [mcp_servers.cortex.env]
@@ -34,7 +34,7 @@ export function runUninstall(argv = []) {
   const act = (msg) => plan.push(msg)
   const write = (path, data) => { if (!dry) { backup(path); writeFileSync(path, data) } }
 
-  process.stdout.write(dry ? '\nCortex uninstall — DRY RUN (nothing will change):\n\n' : '\nCortex uninstall — removing all wiring…\n\n')
+  process.stdout.write(dry ? '\nAgnoclast uninstall — DRY RUN (nothing will change):\n\n' : '\nAgnoclast uninstall — removing all wiring…\n\n')
 
   // 1. MCP server out of ~/.claude.json
   editJson(CLAUDE_JSON, (cfg) => {
@@ -144,7 +144,7 @@ export function runUninstall(argv = []) {
     }
   }
 
-  if (plan.length === 0) { process.stdout.write('  Nothing to remove — this machine has no Cortex wiring.\n\n'); return }
+  if (plan.length === 0) { process.stdout.write('  Nothing to remove — this machine has no Agnoclast wiring.\n\n'); return }
   process.stdout.write(plan.join('\n') + '\n\n')
   if (dry) {
     process.stdout.write('DRY RUN — nothing changed. Re-run without --dry-run to apply.\n')

package/lib/use_brain.mjs

@@ -0,0 +1,82 @@
+import { fetchCortex, classify, resolveBase } from './diagnose.mjs'
+import { resolveToken } from './doctor.mjs'
+
+// `use-brain` — set (or show) which brain this machine's unattended session captures land in.
+//
+// WHY A SUBCOMMAND EXISTS AT ALL. The server side of this shipped 2026-08-09 with NO client surface:
+// no CLI, no MCP tool, no console setting. The only way to set a capture default was a raw
+// authenticated HTTP call, which meant the only people who could fix a broken capture were the ones
+// who could hand-write a curl with a bearer token. Three real users needed it; one of them is not
+// technical. A fix only its author can operate is not a fix.
+//
+// Pairs with the SessionStart notice: the notice tells you captures are being held and names this
+// command, so the loop from "something is wrong" to "it is fixed" is one paste with no docs.
+
+function out(m) { process.stdout.write(m + '\n') }
+
+export async function runUseBrain(args) {
+  const base = resolveBase(process.env.CORTEX_URL)
+  const { token } = resolveToken()
+  if (!token) {
+    out('Agnoclast: no token found. Run: npx -y @theronap/cortex-mcp setup <token>')
+    return 1
+  }
+
+  // Everything after the subcommand is the brain, joined — so an unquoted multi-word name still
+  // works. `use-brain Real estate` is what a person actually types; refusing it over a missing pair
+  // of quotes would be the same species of unhelpfulness this command exists to remove.
+  const wanted = (args ?? []).filter((a) => !a.startsWith('--')).join(' ').trim()
+  const url = `${base}/api/brain/capture-default`
+
+  if (!wanted) {
+    // No argument: report the current state rather than erroring. "What is it set to?" is a fair
+    // question and the answer is one GET away.
+    try {
+      const res = await fetchCortex(url, { headers: { Authorization: `Bearer ${token}` } })
+      if (!res.ok) {
+        const body = await res.text()
+        out(`Agnoclast: could not read your capture settings — ${classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message}`)
+        return 1
+      }
+      const { defaults } = await res.json()
+      if (!defaults?.length) {
+        out('Agnoclast: no capture brain set. Your unattended session captures land in a brain only if')
+        out('  you belong to exactly one; otherwise they are HELD outside every brain until you set this.')
+        out('  Set one:  npx -y @theronap/cortex-mcp use-brain "<brain name or org id>"')
+        return 0
+      }
+      for (const d of defaults) out(`Agnoclast: ${d.sourceType} captures land in "${d.orgName}" (${d.orgId})`)
+      return 0
+    } catch (e) {
+      out(`Agnoclast: could not reach the server (${e?.message ?? String(e)})`)
+      return 1
+    }
+  }
+
+  try {
+    const res = await fetchCortex(url, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sourceType: 'claude-code', brain: wanted }),
+    })
+    const body = await res.text()
+    if (!res.ok) {
+      let msg = classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message
+      // The server's own error text is better than a generic one here: a 404 names the brain that was
+      // not found, and a 409 lists the org ids of an ambiguous name — which is the whole remedy.
+      try { const j = JSON.parse(body); if (j.error) msg = j.error } catch { /* keep the classified message */ }
+      out(`Agnoclast: ${msg}`)
+      return 1
+    }
+    const j = JSON.parse(body)
+    out(`Agnoclast: ✓ your Claude Code sessions now land in "${j.brain}".`)
+    // Say plainly what this does NOT do. The setter's own server-side note makes the same point,
+    // because "I fixed it" reading as "and the backlog is handled" is how held records stay held.
+    out('  Sessions captured BEFORE now are still held — they keep their original dates until sorted.')
+    out('  Ask your assistant to file them (they may not all belong in the same brain).')
+    return 0
+  } catch (e) {
+    out(`Agnoclast: could not reach the server (${e?.message ?? String(e)})`)
+    return 1
+  }
+}

package/package.json

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

package/skills/author-docs/SKILL.md

@@ -1,22 +1,22 @@
 ---
 name: cortex-author-docs
-description: Push new/changed documentation (specs, plans, design docs) from disk into Cortex as authored wiki pages. Run after writing a spec/plan/design doc, when the user asks to sync docs to Cortex, or as part of session close-out.
+description: Push new/changed documentation (specs, plans, design docs) from disk into Agnoclast as authored wiki pages. Run after writing a spec/plan/design doc, when the user asks to sync docs to Agnoclast, or as part of session close-out.
 ---
 
-> **Cortex-managed skill.** This file is installed and kept up to date by Cortex. Local edits are
+> **Agnoclast-managed skill.** This file is installed and kept up to date by Agnoclast. Local edits are
 > restored on the next session (a backup of your version is saved alongside). Don't rely on changes here.
 
 ## Why this exists
 
 Specs, plans, and design docs get written to disk (a repo's `docs/`, skill-generated design docs)
-and never reach Cortex — so the org brain misses its richest artifacts. A spec IS a page: this
+and never reach Agnoclast — so the org brain misses its richest artifacts. A spec IS a page: this
 skill turns pending docs into authored wiki pages. You (the live session) are the pipe — you read
 the doc and author a synthesis. Never dump raw markdown into a page.
 
 ## When to use
 
 - Right after you write or substantially update a spec/plan/design/runbook doc on disk.
-- When the user asks to push/sync docs to Cortex.
+- When the user asks to push/sync docs to Agnoclast.
 - During session close-out (`/cortex-log` runs this as a sweep step).
 
 ## Steps
@@ -67,7 +67,7 @@ the doc and author a synthesis. Never dump raw markdown into a page.
 ## Safety rules
 
 - Do NOT register or sweep the local brain repo (`~/Documents/brain`) while the Robin parity soak
-  is running — the experiment forbids re-syncing Robin into Cortex mid-window.
+  is running — the experiment forbids re-syncing Robin into Agnoclast mid-window.
 - Respect tiers: if a doc is clearly personal/sensitive, author it `confidential` or ask; default
   for work docs is the author path's normal default.
 - This skill writes wiki pages via the `author` tool only. It never sends external messages and

package/skills/context/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: cortex-context
-description: Automatically hydrate Cortex context at the start of a substantive session. Use when Cortex MCP is available and the user has made a real request, so the first answer is grounded in query-centered org context instead of the static baseline alone.
+description: Automatically hydrate Agnoclast context at the start of a substantive session. Use when Agnoclast MCP is available and the user has made a real request, so the first answer is grounded in query-centered org context instead of the static baseline alone.
 ---
 
-> **Cortex-managed skill.** This file is installed and kept up to date by Cortex. Local edits are
+> **Agnoclast-managed skill.** This file is installed and kept up to date by Agnoclast. Local edits are
 > restored on the next session (a backup of your version is saved alongside). Don't rely on changes here.
 
 ## When to use
@@ -14,12 +14,12 @@ chit-chat and requests where org context is obviously irrelevant.
 ## Steps
 
 1. Call `session_context` with the user's opening request, preserving the actual topic in their words.
-2. Use that returned block as the primary Cortex grounding for the first response.
+2. Use that returned block as the primary Agnoclast grounding for the first response.
 3. If `session_context` is unavailable or errors, fall back to `my_context`.
 4. If the conversation materially changes topics later, call `session_context` again for the new topic.
 
 ## Safety rules
 
-- Do not fabricate Cortex context if the tool fails.
+- Do not fabricate Agnoclast context if the tool fails.
 - Prefer the query-centered `session_context` over static `my_context` whenever the user's topic is clear.
 - Do not call `session_context` for every tiny follow-up; refresh only when the topic meaningfully shifts.

package/skills/log/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: cortex-log
-description: Close out a work session into Cortex — summarize what happened, confirm it reached the org, and surface anything teammates should know. Run at or near the end of any working session.
+description: Close out a work session into Agnoclast — summarize what happened, confirm it reached the org, and surface anything teammates should know. Run at or near the end of any working session.
 ---
 
-> **Cortex-managed skill.** This file is installed and kept up to date by Cortex. Local edits are
+> **Agnoclast-managed skill.** This file is installed and kept up to date by Agnoclast. Local edits are
 > restored on the next session (a backup of your version is saved alongside). Don't rely on changes here.
 
 ## Model: session-primary, daily-derived
 
-The **session is the primary atomic unit** — one session = one durable Cortex record (via
+The **session is the primary atomic unit** — one session = one durable Agnoclast record (via
 `log_session`, keyed by `sessionId`), which is also the per-record privacy unit (`set_record_privacy`
 is per record). Any "what happened today / this week" view is a **derived rollup** over those session
 records, never a separately-authored primary. This mirrors records(atomic) → digests(derived); the
@@ -16,7 +16,7 @@ personal `/log` skill follows the same shape against the local brain.
 
 ## When to use
 
-At the end of a Claude Code session, or after finishing a meaningful phase of work. Cortex keeps a
+At the end of a Claude Code session, or after finishing a meaningful phase of work. Agnoclast keeps a
 background auto-capture as a fallback, but this skill is the *authoritative* close-out: it composes a
 clean, structured summary and persists THAT as the session's durable record (superseding the
 auto-capture's raw-transcript re-derivation).
@@ -33,7 +33,7 @@ No arguments. Read the conversation context.
    These are the things a teammate or manager would want to know without reading the whole transcript.
 3. **Persist it as the durable record** — call the `log_session` MCP tool with your curated `summary`
    (plus `project`, and the Claude Code `sessionId` if you know it). This writes YOUR summary as the
-   session's authoritative Cortex record (`capture_source='skill'`). The background auto-capture is a
+   session's authoritative Agnoclast record (`capture_source='skill'`). The background auto-capture is a
    fallback and will not overwrite it; passing the same `sessionId` the auto-capture uses dedupes them
    onto one record. This — not the raw-transcript re-derivation — is the canonical record going forward.
 4. **Confirm + flag privacy** — `log_session` returns a confirmation; if it errors, tell the user to
@@ -72,7 +72,7 @@ No arguments. Read the conversation context.
    > verify a write; the result you already have in hand is the strongest.
    >
    > **What replaces it — at the moment of each write, not at the end:** a rejected `author` comes back
-   > as an ORDINARY tool result with **no error flag** — `Could not author "<page>": Cortex API 409:
+   > as an ORDINARY tool result with **no error flag** — `Could not author "<page>": Agnoclast API 409:
    > <reason>` — and `No change to "<page>"` is a **200 OK that wrote nothing**. Neither is an error at
    > the protocol level, so nothing will interrupt you. **Read the result text of every write; never
    > skim it.** That inline read is where this step's value actually was.

package/skills/walkthrough/SKILL.md

@@ -3,7 +3,7 @@ name: cortex-walkthrough
 description: Run the guided Agnoclast walkthrough for someone new. Use when the person asks for the walkthrough, a tutorial, or getting started — "give me the walkthrough", "walk me through this", "how do I use this", "show me around", "what can this do", "remind me how this works" — or when a brand-new user needs orienting for the first time.
 ---
 
-> **Cortex-managed skill.** This file is installed and kept up to date by Cortex. Local edits are
+> **Agnoclast-managed skill.** This file is installed and kept up to date by Agnoclast. Local edits are
 > restored on the next session (a backup of your version is saved alongside). Don't rely on changes here.
 
 # The Agnoclast walkthrough

package/lib/precompact.mjs

@@ -1,16 +0,0 @@
-// PreCompact "author now" reminder (③ live wiki authoring, [[cortex-wiki-authoring-spec]] D2).
-//
-// Wired by setup.mjs as a PreCompact hook. A hook CANNOT force a model turn — it can only inject text
-// the model sees on its next turn (best-effort). So this prints a reminder to sweep understanding into
-// the wiki BEFORE compaction discards the session's hot mental model. The HARD backstop is the /log
-// skill (cortex-log step 5); this catches the in-session compaction that would otherwise lose the magic.
-//
-// Output goes to stdout, which the Claude Code harness surfaces as additional context for the next turn.
-export function runPrecompactReminder() {
-  process.stdout.write(
-    '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',
-  )
-}