@theronap/cortex-mcp 0.9.92 → 0.9.94

package/lib/server.mjs

@@ -461,6 +461,36 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'gate2_status',
+    {
+      title: 'Gate 2 edit-accountability monitor',
+      description: 'Read the aggregate-only Gate 2 status for this brain — whether every edit records WHICH SESSION made it. It counts only the REPAIRED write paths (absorb, retier, replace) since the 2026-08-17 fix, because the author path was never broken and would certify a repair it never exercised. Operator and migration writes are excluded: they legitimately have no session, and imputing one would violate the 0093 don\'t-impute rule. It never exposes page titles, refs, reasons or session keys. "regressed" means a repaired path lost its session attribution again and the gate must NOT be closed; "machine_evidence_ready" means enough ordinary-work evidence has accumulated to request a human closure decision.',
+      inputSchema: {
+        days: z.number().optional().describe('rolling window in days (1-90, default 14)'),
+        brain: z.string().optional().describe('brain name or org id when you belong to more than one brain; omit for a sole brain'),
+      },
+    },
+    async ({ days, brain }) => {
+      const qs = new URLSearchParams()
+      if (days != null) qs.set('days', String(days))
+      if (brain) qs.set('brain', brain)
+      const suffix = qs.size ? `?${qs}` : ''
+      const res = await fetchCortex(`${BASE}/api/gates/2/status${suffix}`, { 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 status = await res.json()
+      const text = status.status === 'regressed'
+        ? `\u26a0 Gate 2 has REGRESSED: ${status.unattributedMcpRevisions} MCP-authored revisions since ${status.since} carry NO session (${status.unattributedRepairedRevisions} of them on the repaired absorb/retier/replace paths). Attribution is being dropped again — do not close this gate; find the writer.`
+        : status.machineEvidenceReady
+          ? `Gate 2 machine evidence is ready: ${status.repairedPathSessions} distinct sessions exercised the repaired write paths across ${status.repairedPathRevisions} revisions since ${status.since}, and NONE lost its session. A human should confirm these were ordinary work before closing the gate.`
+          : `Gate 2 is still collecting evidence: ${status.repairedPathSessions}/${status.requiredRepairedPathSessions} distinct sessions have exercised the repaired write paths (absorb/retier/replace) since ${status.since}, across ${status.repairedPathRevisions} revisions, 0 unattributed. No gate decision has been made.`
+      return { content: [{ type: 'text', text }] }
+    },
+  )
+
   server.registerTool(
     'session_context',
     {
@@ -886,6 +916,40 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'search_spam_email',
+    {
+      title: 'Search Gmail Spam intentionally',
+      description: 'Search a connected Gmail Spam folder only when the user explicitly asks you to find a message that may have been marked as Spam. This is read-only: results are returned for this request only and are NOT added to Agnoclast records, timeline, or future context. Give a specific Gmail search such as a sender, subject words, or date. Normal Gmail sync never reads Spam.',
+      inputSchema: {
+        query: z.string().min(2).describe('specific Gmail search within Spam, e.g. `from:billing@example.com`, `subject:(appointment reminder)`, or `after:2026/08/01`'),
+        account: z.string().email().optional().describe('which connected Gmail account to search when more than one is available'),
+        limit: z.number().int().min(1).max(10).optional().describe('maximum matches to return (default 5; max 10)'),
+      },
+    },
+    async ({ query, account, limit }) => {
+      const res = await fetchCortex(`${BASE}/api/gmail/search-spam`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query, ...(account ? { account } : {}), ...(limit ? { limit } : {}) }),
+      })
+      const body = await res.json().catch(() => null)
+      if (!res.ok) {
+        if (res.status === 409 && Array.isArray(body?.accounts)) {
+          return toolError(`Choose a connected Gmail account and call again with account: ${body.accounts.join(', ')}`)
+        }
+        return toolError(body?.error ?? `Spam search failed (${res.status}).`)
+      }
+      const rows = Array.isArray(body?.messages) ? body.messages : []
+      if (!rows.length) return { content: [{ type: 'text', text: `No Spam matches in ${body?.account ?? 'the connected Gmail account'}. Nothing was saved to Agnoclast.` }] }
+      const lines = [`Spam matches in ${body.account} (read-only; not saved to Agnoclast):`]
+      for (const m of rows) {
+        lines.push(`- ${m.date || 'unknown date'} · ${m.from || 'unknown sender'} · ${m.subject}\n  ${m.snippet || '(no preview)'}\n  ${m.sourceUri}`)
+      }
+      return { content: [{ type: 'text', text: lines.join('\n') }] }
+    },
+  )
+
   server.registerTool(
     'grep',
     {
@@ -2224,6 +2288,62 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'set_governing_page',
+    {
+      title: 'Choose which attached page sets a record\'s tier',
+      description:
+        'Move a record\'s GOVERNING page — the one attached page whose tier the record takes. A record can sit on several pages, but exactly one of them decides how visible it is; the others confer access without authority (ADR-0027). Use this when a record is on the right pages but the WRONG one is deciding its tier — most often a record governed by your own user node when it plainly belongs to a project. The page must already be attached: run route_record first if it is not, because attaching is a relevance judgement and this is not. It applies immediately in BOTH directions, tightening or widening, because you asking for it IS the human confirmation a widening requires — so read the tier you are moving to before you move. Every move is recorded as a session judgment and is the signal the placement heuristics are calibrated against, which is why the reason matters.',
+      inputSchema: {
+        recordId: z.string().describe('record id (from pending_records or my_records)'),
+        documentId: z.string().describe('document id of the ATTACHED page that should govern the tier'),
+        reason: z.string().describe('why this page should set the tier — recorded, and read as calibration signal'),
+      },
+    },
+    async ({ recordId, documentId, reason }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/triage`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ action: 'regovern', recordId, documentId, reason }),
+        })
+      } catch (e) {
+        return toolError(`Could not set the governing page: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        // A guard rail, not a fault — say what to do instead of naming the code.
+        if (out?.error === 'not_attached') {
+          return toolError(
+            'That page is not attached to this record, so it cannot govern it. Attach it first with route_record.',
+          )
+        }
+        return toolError(
+          `Could not set the governing page: ${out?.error ?? res.status}${out?.detail ? ` — ${out.detail}` : ''}`,
+        )
+      }
+      if (out?.reaffirmed) {
+        return {
+          content: [{
+            type: 'text',
+            text: `That page already governed this record; recorded your confirmation. Tier: ${out?.toPrivacy ?? 'unchanged'}.`,
+          }],
+        }
+      }
+      const moved =
+        out?.fromPrivacy && out?.toPrivacy && out.fromPrivacy !== out.toPrivacy
+          ? `Tier ${out.fromPrivacy} -> ${out.toPrivacy} (${out?.direction}).`
+          : `Tier unchanged (${out?.toPrivacy ?? 'unknown'}).`
+      return {
+        content: [{
+          type: 'text',
+          text: `Governing page moved. ${moved} Recorded as a session judgment${out?.correctedAuto ? ' and counted as a correction to the placement heuristics' : ''}.`,
+        }],
+      }
+    },
+  )
+
   server.registerTool(
     'snooze_red_link',
     {

package/package.json

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