@theronap/agnoclast-mcp 0.9.96

package/lib/statusline.mjs

@@ -0,0 +1,67 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+import { renderStatusline } from './presence.mjs'
+
+// `cortex-mcp statusline` — the ambient half of the presence cue.
+//
+// Claude Code runs a statusline command on each redraw and prints its stdout under the prompt, so
+// this is the only place Agnoclast can sit permanently in view. It must therefore be the cheapest
+// thing in the product: no network, no auth, no org call. It reads one small local file that
+// hydration wrote and renders a line.
+//
+// It also has to be honest when nothing is happening. An indicator that looks alive while the system
+// is disconnected is worse than no indicator — that is precisely how the hook on this machine sat
+// dead for five days without anyone noticing. Hence the decay to `idle`, and `not wired` when there
+// is no breadcrumb at all.
+
+const STATE_DIR = () => join(homedir(), '.cortex')
+const STATE_FILE = () => join(STATE_DIR(), 'presence.json')
+const TICK_FILE = () => join(STATE_DIR(), 'presence-tick')
+
+function readState() {
+  try {
+    return JSON.parse(readFileSync(STATE_FILE(), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+// The blob advances one frame per redraw. Persisting the counter is what makes it BREATHE across
+// renders rather than freeze on a single glyph — without it every render would draw frame 0.
+function nextTick() {
+  try {
+    const prev = Number.parseInt(readFileSync(TICK_FILE(), 'utf8'), 10)
+    const tick = (Number.isFinite(prev) ? prev + 1 : 0) % 1_000_000
+    writeFileSync(TICK_FILE(), String(tick))
+    return tick
+  } catch {
+    try {
+      if (!existsSync(STATE_DIR())) mkdirSync(STATE_DIR(), { recursive: true })
+      writeFileSync(TICK_FILE(), '0')
+    } catch {
+      /* ignore — the statusline must never fail loudly */
+    }
+    return 0
+  }
+}
+
+// Record what hydration served, for the statusline to read. Best-effort by design: a failure here
+// must never affect the turn it was observing.
+export function writePresence({ pages = [], kind = 'hit', at = new Date().toISOString() } = {}) {
+  try {
+    if (!existsSync(STATE_DIR())) mkdirSync(STATE_DIR(), { recursive: true })
+    writeFileSync(STATE_FILE(), JSON.stringify({ pages, kind, at }))
+  } catch {
+    /* best-effort */
+  }
+}
+
+export function runStatusline() {
+  try {
+    process.stdout.write(renderStatusline(readState(), Date.now(), nextTick()) + '\n')
+  } catch {
+    // Print nothing rather than an error: a broken statusline should vanish, not shout.
+  }
+  return 0
+}

package/lib/uninstall.mjs

@@ -0,0 +1,237 @@
+import { readFileSync, writeFileSync, existsSync, copyFileSync, rmSync } from 'fs'
+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 / .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*
+//   6. launchd agent           → ~/Library/LaunchAgents/com.cortex.*.plist (unload + remove)
+//   7. crontab                 → lines tagged "# cortex ..."
+//   8. off-switch env          → launchctl unsetenv CORTEX_SUMMARIZE_DISABLED (macOS)
+//   --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 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')
+// 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')
+  const purge = argv.includes('--purge')
+  const plan = [] // human-readable action log
+  const act = (msg) => plan.push(msg)
+  const write = (path, data) => { if (!dry) { backup(path); writeFileSync(path, data) } }
+
+  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 — 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 + allow rules out of ~/.claude/settings.json
+  editJson(SETTINGS, (s) => {
+    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])
+  if (existsSync(CODEX_TOML)) {
+    const text = readFileSync(CODEX_TOML, 'utf8')
+    const stripped = stripCodexCortexTables(text)
+    if (stripped !== text) { write(CODEX_TOML, stripped); act(`  - [mcp_servers.cortex] tables  ← ${CODEX_TOML}`) }
+  }
+
+  // 4. Codex capture hook
+  editJson(CODEX_HOOKS, (h) => {
+    let changed = false
+    if (Array.isArray(h.hooks?.Stop)) {
+      for (const grp of h.hooks.Stop) {
+        if (!Array.isArray(grp.hooks)) continue
+        const before = grp.hooks.length
+        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)
+    }
+    if (changed) act(`  - cortex capture hook  ← ${CODEX_HOOKS}`)
+    return changed
+  }, write)
+
+  // 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', '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 }) }
+    }
+  }
+
+  // 6. launchd agents (com.cortex.*)
+  if (existsSync(LAUNCH_AGENTS)) {
+    for (const f of safeReaddir(LAUNCH_AGENTS)) {
+      if (!/^com\.(cortex|agnoclast)\..*\.plist$/.test(f)) continue
+      const p = join(LAUNCH_AGENTS, f)
+      act(`  - launchd agent ${p} (unload + remove)`)
+      if (!dry) {
+        tryExec('launchctl', ['bootout', `gui/${process.getuid?.() ?? ''}/${f.replace(/\.plist$/, '')}`])
+        tryExec('launchctl', ['unload', p])
+        rmSync(p, { force: true })
+      }
+    }
+  }
+
+  // 7. crontab — drop cortex-tagged lines
+  const cron = tryExecOut('crontab', ['-l'])
+  if (cron != null) {
+    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')
+    }
+  }
+
+  // 8. off-switch env var (macOS launchd session env)
+  act('  - launchctl unsetenv CORTEX_SUMMARIZE_DISABLED')
+  if (!dry) tryExec('launchctl', ['unsetenv', 'CORTEX_SUMMARIZE_DISABLED'])
+
+  // --purge: state dir + npx cache + backups
+  if (purge) {
+    if (existsSync(CORTEX_DIR)) { act(`  - PURGE state dir ${CORTEX_DIR}`); if (!dry) rmSync(CORTEX_DIR, { recursive: true, force: true }) }
+    for (const cache of npxCacheDirs()) { act(`  - PURGE npx cache ${cache}`); if (!dry) rmSync(cache, { recursive: true, force: true }) }
+    for (const bak of [CLAUDE_JSON, SETTINGS, CODEX_TOML, CODEX_HOOKS]) {
+      for (const suffix of ['.cortex-bak', '.cortex-uninstall-bak']) {
+        const b = bak + suffix
+        if (existsSync(b)) { act(`  - PURGE backup ${b}`); if (!dry) rmSync(b, { force: true }) }
+      }
+    }
+  }
+
+  if (plan.length === 0) { process.stdout.write('  Nothing to remove — this machine has no Agnoclast wiring.\n\n'); return }
+  process.stdout.write(plan.join('\n') + '\n\n')
+  if (dry) {
+    process.stdout.write('DRY RUN — nothing changed. Re-run without --dry-run to apply.\n')
+    process.stdout.write('  Full wipe (state dir + npx cache + backups too):  add --purge\n\n')
+  } else {
+    process.stdout.write('Done. Fully quit and reopen Claude Code (and Codex) to drop the server.\n')
+    if (!purge) process.stdout.write('  State dir ~/.cortex and .cortex-bak backups were KEPT. Remove them too with --purge.\n')
+    process.stdout.write('\n')
+  }
+}
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+function backup(path) {
+  if (!existsSync(path)) return
+  copyFileSync(path, `${path}.cortex-uninstall-bak`)
+}
+
+// Read JSON, run mutator (returns true if it changed anything), write back via `write` if so.
+// Malformed JSON is left untouched (never risk corrupting a file we can't parse).
+function editJson(path, mutate, write) {
+  if (!existsSync(path)) return
+  let obj
+  try { obj = JSON.parse(readFileSync(path, 'utf8') || '{}') } catch { process.stderr.write(`  ! ${path} is not valid JSON — skipped (left as-is)\n`); return }
+  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]',
+                           '[mcp_servers.agnoclast]', '[mcp_servers.agnoclast.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)
+  }
+  return kept.join('\n').replace(/\n{3,}/g, '\n\n')
+}
+
+function safeReaddir(dir) {
+  try { return execFileSync('ls', ['-1', dir], { encoding: 'utf8' }).split('\n').filter(Boolean) } catch { return [] }
+}
+function npxCacheDirs() {
+  const base = join(HOME, '.npm', '_npx')
+  const out = []
+  for (const d of safeReaddir(base)) {
+    const dir = join(base, d)
+    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
+}
+function tryExec(cmd, args) { try { execFileSync(cmd, args, { stdio: 'ignore' }) } catch { /* best-effort */ } }
+function tryExecOut(cmd, args) { try { return execFileSync(cmd, args, { encoding: 'utf8' }) } catch { return null } }
+function tryExecIn(cmd, args, input) { try { execFileSync(cmd, args, { input }) } catch { /* best-effort */ } }

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/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

@@ -0,0 +1,36 @@
+{
+  "name": "@theronap/agnoclast-mcp",
+  "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": {
+    "agnoclast-mcp": "bin/cortex-mcp.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "skills",
+    "!lib/**/*.test.mjs",
+    "!scripts"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^3.23.8"
+  },
+  "keywords": [
+    "mcp",
+    "cortex",
+    "claude",
+    "ai",
+    "org-intelligence"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "release": "node scripts/release.mjs release",
+    "promote": "node scripts/release.mjs promote",
+    "rollback": "node scripts/release.mjs rollback"
+  }
+}

package/skills/author-docs/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: cortex-author-docs
+description: Push new/changed documentation (specs, plans, design docs) from disk into Agnoclast as authored wiki pages. Run after writing a spec/plan/design doc, when the user asks to sync docs to Agnoclast, or as part of session close-out.
+---
+
+> **Agnoclast-managed skill.** This file is installed and kept up to date by Agnoclast. Local edits are
+> restored on the next session (a backup of your version is saved alongside). Don't rely on changes here.
+
+## Why this exists
+
+Specs, plans, and design docs get written to disk (a repo's `docs/`, skill-generated design docs)
+and never reach Agnoclast — so the org brain misses its richest artifacts. A spec IS a page: this
+skill turns pending docs into authored wiki pages. You (the live session) are the pipe — you read
+the doc and author a synthesis. Never dump raw markdown into a page.
+
+## When to use
+
+- Right after you write or substantially update a spec/plan/design/runbook doc on disk.
+- When the user asks to push/sync docs to Agnoclast.
+- During session close-out (`/cortex-log` runs this as a sweep step).
+
+## Steps
+
+1. **Detect:** run `npx -y @theronap/cortex-mcp docs-scan --json`. If `pending` is empty, stop —
+   report nothing. (If no roots are registered and you just wrote docs somewhere, suggest
+   `docs-scan --add-root <dir>` to the user once; don't nag.)
+2. **Triage each pending doc into exactly ONE of three dispositions.** Every pending doc gets one —
+   there is no fourth "deal with it later" state:
+   - **AUTHOR** it (below), then mark it.
+   - **ABSORBED** — the doc is substantive, but an existing page *already covers it as well or
+     better*. Common for build-notes and handoffs: the page kept getting updated while the doc
+     stayed frozen at its writing date. Authoring it again would duplicate, or worse, overwrite a
+     current page with a stale snapshot. **Mark it anyway** (`--mark`), and say which page absorbed
+     it. Do NOT leave it unmarked: it is genuinely handled, and leaving it pending makes every
+     future sweep re-read and re-litigate it. If the doc has one or two durable details the page
+     lacks, add just those to the page, then mark.
+   - **NON-SUBSTANTIVE** — scratch notes, generated output, throwaway logs. Leave unmarked and say
+     so, so a human can decide whether it should be registered at all.
+
+   ⚠ **A doc records the state at its writing date, never the state now.** Before writing any status
+   claim into a page, verify it against the code — a build-notes doc saying "NOT built yet" is
+   evidence about the past, not the present. Copying its status forward is the single most common way
+   this skill injects a false claim into the wiki.
+
+   To author:
+   - Read the file. Decide the target node: a substantial standalone doc becomes its own
+     project-kind node named by the doc's H1 title; a small note folds into its parent project's
+     page as a section. Check the namespace first (`authoring_context`) — enrich an existing node
+     rather than minting a synonym.
+   - Call `author` with a distilled summary + sections — a synthesis of what the doc establishes
+     (decisions, design, status), not a paste. Emit inline `[[links]]`: ALWAYS link up to the
+     parent project node, plus related nodes; include the `[[repo:owner/name]]` stamp when the doc
+     lives in a git repo (that joins the page to its commit timeline).
+   - **Directionality is a hard rule:** the doc page links UP to the hub; NEVER author the hub
+     page just to add a link back to a doc. Fan-in is queryable (`grep "[[hub]]"` = backlinks;
+     `read_page history:true` = the node's event ledger) — hub pages stay curated prose, and a doc
+     belongs on the hub only when a human-judged synthesis mentions it.
+3. **Mark:** run `npx -y @theronap/cortex-mcp docs-scan --mark <path>` for every doc you AUTHORED or
+   judged ABSORBED. Never mark a doc whose `author` failed — it must stay pending for the next sweep.
+4. **Verify before reporting.** For each doc you claim you authored, confirm the write actually landed
+   (`read_page` or `page_history`) — an `author` that returns "no change" when you intended an update
+   did NOT land. Never report a page you did not confirm.
+5. **Report:** one short block — each doc → the page it became, the page that absorbed it, or why it
+   was left unmarked. The count of pending docs should be zero afterwards except for the
+   non-substantive ones you deliberately left.
+
+## Safety rules
+
+- Do NOT register or sweep the local brain repo (`~/Documents/brain`) while the Robin parity soak
+  is running — the experiment forbids re-syncing Robin into Agnoclast mid-window.
+- Respect tiers: if a doc is clearly personal/sensitive, author it `confidential` or ask; default
+  for work docs is the author path's normal default.
+- This skill writes wiki pages via the `author` tool only. It never sends external messages and
+  never deletes anything.

package/skills/context/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: cortex-context
+description: Automatically hydrate Agnoclast context at the start of a substantive session. Use when Agnoclast MCP is available and the user has made a real request, so the first answer is grounded in query-centered org context instead of the static baseline alone.
+---
+
+> **Agnoclast-managed skill.** This file is installed and kept up to date by Agnoclast. Local edits are
+> restored on the next session (a backup of your version is saved alongside). Don't rely on changes here.
+
+## When to use
+
+At the beginning of a work session, once the user has given a real request or question. Skip trivial
+chit-chat and requests where org context is obviously irrelevant.
+
+## Steps
+
+1. Call `session_context` with the user's opening request, preserving the actual topic in their words.
+2. Use that returned block as the primary Agnoclast grounding for the first response.
+3. If `session_context` is unavailable or errors, fall back to `my_context`.
+4. If the conversation materially changes topics later, call `session_context` again for the new topic.
+
+## Safety rules
+
+- Do not fabricate Agnoclast context if the tool fails.
+- Prefer the query-centered `session_context` over static `my_context` whenever the user's topic is clear.
+- Do not call `session_context` for every tiny follow-up; refresh only when the topic meaningfully shifts.