@theronap/cortex-mcp 0.9.86 → 0.9.88

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,161 @@ 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_discard',
+    {
+      title: 'Discard a private intake item',
+      description:
+        'The OTHER terminal outcome for a claimed intake unit: this is nothing, drop it. Use it for content that should never become a record — unsubscribe receipts, empty greetings, marketing blasts, a stranger\'s photo — instead of materializing junk into a brain because materialize was the only verb available. IRREVERSIBLE: the ciphertext and nonces are destroyed in the same transaction, and a content-free tombstone stops the connector re-delivering the unit. You must already hold the claim (discarding something you never read is refused), `reason` is required and is stored, and it is one item per call — a loop discarding a whole pile on one decision is a bulk job, not judgment.',
+      inputSchema: {
+        intakeItemId: z.string().describe('intake item uuid from intake_claim'),
+        reason: z.string().describe('why this is nothing — recorded on the claim, and the only surviving trace of the decision'),
+      },
+    },
+    async ({ intakeItemId, reason }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/intake/discard`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ intakeItemId, reason }),
+        })
+      } catch (e) {
+        return toolError(`Could not discard: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        if (out?.error === 'not_claimed') {
+          return toolError('You do not hold a claim on that item — intake_claim it first, so the discard follows from having read it.')
+        }
+        if (out?.error === 'already_materialized') {
+          return toolError('That unit already became a record. Discarding it now would orphan the record from its source — detach or retier the record instead.')
+        }
+        return toolError(`Could not discard: ${out?.error ?? res.status}${out?.detail ? ` — ${out.detail}` : ''}`)
+      }
+      if (out?.alreadyDiscarded) {
+        return { content: [{ type: 'text', text: 'Already discarded — nothing to do.' }] }
+      }
+      return { content: [{ type: 'text', text: 'Discarded. Content destroyed, tombstone written so the source cannot re-deliver it.' }] }
+    },
+  )
+
+  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 +1661,222 @@ 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, over timeline_claims ────────────────────────────────────────────
+  // 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.
+  //
+  // The ledger is `timeline_claims` (0105) — one claim discipline over one stream. Unclaimed means
+  // NO claim row: absence IS the backlog, and nothing is written at ingest.
+
+  server.registerTool(
+    'pending_records',
+    {
+      title: 'Records waiting for a home',
+      description: 'List recent connector records (GitHub pushes, PRs, email) that NOBODY HAS ATTENDED TO yet — no claim row in the Gate 4 ledger. 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, and you are the only one who can recognize them as yours. 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 takes it out of the backlog so nothing else guesses at something you have real context on. Claims are leased and expire, so a dead session never holds a record hostage, and a record held by another LIVE session cannot be taken. Pass release=true to give one back when it turns out not to be yours — that deletes the claim, so the record looks untouched again rather than attended-to.',
+      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(
+    'unroute_record',
+    {
+      title: 'Remove pages a record should not be on',
+      description:
+        'Detach pages a record does not belong on — the inverse of route_record, and the only way a wrong placement can be undone. route_record is purely ADDITIVE, so attaching more pages can never fix a bad one. Use this when you can see a record sitting on a page it has no real relationship to — the classic case is a fuzzy title match, e.g. a commit attached to a page merely because both contain a common word. Two things it will refuse rather than surprise you: it will not remove every attachment (a record with no home is invisible, which is worse than a wrong home — route or park it instead), and detaching the page that GOVERNS the tier can tighten the record but never republish it, since a widening is pinned and proposed for a human to confirm.',
+      inputSchema: {
+        recordId: z.string().describe('record id from pending_records'),
+        documentIds: z.array(z.string()).describe('page document ids to REMOVE from this record'),
+        reason: z.string().describe('why these placements are wrong — recorded with the removal'),
+      },
+    },
+    async ({ recordId, documentIds, reason }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/triage`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ action: 'detach', recordId, documentIds, reason }),
+        })
+      } catch (e) {
+        return toolError(`Could not detach: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        // These two are guard rails, not faults — say what to do instead of just naming the code.
+        if (out?.error === 'would_strand') {
+          return toolError(`Refused: ${out.detail ?? 'that would leave the record with no pages at all.'}`)
+        }
+        if (out?.error === 'not_attached') {
+          return toolError(`Nothing removed: ${out.detail ?? 'those pages are not attached to this record.'}`)
+        }
+        return toolError(`Could not detach: ${out?.error ?? res.status}${out?.detail ? ` — ${out.detail}` : ''}`)
+      }
+      const n = out?.detached?.length ?? 0
+      const left = out?.remaining ?? 0
+      return {
+        content: [{
+          type: 'text',
+          text: `Detached ${n} page(s); ${left} attachment(s) remain. Record tier: ${out?.privacy ?? 'unchanged'}. Recorded as a session judgment.`,
+        }],
+      }
+    },
+  )
+
   server.registerTool(
     'snooze_red_link',
     {
@@ -1699,7 +2125,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 +2153,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 +2172,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 +2189,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.
@@ -261,10 +236,7 @@ export async function syncOrgSkills(opts = {}) {
 
   const { install, skipped } = planOrgInstall(served, bundledSkills().map((s) => s.name))
   summary.skipped = skipped
-  // Only a cache written by this personal-sync implementation owns local files it may retire. An
-  // older/cache-shaped-alike file is not proof of ownership; treating it as one deleted source
-  // skills that had not yet been accepted by the server. First sync after an upgrade is additive.
-  const prevNames = cache?.version === 1 && Array.isArray(cache?.installed) ? cache.installed : []
+  const prevNames = Array.isArray(cache?.installed) ? cache.installed : []
   const currentNames = install.map((s) => s.name)
   const removeNames = prevNames.filter((n) => !currentNames.includes(n))
 
@@ -293,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({ version: 1, 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
@@ -453,83 +355,10 @@ export async function runSkillsPush(argv) {
   }
 }
 
-export function discoverSkillFiles(root) {
-  if (!root || !existsSync(root)) return []
-  const out = []
-  const walk = (dir) => {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      if (!entry.isDirectory() || entry.name.startsWith('.')) continue
-      const child = join(dir, entry.name)
-      const skill = join(child, 'SKILL.md')
-      if (existsSync(skill)) out.push(skill)
-      walk(child)
-    }
-  }
-  walk(root)
-  // Prefer a direct skill over an equally named nested vendor copy. This gives a user override
-  // priority while still discovering bundled sub-skills such as gstack's long-form workflows.
-  return out.sort((a, b) => {
-    const depth = (path) => path.slice(root.length).split('/').filter(Boolean).length
-    return depth(a) - depth(b) || a.localeCompare(b)
-  })
-}
-
-// `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')
@@ -540,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.86",
+  "version": "0.9.88",
   "description": "Connect your AI assistant to Cortex — your org's projects, activity, gaps, and directives, scoped to you.",
   "type": "module",
   "bin": {