@theronap/agnoclast-mcp 0.9.213 → 0.9.215

package/lib/diagnose.mjs

@@ -679,7 +679,14 @@ export async function fetchCortex(url, opts = {}, policy = {}) {
 
 // Live health probe: hit /api/mcp-context with the token and classify the result.
 // Returns { ok, status, projectCount?, requestId?, diagnosis? }.
-export async function checkToken(token, base) {
+//
+// `probe: true` (the SessionStart status line) asks the server for the token check and the capture
+// notice ONLY, not the context. That hook fires at the same moment as `snapshot-context`, which fetches
+// the full context, so without it every session start assembled the context twice, concurrently, on a
+// max:1 pool: a ~1.6 s start measured ~5 s in prod (2026-10-06). doctor/setup/install keep the full
+// fetch on purpose; they exist to prove the context itself comes back. An older server ignores the
+// parameter and returns the full context, which this still parses, so the two can ship in either order.
+export async function checkToken(token, base, { probe = false } = {}) {
   if (!token) {
     return { ok: false, status: 0, diagnosis: { kind: 'config', retriable: false,
       message: 'No CORTEX_TOKEN found. Run: npx -y @theronap/cortex-mcp login (opens your browser; or `setup <token>` with a token from the console → Connect your AI)' } }
@@ -689,7 +696,7 @@ export async function checkToken(token, base) {
       message: `Token "${String(token).slice(0, 8)}…" is not a valid Agnoclast token (expected a UUID). ` +
         `Re-run setup with the token from the console.` } }
   }
-  const url = `${(base ?? CANONICAL_BASE).replace(/\/$/, '')}/api/mcp-context`
+  const url = `${(base ?? CANONICAL_BASE).replace(/\/$/, '')}/api/mcp-context${probe ? '?probe=1' : ''}`
   let res
   try {
     res = await fetchCortex(url, { headers: { Authorization: `Bearer ${token}` } })

package/lib/doctor.mjs

@@ -71,7 +71,7 @@ async function statusLine(out, { capturesStuck = false } = {}) {
     return
   }
   try {
-    const r = await checkToken(token, base)
+    const r = await checkToken(token, base, { probe: true })
     if (r.ok) {
       // ⚠ THE NOTICE REPLACES THE HAPPY LINE RATHER THAN FOLLOWING IT.
       // "connected — sessions on this machine are captured to your org" was printed truthfully to

package/lib/filing_obligations.mjs

@@ -0,0 +1,96 @@
+// OBLIGATION 53bfd283 — A TEXT ANSWERS "DOES THIS ASK ANYONE FOR ANYTHING?" WHEN IT IS FILED.
+//
+// No extractor reads a text: extraction runs on session transcripts and handoffs (ADR-0059 §5.1), and a
+// text is opened for the first time by the agent that files it. Volunteering `propose_obligation` from
+// there was measured at ~10% for the same kind of ask (§5.6). So `intake_materialize` now carries the
+// answer itself, and the server refuses to file a text from this release on until it has one. `[]` is a
+// complete answer; silence is what is refused.
+//
+// The server checks every quote against the text it just unsealed, so a paraphrase is never written. This
+// file only does what the server cannot: split one call's list across the units of a batch, and refuse
+// loudly — with the reason — what the server would otherwise drop silently.
+
+import { buildProposal } from './propose_obligation.mjs'
+
+/**
+ * PURE. `obligations` as passed to intake_materialize → each unit's own list.
+ *
+ * `byUnit` is null when the caller passed no `obligations` at all, so the request carries no field and an
+ * older server behaves exactly as before. Otherwise EVERY unit gets a list, `[]` included: answering for
+ * the batch answers for each text in it. A quote must name its unit when the call files more than one —
+ * guessing which text a sentence came from is how it would be checked against the wrong one and dropped.
+ */
+export function obligationsForUnits(batch, list) {
+  if (list === undefined || list === null) return { byUnit: null, errors: [], notes: [] }
+  const byUnit = new Map(batch.map((id) => [id, []]))
+  const errors = []
+  const notes = []
+  for (const [i, o] of (Array.isArray(list) ? list : []).entries()) {
+    const id = o?.intakeItemId ?? (batch.length === 1 ? batch[0] : null)
+    if (!id) {
+      errors.push(`obligations[${i}]: name its intakeItemId — this call files ${batch.length} texts and a quote belongs to exactly one`)
+      continue
+    }
+    if (!byUnit.has(id)) {
+      errors.push(`obligations[${i}]: ${id} is not one of the units this call files`)
+      continue
+    }
+    const built = buildProposal(o)
+    if (built.error) {
+      errors.push(`obligations[${i}]: ${built.error}`)
+      continue
+    }
+    if (built.note) notes.push(`obligations[${i}]: ${built.note}`)
+    byUnit.get(id).push(built.candidate)
+  }
+  return { byUnit, errors, notes }
+}
+
+/** What the server says when a text was filed with no answer. Written for the agent holding the text. */
+export const OBLIGATIONS_UNANSWERED_TEXT =
+  'Not filed yet — a text must answer whether it asks anyone for anything. Read it, then call again with ' +
+  '`obligations`: one entry per ask, with `evidence` copied word for word from the text and `obligated_party` ' +
+  'self (the person whose texts these are), other, or none. Pass `[]` when it asks nothing. Nothing was written.'
+
+/**
+ * PURE. What a filing reports about its obligations answer, in words. Empty when the server sent nothing
+ * (no answer was given, or the server predates this), so an older server never reads as "asks nothing".
+ */
+export function renderFilingObligations(o) {
+  if (!o || typeof o !== 'object') return []
+  const lines = []
+  if (o.write === null) {
+    lines.push('⚠ The obligations write FAILED — the record was filed but nothing was proposed. Propose them again with propose_obligation.')
+  }
+  const proposed = o.write?.proposed ?? 0
+  const refreshed = o.write?.refreshed ?? 0
+  if (o.sent === 0) {
+    lines.push('Obligations: none — answered that this asks nothing of anyone.')
+  } else if (proposed || refreshed) {
+    lines.push(
+      `Obligations: proposed ${proposed}${refreshed ? `, updated ${refreshed}` : ''} — PROPOSALS the person confirms or ` +
+      'dismisses (my_obligations), never commitments they made.',
+    )
+  }
+  if (o.write?.undated) lines.push(`⚠ ${o.write.undated} of them has no date, so nothing will raise it by time.`)
+  if (o.write?.unhomed) lines.push(`⚠ ${o.write.unhomed} could not be placed: the record is on no page.`)
+  if (Array.isArray(o.unverified) && o.unverified.length) {
+    lines.push(
+      `⚠ NOT written — not in this text word for word: ${o.unverified.map((e) => `"${e}"`).join('; ')}. ` +
+      "Quote the text's own sentence (propose_obligation with this record id).",
+    )
+  }
+  if (o.malformed) lines.push(`⚠ ${o.malformed} malformed obligation(s) were dropped.`)
+  return lines
+}
+
+/** PURE. The same, folded onto one line for a batch's per-unit detail. */
+export function filingObligationsBrief(o) {
+  if (!o || typeof o !== 'object') return ''
+  if (o.write === null) return ' · ⚠ obligations write FAILED'
+  const bits = []
+  if (o.sent === 0) bits.push('asks nothing')
+  else if (o.write?.proposed) bits.push(`${o.write.proposed} obligation(s) proposed`)
+  if (Array.isArray(o.unverified) && o.unverified.length) bits.push(`⚠ ${o.unverified.length} quote(s) not in the text, not written`)
+  return bits.length ? ` · ${bits.join(', ')}` : ''
+}

package/lib/server.mjs

@@ -25,6 +25,7 @@ import { renderObligations, renderPageObligations, tierReads, who } from './obli
 import { renderRemovalQuestion, renderRemoved } from './member_remove_render.mjs'
 import { renderSettings } from './settings_render.mjs'
 import { renderConversationOffer, renderMaterializeBatch } from './intake_batch_render.mjs'
+import { obligationsForUnits, renderFilingObligations, filingObligationsBrief, OBLIGATIONS_UNANSWERED_TEXT } from './filing_obligations.mjs'
 import { formatCreated, formatDryRun, formatSources, homeFromArgs, pickSource, renderHomeProblem } from './custom_sources.mjs'
 
 // PAGE tiers (ADR-0071). Six for a PAGE; a RECORD keeps three (`privacy` on log_session and
@@ -1273,6 +1274,18 @@ function renderNudge(payload) {
           'ADR-0077: one answer per open folder question from a refused call — exactly one of claim, decline or defer each. ' +
           'Send only after the server has listed the questions; claims and declines are written when the unit is filed.',
         ),
+        obligations: z.array(z.object({
+          intakeItemId: z.string().optional().describe('which unit the quote is from — required when this call files more than one'),
+          subject: z.string().describe('what must be done, one short phrase'),
+          evidence: z.string().describe('the sentence that asks for it, copied WORD FOR WORD from that text — the server checks'),
+          due_phrase: z.string().optional().describe('the words in the evidence that say WHEN ("before 5 tomorrow") — the server dates it from the text'),
+          due_at: z.string().optional().describe('YYYY-MM-DD only when the text states a date'),
+          obligated_party: z.enum(['self', 'other', 'none']).optional().describe('self (default) = the person whose texts these are owes it'),
+        })).optional().describe(
+          'REQUIRED FOR TEXTS: does this ask anyone for anything? One entry per ask — a request to the person, a ' +
+          'yes they gave, a time they agreed to. `[]` when it asks nothing. A text filed without it is refused. ' +
+          'Lands as PROPOSALS; a quote the text does not contain is reported and not written. Any other unit may send it too.',
+        ),
       },
     },
     async (args) => {
@@ -1280,6 +1293,11 @@ function renderNudge(payload) {
       // are looked up once and handled together, but "it shouldn't file all of them as one record". The
       // loop lives here, as it does for place_staged_record's batch: the route stays one unit per call.
       const batch = [...new Set([args.intakeItemId, ...(args.intakeItemIds ?? [])])].slice(0, 50)
+      // Obligation 53bfd283 — each unit's own answer. Refused HERE, before anything is filed, rather than
+      // sent for the server to drop: an agent told nothing believes the ask was surfaced.
+      const ob = obligationsForUnits(batch, args.obligations)
+      if (ob.errors.length) return toolError(`Nothing was filed — fix these obligations first:\n${ob.errors.map((e) => `  · ${e}`).join('\n')}`)
+      const obligationsFor = (id) => (ob.byUnit ? { obligations: ob.byUnit.get(id) ?? [] } : {})
       if (batch.length > 1 && args.mode !== 'preview') {
         const results = []
         for (const id of batch) {
@@ -1298,15 +1316,20 @@ function renderNudge(payload) {
                 // One placement is a decision about ONE conversation: the server refuses any id whose
                 // batch differs from the first id's, so a stray id is never filed onto these pages.
                 sameBatchAs: batch[0],
+                ...obligationsFor(id),
               }),
             })
             const o = await r.json().catch(() => null)
-            results.push({ id, ok: r.ok, detail: r.ok ? (o?.recordId ?? 'filed') : (o?.error ?? `HTTP ${r.status}`) })
+            const why = o?.error === 'obligations_unanswered'
+              ? 'not filed — a text needs `obligations` ([] when it asks nothing)'
+              : (o?.error ?? `HTTP ${r.status}`)
+            results.push({ id, ok: r.ok, detail: r.ok ? `${o?.recordId ?? 'filed'}${filingObligationsBrief(o?.obligations)}` : why })
           } catch (e) {
             results.push({ id, ok: false, detail: e.message })
           }
         }
-        return { content: [{ type: 'text', text: renderMaterializeBatch(results) }] }
+        const notes = ob.notes.length ? `\n${ob.notes.map((n) => `⚠ ${n}`).join('\n')}` : ''
+        return { content: [{ type: 'text', text: `${renderMaterializeBatch(results)}${notes}` }] }
       }
       // 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.
@@ -1329,6 +1352,7 @@ function renderNudge(payload) {
           ...(args.governingPage ? { governingDocumentId: args.governingPage } : {}),
           ...(args.searchedForOtherHomes ? { searchedForOtherHomes: true } : {}),
           ...(args.folderDecisions?.length ? { folderDecisions: args.folderDecisions } : {}),
+          ...obligationsFor(args.intakeItemId),
         }),
       })
       if (!res.ok) {
@@ -1348,6 +1372,7 @@ function renderNudge(payload) {
               'Not filed yet — every page named is one this unit gets anyway, so this would publish it without adding anything of your judgment.',
             ))
           }
+          if (err === 'obligations_unanswered') return toolError(OBLIGATIONS_UNANSWERED_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.')
@@ -1413,6 +1438,7 @@ function renderNudge(payload) {
       // filed onto. Never claimed by the server; the session decides.
       lines.push(...renderFolderDecisionsApplied(body?.folderDecisions))
       lines.push(...renderFolderClaimOffers(body?.folderClaimOffers))
+      lines.push(...renderFilingObligations(body?.obligations), ...ob.notes.map((n) => `⚠ ${n}`))
       if (body?.containerSkipped) {
         lines.push(`⚠ CONTAINER NOT APPLIED — ${body.containerSkipped}. The record exists but is not inside the event you named; place it with contain_record or leave it out.`)
       } else if (body?.contained === true) {

package/package.json

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