@theronap/cortex-mcp 0.9.88 → 0.9.89

package/lib/server.mjs

@@ -192,15 +192,17 @@ export async function runServer(version) {
     'log_session',
     {
       title: 'Log this session to Agnoclast',
-      description: 'Persist a CURATED summary of this work session as its durable Agnoclast record (authoritative — supersedes the auto-capture hook). Call at session close after composing the summary. Pass sessionId (the Claude Code session id) if you have it so this dedupes with the auto-capture of the same session.',
+      description: 'Persist a CURATED summary of this work session as its durable Agnoclast record (authoritative — supersedes the auto-capture hook). Call at session close after composing the summary. Pass sessionId (the Claude Code session id) if you have it so this dedupes with the auto-capture of the same session. If you belong to more than one brain, pass `brain` — without it a session log has no route and is STAGED rather than recorded.',
       inputSchema: {
         summary: z.string().describe('the curated session summary (what was done, decided, left open) — becomes the durable record'),
         project: z.string().optional().describe('project key/name this session worked in'),
         title: z.string().optional().describe('short title for the session'),
         sessionId: z.string().optional().describe('the Claude Code session id (dedupes with the auto-capture hook of the same session)'),
+        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. Use when the summary names confidential work (a candidate evaluation, a security finding) — safer than letting it land org-visible and re-tiering after, which leaves it readable in between.'),
       },
     },
-    async ({ summary, project, title, sessionId }) => {
+    async ({ summary, project, title, sessionId, brain, privacy }) => {
       const res = await fetchCortex(`${BASE}/api/ingest`, {
         method: 'POST',
         headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
@@ -211,6 +213,13 @@ export async function runServer(version) {
           ...(project ? { project } : {}),
           ...(title ? { title } : {}),
           ...(sessionId ? { sessionId } : {}),
+          // ADR-0022 deleted the write pointer, so a session-class source routes ONLY by an explicit
+          // brain or a sole membership — anything else STAGES. This tool never sent one, so every
+          // close-out from a multi-brain member landed in staged_records instead of the org. Measured
+          // 2026-08-09: 86 staged rows, and the pile is not drainable by /api/staged/promote because
+          // promote resolves through the same branch session-class sources skip.
+          ...(brain ? { brain } : {}),
+          ...(privacy ? { privacy } : {}),
           payload: { via: 'log_session' },
         }),
       })
@@ -219,7 +228,26 @@ export async function runServer(version) {
         throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
       }
       const j = await res.json().catch(() => ({}))
-      return { content: [{ type: 'text', text: `Logged to Agnoclast (authoritative): "${j.title ?? title ?? 'session'}" — ${j.inserted ? 'new record' : 'updated existing'}.` }] }
+
+      // NEVER report a non-record as "logged". `staged` and `skipped` are 200 OK responses that wrote
+      // no record, and this line used to print "Logged to Agnoclast (authoritative) … updated existing"
+      // for both — `j.inserted` is merely falsy on a staged write, which reads as an UPDATE. That is
+      // how a session close-out was reported as saved when it had not been (2026-08-09), and it is the
+      // same failure shape the cortex-log skill warns about for `author`: a success string over a write
+      // that did not land. The caller cannot tell the difference, so the message has to.
+      if (j.staged) {
+        const why = j.reason === 'no_route_for_source' && !brain
+          ? 'no brain was named and you belong to more than one, so it had nowhere to route'
+          : `reason: ${j.reason ?? 'unknown'}`
+        return { content: [{ type: 'text', text: `NOT LOGGED — STAGED, not recorded (${why}). Re-run log_session with brain:"<name>" to record it. Staged session logs cannot currently be drained by /api/staged/promote.` }] }
+      }
+      if (j.skipped) {
+        return { content: [{ type: 'text', text: `NOT LOGGED — the server skipped this write: ${j.skipped}` }] }
+      }
+      if (!j.id) {
+        return { content: [{ type: 'text', text: `NOT LOGGED — the server returned no record id. Raw response: ${JSON.stringify(j).slice(0, 300)}` }] }
+      }
+      return { content: [{ type: 'text', text: `Logged to Agnoclast (authoritative): "${j.title ?? title ?? 'session'}" — ${j.inserted ? 'new record' : 'updated existing'} (id ${j.id}).` }] }
     },
   )
 
@@ -1792,7 +1820,16 @@ export async function runServer(version) {
       const out = await res.json().catch(() => null)
       if (!res.ok) {
         if (out?.error === 'already_claimed') {
-          return toolError(`Another live session is already holding that record (${String(out.heldBy).slice(0, 16)}…). Leave it to them.`)
+          // Name the holder when the server knows it. The fallback matters: `heldBy` is absent when
+          // nothing holds a live lease, which means the record was not claimable rather than taken —
+          // printing "another session has it" there sends the reader chasing a session that does not
+          // exist. (This branch printed a bare `undefined` until 2026-08-14; the field was renamed
+          // server-side and the tool was never updated, which is the whole reason it says both now.)
+          if (out.heldBy) {
+            const until = out.heldUntil ? `, lease to ${out.heldUntil}` : ''
+            return toolError(`Session ${String(out.heldBy).slice(0, 16)}… is holding that record${until}. Leave it to them.`)
+          }
+          return toolError(out.detail || 'Could not claim that record and no session holds it — re-run pending_records; it may have been resolved already.')
         }
         return toolError(`Could not claim record: ${out?.error ?? res.status}`)
       }

package/package.json

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

package/skills/log/SKILL.md

@@ -36,9 +36,22 @@ No arguments. Read the conversation context.
    session's authoritative Agnoclast record (`capture_source='skill'`). The background auto-capture is a
    fallback and will not overwrite it; passing the same `sessionId` the auto-capture uses dedupes them
    onto one record. This — not the raw-transcript re-derivation — is the canonical record going forward.
-4. **Confirm + flag privacy** — `log_session` returns a confirmation; if it errors, tell the user to
-   run `npx -y @theronap/cortex-mcp doctor`. If any record from this session should be confidential,
-   note it so the user can mark it (`set_record_privacy`). Default is org-visible under access rules.
+
+   ⚠ **If you belong to more than one brain, pass `brain`.** ADR-0022 deleted the write pointer, so a
+   session-class source routes only by an explicit brain or a sole membership — omit it and the log is
+   **STAGED, not recorded**, and staged session logs are not drainable by `/api/staged/promote`. Pick the
+   brain the work was actually in (`my_brains` shows what each holds). This silently swallowed 86 close-outs
+   before it was caught on 2026-08-09.
+4. **Confirm + flag privacy** — **read the result text, do not assume it succeeded.** `log_session` now
+   answers `NOT LOGGED — STAGED…` or `NOT LOGGED — the server skipped…` when no record was written; only a
+   message carrying a record id means it landed. (It previously printed "Logged … updated existing" for a
+   staged write, because `inserted` is merely falsy when nothing is recorded — an agent reported a session
+   as saved when it was not.) If it errors, tell the user to run `npx -y @theronap/cortex-mcp doctor`.
+
+   If any record from this session should be confidential, prefer passing `privacy: "confidential"` on the
+   `log_session` call itself so it is tiered **at write time** rather than landing org-visible and being
+   corrected after. Otherwise note it so the user can mark it (`set_record_privacy`). Default is org-visible
+   under access rules.
 5. **Sweep the wiki (author what you now understand)** — the HARD backstop for live authoring
    ([[cortex-wiki-authoring-spec]] D2). For each node whose understanding meaningfully advanced this
    session (the project(s) worked on, people you coordinated with, and yourself when your own focus