@theronap/agnoclast-mcp 0.9.151 → 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

@@ -78,6 +78,33 @@ export const sectionCurrencyStamp = (s, day) => {
 // invisible on exactly the sections that were healthy.
 export const renderSection = (s, day) => `### ${s.heading}${sectionCurrencyStamp(s, day)}\n${s.body}`
 
+/**
+ * ADR-0062 §5.1. A materialize PREVIEW goes to its own route: a server too old to know it answers 404,
+ * where /api/intake/materialize would ignore a `mode` it does not know and publish.
+ */
+export function intakeMaterializePath(mode) {
+  return mode === 'preview' ? '/api/intake/preview' : '/api/intake/materialize'
+}
+
+/** ADR-0062 §5.2. Which page governs a materialized record, and who chose it — or '' for an older server. */
+export function renderGoverningLine(governing) {
+  if (!governing || typeof governing !== 'object') return ''
+  const name = governing.title || 'a page'
+  const who = governing.designatedBy === 'session' ? 'chosen by you'
+    : governing.designatedBy === 'human' ? 'chosen by a person'
+    : 'chosen by the ranking — pass governingPage to decide it yourself'
+  return `Governed by ${name} (${governing.tier}) — ${who}.`
+}
+
+/** The one line a preview leads with, so it cannot be mistaken for a publish. */
+export function renderIntakePreviewLine(body) {
+  const p = (body && typeof body === 'object' && body.placement) || {}
+  const pages = Array.isArray(p.pages) ? p.pages.length : 0
+  const g = p.governing
+  const gov = g ? `${g.title || g.kind} (${g.tier})${p.governingJudged ? ', your choice' : ''}` : 'none'
+  return `PREVIEW — nothing was written. Would attach ${pages} page(s); governing: ${gov}; born ${p.tier ?? 'unknown'}.`
+}
+
 // TOP-OF-PAGE NOTES — ADR-0065's size note, and ADR-0064 §3's "Also visible to you" callout.
 //
 // ⚠ PRINTED VERBATIM, NEVER COMPOSED HERE. The server decides whether a note fires and what it says
@@ -88,6 +115,11 @@ export const renderSection = (s, day) => `### ${s.heading}${sectionCurrencyStamp
 // it from offset 0, so the footer of a huge page is the part nobody reaches — and these notes exist for
 // exactly those pages. Shared by read_page and project_status so the two cannot drift, which is how every
 // earlier fix to this file's page rendering landed on one surface and not the other.
+// v1 SCOPE (Theron, 2026-09-16): page splitting moves to v2 and the server refuses it with
+// `splitting_unavailable`. split_page is not registered, so agents do not see a verb that can only refuse.
+// The definition stays for v2: flip this together with the server's SPLITTING_AVAILABLE.
+export const SPLIT_PAGE_TOOL_AVAILABLE = false
+
 export const renderHeaderNotes = (notes) => {
   const lines = (Array.isArray(notes) ? notes : [])
     .filter((n) => typeof n === 'string' && n.trim() !== '')
@@ -877,7 +909,8 @@ function renderNudge(payload) {
     {
       title: 'Claim private intake items',
       description:
-        'Claim a lease on private intake items (relevance or cleanup). Returns decrypted payloads for the lease holder only. Requires x-cortex-session-key (set automatically by this MCP server). Aged work never blocks a claim: the response reports cleanupDueCount and how far behind the oldest unit is, and servicing it is expected but always your call. Claiming is a commitment to process — hand back anything you will not finish with intake_release, or intake_defer if it is the owner\'s decision to make.',
+        'Claim a lease on private intake items (relevance or cleanup). Returns decrypted payloads for the lease holder only. Requires x-cortex-session-key (set automatically by this MCP server). Aged work never blocks a claim: the response reports cleanupDueCount and how far behind the oldest unit is, and servicing it is expected but always your call. Claiming is a commitment to process — hand back anything you will not finish with intake_release, or intake_defer if it is the owner\'s decision to make. ' +
+        'YOU ARE THE JUDGE of every unit you claim (ADR-0062): nothing is published until you materialize, and materializing is when it becomes visible. Each unit carries a `proposal` — the brain its signals point to and, for that brain, the pages it would attach to, the page that would govern it, and the `tier` it would be born with — computed without writing anything. Decide the brain, the pages (confirm, drop or add), which page should govern (the page whose reasons for restricting its audience fit the content, not a person page), and obligations. Pages only tighten a tier; if a record should be LOOSER than `tierReason.baseline`, that is the owner\'s call — intake_defer with the question.',
       inputSchema: {
         claimKind: z.enum(['relevance', 'cleanup']).optional().describe('default relevance'),
         limit: z.number().optional().describe('max items (default 10). Ignored when intakeItemIds is given.'),
@@ -947,7 +980,9 @@ function renderNudge(payload) {
     {
       title: 'Materialize a private intake item',
       description:
-        'Atomically publish a claimed intake item into one brain. Deterministic identifier homes in that brain are always attached; documentIds may add further pages. Sets record confidentiality to the strictest attached page tier. Never writes private intake into search/history before this call.',
+        'Atomically publish a claimed intake item into one brain — the disclosure moment (ADR-0062). Deterministic identifier homes in that brain are always attached; documentIds may add further pages. The record is born at the strictest of its source baseline, what the producer asked for, and every attached page; a source floor (iMessage, claude-code) pins it. ' +
+        'Name the governing page with governingPage (one of documentIds, never a person page) — otherwise the ranking picks it. ' +
+        'Pass mode "preview" first when your choice differs from the claim\'s proposal: it returns the pages, the governing page and the tier this exact call would produce, and writes nothing. Never writes private intake into search/history before this call.',
       inputSchema: {
         intakeItemId: z.string().describe('intake item uuid'),
         orgId: z.string().describe('destination brain org uuid'),
@@ -958,10 +993,21 @@ function renderNudge(payload) {
         recordType: z.string().optional(),
         dedupeKey: z.string().optional(),
         origin: z.enum(['deterministic', 'llm', 'user', 'session']).optional(),
+        governingPage: z.string().optional().describe(
+          'the page that should GOVERN this record (ADR-0062) — a page `ref:` or document id, and one of documentIds. ' +
+          'Choose the page whose reasons for restricting its audience fit the content; never a person page. It can only ' +
+          'tighten the record, and the ranking will not move it. Omit to leave the choice to the ranking.',
+        ),
+        mode: z.enum(['preview', 'apply']).optional().describe(
+          '"preview": report the pages, governing page and tier this call would produce, and write nothing. Default "apply".',
+        ),
       },
     },
     async (args) => {
-      const res = await fetchCortex(`${BASE}/api/intake/materialize`, {
+      // A preview goes to its OWN route: a server too old to know it answers 404, where the materialize
+      // route would ignore a `mode` it does not know and publish.
+      const preview = args.mode === 'preview'
+      const res = await fetchCortex(`${BASE}${intakeMaterializePath(args.mode)}`, {
         method: 'POST',
         headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
         body: JSON.stringify({
@@ -976,13 +1022,20 @@ function renderNudge(payload) {
             dedupe_key: args.dedupeKey,
           },
           attachmentMeta: (args.documentIds ?? []).map(() => ({ origin: args.origin ?? 'llm' })),
+          ...(args.governingPage ? { governingDocumentId: args.governingPage } : {}),
         }),
       })
       if (!res.ok) {
         const body = await res.text()
+        if (preview && res.status === 404) {
+          return toolError('This server cannot preview a materialization yet — nothing was written. Materialize without mode, or wait for the server to update.')
+        }
         return toolError(body)
       }
       const body = await res.json()
+      if (preview) {
+        return { content: [{ type: 'text', text: `${renderIntakePreviewLine(body)}\n\n${JSON.stringify(body, null, 2)}` }] }
+      }
       // WHERE THE SESSION'S OWN WORK LANDED, in words rather than buried in the JSON dump.
       //
       // Three outcomes that look identical in raw JSON and mean completely different things:
@@ -999,6 +1052,8 @@ function renderNudge(payload) {
       // the ordinary case (observed 2026-09-03 on the first handoff record materialised). Silence is
       // correct here, and it also covers a server too old to send the field at all.
       const lines = []
+      const governingLine = renderGoverningLine(body?.governing)
+      if (governingLine) lines.push(governingLine)
       const sa = body?.sessionAttachments
       if (sa === null) {
         lines.push('⚠ Session-page attachment FAILED for this record — it was written, but not filed under the pages this session worked on. Re-run the reconciler.')
@@ -1737,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}`)
@@ -1880,7 +1934,7 @@ function renderNudge(payload) {
     },
   )
 
-  server.registerTool(
+  if (SPLIT_PAGE_TOOL_AVAILABLE) server.registerTool(
     'split_page',
     {
       title: 'Move sections onto a new child page',
@@ -3862,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}`)
       }
@@ -3904,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',
     {
@@ -4045,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',
     {
@@ -4143,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.151",
+  "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": {