@theronap/agnoclast-mcp 0.9.152 → 0.9.154

package/lib/diagnose.mjs

@@ -166,6 +166,7 @@ export function classify(status, contentType, bodyText, requestId) {
   let appMessage = null
   let appBrains = null
   let appCandidates = null
+  let appAcceptUrl = null
   if (isJson) {
     try {
       const parsed = JSON.parse(bodyText)
@@ -186,6 +187,7 @@ export function classify(status, contentType, bodyText, requestId) {
       // saw a bare code like "would_drop_sections" and had no idea what to do with it. The routes
       // were writing careful self-heal guidance that never reached anyone.
       appHint = typeof parsed?.hint === 'string' && parsed.hint.trim() ? parsed.hint.trim() : null
+      appAcceptUrl = typeof parsed?.acceptUrl === 'string' && /^https:\/\//.test(parsed.acceptUrl) ? parsed.acceptUrl : null
     } catch { /* not json after all */ }
   }
   const rid = requestId ? ` [request id: ${requestId}]` : ''
@@ -206,6 +208,19 @@ export function classify(status, contentType, bodyText, requestId) {
         `Vercel firewall / deployment protection on the API route. Re-running setup will not help.${rid}`,
     }
   }
+  // Updated Terms / Privacy Policy not yet accepted (server legal_gate.ts, review D6). The credential is
+  // FINE — this must never read like the 401 branch above, whose advice (rotate the token, re-run setup)
+  // cannot help. Only a person can clear it, in a browser, so the message says exactly that and names
+  // the page. Not retriable: nothing changes until they accept.
+  if (isJson && appError === 'legal_acceptance_required') {
+    const url = appAcceptUrl ?? 'https://agnoclast.com/legal/accept'
+    return {
+      kind: 'app', retriable: false,
+      message: `Agnoclast needs the account owner to accept its updated Terms of Service / Privacy Policy ` +
+        `before it can continue (HTTP ${status}). Ask them to open ${url} in a browser, sign in, and accept. ` +
+        `Your token is valid — rotating it or re-running setup will not help.${rid}`,
+    }
+  }
   // A brain-choice refusal is ANSWERABLE, so it must arrive as the question it is rather than as a
   // code. Deliberately narrow: only these three errors reshape the message, so every other classify()
   // output keeps its existing wording (and its tests).

package/lib/editors/claude.mjs

@@ -23,16 +23,15 @@ 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), 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 /
+ *  unowned-project accessible-default sharp edge, 2026-07-02), rollback_page,
  *  decide_file_request / request_file / get_file, create_brain / set_active_brain, alias_page,
- *  set_writing_style. */
+ *  set_writing_style. (replace_variant and decide_page_merge were here until one page per node,
+ *  ADR-0064 §4, removed them.) */
 export const ALLOWED_TOOL_NAMES = [
   // read surface
   'grep', 'read_page', 'my_context', 'project_status', 'session_context', 'search_org',
   'list_records', 'page_history', 'page_diff', 'timeline_pull', 'my_brains', 'my_sessions', 'writing_style',
-  'code_graph_query', 'my_retier_notices', 'list_page_grants', 'file_requests', 'page_merge_requests',
+  'code_graph_query', 'my_retier_notices', 'list_page_grants', 'file_requests',
   // live authoring core
   'authoring_context', 'author', 'log_session',
   // routine, reversible maintenance

package/lib/server.mjs

@@ -1438,7 +1438,7 @@ function renderNudge(payload) {
     {
       title: 'Read a wiki page in full',
       description:
-        'READ the full authored wiki page for one node (project/person/org/you) by its canonical name — every section, every tier you can see. This is how you READ a node; `grep` only LOCATES pages (snippets + their [[links]]), it does not read them. Navigate like a researcher: read the page you need, then FOLLOW its inline [[links]] by calling read_page on each linked name — keep following while the linked pages stay relevant, stop when they do not. You decide how deep to go. Returns only what you are permitted to see.',
+        'READ the full authored wiki page for one node (project/person/org/you) by its canonical name — every section you can see. This is how you READ a node; `grep` only LOCATES pages (snippets + their [[links]]), it does not read them. Navigate like a researcher: read the page you need, then FOLLOW its inline [[links]] by calling read_page on each linked name — keep following while the linked pages stay relevant, stop when they do not. You decide how deep to go. Returns only what you are permitted to see.',
       inputSchema: {
         name: z.string().describe('the canonical node name exactly as written (e.g. "Agnoclast", "Ben", or a [[link]] target) — identifier links ([[repo:owner/name]]) resolve to their authored HOME + a visible-event count'),
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind — a PREFERENCE, not a filter. The lookup matches every kind by title and only prefers this one when several share a name, so omitting it never hides a person/org/user page. Pass it to disambiguate a name that exists as more than one kind.'),
@@ -1598,7 +1598,7 @@ function renderNudge(payload) {
           // unrecoverable base_version guessing loop; say so explicitly instead.
           const versionLine = t.version
             ? `\nversion: ${t.version}`
-            : `\nversion: none (this variant predates content-hash tracking — base_version writes will always fail here; ask an admin about the ADR-0018 backfill)`
+            : `\nversion: none (this page predates content-hash tracking — base_version writes will always fail here; ask an admin about the ADR-0018 backfill)`
           const head = `[${t.tier}${day(t.updated_at) ? ` · authored ${day(t.updated_at)}` : ''}${t.validity && t.validity !== 'current' ? ` · ${t.validity}` : ''}${versionLine}]`
           // ADR-0030 step 3b (2026-08-24): the summary header is NO LONGER RENDERED here either.
           // ⚠ There were TWO of these — project_status and read_page — and the first patch fixed only
@@ -1792,18 +1792,17 @@ function renderNudge(payload) {
         name: z.string().describe('the exact page name'),
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project)'),
         to_version: z.string().describe('which version to restore: a rev_no (e.g. "3") or a content_hash, from page_history'),
-        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('which tier variant to roll back, if the node has more than one'),
         reason: z.string().optional().describe('optional note recorded on the new rollback version (why you rolled back)'),
       },
     },
-    async ({ name, kind, to_version, tier, reason }) => {
+    async ({ name, kind, to_version, reason }) => {
       const k = kind ?? 'project'
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/rollback`, {
           method: 'POST',
           headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
-          body: JSON.stringify({ kind: k, name, to_version, ...(tier ? { tier } : {}), ...(reason ? { reason } : {}) }),
+          body: JSON.stringify({ kind: k, name, to_version, ...(reason ? { reason } : {}) }),
         })
       } catch (e) {
         return toolError(`Could not roll back "${name}": ${e.message}`)
@@ -1825,19 +1824,18 @@ function renderNudge(payload) {
     'rename_section',
     {
       title: 'Rename one section heading on a wiki page',
-      description: 'Rename ONE section\'s heading on a wiki page, in place. Use this instead of re-authoring the page: `author` cannot express a rename, because a section\'s IDENTITY is its heading string — sending a new title reads as "dropped the old section, added a new one" and is rejected 409 would_drop_sections. This route changes the heading and NOTHING else: the section keeps its body, its position, and crucially its as-of date, so renaming does not reset the currency stamp on a claim nobody re-verified. It is also the ONLY way to fix a heading longer than the 80-char limit, which cannot be re-authored at all. Requires base_version (the `version` read_page prints) — that is also how it finds the right brain, so it can never rename on the wrong one. Refuses, rather than guessing, when the page exists at several tiers, when the heading repeats, or when the new heading is already taken.',
+      description: 'Rename ONE section\'s heading on a wiki page, in place. Use this instead of re-authoring the page: `author` cannot express a rename, because a section\'s IDENTITY is its heading string — sending a new title reads as "dropped the old section, added a new one" and is rejected 409 would_drop_sections. This route changes the heading and NOTHING else: the section keeps its body, its position, and crucially its as-of date, so renaming does not reset the currency stamp on a claim nobody re-verified. It is also the ONLY way to fix a heading longer than the 80-char limit, which cannot be re-authored at all. Requires base_version (the `version` read_page prints) — that is also how it finds the right brain, so it can never rename on the wrong one. Refuses, rather than guessing, when the heading repeats, or when the new heading is already taken.',
       inputSchema: {
         name: z.string().describe('the exact page name, as read_page shows it'),
         from: z.string().describe('the CURRENT heading, exactly as stored (match is case- and whitespace-insensitive)'),
         to: z.string().describe('the new heading. Max 80 chars. Must not already be used by another section on this page.'),
         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 rename in. A rename never moves content between tiers.'),
         ordinal: z.number().optional().describe('only when the same heading appears more than once on the page — which occurrence to rename (the error lists the ordinals).'),
         reason: z.string().optional().describe('why you are renaming it — recorded in page_history like any other edit'),
         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 — e.g. the subject is publishing their OWN contact detail on their own page. Leave unset otherwise; the alternatives the refusal names (a confidential section, or set_routing_identifier for a private claim) are the right answer in every other case.'),
       },
     },
-    async ({ name, from, to, base_version, tier, ordinal, reason, identity_claim_ack }) => {
+    async ({ name, from, to, base_version, ordinal, reason, identity_claim_ack }) => {
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/rename-section`, {
@@ -1845,7 +1843,7 @@ function renderNudge(payload) {
           headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
           body: JSON.stringify({
             name, from, to, base_version,
-            ...(tier ? { tier } : {}), ...(ordinal !== undefined ? { ordinal } : {}),
+            ...(ordinal !== undefined ? { ordinal } : {}),
             ...(reason ? { reason } : {}), ...(identity_claim_ack ? { identity_claim_ack: true } : {}),
           }),
         })
@@ -1881,7 +1879,6 @@ function renderNudge(payload) {
         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.'),
@@ -1889,7 +1886,7 @@ function renderNudge(payload) {
         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 }) => {
+    async ({ name, from, into, new_body, base_version, from_ordinal, into_ordinal, reason, drop_links_ack, identity_claim_ack }) => {
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/merge-sections`, {
@@ -1898,7 +1895,6 @@ function renderNudge(payload) {
           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 } : {}),
@@ -2755,11 +2751,10 @@ function renderNudge(payload) {
         summary: z.string().describe('the new summary: one sentence saying what this is and where it stands. May contain [[links]]. Max 2,000 chars — detail belongs in a section.'),
         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.'),
         reason: z.string().optional().describe('WHY the summary was wrong, in one short phrase — recorded in page_history. Say what changed ("blocker resolved 08-04; was still claiming BLOCKED"), not what you did.'),
-        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('only when the page exists at MORE THAN ONE tier — which one to rewrite. This never moves content between tiers.'),
         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 — e.g. the subject is publishing their OWN contact detail on their own page. Leave unset otherwise; the alternatives the refusal names (a confidential section, or set_routing_identifier for a private claim) are the right answer in every other case.'),
       },
     },
-    async ({ name, summary, base_version, reason, tier, identity_claim_ack }) => {
+    async ({ name, summary, base_version, reason, identity_claim_ack }) => {
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/set-summary`, {
@@ -2767,7 +2762,7 @@ function renderNudge(payload) {
           headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
           body: JSON.stringify({
             name, summary, base_version,
-            ...(tier ? { tier } : {}), ...(reason ? { reason } : {}),
+            ...(reason ? { reason } : {}),
             ...(identity_claim_ack ? { identity_claim_ack: true } : {}),
           }),
         })
@@ -2804,12 +2799,11 @@ function renderNudge(payload) {
         new_string: z.string().describe('what to replace it with. May be empty, which deletes the anchored text.'),
         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.'),
         reason: z.string().describe('WHY you are making this change, in one short phrase — recorded in page_history exactly like an author edit.'),
-        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('only when the page exists at MORE THAN ONE tier — which one to edit. An edit never moves content between tiers.'),
         ordinal: z.number().optional().describe('only when the same heading appears more than once on the page — which occurrence (the error lists the ordinals).'),
         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 — e.g. the subject is publishing their OWN contact detail on their own page. Leave unset otherwise; the alternatives the refusal names (a confidential section, or set_routing_identifier for a private claim) are the right answer in every other case.'),
       },
     },
-    async ({ name, heading, old_string, new_string, base_version, reason, tier, ordinal, identity_claim_ack }) => {
+    async ({ name, heading, old_string, new_string, base_version, reason, ordinal, identity_claim_ack }) => {
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/edit-page`, {
@@ -2817,7 +2811,7 @@ function renderNudge(payload) {
           headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
           body: JSON.stringify({
             name, heading, old_string, new_string, base_version, reason,
-            ...(tier ? { tier } : {}), ...(ordinal !== undefined ? { ordinal } : {}),
+            ...(ordinal !== undefined ? { ordinal } : {}),
             ...(identity_claim_ack ? { identity_claim_ack: true } : {}),
           }),
         })
@@ -3149,7 +3143,7 @@ function renderNudge(payload) {
         org_id: z.string().describe('the org id of the brain to enumerate (from my_brains)'),
         owner: z.string().optional().describe('only pages owned by this person — a user id or an EXACT display name. A name matching no member of the brain is an error, never a silently empty list. Owner applies to scoped/confidential pages; accessible pages have no owner.'),
         updated_within_days: z.number().optional().describe('only pages touched in the last N days'),
-        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('only nodes that have a row at this tier. The row still reports every tier you can see, so a multi-tier page does not come back describing itself as single-tier.'),
+        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('only pages at this tier'),
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('only nodes of this kind'),
         validity: z.enum(['current', 'superseded', 'all']).optional().describe("default 'current'. Pass 'all' for the pre-2026-08 behavior, which mixed superseded pages in with nothing marking them."),
         name_contains: z.string().optional().describe('case-insensitive substring match on the node name or page title'),
@@ -3917,38 +3911,29 @@ function renderNudge(payload) {
     'set_page_privacy',
     {
       title: 'Change who can see a wiki page',
-      description: 'Re-tier a wiki page you own or may edit: "accessible" (anyone in the org), "scoped" (owner + their management chain), or "confidential" (owner only, plus explicit grants). Demoting a PROJECT page also demotes its evidence records (demote-only; each record\'s owner is notified and can revert). Promotions never touch records. If the target tier already has a page, merge your content into it via `author` FIRST, then read_page the target again to get its fresh version, then re-run this with absorb=true and target_version=<that version> — absorb will REJECT (not silently drop content) if target_version doesn\'t match what\'s actually there, so a merge that didn\'t really land can\'t destroy your source page. Org admins may demote any page, never promote.',
+      description: 'Re-tier a wiki page you own or may edit: "accessible" (anyone in the org), "scoped" (owner + their management chain), or "confidential" (owner only, plus explicit grants). Demoting a PROJECT page also demotes its evidence records (demote-only; each record\'s owner is notified and can revert). Promotions never touch records. Org admins may demote any page, never promote.',
       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.'),
         tier: z.enum(['accessible', 'scoped', 'confidential']).describe('the new visibility tier'),
-        source_tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('when the node has multiple tier variants: which one to move'),
-        absorb: z.boolean().optional().describe('after merging your content into an existing target-tier page via author: true removes your now-absorbed source variant. Requires target_version.'),
-        target_version: z.string().optional().describe('REQUIRED with absorb=true — the target page\'s version, read via read_page AFTER your author() merge landed. Proves the merge actually happened before your source page is deleted; a stale or guessed value is rejected, not silently accepted.'),
       },
     },
-    async ({ kind, name, ref, tier, source_tier, absorb, target_version }) => {
+    async ({ kind, name, ref, tier }) => {
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/page-privacy`, {
           method: 'POST',
           headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
-          body: JSON.stringify({ kind, ...(name ? { name } : {}), ...(ref ? { ref } : {}), tier, ...(source_tier ? { source_tier } : {}), ...(absorb ? { absorb: true } : {}), ...(target_version ? { target_version } : {}) }),
+          body: JSON.stringify({ kind, ...(name ? { name } : {}), ...(ref ? { ref } : {}), tier }),
         })
       } catch (e) {
         return toolError(`Could not set page privacy: ${e.message}`)
       }
       const out = await res.json().catch(() => null)
       if (!res.ok) {
-        // 409s carry the collision protocol (merge instruction, both variants when readable) —
-        // surface the server's structured message verbatim so the agent can follow it.
-        if (out?.error) {
-          const extra = out.collision === 'readable' && out.blocking
-            ? `\nYour ${out.source?.tier} page: ${out.source?.summary ?? out.source?.title}\nExisting ${out.blocking.tier} page (current version: ${out.blocking.version ?? 'none — this page predates content-hash tracking and cannot be re-authored via base_version; ask an admin about a backfill'}): ${out.blocking.summary ?? out.blocking.title}`
-            : ''
-          return toolError(`Could not set page privacy: ${out.error}${extra}`)
-        }
+        // The server's refusals carry their own remedy — surface the message verbatim.
+        if (out?.error) return toolError(`Could not set page privacy: ${out.error}`)
         const d = classify(res.status, res.headers.get('content-type'), '', res.headers.get('x-vercel-id'))
         return toolError(`Could not set page privacy: ${d.message}`)
       }
@@ -3959,60 +3944,6 @@ function renderNudge(payload) {
     },
   )
 
-  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.' }] }
-      // The summary rides along with the body, EXCEPT when the source has none — then the target's is
-      // kept rather than erased. Say so on its own line rather than at the tail of `note`: this is the
-      // 2026-08-04 W3 shape, where an empty summary copied over a populated one destroyed 31 of them
-      // under a report that read as success. A rescue the operator does not see is still a silent write.
-      const rescued = out.summaryRescued
-        ? `\n\n⚠ The ${out.moved.from} variant had NO summary. The ${out.moved.to} page's own summary was KEPT rather than overwritten with an empty one — check it still describes the body that just landed, and set_summary if not.`
-        : ''
-      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. Both prior bodies are retained in page history.${rescued}`,
-        }],
-      }
-    },
-  )
-
   server.registerTool(
     'grant_page_access',
     {
@@ -4024,16 +3955,15 @@ function renderNudge(payload) {
         ref: z.string().optional().describe('the page\'s stable id, printed as `ref:` by read_page. Prefer this over name: unique across brains, so it addresses exactly one page.'),
         grantee: z.string().describe('display name or email of a member OF THE PAGE\'S BRAIN (must resolve uniquely — use email if ambiguous)'),
         action: z.enum(['grant', 'revoke']).describe('grant or revoke'),
-        tier: z.enum(['scoped', 'confidential']).optional().describe('which variant (default: the most restrictive one)'),
       },
     },
-    async ({ kind, name, ref, grantee, action, tier }) => {
+    async ({ kind, name, ref, grantee, action }) => {
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/page-grants`, {
           method: 'POST',
           headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
-          body: JSON.stringify({ kind, ...(name ? { name } : {}), ...(ref ? { ref } : {}), grantee, action, ...(tier ? { tier } : {}) }),
+          body: JSON.stringify({ kind, ...(name ? { name } : {}), ...(ref ? { ref } : {}), grantee, action }),
         })
       } catch (e) {
         return toolError(`Could not ${action}: ${e.message}`)
@@ -4049,7 +3979,7 @@ function renderNudge(payload) {
     'list_page_grants',
     {
       title: 'List who has granted access to your page',
-      description: 'Show every explicit access grant on YOUR page\'s tier variants (owner-only). Use after re-tiering a page — grants survive tier changes and keep granting until revoked.',
+      description: 'Show every explicit access grant on YOUR pages (owner-only). Use after re-tiering a page — grants survive tier changes and keep granting until revoked.',
       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)'),
@@ -4069,7 +3999,7 @@ function renderNudge(payload) {
       const out = await res.json().catch(() => null)
       if (!res.ok) return toolError(`Could not list grants: ${out?.error ?? res.status}`)
       if (!out.grants?.length) return { content: [{ type: 'text', text: 'No grants on this page.' }] }
-      const lines = out.grants.map((g) => `- ${g.grantee_name ?? g.grantee_user_id} → ${g.tier} variant (since ${String(g.created_at).slice(0, 10)})`)
+      const lines = out.grants.map((g) => `- ${g.grantee_name ?? g.grantee_user_id} → ${g.tier} page (since ${String(g.created_at).slice(0, 10)})`)
       return { content: [{ type: 'text', text: `Grants (${out.grants.length}):\n${lines.join('\n')}` }] }
     },
   )
@@ -4100,32 +4030,6 @@ function renderNudge(payload) {
     },
   )
 
-  server.registerTool(
-    'page_merge_requests',
-    {
-      title: 'Merge requests on pages you own',
-      description: 'Someone tried to move their page into a tier slot your page occupies (they only saw "slot occupied"). Review pending requests here; read their variant, merge anything worth keeping into your page via author, then decide with decide_page_merge.',
-      inputSchema: {},
-    },
-    async () => {
-      let res
-      try {
-        res = await fetchCortex(`${BASE}/api/brain/page-merge-requests`, { headers: { Authorization: `Bearer ${TOKEN}` } })
-      } catch (e) {
-        return toolError(`Could not list merge requests: ${e.message}`)
-      }
-      if (!res.ok) {
-        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
-        return toolError(`Could not list merge requests: ${d.message}`)
-      }
-      const { requests } = await res.json()
-      if (!requests?.length) return { content: [{ type: 'text', text: 'No pending page merge requests.' }] }
-      const lines = requests.map((q) =>
-        `- [${q.id}] ${q.requester_name ?? 'someone'} wants their ${q.kind} page merged into your ${q.requested_tier} "${q.page_title}". Merge via author first, then decide_page_merge.`)
-      return { content: [{ type: 'text', text: `Pending page merge requests (${requests.length}):\n${lines.join('\n')}` }] }
-    },
-  )
-
   server.registerTool(
     'request_person_page_merge',
     {
@@ -4198,33 +4102,6 @@ function renderNudge(payload) {
     },
   )
 
-  server.registerTool(
-    'decide_page_merge',
-    {
-      title: 'Approve or deny a page merge request',
-      description: 'Decide a pending page merge request you own. IMPORTANT: approve only AFTER you have merged whatever of the requester\'s content you want into your page (via author) — approving DELETES their variant of the node. Deny closes the request and nothing moves.',
-      inputSchema: {
-        id: z.string().describe('the request id from page_merge_requests'),
-        decision: z.enum(['approve', 'deny']).describe('approve = their variant is removed (merge first!); deny = nothing moves'),
-      },
-    },
-    async ({ id, decision }) => {
-      let res
-      try {
-        res = await fetchCortex(`${BASE}/api/brain/page-merge-requests`, {
-          method: 'POST',
-          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
-          body: JSON.stringify({ id, decision }),
-        })
-      } catch (e) {
-        return toolError(`Could not decide: ${e.message}`)
-      }
-      const out = await res.json().catch(() => null)
-      if (!res.ok) return toolError(`Could not decide: ${out?.error ?? res.status}`)
-      return { content: [{ type: 'text', text: out.decision === 'denied' ? 'Denied — nothing moved.' : `Approved — removed variant(s): ${out.removed_variants.join(', ') || 'none remained'}. ${out.note}` }] }
-    },
-  )
-
   // ── File requests: ask the owner for a record's FULL original (lives on their machine) ──
   const fail = (verb, res) => async () =>
     toolError(`Could not ${verb}: ${classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id')).message}`)
@@ -4484,8 +4361,7 @@ function renderNudge(payload) {
       // last chance to notice a page was fixed somewhere nobody reads.
       const corrections = Array.isArray(out?.tierCorrections) && out.tierCorrections.length
         ? `\n⚠ TIER: this wrote to ${out.tierCorrections.map((c) => `${c.actualTier} (you asked for ${c.requestedTier})`).join('; ')}.` +
-          ` If that is not the tier you meant, read_page and check which copy you just changed —` +
-          ` a page can exist at several tiers and they drift apart independently.`
+          ` A page has one tier and author writes at it; to change who can see the page, use set_page_privacy.`
         : ''
       // KWA-26 — the advisory undated flag. The server has computed `undatedSections` since #558 and
       // the route has returned it ever since; NOTHING PRINTED IT, so the one consumer the item names

package/package.json

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