@theronap/cortex-mcp 0.9.108 → 0.9.109

package/lib/server.mjs

@@ -1540,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.108",
+  "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": {