@theronap/cortex-mcp 0.9.79 → 0.9.80

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 Cortex MCP server into a Codex config.toml. Pure + idempotent: strips any existing
+/** Merge the Agnoclast 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 Cortex MCP server into a Cursor mcp.json object. Pure + idempotent: sets only the
+/** Merge the Agnoclast 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 Cortex can wire.
+// Editor adapter registry (P0-b task 1). One place that knows every editor Agnoclast 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,8 +26,42 @@ 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 cwd = argv[0] && !argv[0].startsWith('-') ? argv[0] : process.cwd()
+  const parsed = parseGraphifyArgs(argv)
+  if (parsed.error) { process.stderr.write(parsed.error + '\n'); return 1 }
+  const { cwd, brain } = parsed
   const TOKEN = process.env.CORTEX_TOKEN
   const BASE = resolveBase(process.env.CORTEX_URL)
   if (!TOKEN) {
@@ -73,16 +107,27 @@ 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 }),
+    body: JSON.stringify({ repo, commitSha, nodeCount, edgeCount, communityCount, ...(brain ? { brain } : {}) }),
   })
   if (!res.ok) {
     const body = await res.text()
-    process.stderr.write(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message + '\n')
+    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`,
+      )
+    }
     return 1
   }
   const payload = await res.json()
   process.stdout.write(
-    `Logged to Cortex timeline: ${repo}@${commitSha.slice(0, 7)} (${nodeCount} nodes, ${edgeCount} edges, ${communityCount} communities)` +
+    `Logged to Agnoclast 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 Cortex console).\n')
+    process.stderr.write('cortex grep: CORTEX_TOKEN is required (get yours from the Agnoclast console).\n')
     return 1
   }
   const { query, mode, max } = parseGrepArgs(rest)

package/lib/hydrate.mjs

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

package/lib/imessage_send.mjs

@@ -1,5 +1,5 @@
 // send_imessage — outbound iMessage via Messages.app. This is a personal automation, NOT org
-// intelligence: it writes nothing to Cortex. Three layers of safety (eng-review D3/D6/D10):
+// intelligence: it writes nothing to Agnoclast. Three layers of safety (eng-review D3/D6/D10):
 //   D6  argv-safe: recipient + body are passed as osascript `on run argv` arguments, NEVER
 //       interpolated into the script source → no AppleScript injection, no quote/newline breakage.
 //   D3  draft-by-default: nothing sends unless the caller explicitly passes send:true.

package/lib/ingest_folder.mjs

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

package/lib/install.mjs

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

package/lib/redact.mjs

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

package/lib/resolve.mjs

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