@theronap/agnoclast-mcp 0.9.261 → 0.9.262

package/bin/cortex-mcp.mjs

@@ -106,6 +106,7 @@ 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` +
+    `  channel [stable|latest]  which npm dist-tag this machine's hooks + MCP follow (no arg = show; recorded in ~/.cortex/config.json)\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` +
@@ -169,6 +170,12 @@ if (cmd === 'login') {
   process.exitCode = await runDoctor()
   const { closeFetch } = await import('../lib/diagnose.mjs')
   await closeFetch()
+} else if (cmd === 'channel') {
+  // Which dist-tag this machine follows: `channel latest` (dogfood) / `channel stable` (everyone's
+  // default) / no arg = report. Recorded in ~/.cortex/config.json; every writer of hooks and MCP
+  // entries honours it (lib/channel.mjs). File-only, no network, no token needed.
+  const { runChannel } = await import('../lib/channel.mjs')
+  process.exitCode = runChannel(rest)
 } else if (cmd === 'status') {
   // One-line SessionStart health signal (wired by setup). Always exit 0.
   const { runStatus } = await import('../lib/doctor.mjs')

package/lib/channel.mjs

@@ -0,0 +1,277 @@
+// Which npm dist-tag THIS MACHINE's Agnoclast wiring follows: `@stable` (everyone, the default) or
+// `@latest` (a dogfooding machine that wants every publish the moment it lands).
+//
+// 🔴 WHY THIS IS AN EXPLICIT SETTING AND NOT AN INFERENCE ANY MORE (2026-10-23).
+// Until now the channel was inferred from what was already wired (diagnose.mjs wiredDistTag): "if the
+// MCP entry says @latest, keep @latest". Every writer — setup, repair, install, the desktop app's
+// self-heal (which runs setup) — re-derived it from the config it was about to overwrite. That chain
+// broke silently on Theron's own Mac: the inference read `mcpServers.cortex` only, the ADR-0033 C2
+// flip had moved his @latest entry to `mcpServers.agnoclast`, setup then re-created a `cortex` entry
+// at @stable beside it, and from then on every heal read "stable" and wrote @stable into all five
+// managed hooks. He believed he was on @latest; every hook change published that day never reached
+// him. An inference whose input is its own previous output cannot be trusted to hold a decision.
+//
+// So the decision is RECORDED, once, by a person: `cortex-mcp channel latest`. It lives in
+// ~/.cortex/config.json, which no writer of hooks or MCP entries ever writes to. Every writer asks
+// resolveChannel() and gets the recorded answer first; the wired inference is only the fallback for
+// machines that never chose. Default is stable, for everyone who never ran the command.
+import { homedir } from 'node:os'
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { wiredDistTag } from './diagnose.mjs'
+import { isManagedCommand } from './managed.mjs'
+import { backupFile } from './editors/_fsutil.mjs'
+
+export const CHANNELS = ['stable', 'latest']
+export const DEFAULT_CHANNEL = 'stable'
+const PKG = '@theronap/cortex-mcp'
+
+/** Where the per-machine choice lives. ~/.cortex is the directory this package already owns. */
+export const channelConfigPath = (home = homedir()) => join(home, '.cortex', 'config.json')
+
+/** The command a person runs to choose. Run it through @latest so it works even from a @stable seat. */
+export const channelCommand = (channel) => `npx -y ${PKG}@latest channel ${channel}`
+
+const isChannel = (c) => CHANNELS.includes(c)
+
+/** The recorded choice, or null if this machine never chose. Never throws. */
+export function readChannelSetting(home = homedir()) {
+  try {
+    const p = channelConfigPath(home)
+    if (!existsSync(p)) return null
+    const c = JSON.parse(readFileSync(p, 'utf8') || '{}')?.channel
+    return isChannel(c) ? c : null
+  } catch {
+    return null
+  }
+}
+
+/** Record the choice. Preserves any other keys in config.json. Throws on a bad channel. */
+export function writeChannelSetting(channel, home = homedir()) {
+  if (!isChannel(channel)) throw new Error(`channel must be one of: ${CHANNELS.join(', ')}`)
+  const p = channelConfigPath(home)
+  let cfg = {}
+  try { if (existsSync(p)) cfg = JSON.parse(readFileSync(p, 'utf8') || '{}') ?? {} } catch { cfg = {} }
+  if (typeof cfg !== 'object' || Array.isArray(cfg)) cfg = {}
+  cfg.channel = channel
+  mkdirSync(dirname(p), { recursive: true })
+  writeFileSync(p, JSON.stringify(cfg, null, 2) + '\n')
+  return p
+}
+
+/**
+ * The channel this machine follows, and why. Every writer of hooks / MCP entries calls this.
+ *   source 'config'  — recorded with `channel`; authoritative, nothing overrides it
+ *   source 'wired'   — no record, but an MCP entry is deliberately on @latest (legacy dogfood pin)
+ *   source 'default' — no record, nothing on @latest: stable
+ */
+export function resolveChannel({ home = homedir(), wired } = {}) {
+  const set = readChannelSetting(home)
+  if (set) return { channel: set, source: 'config' }
+  const w = wired === undefined ? wiredDistTag(home) : wired
+  if (w === 'latest') return { channel: 'latest', source: 'wired' }
+  return { channel: DEFAULT_CHANNEL, source: 'default' }
+}
+
+/** The package spec for a channel. Always a moving tag, never a bare spec or a frozen version. */
+export function specFor(channel, pkg = PKG) {
+  return channel === 'latest' ? `${pkg}@latest` : `${pkg}@stable`
+}
+
+/** Convenience: the spec every writer should wire on this machine. */
+export function channelSpec({ home = homedir(), wired } = {}) {
+  return specFor(resolveChannel({ home, wired }).channel)
+}
+
+// ── What is actually wired, and what disagrees ───────────────────────────────────────────────────
+//
+// Only moving TAGS are compared. A version-floored range (`@^0.9.177`, the arrivals-notice hook —
+// see editors/claude.mjs for why it does not follow `spec`) is deliberate and is never "wrong".
+
+const TAG_RE = /@theronap\/(?:cortex|agnoclast)-mcp@(stable|latest)(?![\w.-])/
+const TAG_RE_G = /(@theronap\/(?:cortex|agnoclast)-mcp@)(stable|latest)(?![\w.-])/g
+
+const tagOf = (s) => (String(s ?? '').match(TAG_RE) || [])[1] ?? null
+
+function readJsonSoft(p) {
+  try { return existsSync(p) ? JSON.parse(readFileSync(p, 'utf8') || '{}') : null } catch { return null }
+}
+
+/** Short name for a hook command: the subcommand after the spec ("capture", "skills"). */
+function hookLabel(cmd) {
+  const m = String(cmd).match(/-mcp@\S+\s+([a-z][\w-]*)/)
+  return m ? m[1] : 'hook'
+}
+
+/**
+ * Every Agnoclast entry on this machine that names a moving tag: [{ file, what, tag }].
+ * File reads only — no network — so it is cheap enough for the SessionStart `status` hook.
+ */
+export function wiredEntries(home = homedir()) {
+  const out = []
+  const claudeJson = join(home, '.claude.json')
+  const cfg = readJsonSoft(claudeJson)
+  for (const key of ['agnoclast', 'cortex']) {
+    const e = cfg?.mcpServers?.[key]
+    const tag = e ? tagOf([e.command, ...(e.args ?? [])].join(' ')) : null
+    if (tag) out.push({ file: claudeJson, what: `MCP server "${key}"`, tag })
+  }
+  const settingsJson = join(home, '.claude', 'settings.json')
+  const s = readJsonSoft(settingsJson)
+  for (const [event, groups] of Object.entries(s?.hooks ?? {})) {
+    for (const g of Array.isArray(groups) ? groups : []) {
+      for (const h of g?.hooks ?? []) {
+        if (!isManagedCommand(h?.command)) continue
+        const tag = tagOf(h.command)
+        if (tag) out.push({ file: settingsJson, what: `${event} hook "${hookLabel(h.command)}"`, tag })
+      }
+    }
+  }
+  const codexToml = join(home, '.codex', 'config.toml')
+  try {
+    if (existsSync(codexToml)) {
+      const tag = tagOf(readFileSync(codexToml, 'utf8'))
+      if (tag) out.push({ file: codexToml, what: 'Codex MCP server', tag })
+    }
+  } catch { /* unreadable → not reported */ }
+  const codexHooks = join(home, '.codex', 'hooks.json')
+  const ch = readJsonSoft(codexHooks)
+  for (const [event, groups] of Object.entries(ch?.hooks ?? {})) {
+    for (const g of Array.isArray(groups) ? groups : []) {
+      for (const h of g?.hooks ?? []) {
+        const tag = isManagedCommand(h?.command) ? tagOf(h.command) : null
+        if (tag) out.push({ file: codexHooks, what: `Codex ${event} hook "${hookLabel(h.command)}"`, tag })
+      }
+    }
+  }
+  const cursorJson = join(home, '.cursor', 'mcp.json')
+  const cur = readJsonSoft(cursorJson)
+  for (const key of ['agnoclast', 'cortex']) {
+    const e = cur?.mcpServers?.[key]
+    const tag = e ? tagOf([e.command, ...(e.args ?? [])].join(' ')) : null
+    if (tag) out.push({ file: cursorJson, what: `Cursor MCP server "${key}"`, tag })
+  }
+  return out
+}
+
+/** The wired entries whose tag is not `channel`. */
+export function disagreements(channel, home = homedir()) {
+  return wiredEntries(home).filter((e) => e.tag !== channel)
+}
+
+/**
+ * Lines for `status` (SessionStart) and `channel` (no args). SILENT for the common case — a default
+ * stable seat whose wiring agrees — because status is re-read on every turn of every session and a
+ * line that is always true is noise. It speaks when the machine follows @latest (so the person can see
+ * the choice held) and whenever anything disagrees (so a demotion can never be silent again).
+ */
+export function channelStatusLines(home = homedir(), { verbose = false } = {}) {
+  const { channel, source } = resolveChannel({ home })
+  const bad = disagreements(channel, home)
+  const lines = []
+  const why = source === 'config' ? 'set on this machine' : source === 'wired' ? 'inferred from the MCP entry — not recorded' : 'default'
+  if (verbose || channel !== DEFAULT_CHANNEL || source === 'config' || bad.length) {
+    lines.push(`Agnoclast: channel @${channel} (${why}).`)
+  }
+  if (bad.length) {
+    const list = bad.map((b) => `${b.what} → @${b.tag}`).join(', ')
+    lines.push(`Agnoclast: ⚠ ${bad.length} entr${bad.length === 1 ? 'y' : 'ies'} not on @${channel}: ${list}. Fix: ${channelCommand(channel)}`)
+  }
+  return lines
+}
+
+// ── Applying a choice to what is already wired ───────────────────────────────────────────────────
+
+/** PURE. Rewrite every moving tag of our package in a string to `channel`. Ranges/versions untouched. */
+export function respecText(text, channel) {
+  return String(text ?? '').replace(TAG_RE_G, (_, pre) => `${pre}${channel}`)
+}
+
+/** PURE. Settings/hooks object with every MANAGED hook command re-tagged. Unmanaged hooks untouched. */
+export function respecHooks(obj, channel) {
+  let n = 0
+  for (const groups of Object.values(obj?.hooks ?? {})) {
+    for (const g of Array.isArray(groups) ? groups : []) {
+      for (const h of g?.hooks ?? []) {
+        if (!isManagedCommand(h?.command)) continue
+        const next = respecText(h.command, channel)
+        if (next !== h.command) { h.command = next; n++ }
+      }
+    }
+  }
+  return n
+}
+
+/** PURE. mcpServers object with our entries (agnoclast/cortex) re-tagged. Token/env untouched. */
+export function respecMcp(cfg, channel) {
+  let n = 0
+  for (const key of ['agnoclast', 'cortex']) {
+    const e = cfg?.mcpServers?.[key]
+    if (!e || !Array.isArray(e.args)) continue
+    const next = e.args.map((a) => (typeof a === 'string' ? respecText(a, channel) : a))
+    if (next.some((a, i) => a !== e.args[i])) { e.args = next; n++ }
+  }
+  return n
+}
+
+/**
+ * Re-tag everything already wired on this machine to `channel`, in place, backing up each file it
+ * changes. Touches ONLY our entries' tags — no token rewrite, no skills install, no network — so it
+ * is safe to run from any version. Returns [{ file, changed }].
+ */
+export function applyChannel(channel, home = homedir()) {
+  const results = []
+  const edit = (file, mutate) => {
+    const obj = readJsonSoft(file)
+    if (!obj) return
+    const n = mutate(obj)
+    if (n > 0) {
+      backupFile(file)
+      writeFileSync(file, JSON.stringify(obj, null, 2))
+      results.push({ file, changed: n })
+    }
+  }
+  edit(join(home, '.claude.json'), (o) => respecMcp(o, channel))
+  edit(join(home, '.claude', 'settings.json'), (o) => respecHooks(o, channel))
+  edit(join(home, '.codex', 'hooks.json'), (o) => respecHooks(o, channel))
+  edit(join(home, '.cursor', 'mcp.json'), (o) => respecMcp(o, channel))
+  const codexToml = join(home, '.codex', 'config.toml')
+  try {
+    if (existsSync(codexToml)) {
+      const before = readFileSync(codexToml, 'utf8')
+      const after = respecText(before, channel)
+      if (after !== before) {
+        backupFile(codexToml)
+        writeFileSync(codexToml, after)
+        results.push({ file: codexToml, changed: 1 })
+      }
+    }
+  } catch { /* unreadable toml: leave it, status will keep reporting it */ }
+  return results
+}
+
+/** `cortex-mcp channel [stable|latest]`. No argument = report. Returns an exit code. */
+export function runChannel(argv = [], { home = homedir(), out = (m) => process.stdout.write(m + '\n') } = {}) {
+  const want = (argv ?? []).find((a) => !String(a).startsWith('-'))
+  if (!want) {
+    for (const l of channelStatusLines(home, { verbose: true })) out(l)
+    const entries = wiredEntries(home)
+    for (const e of entries) out(`  ${e.tag === resolveChannel({ home }).channel ? '✓' : '✗'} ${e.what} @${e.tag}  (${e.file})`)
+    if (!entries.length) out('  (nothing wired on this machine)')
+    out(`Switch: ${channelCommand('latest')}   ·   back to everyone's channel: ${channelCommand('stable')}`)
+    return 0
+  }
+  if (!isChannel(want)) {
+    process.stderr.write(`Usage: npx -y ${PKG}@latest channel [stable|latest]\n`)
+    return 1
+  }
+  const p = writeChannelSetting(want, home)
+  out(`✓ This machine now follows @${want} — recorded in ${p}. setup, repair, install and the desktop app all honour it.`)
+  const changed = applyChannel(want, home)
+  for (const c of changed) out(`  ✓ re-tagged ${c.changed} entr${c.changed === 1 ? 'y' : 'ies'} → @${want} in ${c.file} (backup saved)`)
+  if (!changed.length) out('  (every wired entry was already on that channel)')
+  const left = disagreements(want, home)
+  for (const l of left) out(`  ⚠ still @${l.tag}: ${l.what} (${l.file})`)
+  out('⟳ Fully quit and reopen Claude Code so the MCP server restarts on the new channel.')
+  return left.length ? 1 : 0
+}

package/lib/diagnose.mjs

@@ -103,8 +103,9 @@ export function readWiredToken(home = homedir()) {
 
 // Pure: pull the cortex-mcp dist-tag / version out of a wired command line. Exported for tests.
 // Returns 'latest' | 'stable' | a version string (e.g. '0.9.4') | null (no cortex-mcp spec present).
+// Both published names (ADR-0033): a seat may be wired to either.
 export function parseDistTag(line) {
-  const m = String(line || '').match(/@theronap\/cortex-mcp@(latest|stable|[0-9][^\s"']*)/)
+  const m = String(line || '').match(/@theronap\/(?:cortex|agnoclast)-mcp@(latest|stable|[0-9][^\s"']*)/)
   return m ? m[1] : null
 }
 
@@ -112,11 +113,23 @@ export function parseDistTag(line) {
 // command), so a re-run of setup/repair can PRESERVE an intentional channel instead of forcing @stable
 // every time — that silently knocks a dogfooder on @latest back to the pilot channel (bit Theron
 // 2026-07-24). Returns 'latest' | 'stable' | a version string | null (nothing wired yet).
-export function wiredDistTag() {
+//
+// ⚠ BOTH CONFIG KEYS, AND @latest WINS (fixed 2026-10-23). This read `mcpServers.cortex` only. ADR-0033
+// C2 moved the entry to `mcpServers.agnoclast`, so on a migrated machine it found nothing — or, worse,
+// found a `cortex` entry that setup itself had re-created at @stable next to the @latest `agnoclast`
+// one — and every repair/desktop heal wrote @stable into the hooks. That is how Theron's own machine,
+// which he had deliberately put on @latest, was quietly following @stable. An explicit per-machine
+// setting (lib/channel.mjs, `~/.cortex/config.json`) now outranks this inference entirely; this is
+// only the fallback for machines that never ran `channel`.
+export function wiredDistTag(home = homedir()) {
   try {
-    const cfg = JSON.parse(readFileSync(join(homedir(), '.claude.json'), 'utf8'))
-    const c = cfg?.mcpServers?.cortex
-    return parseDistTag([c?.command, ...(c?.args ?? [])].filter(Boolean).join(' '))
+    const cfg = JSON.parse(readFileSync(join(home, '.claude.json'), 'utf8'))
+    const tags = ['agnoclast', 'cortex'].map((k) => {
+      const c = cfg?.mcpServers?.[k]
+      return c ? parseDistTag([c?.command, ...(c?.args ?? [])].filter(Boolean).join(' ')) : null
+    })
+    if (tags.includes('latest')) return 'latest'
+    return tags.find((t) => t) ?? null
   } catch { /* fall through */ }
   return null
 }

package/lib/doctor.mjs

@@ -7,6 +7,7 @@ import { detectSurface, renderSurface } from './surface.mjs'
 import { queueDir, queueStatus, renderQueueNotice } from './capture_queue.mjs'
 import { pendingNotice, renderReportNotice } from './report_spool.mjs'
 import { compactNotice } from './session_start_compact.mjs'
+import { channelStatusLines } from './channel.mjs'
 
 /** ADR-0070 §5: issue reports filed in the BACKGROUND since the last session start. A background
  *  auto-file had no turn to tell anyone in, so this is where the person hears about it. Consumes the
@@ -58,6 +59,9 @@ export async function runStatus(opts = {}) {
   } finally {
     for (const line of queueLines) out(line)
     for (const line of reportLines) out(line)
+    // Which dist-tag this machine follows, and anything wired that disagrees. Silent on a default
+    // stable seat that agrees (lib/channel.mjs) — a demotion off @latest is never silent again.
+    try { for (const line of channelStatusLines(opts.home)) out(line) } catch { /* never break status */ }
     const surface = renderSurface(detectSurface(process.env), 'status')
     if (surface) out(surface)
   }

package/lib/editors/claude.mjs

@@ -7,12 +7,23 @@ import { join } from 'node:path'
 import { readJson, backupFile, ensureDir, writeJson } from './_fsutil.mjs'
 import { markCommand, isManagedSubcommand } from '../managed.mjs'
 
-/** Merge the Agnoclast MCP server into a ~/.claude.json object. Pure + idempotent: sets only the
- *  `cortex` entry (type:'stdio'), preserves every other server. `spec` = the package@dist-tag string. */
+/** Merge the Agnoclast MCP server into a ~/.claude.json object. Pure + idempotent: sets only OUR
+ *  entry (type:'stdio'), preserves every other server. `spec` = the package@dist-tag string.
+ *
+ *  ⚠ WHICH KEY: the one already there. ADR-0033 C2 (`migrate-key`) moves `cortex` → `agnoclast`. This
+ *  used to write `cortex` unconditionally, so a re-run of setup on a migrated machine RE-CREATED a
+ *  `cortex` entry beside the `agnoclast` one: two Agnoclast servers, and the new one at whatever tag
+ *  setup picked — which is how Theron's machine ended up with `agnoclast`@latest and `cortex`@stable
+ *  (2026-10-23). Now: update whichever of the two keys exist; only a machine with neither gets
+ *  `cortex` (fresh installs are still pre-C2). Never deletes a key — removing a duplicate is the
+ *  person's call, not a side effect of setup. */
 export function mergeClaudeMcp(existing, spec, token) {
   const cfg = existing && typeof existing === 'object' ? { ...existing } : {}
   cfg.mcpServers = cfg.mcpServers && typeof cfg.mcpServers === 'object' ? { ...cfg.mcpServers } : {}
-  cfg.mcpServers.cortex = { type: 'stdio', command: 'npx', args: ['-y', spec], env: { CORTEX_TOKEN: token } }
+  const keys = ['agnoclast', 'cortex'].filter((k) => cfg.mcpServers[k])
+  for (const k of keys.length ? keys : ['cortex']) {
+    cfg.mcpServers[k] = { type: 'stdio', command: 'npx', args: ['-y', spec], env: { CORTEX_TOKEN: token } }
+  }
   return cfg
 }
 

package/lib/install.mjs

@@ -7,9 +7,9 @@ import { homedir } from 'node:os'
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs'
 import { join, dirname } from 'node:path'
 import { ADAPTERS, resolveEditors } from './editors/index.mjs'
-import { checkToken, resolveBase, readWiredToken, wiredDistTag } from './diagnose.mjs'
+import { checkToken, resolveBase, readWiredToken } from './diagnose.mjs'
+import { channelSpec } from './channel.mjs'
 
-const PKG = '@theronap/cortex-mcp'
 export const MANIFEST_PATH = join(homedir(), '.cortex', 'editors.json')
 
 /** Parse install argv: an optional positional <token> + `--editor auto|all|<id,...>` (also `--all`,
@@ -70,7 +70,8 @@ export async function runInstall(argv, version) {
   const token = argToken || readWiredToken()
   // Preserve an intentional @latest (dogfood) pin across re-runs; fresh installs + existing @stable
   // get @stable. See wiredDistTag — forcing @stable here silently demoted a dogfooder (2026-07-24).
-  const spec = wiredDistTag() === 'latest' ? `${PKG}@latest` : `${PKG}@stable`
+  // A recorded per-machine channel (lib/channel.mjs) outranks that inference.
+  const spec = channelSpec()
   const home = homedir()
   const log = (m) => process.stdout.write(m + '\n')
 

package/lib/setup.mjs

@@ -1,7 +1,8 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync } from 'fs'
 import { homedir } from 'os'
 import { join, dirname } from 'path'
-import { checkToken, resolveBase, readWiredToken, wiredDistTag } from './diagnose.mjs'
+import { checkToken, resolveBase, readWiredToken } from './diagnose.mjs'
+import { resolveChannel } from './channel.mjs'
 import { installSkills } from './skills.mjs'
 // Pure config-merge functions live in the editor adapters; setup imports (and re-exports) THE SAME
 // functions the `cortex install` path uses, so both write byte-identical config.
@@ -28,6 +29,12 @@ export function pickSpec(distTag, pkg = PKG) {
   return distTag === 'latest' ? `${pkg}@latest` : `${pkg}@stable`
 }
 
+// The spec setup/repair (and so the desktop app, which runs setup) wires on this machine: the
+// recorded channel first, then the wired @latest inference, then @stable. Exported for tests.
+export function setupSpec({ home } = {}) {
+  return pickSpec(resolveChannel({ home }).channel)
+}
+
 // PURE, exported for tests. Returns { token } or { error } — the caller owns process.exit, so the
 // validation itself is reachable from a test runner.
 export function parseSetupArgs(argv, pkg = PKG) {
@@ -68,7 +75,9 @@ export async function runSetup(argv, version) {
   //   npm dist-tag add @theronap/cortex-mcp@<version> stable
   // PRESERVE an intentional @latest (dogfood) pin across re-runs (repair/setup) — otherwise this
   // silently knocks a dogfooder back to @stable. Fresh installs and existing @stable get @stable.
-  const spec = pickSpec(wiredDistTag())
+  // The machine's RECORDED channel (`cortex-mcp channel latest`, ~/.cortex/config.json) outranks the
+  // wired inference — see lib/channel.mjs for the demotion that made inference alone untrustworthy.
+  const spec = setupSpec()
   const base = resolveBase(process.env.CORTEX_URL)
   const home = homedir()
   const claudeJson = join(home, '.claude.json')

package/package.json

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