@theronap/cortex-mcp 0.9.41 → 0.9.43

package/lib/server.mjs

@@ -152,6 +152,75 @@ export async function runServer(version) {
     },
   )
 
+  // Pull/claim attribution ([[cortex-subscription-inference]]): the agent decides which project a
+  // messaging thread is about — on ITS subscription, zero server-metered inference — and records it
+  // here. The server stamps `project:<slug>` onto the thread's timeline events via the locked-down
+  // cortex_labeler role, so the thread threads onto that project's node timeline (retroactive @> join).
+  server.registerTool(
+    'attribute_thread',
+    {
+      title: 'Attribute a messaging thread to a project',
+      description: "Record that a messaging thread (email, etc.) belongs to a project — stamps project:<slug> onto the thread's timeline events so its whole history threads onto that project's node timeline. Attribute AS YOU WORK: when you recognize which known project a thread you're looking at is about, attribute it. KNOWN projects only — if you're not confident, don't (a wrong tag pollutes a timeline; leaving it unattributed self-heals). Idempotent (safe to re-call) and reversible (remove:true undoes an attribution you made).",
+      inputSchema: {
+        threadKey: z.string().describe('the thread identifier — a Gmail threadId, or a full `thread:<id>` key'),
+        project: z.string().describe('the slug/key of the EXISTING project the thread belongs to'),
+        remove: z.boolean().optional().describe('true to REMOVE a project attribution you previously made (reversibility)'),
+      },
+    },
+    async ({ threadKey, project, remove }) => {
+      const res = await fetchCortex(`${BASE}/api/timeline/attribute`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ threadKey, project, ...(remove ? { remove: true } : {}) }),
+      })
+      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 j = await res.json().catch(() => ({}))
+      const verb = remove ? 'Removed' : 'Attributed'
+      const prep = remove ? 'from' : 'to'
+      return { content: [{ type: 'text', text: `${verb} ${j.threadKey ?? threadKey} ${prep} ${j.project ?? `project:${project}`} — ${j.stamped ?? 0} event(s) ${remove ? 'un' : ''}stamped.` }] }
+    },
+  )
+
+  // The PULL half: surface the org's unattributed messaging backlog so the agent can triage it and
+  // attribute the threads it recognizes (pairs with attribute_thread above).
+  server.registerTool(
+    'timeline_pull',
+    {
+      title: 'Pull unattributed messaging threads to triage',
+      description: "Surface messaging threads captured in the org (email, etc.) that AREN'T yet attributed to a project — the backlog awaiting your judgment. Call it as you work; when you recognize which KNOWN project a surfaced thread is about, attribute it with attribute_thread. Threads you don't recognize: leave them (they self-heal as the graph fills). Pass a `project` you're working on to RANK the backlog by relevance (threads sharing participants with that project come first, marked ★). Returns participants + subject + recency per thread — enough to recognize, not the message bodies.",
+      inputSchema: {
+        limit: z.number().optional().describe('max threads to return (default 20)'),
+        project: z.string().optional().describe('optional KNOWN project slug to rank the backlog by relevance to what you are working on; omit for the whole backlog newest-first'),
+      },
+    },
+    async ({ limit, project }) => {
+      const params = new URLSearchParams()
+      if (typeof limit === 'number') params.set('limit', String(limit))
+      if (typeof project === 'string' && project) params.set('project', project)
+      const qs = params.toString() ? `?${params}` : ''
+      const res = await fetchCortex(`${BASE}/api/timeline/pull${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 { threads } = await res.json()
+      if (!threads?.length) return { content: [{ type: 'text', text: 'No unattributed threads in the backlog.' }] }
+      const lines = threads.map((t) => {
+        const who = (t.participants ?? []).map((p) => String(p).replace(/^email:/, '')).join(', ')
+        const when = t.lastAt ? String(t.lastAt).slice(0, 10) : '—'
+        const rel = t.relevance && t.relevance.score > 0 ? ` · ★${t.relevance.score} ${t.relevance.reason}` : ''
+        return `- ${t.threadKey} — ${t.subject ?? '(no subject)'} · ${who || 'unknown participants'} · ${t.eventCount} msg · ${when}${rel}`
+      })
+      const header = project
+        ? `Unattributed threads (${threads.length}), ranked for project:${project} (★ = shares participants)`
+        : `Unattributed threads (${threads.length})`
+      return { content: [{ type: 'text', text: `${header} — attribute recognized ones with attribute_thread(threadKey, project):\n${lines.join('\n')}` }] }
+    },
+  )
+
   server.registerTool(
     'search_org',
     {

package/package.json

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