@theronap/cortex-mcp 0.9.102 → 0.9.104

package/lib/server.mjs

@@ -516,6 +516,41 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'gate4_status',
+    {
+      title: 'Gate 4 claim-clause monitor',
+      description: 'Read the aggregate-only Gate 4 status for this brain — whether SESSIONS are actually claiming timeline records, not just whether records got claimed. Evidence counts only `actor_kind=\'session\'` rows: sweep rows are a machine draining a backlog and are reported for contrast but never as evidence, because counting them would let one bulk drain certify a clause about people doing something. "Sustained" is measured as distinct sessions AND distinct active days, both tunable via minSessions/minActiveDays rather than hardcoded. It never exposes record ids, payloads, reasons or session keys. NOTE gate 4\'s claim clause was already CLOSED (2026-08-20), so "collecting" here does NOT mean progress toward closure — it means the evidence the closure rested on no longer holds in this window. "regressed" means a session claim has lost its attribution.',
+      inputSchema: {
+        days: z.number().optional().describe('rolling window in days (1-90, default 14)'),
+        minSessions: z.number().optional().describe('distinct claiming sessions required (default 3)'),
+        minActiveDays: z.number().optional().describe('distinct days carrying an attributed session claim (default 3)'),
+        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, minSessions, minActiveDays, brain }) => {
+      const qs = new URLSearchParams()
+      if (days != null) qs.set('days', String(days))
+      if (minSessions != null) qs.set('minSessions', String(minSessions))
+      if (minActiveDays != null) qs.set('minActiveDays', String(minActiveDays))
+      if (brain) qs.set('brain', brain)
+      const suffix = qs.size ? `?${qs}` : ''
+      const res = await fetchCortex(`${BASE}/api/gates/4/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 contrast = `${status.sessionClaims} session claims vs ${status.sweepClaims} sweep (sweep is not evidence)`
+      const text = status.status === 'regressed'
+        ? `⚠ Gate 4 has REGRESSED: ${status.anonymousSessionClaims} session-kind claims in the last ${status.days} days carry NO session key. The claim path is dropping attribution — find the writer before trusting any claim count.`
+        : status.machineEvidenceReady
+          ? `Gate 4's claim clause still holds: ${status.claimSessions} distinct sessions claimed across ${status.activeDays} distinct days in ${status.days} days (${contrast}), 0 anonymous. Closed ${status.gateClosedAt}; this is the evidence continuing to hold, not a new closure.`
+          : `⚠ Gate 4 is BELOW the evidence it closed on (${status.gateClosedAt}): ${status.claimSessions}/${status.requiredClaimSessions} distinct sessions across ${status.activeDays}/${status.requiredActiveDays} active days in the last ${status.days} days (${contrast}). No attribution defect — the claiming has thinned out. Re-check before citing the clause as live.`
+      return { content: [{ type: 'text', text }] }
+    },
+  )
+
   server.registerTool(
     'session_context',
     {
@@ -2128,7 +2163,48 @@ export async function runServer(version) {
       const out = await res.json().catch(() => null)
       if (!res.ok) return toolError(`Could not alias "${name}": ${out?.error ?? res.status}`)
       if (!out) return { content: [{ type: 'text', text: `Aliased "${name}", but the server returned no body — re-read the page to confirm.` }] }
-      return { content: [{ type: 'text', text: `Done — [[${out.alias}]] now resolves to "${out.target}" (${out.target_kind}). It's out of the wanted-page backlog.` }] }
+      // Render what the server actually OBSERVED, never a fixed sentence. The old copy asserted both
+      // "now resolves to X" and "out of the wanted-page backlog" unconditionally — it said the second
+      // about a probe name nothing referenced, and said the first for a month about three aliases a
+      // page-less node was shadowing (#687). The route now checks both and reports them.
+      const lines = [`Aliased [[${out.alias}]] -> "${out.target}" (${out.target_kind}).`]
+      if (out.resolves === true) lines.push('Verified: the name resolves to that page now.')
+      else if (out.resolves === false) lines.push('\u26a0 WRITTEN BUT NOT RESOLVING — the alias row is saved, yet the name still does not lead to that page, so something is shadowing it. Re-running this will not help; report it rather than retrying.')
+      else lines.push('Could not verify resolution on this call — re-read the page to confirm.')
+      lines.push(out.backlogCleared
+        ? "It's out of the wanted-page backlog."
+        : 'It was not in the wanted-page backlog, so nothing was cleared there.')
+      return { content: [{ type: 'text', text: lines.join(' ') }] }
+    },
+  )
+
+  server.registerTool(
+    'unalias_page',
+    {
+      title: 'Withdraw an alias',
+      description: 'Remove a name -> page redirect created by `alias_page`, when the alias was wrong or is no longer wanted. The name stops resolving to that page and goes BACK into the org\'s wanted-page backlog, so it can be authored or re-aliased. Aliasing used to be one-way — a mistaken redirect silently sent every future reader of that name somewhere else, with no way back. This does NOT touch the target page itself, only the redirect.',
+      inputSchema: {
+        name: z.string().describe('the aliased [[Name]] to stop redirecting'),
+      },
+    },
+    async ({ name }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/alias?name=${encodeURIComponent(name)}`, {
+          method: 'DELETE',
+          headers: { Authorization: `Bearer ${TOKEN}` },
+        })
+      } catch (e) {
+        return toolError(`Could not withdraw the alias: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return toolError(`Could not withdraw "${name}": ${out?.message ?? out?.error ?? res.status}`)
+      if (!out) return { content: [{ type: 'text', text: `Withdrew the alias for "${name}", but the server returned no body — re-read the page to confirm.` }] }
+      const lines = [`Withdrew the alias [[${out.alias}]] in ${out.brain}.`]
+      lines.push(out.backlogReopened
+        ? 'The name is back in the wanted-page backlog.'
+        : 'It was not marked authored in the backlog, so nothing there changed.')
+      return { content: [{ type: 'text', text: lines.join(' ') }] }
     },
   )
 

package/package.json

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