@theronap/cortex-mcp 0.9.107 → 0.9.109

package/lib/server.mjs

@@ -462,8 +462,8 @@ export async function runServer(version) {
   server.registerTool(
     'gate3_status',
     {
-      title: 'Gate 3 currency monitor',
-      description: 'Read the aggregate-only Gate 3 currency-monitor status for this brain. It counts explicit maintenance-candidate reviews and their same-session durable corrections in the rolling window; it never exposes project names, evidence content, or session keys. "machine_evidence_ready" means enough ordinary-work evidence has accumulated to request a human closure decision, not that the monitor closes the gate itself.',
+      title: 'Maintenance-review counter (informational — NOT a gate 3 criterion)',
+      description: 'Counts explicit maintenance-candidate reviews and their same-session durable corrections in a rolling window, aggregate-only; it never exposes project names, evidence content, or session keys. ⚠ IT DOES NOT DECIDE ANYTHING, AND IT NO LONGER BEARS ON GATE 3. Gate 3 CLOSED for v1 on 2026-08-22 with five residuals named inside the closure, and this counter was dropped from its closure criteria the same day because it measures gate 4\'s machinery rather than currency. It is also the wrong SHAPE of signal: it counts agents catching the wiki being wrong and fixing it, so a rising number means failure is being discovered more often, not that currency is improving. Read it as "how often did anyone review maintenance candidates", nothing more. Gate state lives on [[Agnoclast v1 — the currency gate]]; read that page, not this tool, to learn where a gate stands.',
       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'),
@@ -480,9 +480,23 @@ export async function runServer(version) {
         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.machineEvidenceReady
-        ? `Gate 3 machine evidence is ready: ${status.maintenanceReviewSessions} independent maintenance-review sessions and ${status.correctionSessions} correction sessions in ${status.days} days. A human should confirm these were ordinary work before closing the gate.`
-        : `Gate 3 is still collecting evidence: ${status.maintenanceReviewSessions}/${status.requiredReviewSessions} independent maintenance-review sessions and ${status.correctionSessions}/${status.requiredCorrectionSessions} correction sessions in ${status.days} days. No gate decision has been made.`
+      // ⚠ NO THRESHOLD LANGUAGE, DELIBERATELY. Until 2026-08-24 this rendered
+      // "machine evidence is ready … before closing the gate" — a sentence written when the counter
+      // WAS gate 3's criterion. Gate 3 closed 2026-08-22 and the counter was dropped from its
+      // criteria the same day, and nothing told the tool. Called on 2026-08-24 it still invited a
+      // reader to close a gate that had been closed for two days, on grounds that no longer applied.
+      // The numbers were never wrong; the sentence around them was, and it was recomputed fresh on
+      // every call while its framing stayed frozen — which is what made it read as current.
+      // So: report the count, name what it is not, and point at where gate state actually lives.
+      const text =
+        `Maintenance reviews (informational — NOT a gate criterion): ` +
+        `${status.maintenanceReviewSessions} session${status.maintenanceReviewSessions === 1 ? '' : 's'} reviewed maintenance candidates ` +
+        `and ${status.correctionSessions} made a same-session durable correction, in ${status.days} days.\n` +
+        `⚠ This does not bear on gate 3. Gate 3 CLOSED for v1 on 2026-08-22 (five residuals named inside the closure), ` +
+        `and this counter was dropped from its closure criteria the same day — it measures gate 4's machinery, not currency. ` +
+        `It is also inverted as a health signal: it counts agents catching the wiki being WRONG, so a rising number means ` +
+        `failure is being discovered more often, not that currency is improving.\n` +
+        `For where any gate actually stands, read [[Agnoclast v1 — the currency gate]].`
       return { content: [{ type: 'text', text }] }
     },
   )
@@ -1526,6 +1540,71 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'merge_sections',
+    {
+      title: 'Condense two sections into one, or drop a spent section',
+      description: 'CONDENSE a page: fold one section into another, or remove one outright. This is the only route that can make a page SMALLER — `author` refuses any write that omits a section (409 would_drop_sections), `edit_page` reaches inside one section, and `rename_section` touches only a heading, so without this every correction is additive and pages grow without bound. Use it when two sections overlap and one shorter section would say the same thing, or when a section is spent — closed work, a retraction whose lesson now lives elsewhere, a superseded status block. Pass `into` + `new_body` to condense (the surviving section gets `new_body`, `from` is removed); omit BOTH to drop `from` outright. GUARDS, all of which refuse rather than guess: `base_version` is the same page-level CAS `edit_page` uses; a merge never crosses tiers; the last remaining section cannot be dropped; and if the removal would orphan a `[[link]]` — leaving it nowhere on the page — it 409s with the list, because a [[link]] is a graph EDGE and losing one silently is the exact 2026-07-30 failure the no-drop rule was written for. CURRENCY: the surviving section inherits the OLDER of the two as-of stamps, never now() — relocating a claim does not re-verify it. Fully reversible: the prior revision keeps the removed section in full, so `rollback_page` restores it.',
+      inputSchema: {
+        name: z.string().describe('the exact page name, as read_page shows it'),
+        from: z.string().describe('the heading of the section to REMOVE (match is case- and whitespace-insensitive)'),
+        into: z.string().optional().describe('the heading of the section that SURVIVES and absorbs the content. Omit to drop `from` outright without folding it anywhere.'),
+        new_body: z.string().optional().describe('the condensed body the surviving section should read AFTER the merge — you write it, this route does not summarize. Required with `into`; must be absent without it.'),
+        base_version: z.string().describe('the `version` read_page prints for this page (64-hex). REQUIRED — it is the concurrency check AND how the right brain is resolved. A per-SECTION hash is not valid here.'),
+        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('only when the page exists at MORE THAN ONE tier — which one to condense in. A merge never moves content between tiers.'),
+        from_ordinal: z.number().optional().describe('only when `from`\'s heading appears more than once on the page — which occurrence (the error lists the ordinals).'),
+        into_ordinal: z.number().optional().describe('only when `into`\'s heading appears more than once on the page — which occurrence (the error lists the ordinals).'),
+        reason: z.string().optional().describe('WHY you are condensing, in one short phrase — recorded in page_history. Say what became redundant, not what you did.'),
+        drop_links_ack: z.boolean().optional().describe('ONLY after a 409 drops_links refusal, and only if the answer is genuinely yes: those [[links]] are meant to stop being edges of this page. Otherwise carry them into `new_body` instead.'),
+        identity_claim_ack: z.boolean().optional().describe('ONLY after a 409 identity_claim refusal, and only if the answer is genuinely yes: this text is meant to publish an email address or phone number as page content at this tier.'),
+      },
+    },
+    async ({ name, from, into, new_body, base_version, tier, from_ordinal, into_ordinal, reason, drop_links_ack, identity_claim_ack }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/merge-sections`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            name, from, base_version,
+            ...(into ? { into } : {}), ...(new_body !== undefined ? { new_body } : {}),
+            ...(tier ? { tier } : {}),
+            ...(from_ordinal !== undefined ? { from_ordinal } : {}),
+            ...(into_ordinal !== undefined ? { into_ordinal } : {}),
+            ...(reason ? { reason } : {}),
+            ...(drop_links_ack ? { drop_links_ack: true } : {}),
+            ...(identity_claim_ack ? { identity_claim_ack: true } : {}),
+          }),
+        })
+      } catch (e) {
+        return toolError(`Could not condense the section: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        // Surface every disambiguator the server named, so a 409 is directly actionable rather than
+        // something to retry blindly. `dropped` is the one that matters most: it names the graph edges
+        // that would be lost, which is the decision the caller actually has to make.
+        const extra = [
+          Array.isArray(out?.dropped) ? `would orphan these [[links]]: ${out.dropped.join(', ')}` : '',
+          Array.isArray(out?.available) ? `existing headings: ${out.available.join(' · ')}` : '',
+          Array.isArray(out?.identityClaims) ? `identity identifiers this would publish: ${out.identityClaims.join(', ')}` : '',
+          Array.isArray(out?.tiers) ? `tiers: ${out.tiers.join(', ')}` : '',
+          Array.isArray(out?.ordinals) ? `ordinals: ${out.ordinals.join(', ')}` : '',
+          out?.currentVersion ? `current version: ${out.currentVersion}` : '',
+        ].filter(Boolean).join('\n')
+        const hint = out?.hint ? `\n${out.hint}` : ''
+        return toolError(`Could not condense "${from}" on "${name}": ${out?.error ?? res.status}${extra ? `\n${extra}` : ''}${hint}`)
+      }
+      const what = out.kept
+        ? `Condensed "${out.removed}" into "${out.kept}"`
+        : `Removed section "${out.removed}"`
+      const undated = out.undated ? '\n⚠ The surviving section carries no explicit calendar date — add one so a reader can see when it became true.' : ''
+      const red = Array.isArray(out.redLinks) && out.redLinks.length
+        ? `\nRed links now on this page: ${out.redLinks.join(', ')}` : ''
+      return { content: [{ type: 'text', text: `${what} on "${name}" (${out.brain} · ${out.tier} tier). Reclaimed ${out.chars_reclaimed} chars. New version: ${out.version}${undated}${red}\nReversible: \`page_history "${name}"\` then \`rollback_page\` restores the removed section in full.` }] }
+    },
+  )
+
   server.registerTool(
     'set_summary',
     {

package/package.json

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