@theronap/agnoclast-mcp 0.9.147 → 0.9.149

package/lib/capture.mjs

@@ -404,10 +404,14 @@ async function captureWork(stdinRaw) {
   // merge a deadline stated twice, reclassify whose it is. Never adds; fails open (obligation_review.mjs).
   // Only when there are candidates, which most sessions never produce.
   let obligations = extracted?.obligations ?? []
+  // The quotes the review retired (merged into a later statement, or not owed). The ONLY thing that lets
+  // the server delete an earlier read's proposal; a read that is merely silent about one deletes nothing.
+  let retiredObligations = []
   if (obligations.length) {
-    const { reviewObligations, describeReview } = await import('./obligation_review.mjs')
+    const { reviewObligations, describeReview, retiredEvidence } = await import('./obligation_review.mjs')
     const rev = reviewObligations(obligations, transcript)
     process.stderr.write(`cortex: ${stamp} ${sid} obligations ${describeReview(obligations.length, rev)}\n`)
+    retiredObligations = retiredEvidence(obligations, rev)
     obligations = rev.obligations
   }
   // `pages` is the edge's PROPOSAL of where this record belongs (ADR-0055). Free-text names, resolved
@@ -424,6 +428,8 @@ async function captureWork(stdinRaw) {
         // transcript it was shown — the server cannot re-check the quote (it never receives the
         // transcript), so these arrive already filtered. Omitted when empty, same as `pages`.
         ...(obligations.length ? { obligations } : {}),
+        // ADR-0059 §5.4: quotes the reviewer retired. Omitted when empty, so an older server sees nothing new.
+        ...(retiredObligations.length ? { retiredObligations } : {}),
       }
     : { ...common, transcript }
 

package/lib/edge_extract.mjs

@@ -289,6 +289,51 @@ export function verbatimIn(needle, haystack) {
   return norm(haystack).includes(n)
 }
 
+// ── SNAPPING A NEAR-QUOTE TO ITS SOURCE (ADR-0059 §4.1, added 2026-09-11) ──────────────────────────
+//
+// 🔴 WHY. The STRAT 421 research brief was lost on two separate runs for one word. The model quoted "…but
+// just have it on your radar. That will be September 22nd as well." The lecture says "on THE radar". The
+// gate above is right to refuse that quote, because a paraphrase is not evidence. But refusing the whole
+// CANDIDATE threw away a real, dated deadline whose source passage is right there, differing by one word.
+//
+// So a quote the gate refuses gets one more chance: find the SOURCE passage it came from, and use the
+// SOURCE's words. The quote must be long (SNAP_MIN_WORDS). Its first and last SNAP_ANCHOR_WORDS words must
+// each appear VERBATIM in the source, in order. The span between them must be within
+// SNAP_LENGTH_TOLERANCE of the quote's length. And exactly ONE such span may exist.
+//
+// ⚠ THIS DOES NOT LOOSEN THE GATE. What is stored is still verbatim source text — the transcript's
+// words, not the model's — so "the evidence sentence is in the source" stays true. What changes is who
+// wrote the evidence. A fabrication does not survive: an invented middle must still sit between two exact,
+// in-order, correctly-spaced anchors, and it is then REPLACED by what the source actually says there.
+// That is the text the reviewer and the person read. Not snapped: short quotes (anchors too weak), a
+// quote splicing distant passages (length check), and an anchor pair that matches in two places.
+const SNAP_ANCHOR_WORDS = 6
+const SNAP_MIN_WORDS = 14
+const SNAP_LENGTH_TOLERANCE = 0.25
+
+/** PURE. The source passage a near-verbatim quote was taken from (whitespace-normalised), or null. */
+export function snapToSource(quote, source) {
+  const q = String(quote ?? '').replace(/\s+/g, ' ').trim()
+  const words = q.split(' ')
+  if (!q || words.length < SNAP_MIN_WORDS) return null
+  const src = String(source ?? '')
+  const esc = (w) => w.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const anchor = (ws) => new RegExp(ws.map(esc).join('\\s+'), 'g')
+  const lo = q.length * (1 - SNAP_LENGTH_TOLERANCE)
+  const hi = q.length * (1 + SNAP_LENGTH_TOLERANCE)
+  const found = new Set()
+  for (const h of src.matchAll(anchor(words.slice(0, SNAP_ANCHOR_WORDS)))) {
+    const tail = anchor(words.slice(-SNAP_ANCHOR_WORDS))
+    tail.lastIndex = h.index + h[0].length
+    for (let t = tail.exec(src); t; t = tail.exec(src)) {
+      const span = src.slice(h.index, t.index + t[0].length).replace(/\s+/g, ' ').trim()
+      if (span.length > hi) break
+      if (span.length >= lo) { found.add(span); break }
+    }
+  }
+  return found.size === 1 ? [...found][0] : null
+}
+
 /**
  * Drop every obligation candidate that cannot be verified against the text the model was shown.
  *
@@ -309,18 +354,24 @@ export function keepVerifiableObligations(items, shown) {
     const evidence = typeof it.evidence === 'string' ? it.evidence.trim() : ''
     const party = typeof it.obligated_party === 'string' ? it.obligated_party.trim() : ''
     if (!subject || !evidence || !OBLIGATION_PARTIES.has(party)) continue
-    if (!verbatimIn(evidence, shown)) continue
+    // Verbatim, or a near-quote snapped to the source's own words (snapToSource). Nothing else.
+    let ev = evidence
+    if (!verbatimIn(ev, shown)) {
+      const snapped = snapToSource(ev, shown)
+      if (!snapped || !verbatimIn(snapped, shown)) continue
+      ev = snapped
+    }
     const due = typeof it.due_at === 'string' && it.due_at.trim() ? it.due_at.trim() : null
     // ADR-0059 §5.2: the WHEN words, which the server resolves into a date in code. Kept only if they
     // appear inside the evidence sentence — the check that stops a paraphrase ("Sept 22" for "the
     // 22nd") or a phrase from some other sentence from deciding the date. Dropped otherwise: the server
     // then falls back to due_at, exactly as it did before phrases existed.
     const phraseRaw = typeof it.due_phrase === 'string' ? it.due_phrase.trim() : ''
-    const due_phrase = phraseRaw && normWs(evidence).includes(normWs(phraseRaw)) ? phraseRaw.slice(0, 120) : null
+    const due_phrase = phraseRaw && normWs(ev).includes(normWs(phraseRaw)) ? phraseRaw.slice(0, 120) : null
     out.push({
       subject: subject.slice(0, 200), due_at: due,
       ...(due_phrase ? { due_phrase } : {}),
-      evidence: evidence.slice(0, 500), obligated_party: party,
+      evidence: ev.slice(0, 500), obligated_party: party,
     })
     if (out.length >= MAX_OBLIGATIONS) break
   }

package/lib/obligation_review.mjs

@@ -172,6 +172,29 @@ export function reviewObligations(cands, text, opts = {}) {
   return { obligations: kept, reviewed: true, changes, model }
 }
 
+/**
+ * PURE. The quotes this review RETIRED: candidates it merged into a later statement of the same item, or
+ * dropped as not an obligation. A quote it kept is never retired, even if another decision named it.
+ *
+ * 🔴 THIS IS THE ONLY THING THAT MAY DELETE AN EARLIER READ'S PROPOSAL (ADR-0059 §5.4, 2026-09-11). A read
+ * that simply does not mention a proposal says nothing about it: the model may have missed it this run, may
+ * have paraphrased its quote so the verbatim gate dropped it, or — in a session past 400,000 characters — may
+ * never have been SHOWN it (summaryWindow elides the middle). A reviewer that read the sentence in context
+ * and judged it superseded or not owed is a statement. So the server deletes exactly these, and nothing for
+ * silence. Empty when the review did not run: an unreviewed read retires nothing.
+ */
+export function retiredEvidence(cands, rev) {
+  if (!rev?.reviewed || !Array.isArray(cands)) return []
+  const kept = new Set((rev.obligations ?? []).map((o) => o?.evidence))
+  const idx = [...(rev.changes?.dropped ?? []), ...(rev.changes?.merged ?? []).map(([i]) => i)]
+  const out = []
+  for (const i of idx) {
+    const ev = cands[i]?.evidence
+    if (typeof ev === 'string' && ev && !kept.has(ev) && !out.includes(ev)) out.push(ev)
+  }
+  return out
+}
+
 /** PURE. One log line for a review outcome. */
 export function describeReview(before, rev) {
   if (!rev.reviewed) return `review skipped [${rev.reason}] — ${before} candidate(s) go on unreviewed`

package/lib/obligations_worker.mjs

@@ -25,7 +25,7 @@ import { mkdirSync, openSync, readdirSync, readFileSync, writeFileSync, renameSy
 import { homedir } from 'node:os'
 import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { reviewObligations, describeReview } from './obligation_review.mjs'
+import { reviewObligations, describeReview, retiredEvidence } from './obligation_review.mjs'
 
 export const MAX_PARK_DAYS = 30
 export const FIRST_RETRY_MS = 5 * 60_000
@@ -84,13 +84,14 @@ export function backoffMs(attempts) {
 }
 
 /** POST the candidates. Never throws: a network failure is `retry`, like a 5xx. */
-export async function postCandidates({ base, token, target, obligations, fetchImpl }) {
+export async function postCandidates({ base, token, target, obligations, retired = [], fetchImpl }) {
   if (!token) return { action: 'retry', status: 0, body: { error: 'no CORTEX_TOKEN in env or wired config' } }
   try {
     const res = await fetchImpl(`${base}/api/obligations/candidates`, {
       method: 'POST',
       headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ ...target, obligations }),
+      // retiredObligations: quotes the reviewer retired (ADR-0059 §5.4). Omitted when empty.
+      body: JSON.stringify({ ...target, obligations, ...(retired.length ? { retiredObligations: retired } : {}) }),
     })
     const body = await res.json().catch(() => ({}))
     return { action: classifyPost(res.status), status: res.status, body }
@@ -138,11 +139,15 @@ export async function processJob(job, deps) {
   // drop, merge or reclassify, never add; it fails open. Optional here so a caller without it is unchanged.
   const review = deps.review ?? ((o) => ({ obligations: o, reviewed: false, reason: 'no reviewer' }))
   const before = obligations.length
+  const cands = obligations
   const rev = review(obligations, job.text)
   log(describeReview(before, rev))
   obligations = rev.obligations
-  if (obligations.length === 0) return { outcome: 'none', reviewed: true }
-  const res = await post(job.target, obligations)
+  // What the review RETIRED is the only thing that may delete an earlier read's proposal (retiredEvidence).
+  // So a read whose every candidate was retired still posts: the retirement is the whole message.
+  const retired = retiredEvidence(cands, rev)
+  if (obligations.length === 0 && retired.length === 0) return { outcome: 'none', reviewed: true }
+  const res = await post(job.target, obligations, retired)
   if (res.action === 'recorded') {
     log(describeRecorded(res.body, obligations))
     return { outcome: 'recorded', proposed: res.body?.proposed ?? null }
@@ -152,7 +157,7 @@ export async function processJob(job, deps) {
     return { outcome: 'dropped', status: res.status }
   }
   const t = now()
-  park({ target: job.target, title: job.title ?? null, obligations, parkedAt: t, attempts: 1, nextAttemptAt: t + backoffMs(1) })
+  park({ target: job.target, title: job.title ?? null, obligations, ...(retired.length ? { retired } : {}), parkedAt: t, attempts: 1, nextAttemptAt: t + backoffMs(1) })
   log(`parked ${obligations.length} — ${res.action === 'pending' ? 'the unit is not materialised yet' : `${res.status} ${res.body?.error ?? ''}`.trim()}; retried by later captures`)
   return { outcome: 'parked', status: res.status }
 }
@@ -190,7 +195,7 @@ export async function flushParkedObligations(deps) {
       continue
     }
     if ((entry.nextAttemptAt ?? 0) > t) continue
-    const res = await post(entry.target, entry.obligations)
+    const res = await post(entry.target, entry.obligations, entry.retired ?? [])
     if (res.action === 'recorded' || res.action === 'drop') {
       try { unlinkSync(file) } catch { /* raced with another flush; the write is idempotent */ }
       flushed += 1
@@ -260,7 +265,7 @@ async function realDeps(target) {
     extract: extractSession,
     lastSkip: lastEdgeSkip,
     review: (obligations, text) => reviewObligations(obligations, text),
-    post: (t, obligations) => postCandidates({ base, token, target: t, obligations, fetchImpl: fetchCortex }),
+    post: (t, obligations, retired) => postCandidates({ base, token, target: t, obligations, retired, fetchImpl: fetchCortex }),
     park: (entry) => writeParked(parkDir(), entry),
     log: logger(target),
     sleep: (ms) => new Promise((r) => setTimeout(r, ms)),

package/lib/server.mjs

@@ -933,7 +933,7 @@ function renderNudge(payload) {
       inputSchema: {
         intakeItemId: z.string().describe('intake item uuid'),
         orgId: z.string().describe('destination brain org uuid'),
-        documentIds: z.array(z.string()).optional().describe('additional brain_documents ids in orgId (deterministic homes are merged automatically)'),
+        documentIds: z.array(z.string()).optional().describe('additional pages in orgId — each a page `ref:` exactly as read_page shows it, or a brain_documents id (deterministic homes are merged automatically)'),
         title: z.string().optional(),
         summary: z.string().optional(),
         source: z.string().optional(),

package/package.json

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