@theronap/cortex-mcp 0.9.23 → 0.9.25

package/bin/cortex-mcp.mjs

@@ -97,19 +97,6 @@ if (cmd === 'setup') {
   await runResolve()
   const { closeFetch } = await import('../lib/diagnose.mjs')
   await closeFetch()
-} else if (cmd === 'relationships') {
-  // Tier-3 relationship inference: judge server-flagged nodes' prose-implied relationships via `claude -p`.
-  const { runRelationships } = await import('../lib/relationships.mjs')
-  await runRelationships()
-  const { closeFetch } = await import('../lib/diagnose.mjs')
-  await closeFetch()
-} else if (cmd === 'links') {
-  // CU-2 cross-user link judge: judge server-flagged candidate pairs ("do these interconnect?") via
-  // `claude -p` and push verdicts back (queue/reject — never an auto-write). Sibling of `relationships`.
-  const { runLinks } = await import('../lib/links.mjs')
-  await runLinks()
-  const { closeFetch } = await import('../lib/diagnose.mjs')
-  await closeFetch()
 } else if (cmd === 'materialize') {
   // Brain-page summarizer on the SUBSCRIPTION (claude -p): claim authorized digest jobs, summarize
   // locally, submit the text for the server to write. `--drain` clears the whole backlog.

package/lib/server.mjs

@@ -271,95 +271,16 @@ export async function runServer(version) {
       }
       const page = await res.json()
       if (!page?.authored || !Array.isArray(page.tiers) || !page.tiers.length) {
-        return { content: [{ type: 'text', text: `"${name}" (${k}) exists but has no authored page yet — nothing to read. Try \`grep\` for mentions or \`story\` for a records-derived narrative.` }] }
+        return { content: [{ type: 'text', text: `"${name}" (${k}) exists but has no authored page yet — nothing to read. \`grep\` for mentions, or author it if you hold first-hand knowledge worth capturing.` }] }
       }
       const day = (d) => (d ? String(d).slice(0, 10) : '')
       const blocks = page.tiers.map((t) => {
         const secs = (t.sections ?? []).map((s) => `### ${s.heading}\n${s.body}`).join('\n\n')
-        const head = `[${t.tier}${day(t.updated_at) ? ` · authored ${day(t.updated_at)}` : ''}${t.validity && t.validity !== 'current' ? ` · ${t.validity}` : ''}]`
+        const head = `[${t.tier}${day(t.updated_at) ? ` · authored ${day(t.updated_at)}` : ''}${t.validity && t.validity !== 'current' ? ` · ${t.validity}` : ''}${t.version ? `\nversion: ${t.version}` : ''}]`
         return [head, t.summary, secs].filter(Boolean).join('\n')
       })
-      return { content: [{ type: 'text', text: `# ${page.title ?? name} (full authored page)\n\n${blocks.join('\n\n---\n\n')}\n\n— Follow any [[links]] above with read_page to go deeper.` }] }
-    },
-  )
-
-  server.registerTool(
-    'story',
-    {
-      title: 'Story of a topic',
-      description: 'Ask "what\'s the story of X?" — assembles a chronological narrative of what happened with a project, topic, or piece of work, from across all your activity (commits, sessions, discussions). Scoped to what you can see.',
-      inputSchema: { question: z.string().describe('the topic/project/thing to get the story of, e.g. "the auth work" or "checkout-v2"') },
-    },
-    async ({ question }) => {
-      let res
-      try {
-        res = await fetchCortex(`${BASE}/api/story`, {
-          method: 'POST',
-          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
-          body: JSON.stringify({ question }),
-        })
-      } catch (e) {
-        return { content: [{ type: 'text', text: `Could not assemble story: ${e.message}` }] }
-      }
-      if (!res.ok) {
-        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-        return { content: [{ type: 'text', text: `Could not assemble story: ${d.message}` }] }
-      }
-      const { answer, sourceCount, sources } = await res.json()
-      const srcList = (sources ?? []).map((s) => `  - [${s.id}] ${s.title} (${s.source})`).join('\n')
-      const tail = srcList ? `\n\nSources (pass an id to set_record_privacy to reclassify a record you own):\n${srcList}` : ''
-      return { content: [{ type: 'text', text: `${answer}\n\n(assembled from ${sourceCount} record${sourceCount === 1 ? '' : 's'})${tail}` }] }
-    },
-  )
-
-  server.registerTool(
-    'who_knows',
-    {
-      title: 'Who knows about X',
-      description: 'Ranked teammates who have visibly worked on a topic, with evidence — derived only from records you are permitted to see.',
-      inputSchema: { topic: z.string().describe('the topic/system/skill, e.g. "the embedding pipeline" or "stripe webhooks"') },
-    },
-    async ({ topic }) => {
-      let res
-      try {
-        res = await fetchCortex(`${BASE}/api/who-knows?q=${encodeURIComponent(topic)}`, {
-          headers: { Authorization: `Bearer ${TOKEN}` },
-        })
-      } catch (e) {
-        return { content: [{ type: 'text', text: `Could not look up experts: ${e.message}` }] }
-      }
-      if (!res.ok) {
-        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-        return { content: [{ type: 'text', text: `Could not look up experts: ${d.message}` }] }
-      }
-      const { experts } = await res.json()
-      if (!experts?.length) return { content: [{ type: 'text', text: `No one visible to you has recorded work about "${topic}".` }] }
-      const lines = experts.map((e, i) =>
-        `${i + 1}. ${e.name} — ${e.count} visible record${e.count === 1 ? '' : 's'}\n   e.g. ${e.evidence.join(' · ')}`)
-      return { content: [{ type: 'text', text: `People with visible work on "${topic}":\n${lines.join('\n')}` }] }
-    },
-  )
-
-  server.registerTool(
-    'daily_brief',
-    {
-      title: 'Your daily brief',
-      description: 'A short, action-forward brief of what needs YOU today: pending decisions/directives, your stalled or unowned projects, today\'s meetings, who else moved on your work, and where you left off. The inverse of my_context — call it at the start of a session or whenever you want "what should I focus on?". RLS-scoped to you.',
-      inputSchema: {},
-    },
-    async () => {
-      let res
-      try {
-        res = await fetchCortex(`${BASE}/api/brief`, { headers: { Authorization: `Bearer ${TOKEN}` } })
-      } catch (e) {
-        return { content: [{ type: 'text', text: `Could not build your brief: ${e.message}` }] }
-      }
-      if (!res.ok) {
-        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-        return { content: [{ type: 'text', text: `Could not build your brief: ${d.message}` }] }
-      }
-      const { brief } = await res.json()
-      return { content: [{ type: 'text', text: brief || 'Nothing needs you right now.' }] }
+      const footer = `— Follow any [[links]] above with read_page to go deeper.\n— If you hold fresher FIRST-HAND truth than this page — something you established THIS session (ran the command, made the change, hold the artifact) that a section here gets concretely wrong — re-author just those sections now with \`author\` (any node you are permitted to edit; concise; a material contradiction, not merely extra detail). Pass this page's \`version\` as base_version when you re-author — if the save comes back stale, the page changed under you: re-read, then re-author. Reading a stale page you can fix IS the trigger to fix it.`
+      return { content: [{ type: 'text', text: `# ${page.title ?? name} (full authored page)\n\n${blocks.join('\n\n---\n\n')}\n\n${footer}` }] }
     },
   )
 
@@ -413,29 +334,6 @@ export async function runServer(version) {
     },
   )
 
-  server.registerTool(
-    'org_report',
-    {
-      title: 'Cross-project status report',
-      description: 'A status digest across all projects you can see: how many are healthy vs slowing/stalled/unowned, what needs attention, and (for managers) cross-source gaps. RLS-scoped to you. Use for "where do things stand?" / a standup or weekly review.',
-      inputSchema: {},
-    },
-    async () => {
-      let res
-      try {
-        res = await fetchCortex(`${BASE}/api/report`, { headers: { Authorization: `Bearer ${TOKEN}` } })
-      } catch (e) {
-        return { content: [{ type: 'text', text: `Could not build the report: ${e.message}` }] }
-      }
-      if (!res.ok) {
-        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-        return { content: [{ type: 'text', text: `Could not build the report: ${d.message}` }] }
-      }
-      const { report } = await res.json()
-      return { content: [{ type: 'text', text: report }] }
-    },
-  )
-
   server.registerTool(
     'list_records',
     {
@@ -729,10 +627,11 @@ export async function runServer(version) {
           body: z.string().describe('dense markdown WITH inline [[links]] where the prose references another node'),
         })).describe('3-5 sections; the page body'),
         tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('visibility tier (default accessible — the shareable page)'),
+        base_version: z.string().optional().describe('the `version` hash shown when you read this page (read_page) — REQUIRED when updating an existing page, so a concurrent edit is caught instead of clobbered. Omit only for a brand-new node. If the save returns "stale" or "read first", read_page again and retry with the fresh version.'),
       },
     },
-    async ({ kind, name, summary, sections, tier }) => {
-      const pages = [{ tier: tier ?? 'accessible', summary, sections: Array.isArray(sections) ? sections : [] }]
+    async ({ kind, name, summary, sections, tier, base_version }) => {
+      const pages = [{ tier: tier ?? 'accessible', summary, base_version, sections: Array.isArray(sections) ? sections : [] }]
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/author`, {

package/package.json

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

package/lib/links.mjs

@@ -1,105 +0,0 @@
-import { spawnSync } from 'child_process'
-import { fetchCortex, resolveBase, classify } from './diagnose.mjs'
-import { edgeSafeEnv } from './edge_extract.mjs'
-
-// `cortex-mcp links` — the JUDGE half of CU-2 (cross-user link curation), sibling of `relationships`.
-// The server FLAGS proposed candidate pairs (GET /api/link-judge-candidates) with resolved endpoint names
-// + co-usage evidence; this command judges each LOCALLY via `claude -p` (the server never calls the metered
-// API) — "do these two genuinely interconnect?" — and pushes verdicts back (POST /api/link-judge-apply).
-// SAFETY: the apply only ever moves a candidate to `queued` (human approval) or `rejected`; it never writes
-// a cross_user_links row. Conservative by construction: the prompt asks the model to default to "incidental".
-
-export async function runLinks() {
-  // recursion guard (we spawn `claude --print`; its Stop hook capture no-ops on this flag)
-  if (process.env.CORTEX_SUMMARIZING) { process.stderr.write('cortex: summarizer subprocess, skipping\n'); return }
-  const token = process.env.CORTEX_TOKEN
-  if (!token) { process.stderr.write('cortex: CORTEX_TOKEN not set, skipping\n'); return }
-  const base = resolveBase(process.env.CORTEX_URL)
-
-  // 1. pull proposed candidates (each with resolved endpoint names + co-usage count)
-  let candidates = []
-  try {
-    const res = await fetchCortex(`${base}/api/link-judge-candidates`, { headers: { Authorization: `Bearer ${token}` } })
-    if (!res.ok) {
-      const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-      process.stderr.write(`cortex: link-judge-candidates failed — ${d.message}\n`); return
-    }
-    const j = await res.json().catch(() => ({}))
-    candidates = Array.isArray(j.candidates) ? j.candidates : []
-  } catch (e) { process.stderr.write(`cortex: links fetch failed — ${e.message}\n`); return }
-
-  if (!candidates.length) { process.stderr.write('cortex: no link candidates to judge\n'); return }
-  process.stderr.write(`cortex: judging ${candidates.length} link candidate(s) locally…\n`)
-
-  // 2. judge locally on the subscription — ONE call per candidate (each is a single pair)
-  const judgments = []
-  let judged = 0
-  for (const c of candidates) {
-    const verdict = judgeLink(c)
-    if (verdict === null) { process.stderr.write('cortex: judge unavailable (is `claude` on PATH?) — skipping\n'); break }
-    judged++
-    if (verdict) judgments.push(verdict)
-  }
-  if (!judged) return
-  if (!judgments.length) { process.stderr.write(`cortex: judged ${judged} candidate(s), no verdicts produced\n`); return }
-
-  // 3. apply the verdicts (queue / reject)
-  try {
-    const res = await fetchCortex(`${base}/api/link-judge-apply`, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ judgments }),
-    })
-    if (res.ok) {
-      const j = await res.json().catch(() => ({}))
-      process.stderr.write(`cortex: links — queued ${j.queued ?? 0}, rejected ${j.rejected ?? 0}, skipped ${j.skipped ?? 0}\n`)
-    } else {
-      const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-      process.stderr.write(`cortex: link-judge-apply failed — ${d.message}\n`)
-    }
-  } catch (e) { process.stderr.write(`cortex: link-judge-apply failed — ${e.message}\n`) }
-}
-
-// ONE `claude --print` call decides whether a candidate pair genuinely interconnects. Returns a judgment
-// { candidateId, interconnected, confidence, relationship, reason }, or null if the CLI is unavailable.
-// Mirrors web/lib/engine/link_judge.ts buildJudgePrompt/parseJudgeResponse (kept in sync).
-function judgeLink(c) {
-  if (!c || typeof c.candidateId !== 'string' || !c.src || !c.dst) return false
-  const co = c.coUsageCount != null ? `They have been surfaced together ${c.coUsageCount} time(s) when answering questions.` : ''
-  const prompt = [
-    `Two entities in an organization's knowledge graph keep showing up together but are not yet linked.`,
-    `A: ${c.src.name} (${c.src.kind})`,
-    `B: ${c.dst.name} (${c.dst.kind})`,
-    co,
-    `Question: do A and B genuinely interconnect (a real working/organizational relationship), or is the co-occurrence incidental?`,
-    `Reply with ONLY a JSON object: {"interconnected": boolean, "confidence": 0..1, "relationship": "<short label>", "reason": "<one line>"}.`,
-    `Be conservative — if it looks incidental, say interconnected:false. Never invent specifics you weren't given.`,
-  ].filter(Boolean).join('\n')
-  try {
-    const r = spawnSync(
-      'claude',
-      ['--print', '--model', process.env.CORTEX_SUMMARY_MODEL ?? 'claude-haiku-4-5', prompt],
-      { env: edgeSafeEnv(process.env, { CORTEX_SUMMARIZING: '1' }), encoding: 'utf8', timeout: 120_000, maxBuffer: 4 * 1024 * 1024 },
-    )
-    if (r.status !== 0 || !r.stdout) return null
-    return parseVerdict(r.stdout, c.candidateId)
-  } catch {
-    return null
-  }
-}
-
-function parseVerdict(out, candidateId) {
-  const start = out.indexOf('{')
-  const end = out.lastIndexOf('}')
-  if (start < 0 || end <= start) return false
-  let o
-  try { o = JSON.parse(out.slice(start, end + 1)) } catch { return false }
-  const confidence = Math.max(0, Math.min(1, Number(o.confidence) || 0))
-  return {
-    candidateId,
-    interconnected: !!o.interconnected,
-    confidence,
-    relationship: typeof o.relationship === 'string' ? o.relationship.trim().slice(0, 80) : undefined,
-    reason: typeof o.reason === 'string' ? o.reason.trim().slice(0, 280) : undefined,
-  }
-}

package/lib/relationships.mjs

@@ -1,138 +0,0 @@
-import { spawnSync } from 'child_process'
-import { fetchCortex, resolveBase, classify } from './diagnose.mjs'
-import { edgeSafeEnv } from './edge_extract.mjs'
-
-// `cortex-mcp relationships` — the JUDGE half of Tier-3 relationship inference (relationship layer slice 3,
-// sibling of `resolve`). The server FLAGS nodes worth judging (GET /api/relationship-candidates) with their
-// accessible evidence + already-known connections; this command reads that evidence LOCALLY via `claude -p`
-// (the engine preference — the server never calls the metered API) and infers prose-implied relationships,
-// then pushes them back (POST /api/relationship-apply) where high/medium-confidence ones become [[links]] on
-// the node's page. Conservative by construction: structural/known links are excluded from the prompt, only
-// relationships actually stated in the evidence are returned, and low confidence is dropped server-side.
-
-// Relationship taxonomy (spec §2) — the judge must pick from this enum (business only; no romantic/family).
-const REL_TYPES = [
-  'reports_to', 'manages', 'member_of', 'employed_by', 'works_on', 'works_with', 'owns', 'depends_on',
-  'produces', 'customer_of', 'vendor_to', 'partner_of', 'invested_in', 'governs', 'about', 'cites', 'supersedes',
-]
-
-export async function runRelationships() {
-  // recursion guard (we spawn `claude --print`; if its Stop hook fires capture, that no-ops on this flag)
-  if (process.env.CORTEX_SUMMARIZING) { process.stderr.write('cortex: summarizer subprocess, skipping\n'); return }
-  const token = process.env.CORTEX_TOKEN
-  if (!token) { process.stderr.write('cortex: CORTEX_TOKEN not set, skipping\n'); return }
-  const base = resolveBase(process.env.CORTEX_URL)
-
-  // 1. pull the flagged candidate nodes (each with evidence + known connections)
-  let candidates = []
-  try {
-    const res = await fetchCortex(`${base}/api/relationship-candidates`, { headers: { Authorization: `Bearer ${token}` } })
-    if (!res.ok) {
-      const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-      process.stderr.write(`cortex: relationship-candidates failed — ${d.message}\n`); return
-    }
-    const j = await res.json().catch(() => ({}))
-    candidates = Array.isArray(j.candidates) ? j.candidates : []
-  } catch (e) { process.stderr.write(`cortex: relationships fetch failed — ${e.message}\n`); return }
-
-  if (!candidates.length) { process.stderr.write('cortex: no nodes to judge for relationships\n'); return }
-  process.stderr.write(`cortex: inferring relationships for ${candidates.length} node(s) locally…\n`)
-
-  // 2. judge locally on the subscription — ONE call per node (evidence is per-node, bounded)
-  const relationships = []
-  let judged = 0
-  for (const c of candidates) {
-    const inferred = judgeNode(c)
-    if (inferred === null) { process.stderr.write('cortex: judge unavailable (is `claude` on PATH?) — skipping\n'); break }
-    judged++
-    for (const r of inferred) relationships.push(r)
-  }
-  if (!judged) return
-  if (!relationships.length) { process.stderr.write(`cortex: judged ${judged} node(s), no new relationships inferred\n`); return }
-
-  // 3. apply the judged relationships
-  try {
-    const res = await fetchCortex(`${base}/api/relationship-apply`, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ relationships }),
-    })
-    if (res.ok) {
-      const j = await res.json().catch(() => ({}))
-      process.stderr.write(`cortex: relationships — wrote ${j.relationships ?? 0} across ${j.subjects ?? 0} node(s), skipped ${j.skipped ?? 0}\n`)
-    } else {
-      const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-      process.stderr.write(`cortex: relationship-apply failed — ${d.message}\n`)
-    }
-  } catch (e) { process.stderr.write(`cortex: relationship-apply failed — ${e.message}\n`) }
-}
-
-// ONE `claude --print` call infers a node's prose-implied relationships from its evidence. Returns
-// InferredRelationship[] (subjectId/subjectName carried from the candidate), or null if the CLI is
-// unavailable. Conservative: already-known connections are listed as "do NOT re-assert"; only relationships
-// the evidence actually states are returned; the model self-scores confidence and the server drops < 0.5.
-function judgeNode(c) {
-  if (!c || typeof c.nodeId !== 'string' || typeof c.nodeName !== 'string') return []
-  const evidence = (Array.isArray(c.evidence) ? c.evidence : [])
-    .slice(0, 30)
-    .map((e, i) => `[${i}] ${e?.title ?? ''}${e?.summary ? ` — ${String(e.summary).slice(0, 280)}` : ''}`)
-    .join('\n')
-  if (!evidence.trim()) return []
-  const known = (Array.isArray(c.knownConnections) ? c.knownConnections : []).filter(Boolean).join(', ') || '(none)'
-  const prompt =
-    `You are mapping business relationships for ONE person in an organization knowledge graph: "${c.nodeName}".\n` +
-    `Below is evidence (record titles + summaries) that mentions them. Identify relationships of "${c.nodeName}" ` +
-    `that are EXPLICITLY stated or strongly implied by THIS evidence — to other people, teams, projects, ` +
-    `systems, or organizations.\n\n` +
-    `Rules:\n` +
-    `- Use ONLY these relationship types: ${REL_TYPES.join(', ')}.\n` +
-    `- Be CONSERVATIVE: only assert a relationship the evidence actually supports. When unsure, omit it.\n` +
-    `- Do NOT re-assert these already-known connections: ${known}.\n` +
-    `- "target" is the OTHER endpoint's name exactly as written. Never invent names, numbers, or titles.\n` +
-    `- Business relationships only (no romantic/family).\n` +
-    `Return ONLY a minified JSON array — one object per relationship: ` +
-    `{"rel_type":"<one of the enum>","target":"<name>","confidence":<0..1>,"evidence":"<short quote>"}.\n` +
-    `If the evidence supports no clear relationship, return [].\n\n` +
-    `EVIDENCE:\n${evidence}`
-  try {
-    const r = spawnSync(
-      'claude',
-      ['--print', '--model', process.env.CORTEX_SUMMARY_MODEL ?? 'claude-haiku-4-5', prompt],
-      { env: edgeSafeEnv(process.env, { CORTEX_SUMMARIZING: '1' }), encoding: 'utf8', timeout: 120_000, maxBuffer: 4 * 1024 * 1024 },
-    )
-    if (r.status !== 0 || !r.stdout) return null
-    return parseInferred(r.stdout, c)
-  } catch {
-    return null
-  }
-}
-
-function parseInferred(out, c) {
-  const start = out.indexOf('[')
-  const end = out.lastIndexOf(']')
-  if (start < 0 || end <= start) return []
-  let arr
-  try { arr = JSON.parse(out.slice(start, end + 1)) } catch { return [] }
-  if (!Array.isArray(arr)) return []
-  const valid = new Set(REL_TYPES)
-  const out2 = []
-  for (const d of arr) {
-    const relType = typeof d?.rel_type === 'string' ? d.rel_type.trim() : ''
-    const target = typeof d?.target === 'string' ? d.target.trim() : ''
-    if (!valid.has(relType) || !target) continue
-    out2.push({
-      subjectId: c.nodeId,
-      subjectName: c.nodeName,
-      // echo the candidate's node-kind/tier/owner so the server writes the inference at the right
-      // tier + owner (accessible/person vs the user's own scoped|confidential page). Server re-validates.
-      nodeKind: c.nodeKind,
-      tier: c.tier,
-      ownerUserId: c.ownerUserId ?? null,
-      relType,
-      target,
-      confidence: Number(d.confidence) || 0,
-      evidence: typeof d.evidence === 'string' ? d.evidence.slice(0, 240) : undefined,
-    })
-  }
-  return out2
-}