@theronap/cortex-mcp 0.9.157 → 0.9.159

package/lib/server.mjs

@@ -193,7 +193,16 @@ export async function runServer(version) {
         // seat runs — session-ping carried liveness only. That is why every version gate in this
         // ADR was unobservable. Additive and forward-compatible: the route destructures sessionKey
         // and cwd and ignores the rest, so this is inert until a column exists to store it.
-        body: JSON.stringify({ sessionKey: SESSION_KEY, cwd: process.cwd(), mcpVersion: version }),
+        // repo (ADR-0066 §7): the repo this session is WORKING IN, so it holds more than what it
+        // has read. Same detector the context cache is keyed on, so no new failure mode — a
+        // non-GitHub or non-repo cwd yields null and the field is simply omitted. The server drops
+        // anything malformed; this is attention data, never routing.
+        body: JSON.stringify({
+          sessionKey: SESSION_KEY,
+          cwd: process.cwd(),
+          mcpVersion: version,
+          repo: repoFullNameFrom(process.cwd()) ?? undefined,
+        }),
       })
     } catch { /* best-effort heartbeat — never disrupt the session */ }
   }
@@ -255,6 +264,27 @@ export async function runServer(version) {
 //
 // The SERVER decides who gets this; it only sends `nudge` to a session holding a matching identifier.
 // No threshold logic here to drift out of sync with it.
+// ADR-0066 §8 — THE DELTA LINE. "Each turn, when something arrived since the last turn: a delta
+// line only; silent when empty."
+//
+// ⚠ ONE LINE, AND NO LIST. The whole point is that it costs almost nothing to read, so it can be
+// shown often without training its reader to skip it. The pile itself is one tool call away and the
+// session-start block already rendered it in full.
+//
+// ⚠ DIFFERENT FROM renderNudge, WHICH SITS DIRECTLY BELOW IT. That block is identifier-matched — the
+// cascade believes those records are THIS session's business, and it names them. This claims nothing
+// about relevance; it says the queue moved. Both can be silent and both can fire.
+//
+// Server-decided, like the nudge: it is silent when the session is muted, on a session's first
+// sight, and when nothing arrived — so there is no threshold logic here to drift out of sync.
+function renderArrival(payload) {
+  const a = payload?.arrival
+  const n = Number(a?.count ?? 0)
+  if (!a || !n) return ''
+  return `\n\n⚡ ${n} new arrival${n === 1 ? '' : 's'} in your pile since this session was last told` +
+    ` — \`staged_records\` lists them. Not offered to you, just counted; \`ignore_arrivals\` if this is noise right now.`
+}
+
 function renderNudge(payload) {
   const n = Array.isArray(payload?.nudge) ? payload.nudge : []
   if (!n.length) return ''
@@ -1359,7 +1389,7 @@ function renderNudge(payload) {
         throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
       }
       const payload = await res.json()
-      return { content: [{ type: 'text', text: formatGrepHits(payload, query) + renderNudge(payload) }] }
+      return { content: [{ type: 'text', text: formatGrepHits(payload, query) + renderArrival(payload) + renderNudge(payload) }] }
     },
   )
 
@@ -1668,7 +1698,7 @@ function renderNudge(payload) {
       // `k` is stated rather than hidden. "Only you" and "you and two others" call for different
       // behaviour, and a nudge that claimed certainty it did not have is how an agent learns to stop
       // reading them.
-      const nudgeBlock = renderNudge(page)
+      const nudgeBlock = renderArrival(page) + renderNudge(page)
 
       if (matches.length === 1) {
         return { content: [{ type: 'text', text: renderMatch(matches[0], false) + nudgeBlock }] }
@@ -2741,6 +2771,87 @@ function renderNudge(payload) {
     },
   )
 
+  server.registerTool(
+    'ignore_arrivals',
+    {
+      title: 'Stop offering me arrivals for the rest of this session',
+      description: 'Silence the ⚡ ARRIVED block for THIS session. Use it when you are mid-task and the offers are noise right now — declining is per record (not_mine) and that is not a usable answer to a list of nine. ⚠ THIS IS NOT A DECISION ABOUT THE RECORDS AND IT IS NOT A SUPPRESSION. Every one of them stays unclaimed, stays on the general timeline, and stays offerable to every other session — including your own other sessions. You are saying "stop telling me, here", never "nobody\'s business", and nothing is marked handled. ⚠ IT IS ALSO NOT not_mine: use that one when you LOOKED and a record is not yours, because that answers "why did nobody take this" and this does not. Reversible any time with resume:true, and it dies with this session — a new session is never born muted.',
+      inputSchema: {
+        reason: z.string().optional().describe('optional — why now ("mid-task", "deep in a build"). Unlike not_mine this does not require one, because no ownership question is being answered'),
+        resume: z.boolean().optional().describe('true to start hearing about arrivals again in this session'),
+      },
+    },
+    async ({ reason, resume }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/nudge/mute`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ on: resume === true ? false : true, reason }),
+        })
+      } catch (e) {
+        return toolError(`Could not change arrival notices: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not change arrival notices: ${out?.error ?? res.status}${out?.detail ? `\n${out.detail}` : ''}`)
+      return {
+        content: [{
+          type: 'text',
+          text: resume === true
+            ? 'Arrivals will be offered to this session again.'
+            : 'Quiet for the rest of this session. Nothing was decided about those records — they stay unclaimed, stay on the general timeline, and other sessions still see them. `ignore_arrivals resume:true` turns them back on.',
+        }],
+      }
+    },
+  )
+
+  server.registerTool(
+    'my_source_routes',
+    {
+      title: 'Where a source lands — the routes you declared, and what is waiting for one',
+      description: 'Show the DECLARED landings: (account, source type, key) -> brain, with who decided each one. ⚠ THIS IS A DIFFERENT TABLE FROM my_routing_claims AND ANSWERS A DIFFERENT QUESTION. A claim says which PAGE a record attaches to (and the brain falls out of that); a route says which BRAIN a source\'s raw lands in when nothing else decides. Both can be right and disagree, which is exactly when mail piles up. ⚠ A route settles a claim TIE only when `decided_by` is `explicit` — a person decided it; a `triage` route was an agent unblocking a queue and does not overrule live ambiguity (ADR-0066 §5d). ⚠ APPEND-ONLY BY DESIGN: a route is never updated, because re-pointing a live source splits its stream irreparably — records are unique on the org-scoped (org_id, dedupe_key), so the two halves never reconcile. Creating one is a decision you do not get to take back cheaply. Also lists what is STAGED per source — those are exactly the routes worth creating.',
+      inputSchema: {},
+    },
+    async () => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/source-routes`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return toolError(`Could not read source routes: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not read source routes: ${out?.error ?? res.status}`)
+
+      const routes = Array.isArray(out?.routes) ? out.routes : []
+      const pending = Array.isArray(out?.pendingStaged) ? out.pendingStaged : []
+      const lines = []
+
+      if (routes.length === 0) {
+        lines.push('No declared routes. Every source resolves by claims alone, and a claim tie has nothing to fall back on.')
+      } else {
+        lines.push(`${routes.length} declared route(s):`)
+        for (const r of routes) {
+          // `account`/`sourceKey` are empty when the route means "any" at that position — say so
+          // rather than printing a blank, because a blank reads as missing data.
+          const acct = r.account || '(any account)'
+          const key = r.sourceKey || '(any key)'
+          const mark = r.decidedBy === 'explicit' ? '✓' : '·'
+          lines.push(`  ${mark} ${r.sourceType} · ${acct} · ${key}  →  ${r.brain}   [${r.decidedBy}${r.decidedNote ? `: ${r.decidedNote}` : ''}]`)
+        }
+        lines.push('  ✓ = decided by a person, and therefore able to settle a claim tie. · = decided by triage, which cannot.')
+      }
+
+      if (pending.length) {
+        lines.push('')
+        lines.push('Waiting on a routing decision:')
+        for (const p of pending) {
+          lines.push(`  ${p.sourceType} · ${p.account || '(any account)'} — ${p.count} staged, oldest ${String(p.oldest).slice(0, 10)}`)
+        }
+      }
+      return { content: [{ type: 'text', text: lines.join('\n') }] }
+    },
+  )
+
   server.registerTool(
     'my_routing_claims',
     {
@@ -3293,7 +3404,7 @@ function renderNudge(payload) {
         return toolError(`Could not list records: ${d.message}`)
       }
       const payload = await res.json()
-      return { content: [{ type: 'text', text: (payload?.text ?? '') + renderNudge(payload) }] }
+      return { content: [{ type: 'text', text: (payload?.text ?? '') + renderArrival(payload) + renderNudge(payload) }] }
     },
   )
 

package/package.json

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