@theronap/agnoclast-mcp 0.9.185 → 0.9.186

package/lib/redact.mjs

@@ -10,6 +10,8 @@
 // [pattern, replacement]. Order matters: most specific Anthropic forms first so a
 // login token reads as [REDACTED:anthropic-oauth], not the generic key bucket.
 const PATTERNS = [
+  // Agnoclast's own write-only ingest keys (custom sources): agn_in_ + 43 base64url characters.
+  [/agn_in_[A-Za-z0-9_-]{40,}/g, '[REDACTED:agnoclast-ingest-key]'],
   [/sk-ant-oat\d{2}-[A-Za-z0-9_-]{20,}/g, '[REDACTED:anthropic-oauth]'],
   [/sk-ant-api\d{2}-[A-Za-z0-9_-]{20,}/g, '[REDACTED:anthropic-key]'],
   [/sk-ant-[A-Za-z0-9_-]{20,}/g, '[REDACTED:anthropic]'],

package/lib/server.mjs

@@ -24,6 +24,26 @@ import { renderObligations } from './obligations_render.mjs'
 // tracked wanted page, whether a bare node exists for it, and whether it's a deliberately demoted page,
 // and turn that into an actionable prompt. Wording lives in ./red_link_triage.mjs (pure + tested).
 // Returns '' on any error so a miss never gets worse.
+/**
+ * A page name held by pages in more than one brain: list them, each with the ref that picks it. The page
+ * read already returns every match (matches[] with brain + ref), so this reuses it instead of leaving the
+ * caller at a bare 409. Never throws — a failure falls back to the generic advice.
+ */
+async function ambiguousPageHint(base, token, kind, name) {
+  const generic = `"${name}" names a page in more than one of your brains. Call read_page "${name}" to see each one with its ref, then pass that ref.`
+  try {
+    const res = await fetchCortex(`${base}/api/brain/page?kind=${kind}&key=${encodeURIComponent(name)}`, { headers: { Authorization: `Bearer ${token}` } })
+    if (!res.ok) return generic
+    const page = await res.json()
+    const matches = Array.isArray(page?.matches) ? page.matches.filter((m) => m.ref) : []
+    if (!matches.length) return generic
+    return [`"${name}" names a page in ${matches.length} of your brains — pass the ref of the one you mean:`,
+      ...matches.map((m) => `  - "${m.title ?? name}" in ${m.brain ?? 'a brain'} — ref: ${m.ref}`)].join('\n')
+  } catch {
+    return generic
+  }
+}
+
 async function redLinkTriage(BASE, TOKEN, name) {
   try {
     const r = await fetchCortex(`${BASE}/api/brain/red-link?name=${encodeURIComponent(name)}`, {
@@ -1810,16 +1830,20 @@ function renderNudge(payload) {
         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.'),
         version: z.string().optional().describe('read a HISTORICAL version of this page instead of the current one: a rev_no (e.g. "3") or a content_hash from page_history. Use page_history first to see the versions, then rollback_page to restore one.'),
+        ref: z.string().optional().describe('the page\'s ref (read_page prints it as `ref:`). Addresses exactly one page, so use it when a name exists in more than one brain — history and version reads refuse an ambiguous name and list the refs to choose from.'),
       },
     },
-    async ({ name, kind, expand, history, version }) => {
+    async ({ name, kind, expand, history, version, ref }) => {
       const k = kind ?? 'project'
+      // A ref addresses exactly one page; a name can match one page in each of several brains.
+      const address = (extra = {}) => new URLSearchParams(ref ? { ref, ...extra } : { kind: k, key: name, ...extra })
       // PAGE HISTORY (Part A): a specific version reads one historical body, resolved within this page's
       // own history. Not for identifier-shaped names (those are join keys, handled below).
       if (version && !/^[a-z][a-z0-9_-]*:.+/i.test(name)) {
         try {
-          const qs = new URLSearchParams({ kind: k, key: name, version })
+          const qs = address({ version })
           const vr = await fetchCortex(`${BASE}/api/brain/page?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+          if (vr.status === 409) return { content: [{ type: 'text', text: await ambiguousPageHint(BASE, TOKEN, k, name) }] }
           if (vr.status === 404) return { content: [{ type: 'text', text: `No version "${version}" for "${name}" (or you can't see it). Use page_history "${name}" to list its versions.` }] }
           if (!vr.ok) {
             const d = classify(vr.status, vr.headers.get('content-type'), await vr.text(), vr.headers.get('x-vercel-id'))
@@ -1834,9 +1858,12 @@ function renderNudge(payload) {
       // 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 qs = address()
           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.` }] }
+          // Two brains hold a page by this name. Say which, with the ref for each, rather than a bare 409 —
+          // "Agnoclast API 409: ambiguous_page_name" was a dead end (Reader Engine, 2026-09-29).
+          if (r.status === 409) return { content: [{ type: 'text', text: await ambiguousPageHint(BASE, TOKEN, k, name) }] }
           if (!r.ok) {
             const d = classify(r.status, r.headers.get('content-type'), await r.text(), r.headers.get('x-vercel-id'))
             return toolError(`Could not read the timeline for "${name}": ${d.message}`)
@@ -1868,6 +1895,8 @@ function renderNudge(payload) {
           }
           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)')
+          // The timeline is a list of headlines. The records themselves — every word — are one call away.
+          else lines.push(`Full text of the records on this page: list_records page:"${t.ref ?? ref ?? name}" (order:"oldest" reads them in sequence; offset pages past 50).`)
           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) {
@@ -1915,7 +1944,7 @@ function renderNudge(payload) {
       }
       let res
       try {
-        res = await fetchCortex(`${BASE}/api/brain/page?kind=${k}&key=${encodeURIComponent(name)}`,
+        res = await fetchCortex(`${BASE}/api/brain/page?${address()}`,
           { headers: { Authorization: `Bearer ${TOKEN}` } })
       } catch (e) {
         return toolError(`Could not read "${name}": ${e.message}`)
@@ -4084,17 +4113,25 @@ function renderNudge(payload) {
     'list_records',
     {
       title: 'List activity records (filtered)',
-      description: 'List recent activity records you can see, filtered by type, project, and recency. RLS-scoped. Use to enumerate "what happened on project X this week" or "recent meetings". Returns each record\'s FULL summary + id — never a truncated preview, so what you get back is the whole record you are permitted to read (use an id with request_file to ask its owner for the original file).',
+      description: 'List recent activity records you can see, filtered by type, project, page, source and recency. RLS-scoped. Use to enumerate "what happened on project X this week", "recent meetings", or EVERYTHING FILED ON A PAGE — pass `page` (its name or ref) to read a channel\'s items or a project page\'s records, with order:"oldest" to read a series in sequence and `offset` to page past 50. Returns each record\'s FULL summary + id — never a truncated preview, so what you get back is the whole record you are permitted to read (use an id with request_file to ask its owner for the original file).',
       inputSchema: {
         type: z.string().optional().describe("record type, e.g. 'meeting', 'comm', 'activity', 'ai_session', 'doc', 'note'"),
         project: z.string().optional().describe('project key to filter to (e.g. "cortex")'),
         since_days: z.number().optional().describe('only records from the last N days'),
         limit: z.number().optional().describe('max rows (1-50, default 20)'),
         session: z.string().optional().describe('a session id — returns every record that session produced, INCLUDING the separate halves of a log that was split across brains. Segmented logs share a sessionId and never link to each other, so this is the only way to reassemble one. RLS-scoped: you get the halves you are cleared for and cannot tell whether others exist'),
+        page: z.string().optional().describe('a page — its name or its ref (from read_page) — to list the records filed on it. A name held by pages in several brains lists them all, each row tagged with its brain; pass the ref to pick one.'),
+        source: z.string().optional().describe("a record source, e.g. 'custom' (custom sources), 'github', 'email', 'imessage', 'meeting'"),
+        order: z.enum(['newest', 'oldest']).optional().describe('newest first (default), or oldest first to read a series in sequence'),
+        offset: z.number().optional().describe('skip this many records — page through more than 50 by calling again with offset 50, 100…'),
       },
     },
-    async ({ type, project, since_days, limit, session }) => {
+    async ({ type, project, since_days, limit, session, page, source, order, offset }) => {
       const qs = new URLSearchParams()
+      if (page) qs.set('page', page)
+      if (source) qs.set('source', source)
+      if (order) qs.set('order', order)
+      if (offset != null) qs.set('offset', String(offset))
       if (type) qs.set('type', type)
       if (project) qs.set('project', project)
       if (since_days != null) qs.set('since_days', String(since_days))

package/package.json

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