@theronap/agnoclast-mcp 0.9.195 → 0.9.196

package/lib/server.mjs

@@ -555,15 +555,20 @@ function renderNudge(payload) {
           summary: z.string().describe('a summary that stands ON ITS OWN. It must not mention, allude to, or imply that other segments exist — "the rest of this session covered personal projects" leaks in prose exactly what splitting was meant to contain'),
           title: z.string().optional(),
           project: z.string().optional(),
+          pages: z.array(z.string()).optional().describe('pages IN THAT BRAIN this half belongs on — each a page `ref:` as read_page shows it'),
         })).optional().describe('SPLIT the log, one entry per brain. Use whenever a session touched work belonging to different brains: a session is a container of time, not a topic, and every single-brain answer is wrong — filing it all in the org brain exposes personal work to colleagues, filing it all in the personal one denies the org its record, and summarizing half silently drops the other half. Max ONE segment per brain (they share this session\'s dedupe key, so two aimed at the same brain would overwrite each other). When a chunk is ambiguous, put it in the MORE PRIVATE brain — a misfile there is private, a misfile the other way is visible to everyone in the org.'),
         project: z.string().optional().describe('project key/name this session worked in'),
         title: z.string().optional().describe('short title for the session'),
+        pages: z.array(z.string()).optional().describe('pages this log belongs on — each a page `ref:` as read_page shows it (the project it was about, the decision it bears on). The pages this session WROTE are attached automatically; name the ones it was ABOUT but did not edit. REQUIRED IN EFFECT when you log on behalf of a DIFFERENT session (an explicit sessionId): only a session filing its own log is let through without them. The single-brain form; with `segments`, put pages on each segment'),
         sessionId: z.string().optional().describe('the Claude Code session id — DEFAULTS to the current session, so omit it unless you are logging on behalf of another one. It is shared by every segment and the only thing pairing them, and it is also the join to the pages this session wrote (page_revisions.session_key); without it the record is unattributable forever, since the fallback dedupe key is a timestamp. Deliberately NOT a link: segments never reference each other, so a reader cleared for one brain cannot tell the others exist, while you can join on it across brains'),
         brain: z.string().optional().describe('which brain to record this session in (name or org id, one of your own). REQUIRED IN EFFECT for a multi-brain member: session-class sources route only by an explicit brain or a sole membership, so omitting it stages the log instead of recording it.'),
         privacy: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('tier this record AT WRITE TIME. A record is normally read by whoever can read the page it is filed under. Pass "confidential" when the summary names confidential work (a candidate evaluation, a security finding) so it is yours alone from the start — safer than letting it land page-visible and locking it after, which leaves it readable in between. Pass "scoped" to lock it to you and your managers. OMIT it for ordinary work: the record then follows its page, which is what makes it visible to the people working on that page with you.'),
       },
     },
-    async ({ summary, segments, project, title, sessionId, brain, privacy }) => {
+    async ({ summary, segments, project, title, sessionId, brain, privacy, pages }) => {
+      // read_page prints `ref: <uuid>`; a caller who pastes the label with it must not get a 400.
+      const pageRefs = (list) => (Array.isArray(list) ? list : [])
+        .map((r) => String(r).trim().replace(/^ref:\s*/i, '')).filter(Boolean)
       // Default the session id from the environment when the caller omits it.
       //
       // `sessionId` is optional and the model routinely does not pass it, so the record lands with a
@@ -588,8 +593,8 @@ function renderNudge(payload) {
       // A session is a container of TIME, not a topic (ADR-0029 step 4). Normalize to a list of
       // segments; the single-brain call is just a one-segment list.
       const list = Array.isArray(segments) && segments.length
-        ? segments.map((s) => ({ brain: s.brain, summary: s.summary, title: s.title ?? title, project: s.project ?? project }))
-        : (summary ? [{ brain, summary, title, project }] : null)
+        ? segments.map((s) => ({ brain: s.brain, summary: s.summary, title: s.title ?? title, project: s.project ?? project, pages: pageRefs(s.pages) }))
+        : (summary ? [{ brain, summary, title, project, pages: pageRefs(pages) }] : null)
       if (!list) {
         return toolError('Pass `summary` (single brain) or a non-empty `segments` array (one entry per brain).')
       }
@@ -722,6 +727,12 @@ function renderNudge(payload) {
               body: JSON.stringify({
                 intakeItemId: j.intakeItemId,
                 orgId,
+                // Pages the caller named. The pages this session WROTE need no naming: the server
+                // attaches those by session key. Sent only when given, so a plain close-out keeps
+                // the exact body it always had.
+                ...(seg.pages.length
+                  ? { documentIds: seg.pages, attachmentMeta: seg.pages.map(() => ({ origin: 'session' })) }
+                  : {}),
                 record: {
                   title: seg.title,
                   summary: seg.summary,
@@ -732,16 +743,29 @@ function renderNudge(payload) {
             })
           } catch (e) {
             failures++
-            lines.push(`✗ ${where}: intake ${j.intakeItemId} NOT materialized — ${e.message}`)
+            lines.push(`✗ ${where}: the curated log was NOT written (intake ${j.intakeItemId}) — ${e.message}`)
             continue
           }
           const mj = await m.json().catch(() => ({}))
           if (!m.ok || !mj.recordId) {
             failures++
-            lines.push(`✗ ${where}: intake ${j.intakeItemId} NOT materialized — ${mj.error ?? m.status}`)
+            // 🔴 THE OLD WORDING ("not materialized") WAS A LIE HALF THE TIME (2026-10-02). When this session's unit is
+            // already a record — filed mid-session — the unit IS materialized; what failed is writing
+            // the curated summary onto it. Say what did not happen, and what would make it happen.
+            //
+            // The other-homes refusal (ADR-0051) is answerable from here: name a page. A server that
+            // exempts a session's own close-out never sends it for one; it still does when logging on
+            // behalf of ANOTHER session, which is a judgment about someone else's work.
+            const why = mj.error === 'other_homes_unchecked'
+              ? 'the server asks what pages this log belongs on. Re-run with pages:["<page ref>", …] — the project it was about, the decision it bears on (read_page prints each page\'s ref)'
+              : (mj.error ?? m.status)
+            lines.push(`✗ ${where}: the curated log was NOT written (intake ${j.intakeItemId}) — ${why}`)
             continue
           }
-          lines.push(`✓ ${where}: record ${mj.recordId}`)
+          // `duplicate` with `updated: false` is ingest saying this session's unit had already been
+          // acted on — so the record existed and this call replaced its title and summary.
+          const amended = j.duplicate === true && j.updated === false
+          lines.push(`✓ ${where}: record ${mj.recordId}${amended ? ' (replaced the summary on this session\'s existing record)' : ''}`)
           continue
         }
 

package/package.json

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