@theronap/cortex-mcp 0.9.85 → 0.9.87

package/bin/cortex-mcp.mjs

@@ -50,9 +50,8 @@ if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
     `  doctor          live health check — confirm your token works (no restart needed)\n` +
     `  status          one-line connected/not-connected check (used by the SessionStart hook)\n` +
     `  use-brain [<brain>]    where your session captures are saved — no arg shows the current setting\n` +
-    `  skills [sync]          install/repair bundled, org, and private cross-editor skills\n` +
-    `  skills import --from claude  import all local Claude Code skills into your private library\n` +
-    `  skills push <file> [--brain <name>]  publish a SKILL.md to your org (owner/manager/admin)\n` +
+    `  skills          install/repair the managed Agnoclast skills — bundled + org-published (also wired by setup)\n` +
+    `  skills push <file>     publish a SKILL.md to your org (owner/manager/admin)\n` +
     `  docs-scan       detect new/changed local docs pending Agnoclast authoring (used by /cortex-author-docs)\n` +
     `  graphify-sync [path] [--brain <name-or-id>]  rebuild the local code graph + log a timeline event\n` +
     `  snapshot-context save the exact startup context Agnoclast served to a local snapshot\n` +

package/lib/editors/codex.mjs

@@ -70,7 +70,7 @@ export default {
     promptTimeInjection: true,
     sessionStart: false,
     captureHook: true,
-    skillDir: '~/.codex/skills',
+    skillDir: null,
     docTrigger: 'stop-hook',
   },
 

package/lib/editors/cursor.mjs

@@ -32,7 +32,7 @@ export default {
     promptTimeInjection: false,
     sessionStart: false,
     captureHook: true,           // ~/.cursor/hooks/cortex-cursor.mjs
-    skillDir: '~/.cursor/skills', // Flat SKILL.md directory verified on the supported Cursor build.
+    skillDir: null,              // Cursor rules/commands dir — revisit in Pillar 2
     docTrigger: 'hook',
   },
 

package/lib/server.mjs

@@ -223,6 +223,61 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'maintenance_candidates',
+    {
+      title: 'Review recent project-linked maintenance evidence',
+      description: 'Start here when preparing a handoff, status, or next step for a NAMED project. Returns a bounded, RLS-scoped set of recent raw records already linked to that project, before you trust the authored page. These are candidate evidence, not a command to edit: read them, call project_status, then decide whether a material contradiction warrants a minimal accountable correction. When correcting, retain the decisive factual qualifier (for example completion date or state) in the current-status text. Never mutate merely to clear a candidate.',
+      inputSchema: {
+        project: z.string().describe('the project key or exact project name from the task, e.g. "checkout-v2" or "Checkout v2"'),
+        brain: z.string().optional().describe('brain name or org id when you belong to more than one brain; omit for a sole brain'),
+        since_days: z.number().optional().describe('how far back to inspect (1-90 days, default 30)'),
+        limit: z.number().optional().describe('max candidate records (1-50, default 20)'),
+      },
+    },
+    async ({ project, brain, since_days, limit }) => {
+      const qs = new URLSearchParams({ project })
+      if (brain) qs.set('brain', brain)
+      if (since_days != null) qs.set('since_days', String(since_days))
+      if (limit != null) qs.set('limit', String(limit))
+      const res = await fetchCortex(`${BASE}/api/maintenance/candidates?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      if (!res.ok) {
+        const body = await res.text()
+        throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
+      }
+      const { text } = await res.json()
+      return { content: [{ type: 'text', text }] }
+    },
+  )
+
+  server.registerTool(
+    'gate3_status',
+    {
+      title: 'Gate 3 currency monitor',
+      description: 'Read the aggregate-only Gate 3 currency-monitor status for this brain. It counts explicit maintenance-candidate reviews and their same-session durable corrections in the rolling window; it never exposes project names, evidence content, or session keys. "machine_evidence_ready" means enough ordinary-work evidence has accumulated to request a human closure decision, not that the monitor closes the gate itself.',
+      inputSchema: {
+        days: z.number().optional().describe('rolling window in days (1-90, default 14)'),
+        brain: z.string().optional().describe('brain name or org id when you belong to more than one brain; omit for a sole brain'),
+      },
+    },
+    async ({ days, brain }) => {
+      const qs = new URLSearchParams()
+      if (days != null) qs.set('days', String(days))
+      if (brain) qs.set('brain', brain)
+      const suffix = qs.size ? `?${qs}` : ''
+      const res = await fetchCortex(`${BASE}/api/gates/3/status${suffix}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      if (!res.ok) {
+        const body = await res.text()
+        throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
+      }
+      const status = await res.json()
+      const text = status.machineEvidenceReady
+        ? `Gate 3 machine evidence is ready: ${status.maintenanceReviewSessions} independent maintenance-review sessions and ${status.correctionSessions} correction sessions in ${status.days} days. A human should confirm these were ordinary work before closing the gate.`
+        : `Gate 3 is still collecting evidence: ${status.maintenanceReviewSessions}/${status.requiredReviewSessions} independent maintenance-review sessions and ${status.correctionSessions}/${status.requiredCorrectionSessions} correction sessions in ${status.days} days. No gate decision has been made.`
+      return { content: [{ type: 'text', text }] }
+    },
+  )
+
   server.registerTool(
     'session_context',
     {
@@ -333,6 +388,122 @@ export async function runServer(version) {
     },
   )
 
+  // ── Gate 4 private intake (Slice 3) ──────────────────────────────────────────────────────────
+  server.registerTool(
+    'intake_changes',
+    {
+      title: 'Check private intake changes',
+      description:
+        'Session heartbeat for Gate 4 private intake. Returns an operational delta since your cursor (no ciphertext) plus cleanupDueCount. Call at session start, before each user turn, after long actions, and at least every two minutes while actively working. If cleanupDueCount > 0, call intake_claim with claimKind=cleanup before ordinary work.',
+      inputSchema: {
+        afterSeq: z.number().optional().describe('cursor from the previous call (default 0)'),
+        limit: z.number().optional().describe('max change rows (default 100)'),
+      },
+    },
+    async ({ afterSeq, limit }) => {
+      const params = new URLSearchParams()
+      if (typeof afterSeq === 'number') params.set('afterSeq', String(afterSeq))
+      if (typeof limit === 'number') params.set('limit', String(limit))
+      const qs = params.toString() ? `?${params}` : ''
+      const res = await fetchCortex(`${BASE}/api/intake/changes${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      if (!res.ok) {
+        const body = await res.text()
+        if (res.status === 403) return toolError('Private intake is not enabled for this account.')
+        throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
+      }
+      return { content: [{ type: 'text', text: JSON.stringify(await res.json(), null, 2) }] }
+    },
+  )
+
+  server.registerTool(
+    'intake_claim',
+    {
+      title: 'Claim private intake items',
+      description:
+        'Claim a lease on private intake items (relevance or cleanup). Returns decrypted payloads for the lease holder only. If cleanup is due, relevance claims return 409 — process cleanup first. Requires x-cortex-session-key (set automatically by this MCP server).',
+      inputSchema: {
+        claimKind: z.enum(['relevance', 'cleanup']).optional().describe('default relevance'),
+        limit: z.number().optional().describe('max items (default 10)'),
+      },
+    },
+    async ({ claimKind, limit }) => {
+      const res = await fetchCortex(`${BASE}/api/intake/claim`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ claimKind: claimKind ?? 'relevance', limit, includePayload: true }),
+      })
+      if (!res.ok) {
+        const body = await res.text()
+        if (res.status === 403) return toolError('Private intake is not enabled for this account.')
+        if (res.status === 409) return toolError(body)
+        throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
+      }
+      return { content: [{ type: 'text', text: JSON.stringify(await res.json(), null, 2) }] }
+    },
+  )
+
+  server.registerTool(
+    'intake_materialize',
+    {
+      title: 'Materialize a private intake item',
+      description:
+        'Atomically publish a claimed intake item into one brain. Deterministic identifier homes in that brain are always attached; documentIds may add further pages. Sets record confidentiality to the strictest attached page tier. Never writes private intake into search/history before this call.',
+      inputSchema: {
+        intakeItemId: z.string().describe('intake item uuid'),
+        orgId: z.string().describe('destination brain org uuid'),
+        documentIds: z.array(z.string()).optional().describe('additional brain_documents ids in orgId (deterministic homes are merged automatically)'),
+        title: z.string().optional(),
+        summary: z.string().optional(),
+        source: z.string().optional(),
+        recordType: z.string().optional(),
+        dedupeKey: z.string().optional(),
+        origin: z.enum(['deterministic', 'llm', 'user']).optional(),
+      },
+    },
+    async (args) => {
+      const res = await fetchCortex(`${BASE}/api/intake/materialize`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          intakeItemId: args.intakeItemId,
+          orgId: args.orgId,
+          documentIds: args.documentIds ?? [],
+          record: {
+            title: args.title,
+            summary: args.summary,
+            source: args.source,
+            record_type: args.recordType,
+            dedupe_key: args.dedupeKey,
+          },
+          attachmentMeta: (args.documentIds ?? []).map(() => ({ origin: args.origin ?? 'llm' })),
+        }),
+      })
+      if (!res.ok) {
+        const body = await res.text()
+        return toolError(body)
+      }
+      return { content: [{ type: 'text', text: JSON.stringify(await res.json(), null, 2) }] }
+    },
+  )
+
+  server.registerTool(
+    'intake_cleanup_status',
+    {
+      title: 'Private intake cleanup status',
+      description: 'Counts of pending/claimed/awaiting/cleanup-due intake items plus open clarifying questions for the owner.',
+      inputSchema: {},
+    },
+    async () => {
+      const res = await fetchCortex(`${BASE}/api/intake/cleanup-status`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      if (!res.ok) {
+        const body = await res.text()
+        if (res.status === 403) return toolError('Private intake is not enabled for this account.')
+        throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
+      }
+      return { content: [{ type: 'text', text: JSON.stringify(await res.json(), null, 2) }] }
+    },
+  )
+
   server.registerTool(
     'search_org',
     {
@@ -1451,6 +1622,174 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'set_routing_identifier',
+    {
+      title: 'Claim a routing identifier on a page',
+      description: 'Declare that a page is a Gate 4 attach HOME for an identifier (repo:owner/name or file:owner/name:path). Body [[repo:…]] stamps are navigation only and do NOT drive attach — use this instead. Prefer the narrowest id: mother pages own repo:; feature pages own file: paths. Do not copy every body mention into a routing claim.',
+      inputSchema: {
+        kind: z.enum(['project', 'person', 'org', 'user']).describe('the page kind'),
+        name: z.string().optional().describe('page title (or pass ref)'),
+        ref: z.string().optional().describe('node ref from read_page — prefer over name when available'),
+        brain: z.string().optional().describe('brain label when the title is ambiguous across brains'),
+        identifier: z.string().describe('canonical identifier, e.g. repo:theronap/cortex or file:theronap/cortex:web/lib/engine/github_intake.ts'),
+      },
+    },
+    async ({ kind, name, ref, brain, identifier }) => {
+      if (!name && !ref) return toolError('Pass name or ref')
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/routing-identifiers`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ kind, name, ref, brain, identifier }),
+        })
+      } catch (e) {
+        return toolError(`Could not set routing identifier: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not set routing identifier: ${out?.error ?? res.status}`)
+      const set = out?.set?.join(', ') ?? identifier
+      return { content: [{ type: 'text', text: `Routing identifier set on document ${out?.documentId ?? '?'}: ${set}. Future matching events will attach here (body mentions alone will not).` }] }
+    },
+  )
+
+  // ── Gate 4 record triage ──────────────────────────────────────────────────────────────────
+  // A connector event materializes in seconds and has no idea what the work WAS. The session that
+  // did the work knows exactly, and arrives later. These three tools are that handoff: look at what
+  // landed, claim what is yours, route it when you know where it goes.
+
+  server.registerTool(
+    'pending_records',
+    {
+      title: 'Records waiting for a home',
+      description: 'List connector records (GitHub pushes, PRs, email) that landed WITHOUT a confident home and are waiting for judgment. Check this when your session starts if the headline count sounds related to what you are about to work on — records from your own recent commits are usually in here. Returns titles and current homes only, never payloads. Use view "sweep" on one record to get graded page-name candidates without reading any pages.',
+      inputSchema: {
+        view: z.enum(['digest', 'sweep']).optional().describe('digest = what is waiting (default); sweep = cheap graded candidates for one record'),
+        recordId: z.string().optional().describe('required for view "sweep"'),
+        hours: z.number().int().positive().optional().describe('lookback window, default 3'),
+        stale: z.boolean().optional().describe('include old unclaimed records — the cleanup pile, not the live one'),
+        limit: z.number().int().positive().optional(),
+      },
+    },
+    async ({ view, recordId, hours, stale, limit }) => {
+      const params = new URLSearchParams()
+      params.set('view', view === 'sweep' ? 'sweep' : 'digest')
+      if (recordId) params.set('recordId', recordId)
+      if (hours) params.set('hours', String(hours))
+      if (stale) params.set('stale', '1')
+      if (limit) params.set('limit', String(limit))
+
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/triage?${params}`, {
+          headers: { Authorization: `Bearer ${TOKEN}` },
+        })
+      } catch (e) {
+        return toolError(`Could not read pending records: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not read pending records: ${out?.error ?? res.status}`)
+
+      if (view === 'sweep') {
+        const cands = out?.candidates ?? []
+        if (cands.length === 0) {
+          return { content: [{ type: 'text', text: `No page-name candidates for "${out?.title ?? recordId}". Park it — a stale record with no match is not worth reading pages over.` }] }
+        }
+        const lines = cands.map((c) => `  ${c.strength === 'strong' ? '●' : '○'} ${c.title} (${c.strength}) — ${c.documentId}`)
+        const rec = out?.recommendation
+        return {
+          content: [{
+            type: 'text',
+            text: `Candidates for "${out?.title}":\n${lines.join('\n')}\n\nRecommended: ${rec?.action} — ${rec?.why}\n● strong = titles contain each other, safe to route. ○ weak = one generic word matched; read those pages ONLY if this record is worth the tokens, otherwise park.`,
+          }],
+        }
+      }
+
+      const records = out?.records ?? []
+      if (records.length === 0) {
+        return { content: [{ type: 'text', text: 'Nothing waiting for a home.' }] }
+      }
+      const lines = records.map((r) => {
+        const homes = r.currentHomes?.length ? r.currentHomes.join(', ') : 'nothing'
+        const held = r.claimedBySession ? ` [claimed: ${String(r.claimedBySession).slice(0, 12)}…]` : ''
+        return `  • ${r.title}\n    ${r.source} · ${r.ageHours}h ago · on: ${homes}${held}\n    ${r.recordId}`
+      })
+      return {
+        content: [{
+          type: 'text',
+          text: `${records.length} record(s) waiting for a home:\n\n${lines.join('\n\n')}\n\nRecognize any as your own work? claim_record it now, then route_record once you know where it belongs.`,
+        }],
+      }
+    },
+  )
+
+  server.registerTool(
+    'claim_record',
+    {
+      title: 'Claim a pending record as your work',
+      description: 'Say "this record is mine, I will route it once I know where it goes." Use it as soon as you recognize your own work in pending_records, even before you know the destination page — the claim stops a cheap automatic sweep from guessing at something you have real context on. Claims expire, so a dead session never holds a record hostage. Pass release=true to give one back when it turns out not to be yours.',
+      inputSchema: {
+        recordId: z.string().describe('record id from pending_records'),
+        note: z.string().optional().describe('what you think this is — kept for audit'),
+        leaseMinutes: z.number().int().positive().optional().describe('how long you need it, default 90'),
+        release: z.boolean().optional().describe('give the claim back instead of taking it'),
+      },
+    },
+    async ({ recordId, note, leaseMinutes, release }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/triage`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ action: release ? 'release' : 'claim', recordId, note, leaseMinutes }),
+        })
+      } catch (e) {
+        return toolError(`Could not claim record: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        if (out?.error === 'already_claimed') {
+          return toolError(`Another live session is already holding that record (${String(out.heldBy).slice(0, 16)}…). Leave it to them.`)
+        }
+        return toolError(`Could not claim record: ${out?.error ?? res.status}`)
+      }
+      if (release) return { content: [{ type: 'text', text: 'Released — it is back in the pending pool.' }] }
+      return { content: [{ type: 'text', text: `Claimed until ${out?.expiresAt ?? 'the lease expires'}. Call route_record when you know where it belongs.` }] }
+    },
+  )
+
+  server.registerTool(
+    'route_record',
+    {
+      title: 'Route a record to the pages it belongs on',
+      description: 'Attach a pending record to the pages you judge correct — the point of the whole triage path. Use this when you have real context on what the work was; that judgment is better than any rule the webhook could run. Attachments are additive: existing deterministic homes (routing identifiers, your profile) stay. Pass park=true instead when you have looked and there is genuinely no good home — parking beats attaching to a page that merely shares a word.',
+      inputSchema: {
+        recordId: z.string().describe('record id from pending_records'),
+        documentIds: z.array(z.string()).optional().describe('page document ids to attach (from pending_records sweep, or read_page)'),
+        reason: z.string().describe('why these pages — recorded with the attachment'),
+        park: z.boolean().optional().describe('no good home exists; leave it alone rather than guessing'),
+        tier: z.number().int().optional().describe('2 when this came from the cheap sweep rather than your own context'),
+      },
+    },
+    async ({ recordId, documentIds, reason, park, tier }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/triage`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ action: park ? 'park' : 'route', recordId, documentIds, reason, tier }),
+        })
+      } catch (e) {
+        return toolError(`Could not route record: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not route record: ${out?.error ?? res.status}${out?.detail ? ` — ${out.detail}` : ''}`)
+      if (park) return { content: [{ type: 'text', text: 'Parked. It stays visible and unrouted rather than badly attached.' }] }
+      return { content: [{ type: 'text', text: `Routed — attached to ${out?.attached?.length ?? 0} page(s). Recorded as a session judgment, not a rule match.` }] }
+    },
+  )
+
   server.registerTool(
     'snooze_red_link',
     {
@@ -1699,7 +2038,7 @@ export async function runServer(version) {
     'request_person_page_merge',
     {
       title: 'Offer one duplicate person page for merge',
-      description: 'Offer YOUR accessible person page to be merged into another current accessible person page in the SAME named brain. Use only when the two pages are unquestionably the same real person. Read both pages first and pass their refs and versions. This never crosses brains and does not use fuzzy matching.',
+      description: 'Offer YOUR accessible person NODE for full merge into another current accessible person node in the SAME named brain. Use only when the two nodes are unquestionably the same real person. Read both pages first and pass their refs and versions. This never crosses brains and does not use fuzzy matching.',
       inputSchema: {
         brain: z.string().describe('the exact brain name or brain id; pass an id if names collide'),
         source_ref: z.string().describe('ref of YOUR duplicate source person page'),
@@ -1727,7 +2066,7 @@ export async function runServer(version) {
     'person_page_merge_requests',
     {
       title: 'Review duplicate-person page merge requests',
-      description: 'List pending same-brain person-page merges where you own the canonical page. Read both pages before applying. Applying copies every source summary and section verbatim into the canonical page, preserves its links and as-of dates, and supersedes rather than deletes the source page.',
+      description: 'List pending same-brain person-node merges where you own the canonical page. Read both pages before applying. Applying preserves source page prose/history, moves its raw person attachments (mentions, actor evidence, identifiers, aliases and graph edges) onto the canonical node, and leaves a hidden source alias plus redirect. It refuses conflicting private variants rather than widening them.',
       inputSchema: {},
     },
     async () => {
@@ -1746,7 +2085,7 @@ export async function runServer(version) {
     'apply_person_page_merge',
     {
       title: 'Apply a reviewed duplicate-person page merge',
-      description: 'Apply a pending same-brain person-page merge you own. Re-read the canonical page immediately before applying and pass its version. This is preservation-first: all source summary/sections are retained verbatim in the canonical page, the source page is superseded (not deleted), and its old link target redirects to the canonical page.',
+      description: 'Apply a pending full same-brain person-node merge you own. Re-read the canonical page immediately before applying and pass its version. This is atomic and preservation-first: source prose/history is retained, raw evidence and connections are re-pointed to the canonical node, identifiers are unioned, and the source becomes a hidden alias with a durable redirect. A privacy or identity-metadata conflict refuses the whole merge.',
       inputSchema: {
         request_id: z.string().describe('id from person_page_merge_requests'),
         target_version: z.string().describe('current canonical-page version from a fresh read'),
@@ -1763,7 +2102,7 @@ export async function runServer(version) {
       } catch (e) { return toolError(`Could not apply page merge: ${e.message}`) }
       const out = await res.json().catch(() => null)
       if (!res.ok) return toolError(`Could not apply page merge: ${out?.error ?? res.status}`)
-      return { content: [{ type: 'text', text: `Merged "${out.sourceTitle}" into "${out.targetTitle}". Preserved ${out.preservedSections} source block(s); source page is superseded, not deleted.` }] }
+      return { content: [{ type: 'text', text: `Fully merged "${out.sourceTitle}" into "${out.targetTitle}". Preserved ${out.preservedSections} source page block(s) and moved ${out.movedAttachments} raw attachment(s); source is now a hidden alias with a durable redirect.` }] }
     },
   )
 

package/lib/setup.mjs

@@ -141,16 +141,15 @@ export async function runSetup(argv, version) {
     process.exit(1)
   }
 
-  // ── 3. Managed skills — installed flat into every compatible editor ──────────────────────────
-  // Bundled first (sync, network-free), then org + private served sets (fail-soft pulls), so a
-  // fresh seat has its skills at first session, not second. CORTEX_TOKEN is in env for the pull
-  // only if the caller exported it; each sync falls back to the token this setup just wired.
+  // ── 3. Managed skills — installed flat into every agent CLI present (Claude + Codex) ──
+  // Bundled first (sync, network-free), then the org-published set (fail-soft pull), so a fresh
+  // seat has its org's skills at first session, not second. CORTEX_TOKEN is in env for the pull
+  // only if the caller exported it; syncOrgSkills falls back to the token this setup just wired.
   try {
     installSkills({ quiet: false })
-    const { syncOrgSkills, syncPersonalSkills } = await import('./skills.mjs')
+    const { syncOrgSkills } = await import('./skills.mjs')
     process.env.CORTEX_TOKEN = process.env.CORTEX_TOKEN || token
     await syncOrgSkills({ quiet: false })
-    await syncPersonalSkills({ quiet: false })
   } catch (e) {
     // Non-fatal: a skills hiccup must never block the core connection. Repair runs each session.
     log(`  ⚠ skills install skipped: ${e.message} (will retry on next session)`)

package/lib/skills.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url'
 
 // Managed Agnoclast skills.
 //
-// Three sources, one install pipeline:
+// Two sources, one install pipeline:
 //   1. BUNDLED — shipped inside this package (cortex-log, cortex-context, cortex-author-docs).
 //      Inalterable: canonical content always wins; user edits are backed up + restored.
 //   2. ORG-PUBLISHED — rows in the org's `org_skills` table (documentation-ingestion-spec.md
@@ -13,9 +13,6 @@ import { fileURLToPath } from 'url'
 //      SessionStart `skills --repair` hook pulls + installs it here. Bundled names WIN collisions,
 //      so an org can never shadow a core skill. The pull is fail-soft (offline → last-good cache
 //      at ~/.cortex/org-skills-cache.json → skip), because SessionStart must never break.
-//   3. PERSONAL — rows in `personal_skills`, keyed by auth_id. These are private to one person and
-//      are projected into every compatible editor on their machines. Personal wins an org collision
-//      on that person's machine; bundled core still wins every collision.
 //
 // Installed into EVERY agent CLI present on the machine, at the flat layout each one discovers:
 //   ~/.claude/skills/<name>/SKILL.md   (Claude Code)
@@ -33,16 +30,13 @@ import { fileURLToPath } from 'url'
 const HERE = dirname(fileURLToPath(import.meta.url))
 const BUNDLED = join(HERE, '..', 'skills') // packages/cortex-mcp/skills/<name>/SKILL.md
 const ORG_CACHE = join(homedir(), '.cortex', 'org-skills-cache.json')
-const PERSONAL_CACHE = join(homedir(), '.cortex', 'personal-skills-cache.json')
 const NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/ // mirrors the org_skills check; also blocks path tricks
 
-// Editor skill roots with the compatible flat SKILL.md discovery layout. Cursor's path was verified
-// on-machine before declaring it supported; Antigravity has no documented skill surface yet, so we
-// deliberately do not fabricate one.
+// Agent CLIs we install skills into. Claude is primary; Codex is included whenever it's present.
+// Both use the same flat <cli>/skills/<name>/SKILL.md discovery layout.
 const CLIS = [
   { id: 'Claude Code', dir: join(homedir(), '.claude') },
   { id: 'Codex', dir: join(homedir(), '.codex') },
-  { id: 'Cursor', dir: join(homedir(), '.cursor') },
 ]
 
 // djb2 — tiny, dependency-free content fingerprint for the manifest (drift detection, not security).
@@ -202,25 +196,6 @@ export function planOrgInstall(served, bundledNames) {
   return { install, skipped }
 }
 
-// Personal skills share the same validation and bundled-collision rule as org skills, but never use
-// the cross-brain collision rule: their auth_id uniqueness means only one personal body can exist per
-// name. Keeping this pure makes the precedence contract testable without touching a real home dir.
-export function planPersonalInstall(served, bundledNames) {
-  const bundled = new Set(bundledNames)
-  const install = []
-  const skipped = []
-  const seen = new Set()
-  for (const s of served ?? []) {
-    const name = (s?.name ?? '').trim()
-    if (!NAME_RE.test(name) || typeof s?.body_md !== 'string' || !s.body_md.trim()) { skipped.push({ name: name || '(unnamed)', why: 'invalid' }); continue }
-    if (bundled.has(name)) { skipped.push({ name, why: 'collides with a bundled core skill' }); continue }
-    if (seen.has(name)) { skipped.push({ name, why: 'duplicate personal skill' }); continue }
-    seen.add(name)
-    install.push({ name, source: s.body_md })
-  }
-  return { install, skipped }
-}
-
 /**
  * Pull the org's published skills and install them beside the bundled ones. FAIL-SOFT by design:
  * no token → skip; fetch failure → last-good cache; nothing → skip. SessionStart must never break.
@@ -290,76 +265,6 @@ export async function syncOrgSkills(opts = {}) {
   return summary
 }
 
-/**
- * Pull the caller's personal skill library and project it into every compatible local editor.
- * It is deliberately fail-soft for the same reason as org sync: a network outage must not break a
- * session start. A personal skill wins an unpinned org skill by being installed after org sync.
- */
-export async function syncPersonalSkills(opts = {}) {
-  const quiet = !!opts.quiet
-  const log = (m) => { if (!quiet) process.stdout.write(m + '\n') }
-  const summary = { installed: [], repaired: [], removed: [], skipped: [], source: 'none' }
-  const { resolveBase, readWiredToken, fetchCortex } = await import('./diagnose.mjs')
-  const token = process.env.CORTEX_TOKEN || readWiredToken()
-  if (!token) { log('  · personal skills: no token wired — skipped'); return summary }
-
-  let cache = null
-  try { cache = JSON.parse(readFileSync(PERSONAL_CACHE, 'utf8')) } catch { /* none */ }
-  let served = null
-  try {
-    const res = await fetchCortex(`${resolveBase(process.env.CORTEX_URL)}/api/personal-skills`, {
-      headers: { Authorization: `Bearer ${token}` },
-    })
-    if (res.ok) {
-      served = (await res.json())?.skills ?? []
-      summary.source = 'server'
-    } else {
-      log(`  · personal skills: server said ${res.status} — using last-good cache. Run \`doctor\` if this persists.`)
-    }
-  } catch { /* fall through to cache */ }
-  if (!served && Array.isArray(cache?.skills)) { served = cache.skills; summary.source = 'cache' }
-  if (!served) { log('  · personal skills: unreachable and no cache — skipped'); return summary }
-
-  const bundledNames = bundledSkills().map((s) => s.name)
-  const { install, skipped } = planPersonalInstall(served, bundledNames)
-  summary.skipped = skipped
-  const prevNames = Array.isArray(cache?.installed) ? cache.installed : []
-  const currentNames = install.map((s) => s.name)
-  const retiredNames = prevNames.filter((n) => !currentNames.includes(n))
-
-  // If a personal override was disabled, put back a cached org skill of that name rather than
-  // deleting it. The normal sync sequence has already refreshed ORG_CACHE before this function.
-  let orgCache = null
-  try { orgCache = JSON.parse(readFileSync(ORG_CACHE, 'utf8')) } catch { /* no org fallback */ }
-  const { install: orgInstall } = planOrgInstall(orgCache?.skills, bundledNames)
-  const orgByName = new Map(orgInstall.map((s) => [s.name, s]))
-  const fallback = retiredNames.map((name) => orgByName.get(name)).filter(Boolean)
-  const removeNames = retiredNames.filter((name) => !orgByName.has(name))
-
-  for (const cli of CLIS.filter((c) => existsSync(c.dir))) {
-    // Fallbacks first, personal second: personal > org, but bundled was installed before either.
-    const r = installInto(join(cli.dir, 'skills'), [...fallback, ...install], { removeNames })
-    summary.installed.push(...r.installed)
-    summary.repaired.push(...r.repaired)
-    summary.removed.push(...r.removed)
-  }
-  if (summary.source === 'server') {
-    ensureDir(dirname(PERSONAL_CACHE))
-    writeFileSync(PERSONAL_CACHE, JSON.stringify({ fetchedAt: new Date().toISOString(), skills: served, installed: currentNames }, null, 2))
-  }
-
-  const changed = [...new Set([...summary.installed, ...summary.repaired])]
-  if (changed.length || summary.removed.length) {
-    const bits = []
-    if (changed.length) bits.push(`synced ${changed.join(', ')}`)
-    if (summary.removed.length) bits.push(`removed ${summary.removed.join(', ')}`)
-    process.stdout.write(`Agnoclast: personal skills — ${bits.join('; ')}${summary.source === 'cache' ? ' (offline cache)' : ''}.\n`)
-  } else if (!quiet) {
-    log(`  ✓ personal skills up to date (${currentNames.length} private${skipped.length ? `, ${skipped.length} skipped` : ''})`)
-  }
-  return summary
-}
-
 // Render a failed push. THE SERVER ALREADY ANSWERED THE QUESTION — brain_choice_response.ts builds a
 // body carrying a full `message` plus every brain's NAME, PAGE COUNT and SAMPLE TITLES, explicitly so
 // the caller can choose "by what each one HOLDS, not by which name sounds related". This function
@@ -450,69 +355,10 @@ export async function runSkillsPush(argv) {
   }
 }
 
-export function discoverSkillFiles(root) {
-  if (!root || !existsSync(root)) return []
-  return readdirSync(root, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, 'SKILL.md')))
-    .map((entry) => join(root, entry.name, 'SKILL.md'))
-}
-
-// `skills import --from claude` is the deliberate migration command. It uploads only the user's
-// skill bodies to their private library, then projects the served result; it never publishes to an
-// organization and it never treats a local copy as proof that server sync worked.
-export async function runSkillsImport(argv) {
-  if (argv.length !== 2 || argv[0] !== '--from' || argv[1] !== 'claude') {
-    process.stderr.write('Usage: skills import --from claude\n')
-    return 1
-  }
-  const { resolveBase, readWiredToken, fetchCortex } = await import('./diagnose.mjs')
-  const token = process.env.CORTEX_TOKEN || readWiredToken()
-  if (!token) { process.stderr.write('No Agnoclast token wired — run setup first.\n'); return 1 }
-  const files = discoverSkillFiles(join(homedir(), '.claude', 'skills'))
-  if (!files.length) { process.stderr.write('No Claude Code SKILL.md files found.\n'); return 1 }
-
-  const base = resolveBase(process.env.CORTEX_URL)
-  let imported = 0
-  const skipped = []
-  const seen = new Set()
-  for (const file of files) {
-    const body_md = readFileSync(file, 'utf8')
-    const name = frontmatterName(body_md, '').toLowerCase()
-    if (!NAME_RE.test(name)) { skipped.push(`${file}: invalid frontmatter name`); continue }
-    if (seen.has(name)) { skipped.push(`${file}: duplicate name ${name}`); continue }
-    seen.add(name)
-    try {
-      const res = await fetchCortex(`${base}/api/personal-skills`, {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify({ name, body_md, enabled: true }),
-      })
-      if (!res.ok) {
-        const response = await res.json().catch(() => ({}))
-        skipped.push(`${file}: ${response.error ?? `HTTP ${res.status}`}`)
-        continue
-      }
-      imported++
-    } catch (e) {
-      skipped.push(`${file}: network error: ${e.message}`)
-    }
-  }
-  process.stdout.write(`Agnoclast: imported ${imported}/${files.length} Claude Code skills into your private library.\n`)
-  for (const reason of skipped) process.stdout.write(`  · skipped ${reason}\n`)
-  if (imported) await syncPersonalSkills({ quiet: false })
-  return skipped.length ? 1 : 0
-}
-
 // CLI entry: `cortex-mcp skills [--repair] [--quiet] | skills push …`. (--repair and plain install
 // are the same idempotent operation; --repair is just the name the SessionStart hook uses for intent.)
 export async function runSkills(argv = []) {
   if (argv[0] === 'push') return runSkillsPush(argv.slice(1))
-  if (argv[0] === 'import') return runSkillsImport(argv.slice(1))
-  const syncing = argv[0] === 'sync'
-  if (argv[0] && !syncing && argv[0] !== '--repair' && argv[0] !== '--quiet') {
-    process.stderr.write('Usage: skills [sync|--repair] | skills import --from claude | skills push <SKILL.md> [--brain <name>]\n')
-    return 1
-  }
 
   const quiet = argv.includes('--quiet')
   if (!quiet) process.stdout.write('\nAgnoclast skills — installing managed skills…\n')
@@ -523,9 +369,6 @@ export async function runSkills(argv = []) {
       process.stdout.write(`  ✓ Up to date in ${r.targets.join(' + ')} (${[...new Set(r.unchanged)].join(', ') || 'none'}).\n`)
     }
   }
-  if (r.targets.length) {
-    await syncOrgSkills({ quiet })
-    await syncPersonalSkills({ quiet })
-  }
+  if (r.targets.length) await syncOrgSkills({ quiet })
   return 0
 }

package/package.json

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