@theronap/agnoclast-mcp 0.9.179 → 0.9.181

package/lib/capture.mjs

@@ -80,6 +80,46 @@ export function repoFullNameFrom(cwd) {
   }
 }
 
+/**
+ * The FILES this session is working on, for ADR-0066 §7 session identifiers.
+ *
+ * 🔴 WHY: the session used to hold only `repo:<owner/name>`, while every record arrives carrying the
+ * exact paths it touched. Everything in a repo matches the repo, so on a live session 211 of 217
+ * arrivals came back "matched" — a pile with no bounded action in it, which an agent then claims
+ * none of. Git already knows the answer precisely, so nothing new has to be plumbed or remembered.
+ *
+ * Two questions, unioned:
+ *   working tree vs HEAD  — what is being edited right now
+ *   base..HEAD            — what this branch has already committed
+ *
+ * The second is why this survives a commit: the moment work is committed the working tree goes
+ * clean, and a session that had just built something would stop being a candidate for the very
+ * records that build produces (its own PR, its own release mail).
+ *
+ * ⚠ SCOPED TO THIS BRANCH ON PURPOSE. The base is merge-base(HEAD, origin), so a session sitting on
+ * an unmodified main reports NOTHING rather than the whole repo's recent history — which would be
+ * other people's work, claimed as attention this session never paid.
+ *
+ * Best-effort and bounded like every other git read here: a non-repo cwd, a detached head or a
+ * missing origin yields [], and the caller simply omits the field.
+ */
+export function workingFilesFrom(cwd, max = 40) {
+  if (!cwd) return []
+  const run = (args) => {
+    try {
+      return execFileSync('git', ['-C', String(cwd), ...args], {
+        encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'],
+      }).split('\n').map((l) => l.trim()).filter(Boolean)
+    } catch {
+      return []
+    }
+  }
+  const files = new Set(run(['diff', '--name-only', 'HEAD']))
+  const base = run(['merge-base', 'HEAD', 'origin/HEAD'])[0] || run(['merge-base', 'HEAD', 'origin/main'])[0]
+  if (base) for (const f of run(['diff', '--name-only', base, 'HEAD'])) files.add(f)
+  return [...files].slice(0, max)
+}
+
 // ── SHR-01/T9 — stamp the repos the session WORKED IN, not the one it was launched from ─────────
 //
 // WHY THIS EXISTS. `repoFullNameFrom(cwd)` above reads the session's LAUNCH directory. Measured

package/lib/server.mjs

@@ -15,7 +15,8 @@ import { buildProposal, renderProposal, withAskNotice } from './propose_obligati
 import { renderCaptureStatus } from './capture_status.mjs'
 import { renderTriage } from './red_link_triage.mjs'
 import { runCodeGraphQuery } from './code_graph_cli.mjs'
-import { repoFullNameFrom } from './capture.mjs'
+import { repoFullNameFrom, workingFilesFrom } from './capture.mjs'
+import { findTranscript, createWorkedFilesTracker } from './working_files.mjs'
 import { spawnObligationWorker } from './obligations_worker.mjs'
 import { renderObligations } from './obligations_render.mjs'
 
@@ -185,6 +186,25 @@ export async function runServer(version) {
   // 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)
+  // ADR-0066 §7 — the files this session WORKED ON, read from its own transcript.
+  //
+  // Keyed on CLAUDE_CODE_SESSION_ID, never SESSION_KEY: SESSION_KEY falls back to a random uuid on
+  // hosts that do not set the env var, and no transcript is named after a random uuid. Created LAZILY
+  // because a brand-new session's transcript may not exist yet when this server starts; each
+  // heartbeat retries until it appears, then the tracker reads only what was appended since.
+  let workedFiles = null
+  function currentWorkedFiles() {
+    try {
+      if (!workedFiles) {
+        const t = findTranscript(process.env.CLAUDE_CODE_SESSION_ID)
+        if (!t) return []
+        workedFiles = createWorkedFilesTracker(t)
+      }
+      return workedFiles.poll(40)
+    } catch {
+      return []   // attention data is never worth disturbing a session for
+    }
+  }
   async function pingSession() {
     try {
       await fetchCortex(`${BASE}/api/session-ping`, {
@@ -203,6 +223,16 @@ export async function runServer(version) {
           cwd: process.cwd(),
           mcpVersion: version,
           repo: repoFullNameFrom(process.cwd()) ?? undefined,
+          // files (ADR-0066 §7, 2026-09-25): the exact paths this session is working on, so it can
+          // be told apart from every other session in the same repo. Holding only `repo:` made 211
+          // of 217 arrivals "matched" on a live session — a pile with no bounded action in it.
+          // Best-effort and bounded in workingFilesFrom; a non-repo cwd yields [] and is omitted.
+          files: workingFilesFrom(process.cwd()).slice(0, 40),
+          // workedFiles (2026-09-25): the files the session actually touched, from its transcript,
+          // already qualified as file:<owner/name>:<path>. `files` above reads git in the LAUNCH
+          // directory, and every desktop-launched session launches from home — measured, all five
+          // of Theron's live sessions — so it registered nothing. This is the one that works.
+          workedFiles: currentWorkedFiles(),
         }),
       })
     } catch { /* best-effort heartbeat — never disrupt the session */ }

package/lib/working_files.mjs

@@ -0,0 +1,144 @@
+// ADR-0066 §7 — the FILES a session is working on, read from WHERE IT WORKED, not where it launched.
+//
+// 🔴 THIS IS THE SECOND TIME THIS EXACT MISTAKE HAS SHIPPED. 0.9.180 read git from the MCP server's
+// process.cwd(). Measured the same day: all five of Theron's live sessions report cwd =
+// /Users/theronpeterson — the desktop app launches every session from home, which is not a repo — so
+// the feature registered NOTHING for any of them. capture.mjs documents the identical failure from
+// 2026-08-03 ("still zero carried an identifier … because Claude Code sessions launch from wherever
+// the terminal happened to be") and already fixed it the right way: read the transcript, because the
+// transcript records the files the session actually read and wrote. This reuses that primitive.
+//
+// ⚠ INCREMENTAL, BECAUSE THE TRANSCRIPT IS LARGE AND THIS RUNS EVERY MINUTE. A long session's
+// transcript measured 37.7 MB. The tracker remembers its byte offset and reads only what was
+// appended since the last heartbeat; the first read starts from the tail, since recent work is what
+// "working on" means.
+//
+// ⚠ ATTENTION DATA, NOT A CLEARANCE STAMP. capture.mjs uses the same paths to stamp REPOS onto records
+// behind a MIN_FILES_FOR_STAMP security threshold, because a stamp grants other people read access.
+// Nothing here grants anything: these identifiers only make this person's OWN sessions candidates for
+// this person's OWN arrivals. So it takes every file touched rather than thresholding — and it
+// deliberately does not modify touchedPaths, whose extraction is part of that security surface.
+import { readdirSync, existsSync, statSync, openSync, readSync, closeSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { execFileSync } from 'node:child_process'
+import { touchedPaths, repoFullNameFrom } from './capture.mjs'
+
+const FIRST_READ_TAIL = 2 * 1024 * 1024   // on first poll, only the recent end of a long transcript
+const MAX_READ_PER_POLL = 4 * 1024 * 1024
+const MAX_DIR_PROBES_PER_POLL = 25        // each probe is a git subprocess; bound the heartbeat's cost
+const MAX_KEPT = 200
+
+// touchedPaths only recognises Bash paths under /Users, /home, /opt, /srv, /var — right for its
+// security job, but git worktrees commonly live under /private/tmp or /tmp, and work there would be
+// invisible. Widened HERE, for attention only, rather than in the shared extractor.
+const EXTRA_BASH_PATHS = /\/(?:private|tmp)\/[^\s"'`;|&)<>]+/g
+
+/** Paths one transcript line touched. Exported for the tests. */
+export function pathsInLine(line) {
+  const out = touchedPaths(line)
+  let d
+  try { d = JSON.parse(line) } catch { return out }
+  for (const b of d?.message?.content ?? []) {
+    if (b?.type === 'tool_use' && typeof b.input?.command === 'string') {
+      for (const m of b.input.command.match(EXTRA_BASH_PATHS) ?? []) out.push(m)
+    }
+  }
+  return out
+}
+
+/**
+ * Find this session's transcript by its id alone. Scanning for `<id>.jsonl` avoids depending on how
+ * Claude Code slugs the launch directory into a folder name — the id is unique, the slug rule is not
+ * ours to rely on.
+ */
+export function findTranscript(sessionId, projectsDir = join(homedir(), '.claude', 'projects')) {
+  if (!sessionId) return null
+  try {
+    for (const d of readdirSync(projectsDir)) {
+      const p = join(projectsDir, d, `${sessionId}.jsonl`)
+      if (existsSync(p)) return p
+    }
+  } catch { /* no projects dir: a non-Claude-Code host */ }
+  return null
+}
+
+function gitRoot(dir) {
+  try {
+    return execFileSync('git', ['-C', dir, 'rev-parse', '--show-toplevel'], {
+      encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim() || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Tracks the files a session touches, reading its transcript incrementally.
+ * `poll()` returns fully-qualified identifiers, most recent first: `file:<owner/name>:<repo-relative>`.
+ */
+export function createWorkedFilesTracker(transcriptPath, opts = {}) {
+  const resolveRoot = opts.gitRoot ?? gitRoot
+  const resolveRepo = opts.repoFullNameFrom ?? repoFullNameFrom
+  let offset = -1
+  let carry = ''
+  const repoOfDir = new Map()   // dir -> { root, repo } | null
+  const recent = new Map()      // identifier -> true, insertion order = recency
+
+  function locate(p) {
+    const dir = dirname(p)
+    if (repoOfDir.has(dir)) return repoOfDir.get(dir)
+    return undefined
+  }
+
+  function poll(limit = 40) {
+    if (!transcriptPath) return []
+    let size
+    try { size = statSync(transcriptPath).size } catch { return [...recent.keys()].reverse().slice(0, limit) }
+    if (offset < 0 || size < offset) {       // first read, or the file was rewritten
+      offset = Math.max(0, size - FIRST_READ_TAIL)
+      carry = ''
+    }
+    if (size > offset) {
+      const len = Math.min(size - offset, MAX_READ_PER_POLL)
+      const buf = Buffer.alloc(len)
+      let fd
+      try {
+        fd = openSync(transcriptPath, 'r')
+        readSync(fd, buf, 0, len, offset)
+      } catch { return [...recent.keys()].reverse().slice(0, limit) } finally { if (fd !== undefined) closeSync(fd) }
+      offset += len
+      const text = carry + buf.toString('utf8')
+      const nl = text.lastIndexOf('\n')
+      carry = nl >= 0 ? text.slice(nl + 1) : text
+      const lines = nl >= 0 ? text.slice(0, nl).split('\n') : []
+
+      const touched = []
+      for (const line of lines) if (line) touched.push(...pathsInLine(line))
+
+      let probes = 0
+      for (const p of touched) {
+        if (p.includes('/.git/') || p.endsWith('/')) continue
+        const dir = dirname(p)
+        if (!repoOfDir.has(dir)) {
+          if (probes >= MAX_DIR_PROBES_PER_POLL) continue
+          probes++
+          const root = existsSync(dir) ? resolveRoot(dir) : null
+          const repo = root ? resolveRepo(root) : null
+          repoOfDir.set(dir, root && repo ? { root, repo } : null)
+        }
+        const hit = locate(p)
+        if (!hit || !p.startsWith(hit.root + '/')) continue
+        const rel = p.slice(hit.root.length + 1)
+        if (!rel) continue
+        const id = `file:${hit.repo}:${rel}`
+        recent.delete(id)
+        recent.set(id, true)
+        if (recent.size > MAX_KEPT) recent.delete(recent.keys().next().value)
+      }
+    }
+    return [...recent.keys()].reverse().slice(0, limit)
+  }
+
+  return { poll }
+}

package/package.json

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