@theronap/cortex-mcp 0.9.27 → 0.9.29

package/bin/cortex-mcp.mjs

@@ -46,7 +46,6 @@ 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` +
     `  skills          install/repair the managed Cortex skills (also wired by setup)\n` +
-    `  materialize [--drain]  build brain pages on your Claude subscription (claude -p); --drain clears the backlog\n` +
     `  snapshot-context save the exact startup context Cortex served to a local snapshot\n` +
     `  capture         Stop-hook capturer (invoked by Claude Code)\n` +
     `  ingest-folder <path>   ingest a local markdown folder as your authored records\n` +
@@ -98,12 +97,9 @@ if (cmd === 'setup') {
   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.
-  const { runMaterializeCli } = await import('../lib/materialize.mjs')
-  process.exitCode = await runMaterializeCli(rest)
-  const { closeFetch } = await import('../lib/diagnose.mjs')
-  await closeFetch()
+  // EXCISED 2026-07-02 (legacy-materializer incident): the digest pipeline deleted live-authored
+  // pages. Pages come from live authoring now; this stub keeps old hook invocations harmless.
+  process.stderr.write('cortex-mcp: `materialize` was removed — pages come from live authoring (the `author` tool + /log). Nothing to do.\n')
 } else if (cmd === 'ingest-folder') {
   const { runIngestFolder } = await import('../lib/ingest_folder.mjs')
   await runIngestFolder(rest)

package/lib/capture.mjs

@@ -5,7 +5,6 @@ import { createHash } from 'crypto'
 import { fetchCortex, classify, resolveBase } from './diagnose.mjs'
 import { extractSession } from './edge_extract.mjs'
 import { extractTyped } from './extract_typed.mjs'
-import { runMaterialize } from './materialize.mjs'
 import { redactSecrets } from './redact.mjs'
 
 // Fetch the node-type registry (global + this org's custom types) — the catalog the typed extractor
@@ -166,11 +165,7 @@ export async function runCapture() {
     process.stderr.write(`cortex: ingest failed — ${d.message}\n`)
   }
 
-  // Keystone fix (b): ingest just marked this session's nodes dirty server-side. Summarize the freshly
-  // dirtied pages on the SUBSCRIPTION (claude -p) so the brain stays current without the dead server
-  // API. OPT-IN (CORTEX_MATERIALIZE) + bounded so it never adds unbounded latency to session stop;
-  // `cortex-mcp materialize --drain` is the bulk/backlog path. Best-effort: never blocks capture.
-  if (process.env.CORTEX_MATERIALIZE) {
-    try { await runMaterialize({ max: 3 }) } catch { /* best-effort */ }
-  }
+  // The post-capture edge-materialize batch (CORTEX_MATERIALIZE → runMaterialize) was EXCISED
+  // 2026-07-02 with the legacy materializer: its server pipeline deleted live-authored pages whose
+  // record-hashes drifted. Pages come from live authoring (the `author` tool + /log sweep) now.
 }

package/lib/server.mjs

@@ -252,10 +252,35 @@ export async function runServer(version) {
         name: z.string().describe('the canonical node name exactly as written (e.g. "Cortex", "Ben", or a [[link]] target) — identifier links ([[repo:owner/name]]) resolve to their authored HOME + a visible-event count'),
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project; pass person/org for people/teams)'),
         expand: z.boolean().optional().describe('identifier names only: also list recent visible timeline events for this identifier (default: home + count)'),
+        history: z.boolean().optional().describe('node names only: return the node\'s TIMELINE (events joined via its [[repo:…]] stamps, reverse-chron, viewer-visible) instead of the page body. The page is the present; this is the history.'),
       },
     },
-    async ({ name, kind, expand }) => {
+    async ({ name, kind, expand, history }) => {
       const k = kind ?? 'project'
+      // PER-NODE TIMELINE (slice 4): history = the projection over the node's identifier stamps.
+      if (history && !/^[a-z][a-z0-9_-]*:.+/i.test(name)) {
+        try {
+          const qs = new URLSearchParams({ kind: k, key: name })
+          const r = await fetchCortex(`${BASE}/api/node/timeline?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+          if (r.status === 404) return { content: [{ type: 'text', text: `No ${k} named "${name}" — cannot project a timeline.` }] }
+          if (!r.ok) {
+            const d = classify(r.status, r.headers.get('content-type'), await r.text(), r.headers.get('x-vercel-id'))
+            return { content: [{ type: 'text', text: `Could not read the timeline for "${name}": ${d.message}` }] }
+          }
+          const t = await r.json()
+          if (!t.identifiers?.length) {
+            return { content: [{ type: 'text', text: `"${name}" carries no identifier stamps yet — no history joins. Stamp its page with [[repo:owner/name]] (what it identifies) and events will accrue here.` }] }
+          }
+          const lines = [`# ${name} — node timeline (history; the page is the present)`]
+          lines.push(`Joins: ${t.identifiers.map((i) => `[[${i.id}]] · ${i.visibleCount} visible`).join('  |  ')}${t.incomplete ? '  (partial — one join failed to read)' : ''}`)
+          for (const e of t.events) lines.push(`- ${String(e.occurredAt).slice(0, 10)} · ${e.source} · ${e.summary}`)
+          if (!t.events.length) lines.push('(no events visible to you yet on these joins)')
+          if (t.siblings?.length) lines.push(`Sibling homes (share a stamp — bridges, not history): ${t.siblings.map((s) => `"${s.title}"`).join(', ')}`)
+          return { content: [{ type: 'text', text: lines.join('\n') }] }
+        } catch (e) {
+          return { content: [{ type: 'text', text: `Could not read the timeline for "${name}": ${e.message}` }] }
+        }
+      }
       // IDENTIFIER RESOLUTION (slice 3): an identifier-shaped name is a JOIN KEY, not a page — resolve
       // it to its authored home + a viewer-honest event count instead of 404ing. Loose shape-detect here;
       // the server enforces the strict canonical law (identifiers.ts) and 400s malformed forms with an
@@ -311,7 +336,12 @@ export async function runServer(version) {
         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')
       })
-      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.`
+      let 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.`
+      // slice 4: when the page carries identifier stamps, the history projection is one flag away.
+      // (client-side shape check — the acknowledged registry copy of identifiers.ts)
+      const allBody = page.tiers.flatMap((t) => (t.sections ?? []).map((s) => s.body)).join('\n')
+      const stamps = [...new Set((allBody.match(/\[\[repo:[a-z0-9][a-z0-9-]*\/[a-z0-9_.-]+\]\]/gi) ?? []).map((s) => s.toLowerCase()))]
+      if (stamps.length) footer += `\n— This page carries ${stamps.join(', ')} — \`read_page "${name}"\` with history: true for its event timeline (page = present, timeline = history).`
       return { content: [{ type: 'text', text: `# ${page.title ?? name} (full authored page)\n\n${blocks.join('\n\n---\n\n')}\n\n${footer}` }] }
     },
   )

package/package.json

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

package/lib/materialize.mjs

@@ -1,117 +0,0 @@
-import { spawnSync } from 'child_process'
-import { fetchCortex, resolveBase } from './diagnose.mjs'
-import { edgeSafeEnv } from './edge_extract.mjs'
-
-// Edge materialize worker (keystone fix "b"): the brain-page summarizer moved OFF the dead server-side
-// Anthropic API onto the user's Claude SUBSCRIPTION (`claude -p`), mirroring edge extraction + edge
-// relationship inference. The SERVER still owns gather + tier-authorization + the write
-// (/api/brain/materialize/{claim,submit}); this worker ONLY runs the LLM step. It claims a batch of
-// jobs the user is authorized to summarize, runs `claude --print` per (node, tier), and POSTs the RAW
-// model text back for the server to parse + validate + write. The edge is never trusted: it cannot
-// pick a node, choose a tier, or shape a section — it only turns a server-handed corpus into text.
-//
-// Best-effort throughout: a tier the edge can't summarize is simply not submitted and stays queued for
-// a later run. Guarded by CORTEX_SUMMARIZING so it never recurses through the Stop-hook capturer.
-
-const SUMMARY_MODEL = process.env.CORTEX_SUMMARY_MODEL ?? 'claude-haiku-4-5'
-
-// ONE `claude --print` call → the raw model text for a single tier's digest prompt. Subscription auth
-// via edgeSafeEnv (keeps CLAUDE_CODE_OAUTH_TOKEN, strips billed/proxy ANTHROPIC_*). null on any failure.
-// The server returns a separate system + user prompt; claude --print takes one prompt, so we prepend
-// the system instructions (same as edge_extract puts its instructions in the prompt body).
-function summarizeTier(tier) {
-  const prompt = `${tier.system}\n\n${tier.user}`
-  try {
-    const r = spawnSync(
-      'claude',
-      ['--print', '--model', SUMMARY_MODEL, prompt],
-      {
-        env: edgeSafeEnv(process.env, { CORTEX_SUMMARIZING: '1' }),
-        encoding: 'utf8',
-        timeout: 120_000,
-        maxBuffer: 8 * 1024 * 1024,
-      },
-    )
-    if (r.status !== 0 || !r.stdout) return null
-    return r.stdout.trim() || null
-  } catch {
-    return null
-  }
-}
-
-async function claimBatch(base, token, max) {
-  const res = await fetchCortex(`${base}/api/brain/materialize/claim`, {
-    method: 'POST',
-    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify({ max }),
-  })
-  if (!res.ok) throw new Error(`claim HTTP ${res.status}`)
-  const j = await res.json().catch(() => ({}))
-  return Array.isArray(j.jobs) ? j.jobs : []
-}
-
-async function submitNode(base, token, kind, ref, results) {
-  const res = await fetchCortex(`${base}/api/brain/materialize/submit`, {
-    method: 'POST',
-    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify({ kind, ref, results }),
-  })
-  if (!res.ok) throw new Error(`submit HTTP ${res.status}`)
-  return res.json().catch(() => ({}))
-}
-
-// Claim → summarize → submit. opts.drain loops until the queue is empty (clears a backlog); otherwise
-// it does ONE bounded batch (the freshness path called after a capture). Returns a tally.
-export async function runMaterialize(opts = {}) {
-  const log = opts.log ?? ((m) => process.stderr.write(`${m}\n`))
-  const token = process.env.CORTEX_TOKEN
-  if (!token) { log('cortex: CORTEX_TOKEN not set, skipping materialize'); return { built: 0, batches: 0 } }
-  // Never run inside the summarizer subprocess (it sets CORTEX_SUMMARIZING) — would recurse.
-  if (process.env.CORTEX_SUMMARIZING) return { built: 0, batches: 0 }
-
-  const base = resolveBase(process.env.CORTEX_URL)
-  const max = Math.min(Math.max(Number(opts.max) || 6, 1), 12)
-  const maxBatches = opts.drain ? (Number(opts.maxBatches) || 50) : 1
-
-  let built = 0
-  let batches = 0
-  for (let i = 0; i < maxBatches; i++) {
-    let jobs
-    try {
-      jobs = await claimBatch(base, token, max)
-    } catch (e) {
-      log(`cortex: materialize claim failed — ${e.message}`)
-      break
-    }
-    if (!jobs.length) break
-    batches++
-    for (const job of jobs) {
-      const results = []
-      for (const tier of job.tiers ?? []) {
-        const text = summarizeTier(tier)
-        if (text) results.push({ tier: tier.tier, text })
-      }
-      if (!results.length) { log(`cortex: ${job.kind} "${job.name}" — summarizer produced nothing, leaving queued`); continue }
-      try {
-        const out = await submitNode(base, token, job.kind, job.ref, results)
-        const n = out.built ?? 0
-        built += n
-        log(`cortex: materialized ${job.kind} "${job.name}" — ${n} tier${n === 1 ? '' : 's'}${out.settled ? '' : ' (partial)'}`)
-      } catch (e) {
-        log(`cortex: materialize submit failed for ${job.kind} "${job.name}" — ${e.message}`)
-      }
-    }
-  }
-  if (opts.drain) log(`cortex: materialize drain complete — ${built} tier-page(s) built across ${batches} batch(es)`)
-  return { built, batches }
-}
-
-// CLI entry: `cortex-mcp materialize [--drain] [--max N]`. --drain clears the whole backlog now;
-// without it, one bounded batch. Always exits 0 (best-effort maintenance, never a hard failure).
-export async function runMaterializeCli(args = []) {
-  const drain = args.includes('--drain')
-  const mi = args.indexOf('--max')
-  const max = mi >= 0 ? Number(args[mi + 1]) : undefined
-  await runMaterialize({ drain, max })
-  return 0
-}