@theronap/cortex-mcp 0.9.40 → 0.9.42

package/lib/capture.mjs

@@ -189,11 +189,14 @@ async function captureWork(stdinRaw) {
 
   let res
   try {
+    // Best-effort background ingest: bound it tight and retry once so a hanging/504-ing server
+    // makes a DETACHED worker self-terminate in ~20s instead of lingering on 3 unbounded attempts.
     res = await fetchCortex(`${base}/api/ingest`, {
       method: 'POST',
       headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
       body: JSON.stringify(ingestBody),
-    })
+      timeoutMs: 10_000,
+    }, { retries: 1 })
   } catch (e) {
     // Never break a session — just report and move on.
     process.stderr.write(`cortex: ${e.message}\n`)

package/lib/diagnose.mjs

@@ -68,20 +68,10 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 //         'app'   → a real Cortex API error with a JSON message (retriable only if 5xx)
 export function classify(status, contentType, bodyText, requestId) {
   const isJson = (contentType ?? '').includes('application/json')
-  let body = null
-  if (isJson) { try { body = JSON.parse(bodyText) } catch { /* not json after all */ } }
-  const appError = body?.error ?? null
+  let appError = null
+  if (isJson) { try { appError = JSON.parse(bodyText)?.error ?? null } catch { /* not json after all */ } }
   const rid = requestId ? ` [request id: ${requestId}]` : ''
 
-  // Multi-brain: 409 no_active_brain means the caller belongs to >1 brain and hasn't chosen one. It is
-  // NOT an auth failure — surface the action (set_active_brain) directly, not a "Cortex API 409:" wrapper.
-  if (status === 409 && body?.code === 'no_active_brain') {
-    return {
-      kind: 'app', retriable: false,
-      message: `${appError ?? 'You belong to more than one brain — call set_active_brain to choose where your writes land.'} (see my_brains for your options)${rid}`,
-    }
-  }
-
   if (status === 401 || (isJson && appError === 'invalid token')) {
     return {
       kind: 'auth', retriable: false,
@@ -107,11 +97,23 @@ export function classify(status, contentType, bodyText, requestId) {
 // fetch with retry on TRANSIENT responses only (429, 5xx, and infra-style non-JSON 403).
 // App-level 401/403-with-JSON are returned immediately (retrying won't change the verdict).
 // Throws a clear network error if the host is unreachable after retries.
+//
+// PER-ATTEMPT TIMEOUT (added 2026-07-08): every attempt is bounded by an AbortSignal so a
+// HANGING server (not a fast 5xx — an ingest endpoint that just never responds, observed this day)
+// can't stall a hook indefinitely. Without it, `fetch` waits forever and the retry loop made it
+// WORSE — 3 unbounded attempts stacked. Now worst case = (retries+1) * timeoutMs + backoff, and a
+// timed-out attempt is treated as transient (retried, then surfaced as the reach error the callers
+// already swallow). Tunable via CORTEX_HTTP_TIMEOUT_MS; per-call override via opts.timeoutMs.
 export async function fetchCortex(url, opts = {}, { retries = 2, baseDelayMs = 400 } = {}) {
+  const { timeoutMs: optTimeout, signal: callerSignal, ...fetchOpts } = opts
+  const timeoutMs = optTimeout ?? (Number(process.env.CORTEX_HTTP_TIMEOUT_MS) || 15_000)
   let lastErr
   for (let attempt = 0; attempt <= retries; attempt++) {
     try {
-      const res = await fetch(url, opts)
+      // Fresh timeout signal per attempt; compose with any caller-supplied signal.
+      const timeoutSignal = AbortSignal.timeout(timeoutMs)
+      const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal
+      const res = await fetch(url, { ...fetchOpts, signal })
       const ct = res.headers.get('content-type') ?? ''
       const transient =
         res.status === 429 ||

package/lib/server.mjs

@@ -152,6 +152,65 @@ 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). 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)') },
+    },
+    async ({ limit }) => {
+      const qs = typeof limit === 'number' ? `?limit=${limit}` : ''
+      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) : '—'
+        return `- ${t.threadKey} — ${t.subject ?? '(no subject)'} · ${who || 'unknown participants'} · ${t.eventCount} msg · ${when}`
+      })
+      return { content: [{ type: 'text', text: `Unattributed threads (${threads.length}) — 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.40",
+  "version": "0.9.42",
   "description": "Connect your AI assistant to Cortex — your org's projects, activity, gaps, and directives, scoped to you.",
   "type": "module",
   "bin": {