@theronap/agnoclast-mcp 0.9.166 → 0.9.167

package/lib/server.mjs

@@ -291,40 +291,39 @@ function renderSettling(payload) {
   if (!offers.length) return ''
   const total = Number(feed?.total ?? offers.length)
 
+  // ⚠ THE THREE STAGES READ DIFFERENTLY BECAUSE THE RIGHT RESPONSE DIFFERS. A `matched` arrival is
+  // probably yours. An `orphan` reached you because it reached NOBODY — you are not the obvious
+  // owner, you are the only one looking, and the burden of proof is lower for leaving it. Rendering
+  // all three as "matched to what you have open" would be a claim the feed cannot support, and an
+  // agent that catches a nudge overstating itself stops trusting the rest of it.
   const lines = offers.map((x) => {
-    const why = x.via?.length ? ` — matches ${x.via.map((v) => `\`${v}\``).join(', ')}` : ''
-    // Looks without claims is evidence about the UNIT, not about the sessions that walked away.
+    const why = x.via_reason === 'matched' && x.via?.length
+      ? ` — matches ${x.via.map((v) => `\`${v}\``).join(', ')}`
+      : x.via_reason === 'orphan'
+        ? ' — ⚠ NO session of yours matches this; it is here because it reached nobody'
+        : ' — every session that matched it declined, so it is back to everyone'
     const looked = x.looks > 0 ? `  [looked at ${x.looks}x, still unclaimed]` : ''
     return `    - ${x.source} · ${x.hoursAgo}h ago · ${x.intakeItemId}${why}${looked}`
   })
 
-  // ⚠ SAY THE TRUE TOTAL, NOT THE PAGE SIZE. Measured 2026-09-22: one identifier matched 113 settling
-  // units against a cap of 12. A block that says "here are 12" when there are 113 is claiming
-  // certainty it does not have — and renders identically every turn, which teaches the reader that
-  // it never changes and can be skipped.
   const more = total > offers.length
     ? `\n— Showing ${offers.length} of ${total}. \`intake_changes\` lists the rest; this is a sample, not the queue.`
     : ''
 
-  // ⚠ CONTENTION IS STATED, exactly as the record nudge states `k`. Measured the same day: THREE live
-  // sessions each matched the SAME 113 units on one identifier. Silent about that, each would claim
-  // the same units and learn about the race from a failed lease.
   const maxHolders = offers.reduce((m, x) => Math.max(m, Number(x.holders ?? 1)), 1)
   const who = maxHolders > 1
     ? `\n— ⚠ ${maxHolders} live sessions of yours hold a matching identifier, so these are offered to all of them. \`intake_claim\` takes a lease — claim before you work, not after, or two sessions judge the same arrival.`
-    : `\n— No other live session of yours holds a matching identifier, so nobody else is looking at these.`
+    : ''
 
   return `\n\n⚡ ARRIVALS SETTLING — yours alone, and no one else can see these yet:\n${lines.join('\n')}\n` +
     `— These are unjudged ARRIVALS, not records. Since automatic materialization was deleted, nothing files them for you.\n` +
     `— \`intake_look <id>\` reads the full body without claiming it — looking is free, non-exclusive and logged, so look rather than guess from the headline.\n` +
-    // ⚠ NAME THE EXACT CALL, INCLUDING THE ARRAY. This line used to read "Then `intake_claim` and
-    // `intake_materialize`" straight after a list of ids, which reads as `intake_claim <id>`. It is not:
-    // the parameter is `intakeItemIds`, an ARRAY, and on 2026-09-22 following this very sentence took a
-    // lease on ten unrelated units. The singular is accepted now, but an offer must still state the call
-    // that acts on the thing being offered — a reader should not have to consult a schema to use a nudge.
-    `— Then \`intake_claim {intakeItemIds: ["<id>"]}\` to take a lease on THAT unit (the array is required; without an id you claim the head of the queue instead), then \`intake_materialize\` into the brain and pages it belongs to — or \`intake_discard\`, or \`intake_defer\` with a question when only the owner can decide.` +
-    more + who +
-    `\n— If none are yours, leave them: they stay settling for your other sessions, and become everyone's business once the window closes.`
+    `— Then \`intake_claim {intakeItemIds: ["<id>"]}\` to take a lease on THAT unit (the array is required; without an id you claim the head of the queue instead), then \`intake_materialize\` into the brain and pages it belongs to — or \`intake_discard\`, or \`intake_defer\` with a question when only the owner can decide.\n` +
+    // ⚠ THE DECLINE IS NAMED HERE BECAUSE IT DID NOT EXIST BEFORE 0.9.167. An offer with no
+    // available "no" is re-offered on every tool call until the window closes, which is how an
+    // agent learns to skip the block entirely.
+    `— NOT yours? \`not_mine {intake_item_id: "<id>", reason: "..."}\` — per session, not a suppression: it keeps going to your other matching sessions, and once they have all declined it comes back to everyone.` +
+    more + who
 }
 
 function renderNudge(payload) {
@@ -2852,11 +2851,41 @@ function renderNudge(payload) {
       title: 'Decline a nudged record — it is not this session\'s business',
       description: 'Say a nudged record is NOT your business. Use it when the ⚡ ARRIVED block offered you a record and you have looked and it does not belong to what you are doing. ⚠ THIS IS NOT A CLAIM AND NOT A SUPPRESSION: the record stays unclaimed, stays on the general timeline, and stays offerable to any other session holding a matching identifier. You are saying "not MY business", never "nobody\'s business", and no other session is affected. Declining is a COMPLETE and expected answer — the cascade offers on the evidence of what you have open, which is a good guess and not a fact, and a wrong claim costs more than a decline. Without this the same nudge returns on your next tool call and the disagreement is recorded nowhere.',
       inputSchema: {
-        record_id: z.string().describe('the record id from the ⚡ ARRIVED block'),
+        record_id: z.string().optional().describe('the record id from the ⚡ ARRIVED block'),
+        // ⚠ THE TWO BLOCKS OFFER DIFFERENT KINDS OF THING, and this verb now answers both. ⚡ ARRIVED
+        // offers unclaimed RECORDS; ⚡ ARRIVALS SETTLING offers intake ARRIVALS that are not records
+        // and may never become one. Until 0.9.167 the settling block had no decline at all, so a unit
+        // a session had judged irrelevant was re-offered on every tool call — pilot B's 22-hour
+        // re-offer defect (§11), recreated by the fix for the other half of the same problem.
+        intake_item_id: z.string().optional().describe('the ARRIVAL id from the ⚡ ARRIVALS SETTLING block (not a record id)'),
         reason: z.string().describe('WHY it is not yours — recorded, and the only thing that can later answer "why did nobody take this"'),
       },
     },
-    async ({ record_id, reason }) => {
+    async ({ record_id, intake_item_id, reason }) => {
+      // ⚠ REFUSE BOTH AND NEITHER EXPLICITLY. Tonight's other defect was a parameter accepted by the
+      // caller, dropped by the schema, and replaced by a default that did something else entirely.
+      // An ambiguous decline must fail loudly, never pick one.
+      if (record_id && intake_item_id) {
+        return toolError('Pass record_id OR intake_item_id, not both — they are different kinds of thing and I will not guess which you meant.')
+      }
+      if (!record_id && !intake_item_id) {
+        return toolError('Pass record_id (from ⚡ ARRIVED) or intake_item_id (from ⚡ ARRIVALS SETTLING).')
+      }
+      if (intake_item_id) {
+        let r
+        try {
+          r = await fetchCortex(`${BASE}/api/settling/reject`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ intakeItemId: intake_item_id, reason }),
+          })
+        } catch (e) {
+          return toolError(`Could not decline ${intake_item_id}: ${e.message}`)
+        }
+        const o = await r.json().catch(() => null)
+        if (!r.ok) return toolError(`Could not decline ${intake_item_id}: ${o?.error ?? r.status}`)
+        return { content: [{ type: 'text', text: `Noted — arrival ${intake_item_id} will not be offered to THIS session again. It stays pending and still goes to your other matching sessions; once they have all declined it, it comes back to everyone as unclaimed.` }] }
+      }
       let res
       try {
         res = await fetchCortex(`${BASE}/api/nudge/reject`, {

package/package.json

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