@theronap/agnoclast-mcp 0.9.174 → 0.9.176

package/bin/cortex-mcp.mjs

@@ -58,6 +58,33 @@ if (process.env.CORTEX_SUMMARIZING && CONTEXT_HOOK_COMMANDS.has(cmd)) {
   process.exit(0)
 }
 
+// ADR-0020 Stage 2, amended 2026-09-25 — stamp THIS session's identity on the read-only context
+// hooks. Until now setSessionKey was called ONLY in server.mjs, so a one-shot hook sent no
+// x-cortex-session-key header, /api/mcp-context resolved the person-wide pointer, and the settling
+// feed — which is session-scoped by definition — rendered nothing at session start no matter how
+// many arrivals were asking this session to judge them. 269 units sat in the settle window on the
+// day this was found; the block had been silently empty through three separate attempts to fix it
+// further upstream, because every one of them fixed the server while the HOOK stayed anonymous.
+//
+// Placed at the dispatcher for the same reason the guard above is: it is one rule about what a hook
+// process IS, and putting it in four subcommands is how the fifth gets forgotten.
+//
+// env ONLY, deliberately never stdin: arrivals-notice and hydrate consume stdin themselves with
+// readFileSync(0), which DRAINS the pipe. A read here would starve them of their own payload —
+// fixing one notice by breaking another.
+//
+// hookSessionKey never invents a random id (see its note in session_key.mjs): no id -> no header ->
+// exactly the previous behavior, rather than a key that matches nothing and prints a confident
+// "nothing is waiting for you".
+if (CONTEXT_HOOK_COMMANDS.has(cmd)) {
+  const { hookSessionKey } = await import('../lib/session_key.mjs')
+  const forSession = hookSessionKey(process.env)
+  if (forSession) {
+    const { setSessionKey } = await import('../lib/diagnose.mjs')
+    setSessionKey(forSession)
+  }
+}
+
 if (cmd === '--version' || cmd === '-v') {
   process.stdout.write(`cortex-mcp ${VERSION}\n`)
   process.exit(0)

package/lib/diagnose.mjs

@@ -542,6 +542,26 @@ export function outageReport(outcome, { tool, requestId = null, version = CLIENT
   return null
 }
 
+// ⚠ "COULD NOT CONNECT" IS ALSO WHAT A LAPTOP WITH NO NETWORK LOOKS LIKE. The first real report (2026-09-25)
+// was ×12 `connect` outages from one Mac between 09:34 and 11:39 — hooks running during DarkWake /
+// Maintenance Sleep with the network half up, while production was healthy. So a thrown connect/timeout
+// is only filed when the INTERNET is reachable and Agnoclast is not. The probe hits a neutral anycast host
+// with its own short budget; if that fails too, the fault is local and nothing is filed. A response of any
+// kind (infra 4xx/5xx, 503) proves the network worked, so those paths never probe.
+const REACHABILITY_URL = 'https://1.1.1.1/cdn-cgi/trace'
+const REACHABILITY_TIMEOUT_MS = 2500
+let reachabilityProbe = async () => {
+  try {
+    const r = await fetch(REACHABILITY_URL, { method: 'GET', signal: AbortSignal.timeout(REACHABILITY_TIMEOUT_MS) })
+    try { await r.body?.cancel() } catch { /* nothing to drain */ }
+    return true
+  } catch {
+    return false
+  }
+}
+/** Tests: replace the internet-reachability probe. Returns the previous one. */
+export function setReachabilityProbe(fn) { const prev = reachabilityProbe; reachabilityProbe = fn; return prev }
+
 /** Auto-filing is off under `bun test` unless the test points the spool somewhere (never the real home). */
 function autofileEnabled(env = process.env) {
   if (env.CORTEX_AUTOFILE === '0') return false
@@ -601,7 +621,9 @@ export async function fetchCortex(url, opts = {}, policy = {}) {
   } catch (e) {
     if (hook && e?.retryClass) {
       const r = outageReport({ thrownClass: e.retryClass }, { tool: toolForUrl(url) })
-      if (r) spoolReport(r)
+      // Awaited, not fire-and-forget: hook processes are short-lived and would exit before a detached
+      // probe answered. Bounded by REACHABILITY_TIMEOUT_MS, and only on a path that is already failing.
+      try { if (r && await reachabilityProbe()) spoolReport(r) } catch { /* filing must never change the error */ }
     }
     throw e
   }

package/lib/server.mjs

@@ -231,25 +231,13 @@ export async function runServer(version) {
       const body = await res.text()
       throw new Error(classify(res.status, res.headers.get('content-type'), body, res.headers.get('x-vercel-id')).message)
     }
-    const { context, brainRefs, settling } = await res.json()
-    // ⭐ THE SETTLING FEED, APPENDED TO THE SESSION-START BLOCK — the thing it has never carried.
-    //
-    // Everything else in that block is PERSON-scoped, so /api/mcp-context never needed to know which
-    // session was asking and never read the `x-cortex-session-key` header it has been receiving on
-    // every request since fetchCortex started sending it. The settling feed is the only inherently
-    // SESSION-scoped signal in the block, which is why it was structurally excluded rather than
-    // forgotten — and why a NEW SESSION has never once been told which arrivals are asking it a
-    // question. That is the resume case: start a session, and the offers are waiting.
-    //
-    // ⚠ NOT CACHED, and the distinction matters. The block is cached for 5 minutes; an OFFER is
-    // live state that another session can claim out from under this one. Baking it into the cached
-    // string would serve an offer already taken, or hide one that just arrived — and a feed whose
-    // whole contract is "this persists until you answer it" cannot afford to be five minutes wrong.
-    // So the cache keeps the person-scoped context exactly as before, and the session-scoped feed is
-    // appended only on a FRESH fetch. Session start and resume are always fresh fetches, which is
-    // the case this exists for; mid-session cache hits are covered by the tools.
+    const { context, brainRefs } = await res.json()
+    // ⚠ THE FEED IS RENDERED SERVER-SIDE NOW, inside assembleMcpContext, NOT appended here.
+    // Appending client-side only reached the MCP tool path: the session-start block is printed by a
+    // CLI subcommand that takes `payload.context` verbatim, and the hooks run `cortex-mcp@stable` —
+    // six versions behind. Server-side rendering reaches every client including the pinned one.
     cache = { text: context, ts: now, repo }
-    const withSettling = (context ?? '') + renderSettling({ settling })
+
     // T11: stash the digest node refs surfaced this fetch so capture.mjs can forward them as
     // hydrated_from at the session's ingest (feedback-loop guard). Keyed by cwd so the matching
     // session picks them up. Best-effort + inert when brainRefs is empty (digest flag off).
@@ -261,8 +249,7 @@ export async function runServer(version) {
         writeFileSync(join(dir, `${key}.json`), JSON.stringify({ refs: brainRefs, ts: now }))
       }
     } catch { /* best-effort — never break context serving */ }
-    // The fresh block carries the offers; the cached one deliberately does not (see above).
-    return withSettling
+    return context
   }
 
   const server = new McpServer({ name: 'cortex', version })

package/lib/session_key.mjs

@@ -35,3 +35,27 @@ export function resolveLogSessionId(explicit, env) {
   if (typeof fromEnv === 'string' && fromEnv.trim()) return fromEnv.trim()
   return undefined
 }
+
+// Which session a one-shot CONTEXT HOOK process is acting FOR. Pure — see session_key.test.mjs.
+//
+// Third session-id question in this file, and like resolveLogSessionId it is deliberately NOT built
+// on resolveSessionKey. That one answers "which session is this process" for the WRITE POINTER, and
+// may invent a randomUUID() because a write pointer is only ever compared to ITSELF — any stable
+// value works.
+//
+// This key is compared to OTHER sessions' keys: the server uses it to decide which settling offers
+// are asking THIS session to judge an arrival. A random value there matches no offer, so the block
+// renders EMPTY rather than absent — "nothing is waiting for you" when 269 units were. An empty
+// queue and an unidentified process MUST NOT look the same, so there is no random fallback here.
+//
+// So: the conversation id Claude Code names, else NOTHING. Never a random.
+//
+// Why a hook has an identity at all, given the ADR-0020 note in diagnose.mjs says these processes
+// "have no session of their own": true, and unchanged for writes. But a SessionStart hook runs ON
+// BEHALF of a session, and CLAUDE_CODE_SESSION_ID names it. Read-only context commands may therefore
+// speak for it; capture and the other writers still fall back to the account pointer as intended.
+export function hookSessionKey(env) {
+  const fromEnv = env?.CLAUDE_CODE_SESSION_ID
+  if (typeof fromEnv === 'string' && fromEnv.trim()) return fromEnv.trim()
+  return null
+}

package/package.json

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