@theronap/cortex-mcp 0.9.70 → 0.9.71

package/lib/editors/claude.mjs

@@ -22,7 +22,9 @@ export function mergeClaudeMcp(existing, spec, token) {
  *  CAS-protected + snapshotted (page_revisions → page_history/rollback_page).
  *  Deliberately EXCLUDED — these keep prompting: send_imessage (external side effect),
  *  set_page_privacy / set_record_privacy / grant_page_access (visibility widening — the
- *  unowned-project accessible-default sharp edge, 2026-07-02), rollback_page, decide_page_merge /
+ *  unowned-project accessible-default sharp edge, 2026-07-02), replace_variant (destroys a page body
+ *  and deletes a variant row — the one write here that is not merely CAS-protected but genuinely
+ *  lossy at the row level, so the prompt IS the guard D1 argued for), rollback_page, decide_page_merge /
  *  decide_file_request / request_file / get_file, create_brain / set_active_brain, alias_page,
  *  set_writing_style. */
 export const CORTEX_ALLOWED_TOOLS = [

package/lib/server.mjs

@@ -1469,6 +1469,53 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'replace_variant',
+    {
+      title: 'Move one tier variant\'s body into another, collapsing the node to one page',
+      description: 'DESTRUCTIVE, and the only sanctioned way to fix a FORKED page. When one node exists at two tiers with different bodies, this moves the SOURCE variant\'s body into the TARGET variant\'s slot and DELETES the source, leaving the node with a single page. The source\'s body WINS — this is not `absorb`, where the target survives; in a fork repair the target is usually the damaged page, so mirroring absorb would keep the damage and delete the good copy. Sections are copied as ROWS, never re-derived from text: re-deriving a body from context is exactly what destroyed 258 sections on 2026-07-18 while sincerely reporting "copied verbatim". BEFORE CALLING: read_page the TARGET and pass its version as target_version — it proves you know which body is about to be overwritten, and a stale or guessed value is rejected rather than silently accepted. If the target tier has NO page, do not use this: the slot is free, so set_page_privacy moves the page there cheaply. Both prior bodies are retained in page history and the operation is reversible via page_history/rollback_page. Owner or editor on BOTH variants; an OWNERLESS target may be overwritten only by an org admin.',
+      inputSchema: {
+        kind: z.enum(['project', 'person', 'org', 'user']).describe('the page kind'),
+        name: z.string().optional().describe('the exact page name (or pass `ref` instead — one of the two is required)'),
+        ref: z.string().optional().describe('the page\'s stable id, printed as `ref:` by read_page. PREFER THIS over name when you have it: a ref is unique across brains, so it addresses exactly one page and never needs a brain to disambiguate it.'),
+        source_tier: z.enum(['accessible', 'scoped', 'confidential']).describe('the variant whose BODY WINS and survives. This variant\'s row is then deleted.'),
+        target_tier: z.enum(['accessible', 'scoped', 'confidential']).describe('the OCCUPIED slot the body lands in. This variant\'s current body is DESTROYED (snapshotted to page history first). The surviving page sits at this tier.'),
+        target_version: z.string().describe('REQUIRED — the TARGET page\'s version, from read_page. Proves you know what is being overwritten. Do not retry a rejection blindly; re-read the target and confirm you are replacing what you think you are.'),
+        brain: z.string().optional().describe('only when the same page name exists in more than one of your brains'),
+      },
+    },
+    async ({ kind, name, ref, source_tier, target_tier, target_version, brain }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/replace-variant`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            kind, ...(name ? { name } : {}), ...(ref ? { ref } : {}),
+            source_tier, target_tier, target_version, ...(brain ? { brain } : {}),
+          }),
+        })
+      } catch (e) {
+        return toolError(`Could not replace variant: ${e.message}`)
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        // The engine's rejections carry the remedy in their text (free slot → use set_page_privacy;
+        // hash mismatch → re-read, do not retry blindly). Surface it verbatim rather than paraphrasing.
+        if (out?.error) return toolError(`Could not replace variant: ${out.error}`)
+        const d = classify(res.status, res.headers.get('content-type'), '', res.headers.get('x-vercel-id'))
+        return toolError(`Could not replace variant: ${d.message}`)
+      }
+      if (!out) return { content: [{ type: 'text', text: 'Replace reported success, but the server returned no body — re-read the page before assuming it landed.' }] }
+      return {
+        content: [{
+          type: 'text',
+          text: `Done — "${out.moved.title}": the ${out.moved.from} body now occupies the ${out.moved.to} page (${out.sections} section${out.sections === 1 ? '' : 's'}), and the ${out.moved.from} variant was removed. The node now has ONE variant. ${out.note}`,
+        }],
+      }
+    },
+  )
+
   server.registerTool(
     'grant_page_access',
     {

package/package.json

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