@theronap/cortex-mcp 0.9.95 → 0.9.96

package/lib/uninstall.mjs

@@ -2,10 +2,12 @@ import { readFileSync, writeFileSync, existsSync, copyFileSync, rmSync } from 'f
 import { homedir } from 'os'
 import { join } from 'path'
 import { execFileSync } from 'child_process'
+import { isManagedCommand } from './managed.mjs'
 
 // 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
+//   1. ~/.claude.json          → mcpServers.cortex / .agnoclast
+//   1b. ~/.cursor/mcp.json     → same shape (editors/cursor.mjs writes it; was never removed)
+//   2. ~/.claude/settings.json → Stop/SessionStart/UserPromptSubmit/PreCompact hooks + allow rules
 //   3. ~/.codex/config.toml    → [mcp_servers.cortex] + [mcp_servers.cortex.env]
 //   4. ~/.codex/hooks.json     → cortex capture Stop hook
 //   5. managed skills          → ~/.claude/skills/cortex* + ~/.codex/skills/cortex*
@@ -15,17 +17,21 @@ import { execFileSync } from 'child_process'
 //   --purge also removes: ~/.cortex state dir, the npx cache, and every .cortex-bak backup.
 //
 // Safe by construction: --dry-run prints the plan and changes nothing; every JSON/TOML file is backed
-// up to <file>.cortex-uninstall-bak before edit; JSON surgery filters only cortex-tagged entries and
-// leaves every other MCP server / hook untouched. Idempotent — re-running is a no-op.
+// up to <file>.cortex-uninstall-bak before edit; JSON surgery filters only entries we wrote (see
+// managed.mjs — marker first, legacy name match second) and leaves every other MCP server / hook
+// untouched. Idempotent — re-running is a no-op.
 
 const HOME = homedir()
 const CLAUDE_JSON = join(HOME, '.claude.json')
 const SETTINGS = join(HOME, '.claude', 'settings.json')
 const CODEX_TOML = join(HOME, '.codex', 'config.toml')
 const CODEX_HOOKS = join(HOME, '.codex', 'hooks.json')
+const CURSOR_JSON = join(HOME, '.cursor', 'mcp.json')
 const CORTEX_DIR = join(HOME, '.cortex')
 const LAUNCH_AGENTS = join(HOME, 'Library', 'LaunchAgents')
-const CORTEX_RE = /cortex-mcp|capture-session-cloud|@theronap\/cortex/
+// Hook events the installer writes (editors/claude.mjs). UserPromptSubmit was MISSING here until
+// 2026-08-19, so every uninstall left the `hydrate` hook behind while reporting success.
+export const MANAGED_HOOK_EVENTS = ['Stop', 'SessionStart', 'UserPromptSubmit', 'PreCompact']
 
 export function runUninstall(argv = []) {
   const dry = argv.includes('--dry-run') || argv.includes('-n')
@@ -36,41 +42,24 @@ export function runUninstall(argv = []) {
 
   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) => {
-    if (cfg.mcpServers && cfg.mcpServers.cortex) { delete cfg.mcpServers.cortex; act(`  - mcpServers.cortex  ← ${CLAUDE_JSON}`); return true }
-    return false
-  }, write)
+  // 1. MCP server out of ~/.claude.json — and 1b, out of ~/.cursor/mcp.json, which uses the same
+  // shape (editors/cursor.mjs:15) and which uninstall never touched until 2026-08-19, so every
+  // `install --editor all` left Cursor permanently wired.
+  for (const path of [CLAUDE_JSON, CURSOR_JSON]) {
+    editJson(path, (cfg) => {
+      const removed = stripManagedMcpServers(cfg)
+      if (removed.length) act(`  - mcpServers.${removed.join(' / ')}  ← ${path}`)
+      return removed.length > 0
+    }, write)
+  }
 
-  // 2. Hooks out of ~/.claude/settings.json (Stop, SessionStart, PreCompact)
+  // 2. Hooks + allow rules out of ~/.claude/settings.json
   editJson(SETTINGS, (s) => {
-    let changed = false
-    for (const evt of ['Stop', 'SessionStart', 'PreCompact']) {
-      if (!Array.isArray(s.hooks?.[evt])) continue
-      for (const grp of s.hooks[evt]) {
-        if (!Array.isArray(grp.hooks)) continue
-        const before = grp.hooks.length
-        grp.hooks = grp.hooks.filter((h) => !CORTEX_RE.test(h?.command ?? ''))
-        if (grp.hooks.length !== before) changed = true
-      }
-      // drop groups we emptied
-      s.hooks[evt] = s.hooks[evt].filter((g) => !Array.isArray(g.hooks) || g.hooks.length > 0)
-      if (s.hooks[evt].length === 0) delete s.hooks[evt]
-    }
-    if (changed) act(`  - Stop/SessionStart/PreCompact cortex hooks  ← ${SETTINGS}`)
-    // cortex permission allowlist (setup wires CORTEX_ALLOWED_TOOLS so authoring never stalls on a
-    // prompt) — strip every mcp__cortex__* allow rule; the user's deny list is never touched.
-    if (Array.isArray(s.permissions?.allow)) {
-      const before = s.permissions.allow.length
-      s.permissions.allow = s.permissions.allow.filter((r) => !/^mcp__cortex__/.test(String(r)))
-      if (s.permissions.allow.length !== before) {
-        changed = true
-        act(`  - mcp__cortex__* permission allow rules  ← ${SETTINGS}`)
-        if (s.permissions.allow.length === 0) delete s.permissions.allow
-        if (Object.keys(s.permissions).length === 0) delete s.permissions
-      }
-    }
-    return changed
+    const hooks = stripManagedHooks(s)
+    const allows = stripManagedAllows(s)
+    if (hooks) act(`  - ${MANAGED_HOOK_EVENTS.join('/')} hooks  ← ${SETTINGS}`)
+    if (allows) act(`  - mcp__cortex__* / mcp__agnoclast__* permission allow rules  ← ${SETTINGS}`)
+    return hooks || allows
   }, write)
 
   // 3. Codex MCP tables (strip [mcp_servers.cortex] + [mcp_servers.cortex.env])
@@ -87,7 +76,7 @@ export function runUninstall(argv = []) {
       for (const grp of h.hooks.Stop) {
         if (!Array.isArray(grp.hooks)) continue
         const before = grp.hooks.length
-        grp.hooks = grp.hooks.filter((c) => !CORTEX_RE.test(c?.command ?? ''))
+        grp.hooks = grp.hooks.filter((c) => !isManagedCommand(c?.command))
         if (grp.hooks.length !== before) changed = true
       }
       h.hooks.Stop = h.hooks.Stop.filter((g) => !Array.isArray(g.hooks) || g.hooks.length > 0)
@@ -98,7 +87,8 @@ export function runUninstall(argv = []) {
 
   // 5. Managed skills
   for (const skillsRoot of [join(HOME, '.claude', 'skills'), join(HOME, '.codex', 'skills')]) {
-    for (const name of ['cortex', 'cortex-author-docs', 'cortex-context', 'cortex-log']) {
+    for (const name of ['cortex', 'cortex-author-docs', 'cortex-context', 'cortex-log', 'cortex-walkthrough',
+                        'agnoclast', 'agnoclast-author-docs', 'agnoclast-context', 'agnoclast-log', 'agnoclast-walkthrough']) {
       const p = join(skillsRoot, name)
       if (existsSync(p)) { act(`  - skill ${p}`); if (!dry) rmSync(p, { recursive: true, force: true }) }
     }
@@ -107,7 +97,7 @@ export function runUninstall(argv = []) {
   // 6. launchd agents (com.cortex.*)
   if (existsSync(LAUNCH_AGENTS)) {
     for (const f of safeReaddir(LAUNCH_AGENTS)) {
-      if (!/^com\.cortex\..*\.plist$/.test(f)) continue
+      if (!/^com\.(cortex|agnoclast)\..*\.plist$/.test(f)) continue
       const p = join(LAUNCH_AGENTS, f)
       act(`  - launchd agent ${p} (unload + remove)`)
       if (!dry) {
@@ -121,7 +111,7 @@ export function runUninstall(argv = []) {
   // 7. crontab — drop cortex-tagged lines
   const cron = tryExecOut('crontab', ['-l'])
   if (cron != null) {
-    const kept = cron.split('\n').filter((l) => !CORTEX_RE.test(l) && !/\.cortex\//.test(l))
+    const kept = cron.split('\n').filter((l) => !isManagedCommand(l) && !/\.cortex\//.test(l))
     if (kept.join('\n') !== cron) {
       act('  - crontab cortex entries')
       if (!dry) tryExecIn('crontab', ['-'], kept.join('\n').replace(/\n+$/, '') + '\n')
@@ -171,10 +161,55 @@ function editJson(path, mutate, write) {
   if (mutate(obj)) write(path, JSON.stringify(obj, null, 2) + '\n')
 }
 
+// PURE. Removes our MCP server entry under EITHER spelling. uninstall.mjs:45 used to delete only
+// `cortex`, so after the Phase C key flip (ADR-0033 §5) the server entry — the single most important
+// thing uninstall removes — would survive a "successful" uninstall. Returns the keys it removed so
+// the caller can report which spelling this machine actually carried.
+export function stripManagedMcpServers(cfg) {
+  const removed = []
+  for (const key of ['cortex', 'agnoclast']) {
+    if (cfg?.mcpServers && cfg.mcpServers[key]) { delete cfg.mcpServers[key]; removed.push(key) }
+  }
+  return removed
+}
+
+// PURE (mutates the passed object, returns whether anything changed) so uninstall's riskiest logic
+// is testable without touching a real filesystem. Empty hook groups and empty events are pruned so
+// a fully-uninstalled settings.json is indistinguishable from one we never touched.
+export function stripManagedHooks(s) {
+  let changed = false
+  for (const evt of MANAGED_HOOK_EVENTS) {
+    if (!Array.isArray(s?.hooks?.[evt])) continue
+    for (const grp of s.hooks[evt]) {
+      if (!Array.isArray(grp.hooks)) continue
+      const before = grp.hooks.length
+      grp.hooks = grp.hooks.filter((h) => !isManagedCommand(h?.command))
+      if (grp.hooks.length !== before) changed = true
+    }
+    s.hooks[evt] = s.hooks[evt].filter((g) => !Array.isArray(g.hooks) || g.hooks.length > 0)
+    if (s.hooks[evt].length === 0) delete s.hooks[evt]
+  }
+  return changed
+}
+
+// Strip every allow rule for OUR tool namespaces. Both spellings: a machine mid-migration can carry
+// mcp__cortex__* and mcp__agnoclast__* at once, because C1 adds the new rules without removing the
+// old ones (ADR-0033 §5). The user's `deny` list is never touched — a user deny always wins.
+export function stripManagedAllows(s) {
+  if (!Array.isArray(s?.permissions?.allow)) return false
+  const before = s.permissions.allow.length
+  s.permissions.allow = s.permissions.allow.filter((r) => !/^mcp__(cortex|agnoclast)__/.test(String(r)))
+  if (s.permissions.allow.length === before) return false
+  if (s.permissions.allow.length === 0) delete s.permissions.allow
+  if (Object.keys(s.permissions).length === 0) delete s.permissions
+  return true
+}
+
 // Strip [mcp_servers.cortex] and [mcp_servers.cortex.env] tables from a Codex config.toml.
 // Same table-skip logic as setup.mergeCodexToml, in reverse.
 export function stripCodexCortexTables(text) {
-  const targets = new Set(['[mcp_servers.cortex]', '[mcp_servers.cortex.env]'])
+  const targets = new Set(['[mcp_servers.cortex]', '[mcp_servers.cortex.env]',
+                           '[mcp_servers.agnoclast]', '[mcp_servers.agnoclast.env]'])
   const kept = []
   let skipping = false
   for (const line of (text || '').split('\n')) {
@@ -193,7 +228,7 @@ function npxCacheDirs() {
   const out = []
   for (const d of safeReaddir(base)) {
     const dir = join(base, d)
-    try { if (execFileSync('grep', ['-rl', '@theronap/cortex-mcp', join(dir, 'package.json')], { encoding: 'utf8' }).trim()) out.push(dir) } catch { /* not a cortex cache */ }
+    try { if (execFileSync('grep', ['-rlE', '@theronap/(cortex|agnoclast)-mcp', join(dir, 'package.json')], { encoding: 'utf8' }).trim()) out.push(dir) } catch { /* not one of ours */ }
   }
   return out
 }

package/lib/with_token.mjs

@@ -0,0 +1,66 @@
+import { spawnSync } from 'child_process'
+import { resolveTokenSource, TOKEN_ENV_VARS } from './diagnose.mjs'
+
+// `with-token -- <command…>` — run a command with the resolved Agnoclast token in its environment.
+//
+// Why this exists (ADR-0033 D9). Generated helper scripts used to inline their own config parse:
+//
+//   TOKEN="$(node -e "…JSON.parse(…'/.claude.json')?.mcpServers?.cortex?.env?.CORTEX_TOKEN…")"
+//   CORTEX_TOKEN="$TOKEN" bun run …
+//
+// Those scripts are written to disk once and FROZEN. Upgrading the package never rewrites a file
+// that already exists, so any change to config shape strands them — and the Phase C key flip would
+// have done exactly that, silently, because the script's own `catch { exit 0 }` swallows it.
+// Delegating means the resolution rule lives in one versioned place and a script written today keeps
+// working through arbitrary future config changes.
+//
+// It also removes the secret from the shell. Previously the token landed in a shell variable and was
+// re-exported by the caller; here it goes straight from the resolver into the child's environment,
+// so it is never a shell value, never in a log line, and never in an argv the process table shows.
+//
+// Both variable names are injected so the child works whichever one it reads — the whole point of a
+// transition period is that callers need not be updated in lockstep.
+
+/** Split `with-token -- cmd args` (or `with-token cmd args`) into the command to run. */
+export function parseWithTokenArgs(rest = []) {
+  const args = rest.filter((a) => a !== undefined && a !== null)
+  const sep = args.indexOf('--')
+  const cmd = sep === -1 ? args : args.slice(sep + 1)
+  if (!cmd.length) {
+    return { error: 'Usage: cortex-mcp with-token -- <command> [args…]\n  Runs <command> with the wired Agnoclast token in its environment.\n' }
+  }
+  return { command: cmd[0], args: cmd.slice(1) }
+}
+
+/** Build the child environment. Exported so a test can assert it without spawning anything. */
+export function tokenEnv(token, baseEnv = process.env) {
+  const out = { ...baseEnv }
+  for (const name of TOKEN_ENV_VARS) out[name] = token
+  return out
+}
+
+// Exit codes, distinct so a caller's log can tell them apart:
+//   3 — no token wired (the "skip quietly" case a cron wrapper wants)
+//   2 — bad usage
+//   otherwise the child's own code
+export const EXIT_NO_TOKEN = 3
+export const EXIT_USAGE = 2
+
+export function runWithToken(rest = [], deps = {}) {
+  const { resolve = resolveTokenSource, spawn = spawnSync, stderr = (m) => process.stderr.write(m) } = deps
+  const parsed = parseWithTokenArgs(rest)
+  if (parsed.error) { stderr(parsed.error); return EXIT_USAGE }
+
+  const { token } = resolve()
+  if (!token) {
+    stderr('cortex-mcp with-token: no Agnoclast token in the environment or wired config — skipping.\n')
+    return EXIT_NO_TOKEN
+  }
+
+  const res = spawn(parsed.command, parsed.args, { stdio: 'inherit', env: tokenEnv(token) })
+  if (res?.error) {
+    stderr(`cortex-mcp with-token: could not run ${parsed.command}: ${res.error.message}\n`)
+    return 1
+  }
+  return res?.status ?? 1
+}

package/package.json

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