@theronap/cortex-mcp 0.9.113 → 0.9.115

package/lib/context_log.mjs

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlink
 import { homedir } from 'os'
 import { join } from 'path'
 import { fetchCortex, classify, resolveBase, resolveTokenSource } from './diagnose.mjs'
+import { repoFullNameFrom } from './capture.mjs'
 
 // The private third copy of this lived here until 2026-08-19. doctor.mjs:14 warned that a third
 // copy is how a machine ends up connected to one command and 'no token found' to another; it also
@@ -47,9 +48,13 @@ export async function runSnapshotContext() {
   }
 
   const base = resolveBase(process.env.CORTEX_URL)
+  // The SessionStart snapshot is the surface that actually reaches a session's first turn, so the
+  // repo-scoped Gate 4 block is worth more here than anywhere else. Fail-closed: a non-GitHub cwd
+  // yields null and the hint is omitted (see repoFullNameFrom).
+  const repo = repoFullNameFrom(process.cwd())
   let res
   try {
-    res = await fetchCortex(`${base}/api/mcp-context`, { headers: { Authorization: `Bearer ${token}` } })
+    res = await fetchCortex(`${base}/api/mcp-context${repo ? `?repo=${encodeURIComponent(repo)}` : ''}`, { headers: { Authorization: `Bearer ${token}` } })
   } catch (e) {
     out(`Agnoclast: context snapshot failed — ${e?.message ?? String(e)}`)
     return 0

package/lib/diagnose.mjs

@@ -238,11 +238,29 @@ export function classify(status, contentType, bodyText, requestId) {
 let SESSION_KEY = null
 export function setSessionKey(key) { SESSION_KEY = key || null }
 
+// WHO IS CALLING — an identity INDEPENDENT of the session key, and it must stay independent.
+//
+// The server labels every page revision's `actor_source` from this header. It used to default to
+// 'mcp' server-side with nothing setting it, so 'mcp' silently meant "unlabelled" and an ADR-0030
+// scrub run against the HTTP API on 2026-08-26 wrote 340 revisions that read as MCP sessions with
+// dropped attribution — which reopened gate 2 on 2026-08-27 against a cause that was never MCP.
+//
+// ⚠ Deliberately NOT derived from SESSION_KEY, and deliberately sent even when SESSION_KEY is null.
+// The alarm's whole subject is `actor_source='mcp' AND session_key IS NULL`; if this header were
+// conditional on the session, that pair could never occur and the detector would be structurally
+// blind. A one-shot hook process legitimately has no session and IS still cortex-mcp — it should
+// say so, and be visible as one, not disguise itself as a script.
+let CLIENT_ID = 'cortex-mcp/unknown'
+export function setClientVersion(version) {
+  CLIENT_ID = `cortex-mcp/${version || 'unknown'}`
+}
+
 export async function fetchCortex(url, opts = {}, { retries = 2, baseDelayMs = 400 } = {}) {
   const { timeoutMs: optTimeout, signal: callerSignal, ...rest } = opts
+  const baseHeaders = { ...(rest.headers ?? {}), 'x-cortex-client': CLIENT_ID }
   const fetchOpts = SESSION_KEY
-    ? { ...rest, headers: { ...(rest.headers ?? {}), 'x-cortex-session-key': SESSION_KEY } }
-    : rest
+    ? { ...rest, headers: { ...baseHeaders, 'x-cortex-session-key': SESSION_KEY } }
+    : { ...rest, headers: baseHeaders }
   const timeoutMs = optTimeout ?? (Number(process.env.CORTEX_HTTP_TIMEOUT_MS) || 15_000)
   let lastErr
   for (let attempt = 0; attempt <= retries; attempt++) {

package/lib/server.mjs

@@ -5,13 +5,14 @@ import { writeFileSync, mkdirSync } from 'fs'
 import { homedir } from 'os'
 import { join } from 'path'
 import { createHash, randomUUID } from 'crypto'
-import { fetchCortex, classify, resolveBase, resolveEnvToken, setSessionKey } from './diagnose.mjs'
+import { fetchCortex, classify, resolveBase, resolveEnvToken, setSessionKey, setClientVersion } from './diagnose.mjs'
 import { folderClaimLine } from './folder_claims.mjs'
 import { resolveSessionKey, resolveLogSessionId } from './session_key.mjs'
 import { runSendImessage } from './imessage_send.mjs'
 import { formatGrepHits } from './grep_cli.mjs'
 import { renderTriage } from './red_link_triage.mjs'
 import { runCodeGraphQuery } from './code_graph_cli.mjs'
+import { repoFullNameFrom } from './capture.mjs'
 
 // Reactive red-link triage (Mechanism 2). On a read_page miss, ask the server whether the name is a
 // tracked wanted page, whether a bare node exists for it, and whether it's a deliberately demoted page,
@@ -104,6 +105,10 @@ export async function runServer(version) {
   // resolve THIS session's brain pointer. Must be set BEFORE the first fetchCortex call below —
   // otherwise the opening requests of a session would silently resolve by the account pointer.
   setSessionKey(SESSION_KEY)
+  // Paired with setSessionKey and set at the same moment, but a SEPARATE signal on purpose: the
+  // server labels actor_source from this and watches for `mcp` + no session. Tying the two together
+  // would make that pair impossible and blind the detector. See actorSourceFrom in auth_cloud.ts.
+  setClientVersion(version)
   async function pingSession() {
     try {
       await fetchCortex(`${BASE}/api/session-ping`, {
@@ -122,19 +127,27 @@ export async function runServer(version) {
   if (typeof _hb.unref === 'function') _hb.unref()   // don't keep the process alive just for the heartbeat
 
   // Cache context for 5 minutes so repeated tool calls don't re-fetch.
+  // KEYED BY REPO since 2026-08-27: the context now carries a repo-scoped Gate 4 block, so the same
+  // token can legitimately get different context from different cwds. One stdio server serves one cwd
+  // today and this is belt-and-braces — but an unkeyed cache would serve one repo's block to another
+  // silently, and "your repo has 12 records waiting" pointing at the wrong repo is worse than no line.
   let cache = null
   async function fetchContext() {
     const now = Date.now()
-    if (cache && now - cache.ts < 5 * 60 * 1000) return cache.text
+    // Fail-closed by construction (see repoFullNameFrom): a non-GitHub or non-repo cwd yields null and
+    // the request simply omits the hint, degrading to the generic block.
+    const repo = repoFullNameFrom(process.cwd())
+    if (cache && cache.repo === repo && now - cache.ts < 5 * 60 * 1000) return cache.text
     // fetchCortex retries transient infra/5xx; classify turns a failure into an honest message
     // (token vs infra-block vs network) instead of a bare "Agnoclast API 403: unknown".
-    const res = await fetchCortex(`${BASE}/api/mcp-context`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+    const url = `${BASE}/api/mcp-context${repo ? `?repo=${encodeURIComponent(repo)}` : ''}`
+    const res = await fetchCortex(url, { headers: { Authorization: `Bearer ${TOKEN}` } })
     if (!res.ok) {
       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 } = await res.json()
-    cache = { text: context, ts: now }
+    cache = { text: context, ts: now, repo }
     // 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).

package/package.json

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