@theronap/agnoclast-mcp 0.9.152 → 0.9.153

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

@@ -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}`)
@@ -3917,38 +3916,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 +3949,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',
     {
@@ -4100,32 +4036,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 +4108,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}`)

package/package.json

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