@theronap/cortex-mcp 0.9.76 → 0.9.78

package/bin/cortex-mcp.mjs

@@ -49,10 +49,11 @@ if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
     `  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` +
+    `  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 Agnoclast authoring (used by /cortex-author-docs)\n` +
-    `  graphify-sync [path]  rebuild the local code graph (graphify) + log an evidence-tier timeline event\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` +
@@ -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') {
@@ -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/diagnose.mjs

@@ -90,10 +90,19 @@ 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
@@ -120,6 +129,25 @@ export function classify(status, contentType, bodyText, requestId) {
         `Vercel firewall / deployment protection on the API route. Re-running setup will not help.${rid}`,
     }
   }
+  // A brain-choice refusal is ANSWERABLE, so it must arrive as the question it is rather than as a
+  // code. Deliberately narrow: only these two errors reshape the message, so every other classify()
+  // output keeps its existing wording (and its tests).
+  if (isJson && (appError === 'brain_required' || appError === 'unknown_brain') && (appMessage || appBrains)) {
+    const list = (appBrains ?? []).map((b) => {
+      const pages = typeof b?.pageCount === 'number' ? ` — ${b.pageCount} page${b.pageCount === 1 ? '' : 's'}` : ''
+      const titles = Array.isArray(b?.sampleTitles) && b.sampleTitles.length
+        ? `: ${b.sampleTitles.slice(0, 2).join('; ')}` : ''
+      // Name AND id: brain names are NOT unique (one account holds two called "Personal"), so a name
+      // alone can come back as unknown_brain. The id always resolves.
+      return `  - ${b?.name ?? '(unnamed)'}${pages}${titles}${b?.orgId ? ` [${b.orgId}]` : ''}`
+    })
+    return {
+      kind: 'app', retriable: false,
+      message: `Agnoclast API ${status}: ${appMessage ?? appError}${list.length ? `\n${list.join('\n')}` : ''}` +
+        `\nRe-run this tool with \`brain\` set to one of the names or ids above.${rid}`,
+    }
+  }
+
   return {
     kind: 'app', retriable: status >= 500,
     message: `Agnoclast API ${status}: ${appError ?? 'unknown error'}.${appHint ? ` ${appHint}` : ''}${rid}`,
@@ -207,12 +235,19 @@ 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.

package/lib/doctor.mjs

@@ -11,7 +11,10 @@ import { checkToken, checkSkills, resolveBase } from './diagnose.mjs'
 
 // 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)) {
@@ -39,6 +42,16 @@ export async function runStatus() {
   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(`Agnoclast: connected — sessions on this machine are captured to your org${n}.`)
     } else {

package/lib/editors/claude.mjs

@@ -41,7 +41,8 @@ export const CORTEX_ALLOWED_TOOLS = [
 /** 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
@@ -105,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

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,11 +107,22 @@ 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()

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

package/lib/server.mjs

@@ -137,6 +137,53 @@ export async function runServer(version) {
     },
   )
 
+  // Where this machine's unattended session captures land. The server half shipped 2026-08-09 with no
+  // client surface at all, so the only way to set it was a hand-written authenticated HTTP call —
+  // which meant three real users whose sessions were silently being held could not fix it themselves.
+  // This is the surface that makes it answerable in conversation: "put my sessions in TTO".
+  server.registerTool(
+    'set_capture_brain',
+    {
+      title: 'Choose where your session captures are saved',
+      description:
+        'Set which brain THIS PERSON\'s unattended session captures (the automatic end-of-session record) land in, or read the current setting by omitting `brain`. WHEN TO USE: whenever the user says their sessions are not being saved, asks where their work is going, or a session-start notice says captures are being HELD. WHY IT IS NEEDED: with more than one brain, a capture that names no brain cannot be routed and is held outside every brain — correct, but invisible, so it accumulates silently. This is per-PERSON and applies to their own captures only; it cannot be set for someone else. ⚠ PASS THE ORG ID when the user has two brains with the SAME NAME (e.g. two called "Personal") — a name matching more than one is REFUSED rather than guessed, and the error lists the ids to choose from. Setting this does NOT file already-held captures; those keep their original dates and may belong in different brains, so sort them deliberately rather than dumping them into the new default.',
+      inputSchema: {
+        brain: z.string().optional().describe('the brain name or org id (from my_brains) where this person\'s session captures should land. Omit to read the current setting instead of changing it.'),
+      },
+    },
+    async ({ brain }) => {
+      const url = `${BASE}/api/brain/capture-default`
+      if (!brain?.trim()) {
+        const res = await fetchCortex(url, { headers: { Authorization: `Bearer ${TOKEN}` } })
+        if (!res.ok) {
+          const body = await res.text()
+          throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
+        }
+        const { defaults } = await res.json()
+        if (!defaults?.length) {
+          return { content: [{ type: 'text', text: 'No capture brain is set. If you belong to more than one brain, your session captures are being HELD outside every brain until you set one. Call this tool again with `brain` to fix it.' }] }
+        }
+        const lines = defaults.map((d) => `${d.sourceType} captures land in "${d.orgName}" (${d.orgId}), set ${String(d.updatedAt).slice(0, 10)}`)
+        return { content: [{ type: 'text', text: lines.join('\n') }] }
+      }
+      const res = await fetchCortex(url, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sourceType: 'claude-code', brain: brain.trim() }),
+      })
+      const body = await res.text()
+      if (!res.ok) {
+        // Prefer the server's own error: a 409 lists the org ids of an ambiguous name, which IS the
+        // remedy, and a generic classification would throw that away.
+        let msg
+        try { msg = JSON.parse(body).error } catch { /* fall through to the classified message */ }
+        throw new Error(msg ?? classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
+      }
+      const j = JSON.parse(body)
+      return { content: [{ type: 'text', text: `✓ Your Claude Code sessions now land in "${j.brain}" (${j.orgId}). Sessions captured before now are still held and keep their original dates — file those deliberately, they may not all belong in this brain.` }] }
+    },
+  )
+
   // T8: cortex-log's authoritative writer. The skill composes a curated summary, then calls this to
   // persist it AS the durable record (capture_source='skill'). The ingest conflict guard ensures the
   // auto-capture hook never clobbers it. Pass the SAME sessionId the hook uses so the two dedupe onto
@@ -892,13 +939,15 @@ export async function runServer(version) {
     'writing_style',
     {
       title: 'How the user writes (for drafting in their voice)',
-      description: 'Returns the user\'s saved writing-style profile so you can DRAFT in their voice (email, message, doc). Call this right before composing anything on their behalf. Self-only — it is always the calling user\'s own profile. If none is saved, it tells you to derive one and save it with set_writing_style.',
-      inputSchema: {},
+      description: 'Returns the user\'s saved writing-style profile so you can DRAFT in their voice (email, message, doc). Call this right before composing anything on their behalf. Self-only — it is always the calling user\'s own profile. If none is saved, it tells you to derive one and save it with set_writing_style. A profile is stored per (user, BRAIN) — it is injected into authoring IN a brain — so if you hold several, name the one you are drafting in.',
+      inputSchema: {
+        brain: z.string().optional().describe('which brain\'s style profile, by name or org id. Unnecessary when you only have one brain; pass the org id when a name matches more than one of yours'),
+      },
     },
-    async () => {
+    async ({ brain } = {}) => {
       let res
       try {
-        res = await fetchCortex(`${BASE}/api/style`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+        res = await fetchCortex(`${BASE}/api/style${brain ? `?brain=${encodeURIComponent(brain)}` : ''}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
       } catch (e) {
         return toolError(`Could not load writing style: ${e.message}`)
       }
@@ -916,12 +965,15 @@ export async function runServer(version) {
     {
       title: 'Save the user\'s writing-style profile',
       description: 'Save (or update) a description of HOW the user writes — tone, sentence rhythm, structure, formatting habits, signature quirks — derived from prose you have seen them write this session. Store the STYLE, never their private content. Self-only: it always updates the calling user\'s own profile. Pass an empty string to clear it.',
-      inputSchema: { style_md: z.string().describe('a concise markdown description of the user\'s writing voice (tone/structure/quirks), ~1-2 paragraphs') },
+      inputSchema: {
+        style_md: z.string().describe('a concise markdown description of the user\'s writing voice (tone/structure/quirks), ~1-2 paragraphs'),
+        brain: z.string().optional().describe('which brain to save the profile in, by name or org id. A profile is stored per (user, brain), so this is a real choice when you hold several; pass the org id when a name matches more than one of yours'),
+      },
     },
-    async ({ style_md }) => {
+    async ({ style_md, brain }) => {
       let res
       try {
-        res = await fetchCortex(`${BASE}/api/style`, {
+        res = await fetchCortex(`${BASE}/api/style${brain ? `?brain=${encodeURIComponent(brain)}` : ''}`, {
           method: 'PUT',
           headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
           body: JSON.stringify({ style_md }),
@@ -1159,7 +1211,7 @@ export async function runServer(version) {
     'list_brain_pages',
     {
       title: 'List every authored page in one brain',
-      description: 'Enumerate ALL authored pages in ONE brain, by its org id (from my_brains). Unlike my_brains — which ships only a count plus a few sample titles — this returns the FULL page list: one row per node with its kind, validity, tier(s), last-updated date and content hash. Use it to audit a brain, or to VERIFY a brain-to-brain migration — list BOTH brains, diff the page sets, and compare freshness before retiring any original. You can only list a brain you are a member of; reads never widen past your own brains.',
+      description: 'Enumerate ALL authored pages in ONE brain, by its org id (from my_brains). Unlike my_brains — which ships only a count plus a few sample titles — this returns the FULL page list: one row per node with its kind, validity, tier(s), last-updated date and content hash. Use it to audit a brain, or to VERIFY a brain-to-brain migration — list BOTH brains, diff the page sets, and compare freshness before retiring any original. You can only list a brain you are a member of, and within it you see only the pages you are cleared to read — a confidential page owned by someone else is not listed, not even by title.',
       inputSchema: {
         org_id: z.string().describe('the org id of the brain to enumerate (from my_brains)'),
       },

package/lib/setup.mjs

@@ -128,8 +128,9 @@ export async function runSetup(argv, version) {
       process.exit(1)
     }
     const bak = backup(settingsJson)
-    // Capture (Stop) + status/skills/snapshot (SessionStart) + precompact (PreCompact), idempotent
-    // merge — the same pure function the `cortex install` Claude adapter uses.
+    // Capture (Stop) + status/skills/snapshot (SessionStart) + hydrate (UserPromptSubmit), idempotent
+    // merge — the same pure function the `cortex install` Claude adapter uses. Also unwires the retired
+    // PreCompact reminder from seats that still carry it.
     s = mergeClaudeSettings(s, spec)
 
     ensureDir(settingsJson)

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.76",
+  "version": "0.9.78",
   "description": "Connect your AI assistant to Cortex — your org's projects, activity, gaps, and directives, scoped to you.",
   "type": "module",
   "bin": {

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(
-    'Agnoclast: 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',
-  )
-}