@theronap/cortex-mcp 0.9.93 → 0.9.95

package/lib/capture.mjs

@@ -1,4 +1,4 @@
-import { readFileSync } from 'fs'
+import { readFileSync, accessSync, constants } from 'fs'
 import { spawn, execFileSync } from 'child_process'
 import { homedir } from 'os'
 import { resolve, dirname, join } from 'path'
@@ -180,6 +180,16 @@ function readStdin() {
 // though only the tail ships) and append the flagged spans.
 const LIFECYCLE_RE = /\b(paus\w*|resum\w*|shipp?\w*|kill\w*|cancel\w*|on hold|sunset\w*)\b/i
 
+// Whether the Stop hook's transcript_path actually resolves to a READABLE file.
+//
+// This distinguishes "no transcript was ever written" from "transcript exists but yielded no prose" —
+// transcriptTail() flattens both into the same empty string, which is exactly why the empty-session
+// guard below could never see the first case.
+export function transcriptReadable(path) {
+  if (!path) return false
+  try { accessSync(path, constants.R_OK); return true } catch { return false }
+}
+
 function transcriptTail(path) {
   let raw = ''
   try { raw = readFileSync(path, 'utf8') } catch { return '' }
@@ -272,6 +282,26 @@ async function captureWork(stdinRaw) {
   // must never be transmitted or stored. See redact.mjs.
   const transcript = hook.transcript_path ? redactSecrets(transcriptTail(hook.transcript_path)) : ''
 
+  // A transcript_path that was SUPPLIED but is unreadable means the session ran with transcript writes
+  // disabled — `claude --print --no-session-persistence`, or the SDK's `persistSession:false`. Verified
+  // A/B 2026-08-18: with the flag, Claude Code writes no JSONL at all; without it, one appears.
+  //
+  // The guard below cannot catch that case, and never could: `session_id` is ALWAYS present in a Stop
+  // payload, so `!transcript && !hook.session_id` can only ever fire on the session_id half. Capture
+  // therefore sailed straight on and shipped `{...common, transcript: ''}` — a contentless record that
+  // ALSO lost its repo stamp (repoFullNamesFrom throws on the missing file and is swallowed), leaving it
+  // permanently private. That is worse than capturing nothing: it reports `cortex: captured`, and it
+  // inflates the very record count that capture health is judged by (there is no freshness monitor).
+  //
+  // Safe to skip rather than degrade, because capture is not one-shot: the Stop hook fires after EVERY
+  // assistant turn and the server upserts ONE record per session_id. A transcript that is merely
+  // unreadable for a moment is picked up by the next turn, so a transient miss self-heals; only a
+  // genuinely persistence-disabled session is dropped, and that session has no content to capture.
+  if (hook.transcript_path && !transcriptReadable(hook.transcript_path)) {
+    process.stderr.write('cortex: transcript_path unreadable (session persistence disabled?), skipping\n')
+    return
+  }
+
   if (!transcript && !hook.session_id) { process.stderr.write('cortex: empty session, skipping\n'); return }
 
   // T11: digest node refs surfaced to this session (stashed by the MCP server's my_context, keyed by

package/lib/server.mjs

@@ -916,6 +916,40 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'search_spam_email',
+    {
+      title: 'Search Gmail Spam intentionally',
+      description: 'Search a connected Gmail Spam folder only when the user explicitly asks you to find a message that may have been marked as Spam. This is read-only: results are returned for this request only and are NOT added to Agnoclast records, timeline, or future context. Give a specific Gmail search such as a sender, subject words, or date. Normal Gmail sync never reads Spam.',
+      inputSchema: {
+        query: z.string().min(2).describe('specific Gmail search within Spam, e.g. `from:billing@example.com`, `subject:(appointment reminder)`, or `after:2026/08/01`'),
+        account: z.string().email().optional().describe('which connected Gmail account to search when more than one is available'),
+        limit: z.number().int().min(1).max(10).optional().describe('maximum matches to return (default 5; max 10)'),
+      },
+    },
+    async ({ query, account, limit }) => {
+      const res = await fetchCortex(`${BASE}/api/gmail/search-spam`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query, ...(account ? { account } : {}), ...(limit ? { limit } : {}) }),
+      })
+      const body = await res.json().catch(() => null)
+      if (!res.ok) {
+        if (res.status === 409 && Array.isArray(body?.accounts)) {
+          return toolError(`Choose a connected Gmail account and call again with account: ${body.accounts.join(', ')}`)
+        }
+        return toolError(body?.error ?? `Spam search failed (${res.status}).`)
+      }
+      const rows = Array.isArray(body?.messages) ? body.messages : []
+      if (!rows.length) return { content: [{ type: 'text', text: `No Spam matches in ${body?.account ?? 'the connected Gmail account'}. Nothing was saved to Agnoclast.` }] }
+      const lines = [`Spam matches in ${body.account} (read-only; not saved to Agnoclast):`]
+      for (const m of rows) {
+        lines.push(`- ${m.date || 'unknown date'} · ${m.from || 'unknown sender'} · ${m.subject}\n  ${m.snippet || '(no preview)'}\n  ${m.sourceUri}`)
+      }
+      return { content: [{ type: 'text', text: lines.join('\n') }] }
+    },
+  )
+
   server.registerTool(
     'grep',
     {

package/package.json

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