@theronap/cortex-mcp 0.9.44 → 0.9.46

package/lib/graphify_sync.mjs

@@ -0,0 +1,89 @@
+import { spawnSync } from 'child_process'
+import { existsSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { fetchCortex, classify, resolveBase } from './diagnose.mjs'
+
+// `cortex-mcp graphify-sync [path]` — local producer: incrementally rebuild a repo's structural
+// code graph (graphify — tree-sitter AST, no LLM) and log an evidence-tier timeline event via
+// POST /api/timeline/graphify. LLM-free, idempotent (server dedupes on repo+commit), additive —
+// never touches the wiki graph (cortex-wiki-primary-spec: extracted/structural data is evidence,
+// never auto-promoted into an authored page).
+//
+// Meant to run from a periodic cron/launchd job per repo you want graphed — NOT a git post-commit
+// hook. A hook fires synchronously inside `git commit`/`git push` and can race another session's
+// git operations in a shared checkout (see reference-cortex-shared-checkout-hazards); a timer-based
+// job just reads whatever the tree looks like at that moment, no hook into git operations at all.
+
+function run(cmd, args, cwd) {
+  const r = spawnSync(cmd, args, { cwd, encoding: 'utf8', timeout: 120_000 })
+  return r.status === 0 ? (r.stdout || '').trim() : null
+}
+
+function repoFullNameFromRemote(cwd) {
+  const url = run('git', ['remote', 'get-url', 'origin'], cwd)
+  if (!url) return null
+  const m = /github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/i.exec(url)
+  return m ? `${m[1]}/${m[2]}` : null
+}
+
+export async function runGraphifySync(argv = []) {
+  const cwd = argv[0] && !argv[0].startsWith('-') ? argv[0] : process.cwd()
+  const TOKEN = process.env.CORTEX_TOKEN
+  const BASE = resolveBase(process.env.CORTEX_URL)
+  if (!TOKEN) {
+    process.stderr.write('cortex-mcp graphify-sync: CORTEX_TOKEN is required.\n')
+    return 1
+  }
+  const graphFile = join(cwd, 'graphify-out', 'graph.json')
+  if (!existsSync(graphFile)) {
+    process.stderr.write(`cortex-mcp graphify-sync: no graph at ${graphFile} — run the graphify skill (\`/graphify .\`) in this repo first.\n`)
+    return 1
+  }
+  if (!run('graphify', ['--version'], cwd)) {
+    process.stderr.write('cortex-mcp graphify-sync: graphify CLI not on PATH (`uv tool install graphifyy`).\n')
+    return 1
+  }
+
+  const update = spawnSync('graphify', ['update', '.'], { cwd, encoding: 'utf8', timeout: 300_000, maxBuffer: 8 * 1024 * 1024 })
+  if (update.status !== 0) {
+    process.stderr.write(`cortex-mcp graphify-sync: \`graphify update\` failed:\n${(update.stderr || update.stdout || '').trim()}\n`)
+    return 1
+  }
+  if (update.stdout) process.stdout.write(update.stdout.trim() + '\n')
+
+  let graph
+  try {
+    graph = JSON.parse(readFileSync(graphFile, 'utf8'))
+  } catch (e) {
+    process.stderr.write(`cortex-mcp graphify-sync: could not read ${graphFile}: ${e.message}\n`)
+    return 1
+  }
+  const nodes = Array.isArray(graph.nodes) ? graph.nodes : []
+  const nodeCount = nodes.length
+  const edgeCount = Array.isArray(graph.links) ? graph.links.length : 0
+  const communityCount = new Set(nodes.map((n) => n.community).filter((c) => c !== undefined)).size
+  const commitSha = typeof graph.built_at_commit === 'string' ? graph.built_at_commit : null
+
+  const repo = repoFullNameFromRemote(cwd)
+  if (!commitSha || !repo) {
+    process.stdout.write('cortex-mcp graphify-sync: graph updated locally; skipping timeline log (no git commit / no github.com origin found).\n')
+    return 0
+  }
+
+  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 }),
+  })
+  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')
+    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)` +
+      `${payload.inserted ? '' : ' (already logged)'}\n`,
+  )
+  return 0
+}

package/lib/install.mjs

@@ -0,0 +1,161 @@
+// `cortex install` — the cross-editor hub installer (P0-b). One command that wires the Cortex 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
+// multi-editor superset that drives the SAME adapter `wire()` functions.
+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 } from './diagnose.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`,
+ *  `--editor=<v>`, `-e <v>`). Unknown flags are ignored (fail-soft — never mistaken for the token). */
+export function parseInstallArgs(argv = []) {
+  let editor = 'auto'
+  let token
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === '--editor' || a === '-e') { editor = argv[++i] ?? editor; continue }
+    if (a.startsWith('--editor=')) { editor = a.slice('--editor='.length); continue }
+    if (a === '--all') { editor = 'all'; continue }
+    if (a.startsWith('-')) continue // ignore unknown flags, don't treat as token
+    if (token === undefined) token = a
+  }
+  return { token, editor: editor || 'auto' }
+}
+
+/** Pure: build the capability manifest from resolved per-editor entries. Injectable `now`/`cortexMcp`
+ *  keep it deterministic for tests. Each entry = { adapter, detected, wired, wrote?, warnings? }. */
+export function buildManifest(entries, { now = new Date().toISOString(), cortexMcp = null } = {}) {
+  return {
+    schema: 1,
+    generatedAt: now,
+    cortexMcp,
+    editors: entries.map((e) => ({
+      id: e.adapter.id,
+      displayName: e.adapter.displayName,
+      detected: !!e.detected,
+      wired: !!e.wired,
+      capabilities: e.adapter.capabilities,
+      wrote: e.wrote ?? [],
+      warnings: e.warnings ?? [],
+    })),
+  }
+}
+
+/** Read the existing manifest ({} if absent/malformed — never throws). */
+export function readManifest({ path = MANIFEST_PATH } = {}) {
+  try {
+    if (!existsSync(path)) return {}
+    const raw = readFileSync(path, 'utf8').trim()
+    return raw ? JSON.parse(raw) : {}
+  } catch {
+    return {} // malformed manifest is not fatal — a fresh install rewrites it
+  }
+}
+
+export function writeManifest(manifest, { path = MANIFEST_PATH } = {}) {
+  const dir = dirname(path)
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  writeFileSync(path, JSON.stringify(manifest, null, 2))
+  return path
+}
+
+export async function runInstall(argv, version) {
+  const { token: argToken, editor } = parseInstallArgs(argv)
+  const token = argToken || readWiredToken()
+  const spec = `${PKG}@stable`
+  const home = homedir()
+  const log = (m) => process.stdout.write(m + '\n')
+
+  if (!token) {
+    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',
+    )
+    process.exit(1)
+  }
+
+  let targets
+  try {
+    targets = resolveEditors(editor)
+  } catch (e) {
+    process.stderr.write(`\n✗ ${e.message}\n`)
+    process.exit(1)
+  }
+
+  log('')
+  log('Cortex 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)')
+  }
+
+  // Carry forward prior manifest state for editors NOT targeted this run, so a single-editor
+  // `install --editor cursor` doesn't wipe the "wired" record of editors a previous run set up.
+  const priorById = new Map((readManifest().editors ?? []).map((e) => [e.id, e]))
+  const targetIds = new Set(targets.map((a) => a.id))
+
+  const entries = []
+  for (const adapter of ADAPTERS) {
+    const detected = safeDetect(adapter)
+    if (!targetIds.has(adapter.id)) {
+      const p = priorById.get(adapter.id)
+      entries.push({ adapter, detected, wired: p?.wired ?? false, wrote: p?.wrote ?? [], warnings: [] })
+      continue
+    }
+    log(`\n${adapter.displayName}:`)
+    let res = { wrote: [], skipped: [], warnings: [] }
+    try {
+      res = (await adapter.wire({ home, token, spec, log })) ?? res
+    } catch (e) {
+      // A single editor's failure must never abort the others (fail-soft, like setup's Codex block).
+      res.warnings = [...(res.warnings ?? []), `wire failed: ${e.message}`]
+      log(`  ⚠ ${adapter.displayName} wiring failed: ${e.message}`)
+    }
+    for (const w of res.warnings ?? []) log(`  ⚠ ${w}`)
+    entries.push({
+      adapter,
+      detected,
+      wired: (res.wrote ?? []).length > 0,
+      wrote: res.wrote ?? [],
+      warnings: res.warnings ?? [],
+    })
+  }
+
+  const mpath = writeManifest(buildManifest(entries, { cortexMcp: version ?? null }))
+  log(`\n  ✓ Capability manifest → ${mpath}`)
+
+  // 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…')
+  try {
+    const health = await checkToken(token, base)
+    if (health.ok) {
+      const n = health.projectCount
+      log(`  ✓ Verified — your token works${typeof n === 'number' ? ` (you can see ${n} project${n === 1 ? '' : 's'})` : ''}.`)
+    } else {
+      log('  ⚠ Config written, but the live check did NOT pass:')
+      log(`     ${health.diagnosis?.message ?? 'unknown error'}`)
+      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'.`)
+  }
+
+  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(`   Console: ${base}`)
+  log('')
+}
+
+function safeDetect(adapter) {
+  try { return !!adapter.detect() } catch { return false }
+}

package/lib/server.mjs

@@ -8,6 +8,7 @@ import { createHash, randomUUID } from 'crypto'
 import { fetchCortex, classify, resolveBase } from './diagnose.mjs'
 import { runSendImessage } from './imessage_send.mjs'
 import { formatGrepHits } from './grep_cli.mjs'
+import { runCodeGraphQuery } from './code_graph_cli.mjs'
 
 // The Cortex MCP server (stdio). Serves the signed-in employee's scoped org
 // context to their AI assistant. CORTEX_TOKEN identifies the user + org.
@@ -284,6 +285,26 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'code_graph_query',
+    {
+      title: 'Query the local code structure graph (graphify)',
+      description:
+        'Query a structural code graph for the repo at the CURRENT working directory, built locally by graphify (tree-sitter AST — deterministic, no LLM, no server round-trip; this is LOCAL MACHINE data, not org-shared Cortex content, and reflects a snapshot of one commit, not live files). Use for MULTI-HOP questions a single grep cannot answer: what calls/imports/depends on X, how A structurally reaches B, or a repo-wide overview (hub/community files). Do NOT use for single-hop lookups (does file X import Y) — grep is faster and always current. Structure only — it knows what imports/calls what, never WHY; read the actual files or authored Cortex pages for intent.',
+      inputSchema: {
+        action: z.enum(['query', 'path', 'explain']).describe('"query" = open-ended natural-language question (graph traversal); "path" = shortest structural path between two named nodes; "explain" = describe one node and list its direct connections'),
+        question: z.string().optional().describe('required for action:"query" — the natural-language question'),
+        from: z.string().optional().describe('required for action:"path" — the starting node name'),
+        to: z.string().optional().describe('required for action:"path" — the target node name'),
+        node: z.string().optional().describe('required for action:"explain" — the node name to describe'),
+      },
+    },
+    async ({ action, question, from, to, node }) => {
+      const result = runCodeGraphQuery({ action, question, from, to, node })
+      return { content: [{ type: 'text', text: result.text }] }
+    },
+  )
+
   server.registerTool(
     'project_status',
     {
@@ -643,6 +664,33 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'create_brain',
+    {
+      title: 'Create a new brain under your existing account',
+      description: 'Create a brand-new brain (org/workspace) — a fully independent knowledge graph — under your EXISTING account. No new login, no new email/password: this adds a second membership to the account you are already using. Reads never cross brains; use set_active_brain afterward to point writes at it (creating it does not switch your active write brain automatically).',
+      inputSchema: { name: z.string().describe('display name for the new brain, e.g. "Cortex Codebase"') },
+    },
+    async ({ name }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brains`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not create brain: ${e.message}` }] }
+      }
+      if (!res.ok) {
+        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
+        return { content: [{ type: 'text', text: `Could not create brain: ${d.message}` }] }
+      }
+      const r = await res.json()
+      return { content: [{ type: 'text', text: `Created brain "${name}" [${r.orgId}]. Run set_active_brain with this org_id to start writing to it — reads already span it automatically.` }] }
+    },
+  )
+
   server.registerTool(
     'list_records',
     {

package/lib/setup.mjs

@@ -3,6 +3,10 @@ import { homedir } from 'os'
 import { join, dirname } from 'path'
 import { checkToken, resolveBase, readWiredToken } from './diagnose.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.
+import { mergeClaudeMcp, mergeClaudeSettings } from './editors/claude.mjs'
+import { mergeCodexToml, mergeCodexHooks } from './editors/codex.mjs'
 
 // One-command employee onboarding. Wires both:
 //   1. ~/.claude.json        → the cortex MCP server (context-serving)
@@ -14,33 +18,7 @@ import { installSkills } from './skills.mjs'
 
 const PKG = '@theronap/cortex-mcp'
 
-// Merge the Cortex 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.
-export function mergeCodexToml(text, spec, token) {
-  const targets = new Set(['[mcp_servers.cortex]', '[mcp_servers.cortex.env]'])
-  const kept = []
-  let skipping = false
-  for (const line of (text || '').split('\n')) {
-    const t = line.trim()
-    if (t.startsWith('[') && t.endsWith(']')) skipping = targets.has(t)
-    if (!skipping) kept.push(line)
-  }
-  while (kept.length && kept[kept.length - 1].trim() === '') kept.pop() // drop trailing blanks
-  const block = [
-    '',
-    '[mcp_servers.cortex]',
-    'command = "npx"',
-    `args = ["-y", "${spec}"]`,
-    'startup_timeout_sec = 60', // first npx fetch can be slow; don't time out the server on cold start
-    '',
-    '[mcp_servers.cortex.env]',
-    `CORTEX_TOKEN = "${token}"`,
-    '',
-  ]
-  return [...kept, ...block].join('\n')
-}
+// mergeCodexToml / mergeCodexHooks moved to ./editors/codex.mjs (imported above, re-exported below).
 
 function readJson(path) {
   if (!existsSync(path)) return {}
@@ -61,28 +39,6 @@ function ensureDir(path) {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
 }
 
-// Merge the capture Stop hook into a Codex hooks.json object. Pure + idempotent: drops any prior
-// cortex capture entry (old token / old path / old pinned version) before appending the current one,
-// so re-running never duplicates and never leaves a stale version pinned behind a live one.
-// Mirrors the Claude Stop-hook merge in step 2 below, minus the SessionStart/PreCompact hooks Codex
-// doesn't support (confirmed: Codex's hook runtime only recognizes PreToolUse/PostToolUse/PreCompact/
-// UserPromptSubmit/Stop — no SessionStart, so status/skills-repair/snapshot-context stay Claude-only).
-export function mergeCodexHooks(existing, captureCmd) {
-  const h = existing && typeof existing === 'object' ? existing : {}
-  h.hooks = h.hooks && typeof h.hooks === 'object' ? h.hooks : {}
-  h.hooks.Stop = Array.isArray(h.hooks.Stop) ? h.hooks.Stop : []
-  for (const grp of h.hooks.Stop) {
-    if (Array.isArray(grp.hooks)) {
-      grp.hooks = grp.hooks.filter((c) => !/cortex-mcp.*capture|capture-session-cloud/.test(c.command ?? ''))
-    }
-  }
-  let grp = h.hooks.Stop.find((g) => (g.matcher ?? '') === '')
-  if (!grp) { grp = { matcher: '', hooks: [] }; h.hooks.Stop.push(grp) }
-  grp.hooks = grp.hooks ?? []
-  grp.hooks.push({ type: 'command', command: captureCmd })
-  return h
-}
-
 export async function runSetup(argv, version) {
   const token = argv[0]
   if (!token || token.startsWith('-')) {
@@ -115,13 +71,7 @@ export async function runSetup(argv, version) {
       process.exit(1)
     }
     const bak = backup(claudeJson)
-    cfg.mcpServers = cfg.mcpServers ?? {}
-    cfg.mcpServers.cortex = {
-      type: 'stdio',
-      command: 'npx',
-      args: ['-y', spec],
-      env: { CORTEX_TOKEN: token },
-    }
+    cfg = mergeClaudeMcp(cfg, spec, token)
     ensureDir(claudeJson)
     writeFileSync(claudeJson, JSON.stringify(cfg, null, 2))
     log(`  ✓ MCP server → ${claudeJson}${bak ? ' (backup saved)' : ''}`)
@@ -176,72 +126,9 @@ export async function runSetup(argv, version) {
       process.exit(1)
     }
     const bak = backup(settingsJson)
-    s.hooks = s.hooks ?? {}
-    s.hooks.Stop = Array.isArray(s.hooks.Stop) ? s.hooks.Stop : []
-
-    // NO inline token — same hygiene as the Codex hook above; `capture` self-resolves from
-    // ~/.claude.json (which this setup run writes). The filter below drops the old inlined form.
-    const captureCmd = `npx -y ${spec} capture`
-    // Remove any prior cortex capture hook (idempotent: drop old token / old path forms).
-    for (const grp of s.hooks.Stop) {
-      if (Array.isArray(grp.hooks)) {
-        grp.hooks = grp.hooks.filter((h) => !/cortex-mcp.*capture|capture-session-cloud/.test(h.command ?? ''))
-      }
-    }
-    // Find or create a matcher:"" group and append.
-    let grp = s.hooks.Stop.find((g) => (g.matcher ?? '') === '')
-    if (!grp) { grp = { matcher: '', hooks: [] }; s.hooks.Stop.push(grp) }
-    grp.hooks = grp.hooks ?? []
-    grp.hooks.push({ type: 'command', command: captureCmd })
-
-    // Connected-status SessionStart hook: one line inside Claude Code itself saying whether
-    // this machine's sessions are flowing to the org (dry-run finding: silence is unreadable).
-    // `status` reads the token from ~/.claude.json, so the command carries no secret.
-    s.hooks.SessionStart = Array.isArray(s.hooks.SessionStart) ? s.hooks.SessionStart : []
-    const statusCmd = `npx -y ${spec} status`
-    for (const sg of s.hooks.SessionStart) {
-      if (Array.isArray(sg.hooks)) {
-        sg.hooks = sg.hooks.filter((h) => !/cortex-mcp(@[^ ]*)? status/.test(h.command ?? ''))
-      }
-    }
-    let sgrp = s.hooks.SessionStart.find((g) => (g.matcher ?? '') === '')
-    if (!sgrp) { sgrp = { matcher: '', hooks: [] }; s.hooks.SessionStart.push(sgrp) }
-    sgrp.hooks = sgrp.hooks ?? []
-    sgrp.hooks.push({ type: 'command', command: statusCmd })
-
-    // Skills self-heal: every session start, restore any drifted managed Cortex skill (quiet — only
-    // speaks up if it actually changed something). This is what makes the core skills "inalterable".
-    const skillsCmd = `npx -y ${spec} skills --repair --quiet`
-    for (const sg of s.hooks.SessionStart) {
-      if (Array.isArray(sg.hooks)) {
-        sg.hooks = sg.hooks.filter((h) => !/cortex-mcp(@[^ ]*)? skills/.test(h.command ?? ''))
-      }
-    }
-    sgrp.hooks.push({ type: 'command', command: skillsCmd })
-
-    const snapshotCmd = `npx -y ${spec} snapshot-context`
-    for (const sg of s.hooks.SessionStart) {
-      if (Array.isArray(sg.hooks)) {
-        sg.hooks = sg.hooks.filter((h) => !/cortex-mcp(@[^ ]*)? snapshot-context/.test(h.command ?? ''))
-      }
-    }
-    sgrp.hooks.push({ type: 'command', command: snapshotCmd })
-
-    // PreCompact "author now" reminder (③ live wiki authoring, best-effort). Merges into the PreCompact
-    // array WITHOUT clobbering other hooks (filters only prior cortex entries, then appends to the ''
-    // matcher group). A hook can't force a turn — this just nudges the session to sweep understanding
-    // into the wiki before compaction; the /log skill is the hard backstop.
-    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 ?? ''))
-      }
-    }
-    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 })
+    // Capture (Stop) + status/skills/snapshot (SessionStart) + precompact (PreCompact), idempotent
+    // merge — the same pure function the `cortex install` Claude adapter uses.
+    s = mergeClaudeSettings(s, spec)
 
     ensureDir(settingsJson)
     writeFileSync(settingsJson, JSON.stringify(s, null, 2))
@@ -291,6 +178,10 @@ export async function runSetup(argv, version) {
 // resolver — hook commands no longer inline the token. Re-exported for compatibility.
 export { readWiredToken }
 
+// Re-export the pure merge functions from their adapter homes so existing importers of setup.mjs keep
+// working and tests can assert setup uses the SAME function the install path does (byte-identity).
+export { mergeClaudeMcp, mergeClaudeSettings, mergeCodexToml, mergeCodexHooks }
+
 // `repair`: re-run the FULL setup at THIS version using the already-wired token. The one-command fix
 // for a machine set up with an older version (e.g. when skills were installed to the old nested path,
 // or the hooks are pinned to a stale version). No token argument needed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theronap/cortex-mcp",
-  "version": "0.9.44",
+  "version": "0.9.46",
   "description": "Connect your AI assistant to Cortex — your org's projects, activity, gaps, and directives, scoped to you.",
   "type": "module",
   "bin": {
@@ -9,7 +9,8 @@
   "files": [
     "bin",
     "lib",
-    "skills"
+    "skills",
+    "!lib/**/*.test.mjs"
   ],
   "engines": {
     "node": ">=18"

package/lib/docs_scan.test.mjs

@@ -1,73 +0,0 @@
-import { describe, it, expect, beforeEach } from 'bun:test'
-import { mkdtempSync, writeFileSync, mkdirSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { loadState, saveState, scanRoots, markFiles, collectMarkdown, hashContent } from './docs_scan.mjs'
-
-const tmp = () => mkdtempSync(join(tmpdir(), 'docs-scan-'))
-
-describe('state round-trip', () => {
-  it('missing/corrupt state loads as empty and saves back', () => {
-    const dir = tmp()
-    const path = join(dir, 'nested', 'docs-sync.json')
-    expect(loadState(path)).toEqual({ version: 1, roots: [], files: {} })
-    const s = { version: 1, roots: ['/a'], files: { '/a/x.md': { hash: 'h', markedAt: 't' } } }
-    saveState(s, path)
-    expect(loadState(path)).toEqual(s)
-    writeFileSync(path, '{not json')
-    expect(loadState(path)).toEqual({ version: 1, roots: [], files: {} })
-  })
-})
-
-describe('collectMarkdown skip rules', () => {
-  let root
-  beforeEach(() => {
-    root = tmp()
-    writeFileSync(join(root, 'spec.md'), '# spec')
-    writeFileSync(join(root, 'notes.txt'), 'not md')
-    writeFileSync(join(root, 'old.md.bak'), 'backup')
-    mkdirSync(join(root, 'node_modules', 'pkg'), { recursive: true })
-    writeFileSync(join(root, 'node_modules', 'pkg', 'README.md'), 'dep readme')
-    mkdirSync(join(root, '.git'))
-    writeFileSync(join(root, '.git', 'x.md'), 'git internals')
-    mkdirSync(join(root, 'sub'))
-    writeFileSync(join(root, 'sub', 'plan.md'), '# plan')
-    writeFileSync(join(root, 'big.md'), 'x'.repeat(256 * 1024 + 1))
-  })
-  it('finds nested .md, skips node_modules/.git/.bak/non-md/oversize', () => {
-    const found = collectMarkdown(root)
-    expect(found).toEqual([join(root, 'spec.md'), join(root, 'sub', 'plan.md')])
-  })
-})
-
-describe('scan + mark lifecycle', () => {
-  it('new → pending; mark → clean; edit → changed; re-mark → clean', () => {
-    const root = tmp()
-    const doc = join(root, 'design.md')
-    writeFileSync(doc, 'v1')
-    const state = { version: 1, roots: [root], files: {} }
-
-    let r = scanRoots(state)
-    expect(r.pending).toEqual([{ path: doc, status: 'new' }])
-
-    const m = markFiles(state, [doc], '2026-07-02T00:00:00Z')
-    expect(m.marked).toEqual([doc])
-    expect(state.files[doc].hash).toBe(hashContent('v1'))
-    expect(scanRoots(state).pending).toEqual([])
-
-    writeFileSync(doc, 'v2')
-    r = scanRoots(state)
-    expect(r.pending).toEqual([{ path: doc, status: 'changed' }])
-
-    markFiles(state, [doc])
-    expect(scanRoots(state).pending).toEqual([])
-  })
-  it('mark of an unreadable file reports missing and records nothing', () => {
-    const state = { version: 1, roots: [], files: {} }
-    const gone = join(tmp(), 'nope.md')
-    const m = markFiles(state, [gone])
-    expect(m.marked).toEqual([])
-    expect(m.missing).toEqual([gone])
-    expect(state.files[gone]).toBeUndefined()
-  })
-})

package/lib/grep_cli.test.mjs

@@ -1,46 +0,0 @@
-import { describe, it, expect } from 'bun:test'
-import { parseGrepArgs, formatGrepHits } from './grep_cli.mjs'
-
-describe('parseGrepArgs', () => {
-  // #220: default is 'fts' (ranked keyword); --substring/--literal opts back into exact matching.
-  it('joins free terms into the query, defaults fts', () => {
-    expect(parseGrepArgs(['hello', 'world'])).toEqual({ query: 'hello world', mode: 'fts', max: undefined })
-  })
-  it('honors --substring/--literal to force exact matching, else fts', () => {
-    expect(parseGrepArgs(['q', '--substring']).mode).toBe('substring')
-    expect(parseGrepArgs(['q', '--literal']).mode).toBe('substring')
-    expect(parseGrepArgs(['q', '--mode', 'substring']).mode).toBe('substring')
-    expect(parseGrepArgs(['q', '--mode', 'fts']).mode).toBe('fts')
-    expect(parseGrepArgs(['--fts', 'q']).mode).toBe('fts')
-    expect(parseGrepArgs(['q', '--mode', 'bogus']).mode).toBe('fts')
-  })
-  it('parses --max as an integer, ignores non-numeric', () => {
-    expect(parseGrepArgs(['q', '--max', '25']).max).toBe(25)
-    expect(parseGrepArgs(['q', '--max', 'abc']).max).toBeUndefined()
-  })
-  it('keeps the query when flags are interleaved', () => {
-    expect(parseGrepArgs(['foo', '--max', '5', 'bar']).query).toBe('foo bar')
-  })
-})
-
-describe('formatGrepHits', () => {
-  it('reports no matches', () => {
-    expect(formatGrepHits({ hits: [] }, 'xyz')).toBe('No matches for "xyz".')
-    expect(formatGrepHits({}, 'xyz')).toBe('No matches for "xyz".')
-  })
-  it('renders ASCII hit lines with heading, tier, snippet, links', () => {
-    const out = formatGrepHits(
-      { hits: [{ title: 'Acme', heading: 'Current state', tier: 'accessible', snippet: 'big   deal', links: ['Bob', 'Q3'] }] },
-      'deal',
-    )
-    expect(out).toContain('1 match for "deal":')
-    expect(out).toContain('- Acme > Current state [accessible]')
-    expect(out).toContain('    big deal')
-    expect(out).toContain('    -> [[Bob]] [[Q3]]')
-  })
-  it('is ASCII-only', () => {
-    const out = formatGrepHits({ hits: [{ title: 'X', heading: 'H', tier: 'scoped', snippet: 's', links: ['L'] }] }, 'q')
-    // eslint-disable-next-line no-control-regex
-    expect(/^[\x00-\x7F]*$/.test(out)).toBe(true)
-  })
-})