@theronap/cortex-mcp 0.9.98 → 0.9.100

package/lib/capture.mjs

@@ -232,7 +232,7 @@ export async function runCapture() {
   // Recursion guard: edge extraction shells out to `claude --print` with CORTEX_SUMMARIZING=1. That
   // headless session fires its own Stop hook → this same capture command. Without this guard it would
   // recurse (and re-ingest the summarizer's prompt as a phantom session). Bail immediately.
-  if (process.env.CORTEX_SUMMARIZING) { process.stderr.write('cortex: summarizer subprocess, skipping\n'); return }
+  if (process.env.CORTEX_SUMMARIZING) { process.stderr.write(`cortex: ${new Date().toISOString()} (summarizer subprocess) skipping — recursion guard\n`); return }
 
   const stdinRaw = readStdin()
 
@@ -291,14 +291,29 @@ function spawnDetachedWorker(stdinRaw) {
 }
 
 async function captureWork(stdinRaw) {
+  // Parse the hook payload FIRST so every diagnostic below can name its session.
+  //
+  // This used to sit after the token check, which meant the `no CORTEX_TOKEN` line — the one that
+  // fires on a whole misconfigured machine — was the only failure that could not say which session
+  // it lost. Parsing stdin depends on nothing, so the old order bought nothing.
+  let hook = {}
+  try { hook = JSON.parse(stdinRaw) } catch { /* no/invalid stdin */ }
+
+  // Every line in ~/.cortex/capture.log carries an ISO timestamp and the session id, so a silent
+  // stretch can be reconstructed afterwards and matched against `records` and
+  // `page_revisions.session_key`. A line without a session id is a line you cannot act on: it tells
+  // you something was lost and not what. That was the state of all five early returns below until
+  // now — visible since the log landed, but unattributable, which is the same shape as the defect
+  // this whole file has been chasing.
+  const stamp = new Date().toISOString()
+  const sid = hook.session_id ?? '(no session_id)'
+
   // Env first (explicit override / legacy inlined hooks), else the token wired into this machine's
   // MCP config — so hook commands carry no secret (token-hygiene, 2026-07-02).
   const token = resolveTokenSource().token
-  if (!token) { process.stderr.write('cortex: no CORTEX_TOKEN in env or wired config, skipping\n'); return }
+  if (!token) { process.stderr.write(`cortex: ${stamp} ${sid} NOT RECORDED — no CORTEX_TOKEN in env or wired config\n`); return }
   const base = resolveBase(process.env.CORTEX_URL)
 
-  let hook = {}
-  try { hook = JSON.parse(stdinRaw) } catch { /* no/invalid stdin */ }
   const repo = projectFrom(hook.cwd)
   // Redact credential-shaped strings BEFORE anything leaves the machine — this `transcript`
   // feeds local edge/typed extraction AND the fallback POST to the org. A secret in a
@@ -322,11 +337,11 @@ async function captureWork(stdinRaw) {
   // 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')
+    process.stderr.write(`cortex: ${stamp} ${sid} NOT RECORDED — transcript_path unreadable (session persistence disabled?)\n`)
     return
   }
 
-  if (!transcript && !hook.session_id) { process.stderr.write('cortex: empty session, skipping\n'); return }
+  if (!transcript && !hook.session_id) { process.stderr.write(`cortex: ${stamp} ${sid} NOT RECORDED — empty session\n`); return }
 
   // T11: digest node refs surfaced to this session (stashed by the MCP server's my_context, keyed by
   // cwd). Forwarded as hydratedFrom so the materializer excludes this session from the digests it
@@ -370,7 +385,7 @@ async function captureWork(stdinRaw) {
     ...(hydratedFrom.length ? { hydratedFrom } : {}),
   }
   const extracted = transcript ? extractSession(transcript) : null
-  if (extracted && /^NOOP\b/i.test(extracted.summary)) { process.stderr.write('cortex: no-op session, skipping\n'); return }
+  if (extracted && /^NOOP\b/i.test(extracted.summary)) { process.stderr.write(`cortex: ${stamp} ${sid} NOT RECORDED — summarizer classified it a no-op session\n`); return }
   const ingestBody = extracted
     ? { ...common, summary: extracted.summary, people: extracted.people, entities: extracted.namedEntities }
     : { ...common, transcript }
@@ -388,12 +403,6 @@ async function captureWork(stdinRaw) {
     } catch { /* best-effort — never block capture */ }
   }
 
-  // Defined before the fetch so the throw path below can stamp its line the same way. Every line in
-  // capture.log carries an ISO timestamp and the session id, so a silent day can be reconstructed
-  // afterwards and matched against `records` / `page_revisions.session_key`.
-  const stamp = new Date().toISOString()
-  const sid = hook.session_id ?? '(no session_id)'
-
   let res
   try {
     // Best-effort background ingest: bound it tight and retry once so a hanging/504-ing server

package/lib/edge_extract.mjs

@@ -105,9 +105,67 @@ const ENTITY_FRAGMENT =
   '"importance" ("high" if central to the work, "low" if incidental). ' +
   'Do NOT include people or companies (those go in "people"). Omit vague/generic mentions. Empty array is fine.)'
 
+// PURE. The scheduled task this transcript is an unattended run of, or null for a human session.
+// Claude Code wraps a scheduled run's instructions in <scheduled-task name="..." file="...">.
+export function scheduledTaskName(transcript) {
+  const m = String(transcript ?? '').match(/<scheduled-task\s+[^>]*name="([^"]+)"/)
+  return m ? m[1] : null
+}
+
+// PURE. Drop the <scheduled-task>…</scheduled-task> blocks — they are the task's OWN INSTRUCTIONS,
+// not anything the run observed, and Claude Code emits them TWICE per transcript. Measured
+// 2026-08-19 on real units: ~2.1KB of instructions repeated, so ~4.2KB of the summarizer's 12KB
+// window went to text describing what the agent was told to do before a single line of what it
+// found. Stripping them spends the budget on the run's actual output.
+export function stripScheduledTaskBlocks(transcript) {
+  return String(transcript ?? '').replace(/<scheduled-task\b[\s\S]*?<\/scheduled-task>/g, '').trim()
+}
+
+// The NOOP bar for an unattended run. The generic bar ("greetings, no tasks") does not fit these and
+// was never meant to: a scheduled run DID do something — it read a file, evaluated a condition,
+// maybe sent a notification — so a summarizer following the generic instruction correctly writes
+// "Automated scripture study check ran; no confirmation for 2026-08-14; reminder sent." That is a
+// faithful summary of a heartbeat, and it is why 36% of session records since 2026-08-01 are
+// automation reporting its own execution. The summarizer was not malfunctioning; it was answering
+// the question it was asked.
+//
+// The distinction that matters is not attended-vs-unattended, it is CHANGED-vs-UNCHANGED. A routine
+// run that found the expected state is a heartbeat. The SAME task finding the domain finally
+// reactivated, or the backlog crossing a threshold, is exactly the thing the knowledge base exists
+// to hold — so this deliberately does not blanket-skip scheduled tasks, which would throw away the
+// one run in a hundred that matters. There are 12 tasks configured and one of them alone fires up to
+// 11 times a day.
+// ⚠ THE WORDING HERE IS LOAD-BEARING AND WAS WRONG ON THE FIRST ATTEMPT. Verified 2026-08-19 against
+// two real transcripts: a first draft ended "when it is genuinely borderline, prefer NOOP" and
+// correctly suppressed the heartbeat — but ALSO suppressed a run of the same task that had flagged a
+// live read path into the frozen Robin archive, a genuine finding. Every unit test still passed,
+// because they cover the stripping, not the judgement. The prompt was killing signal with the noise.
+//
+// Two fixes: the borderline tilt is gone (it resolved every mixed case toward silence), and an
+// incidental observation now counts explicitly — these findings arrive as an aside at the END of an
+// otherwise routine report, which is exactly where a "was this routine?" reading drops them.
+const scheduledTaskFragment = (name) =>
+  '\n\nIMPORTANT — this session is an UNATTENDED run of the scheduled task "' + name + '". ' +
+  'Its instructions have been removed; what remains is only what the run reported. ' +
+  'Judge what it FOUND and what it CHANGED — never merely that it executed. ' +
+  'If the run only confirmed the state it expected and changed nothing, set summary to exactly ' +
+  '"NOOP": a routine run that found nothing new is a heartbeat, not knowledge, and these fire many ' +
+  'times a day. ' +
+  'BUT summarize whenever the run found something changed, hit an error, took an action with a ' +
+  'lasting effect, OR raised a problem, risk or observation the operator would not already know — ' +
+  'INCLUDING one mentioned only in passing at the very end of an otherwise routine report. ' +
+  'One genuine finding outweighs an otherwise unremarkable run; summarize the FINDING, not the run.'
+
 export function extractSession(transcript) {
-  const text = (transcript ?? '').trim()
-  if (!text || process.env.CORTEX_SUMMARIZE_DISABLED) return null
+  const raw = (transcript ?? '').trim()
+  if (!raw || process.env.CORTEX_SUMMARIZE_DISABLED) return null
+  const task = scheduledTaskName(raw)
+  // Strip instructions only for scheduled runs; a human transcript has no such blocks and is passed
+  // through untouched, so this cannot change how ordinary sessions are summarized.
+  const text = task ? stripScheduledTaskBlocks(raw) : raw
+  // A run whose entire transcript WAS the instruction block leaves nothing to judge. That is a
+  // heartbeat by definition — skip without spending a `claude -p` call on it.
+  if (task && !text) return { summary: 'NOOP', people: [], namedEntities: [] }
   const prompt =
     'You are processing a Claude Code work session for a knowledge base. Return ONLY minified JSON ' +
     '(no prose, no markdown fences) with EXACTLY these three keys:\n' +
@@ -115,6 +173,7 @@ export function extractSession(transcript) {
     'had no real work — greetings, no tasks — set summary to exactly "NOOP"),\n' +
     PEOPLE_FRAGMENT + ',\n' +
     ENTITY_FRAGMENT +
+    (task ? scheduledTaskFragment(task) : '') +
     '\n\n--- SESSION ---\n' + text.slice(0, 12000) + '\n--- END ---'
   // Single-flight: if another session already has a summarizer running, skip (caller ships the tail;
   // server summarizes). Prevents the concurrent-`claude -p` stampede that deadlocks the OAuth refresh.

package/lib/skills.mjs

@@ -131,6 +131,52 @@ function installInto(skillsRoot, skills, { removeNames = [] } = {}) {
  * @param {{ quiet?: boolean }} opts  quiet → only emit on actual change (for the SessionStart hook)
  * @returns {{ installed: string[], repaired: string[], unchanged: string[], targets: string[] }}
  */
+// Skills renamed in C3 (ADR-0033). The old name keeps working for one release via a forwarding
+// stub, then both the map and the stubs are deleted.
+//
+// The stub is a REAL skill that delegates, not a message that the command moved. A stub which only
+// announces the rename breaks every caller that invokes the old name from automation — and this repo
+// has a rule about surfaces that report something other than what happened. The model reads the stub,
+// follows the pointer, and does the actual work, so `/cortex-log` behaves exactly as it always did.
+export const RENAMED_SKILLS = {
+  'cortex-log': 'agnoclast-log',
+  'cortex-context': 'agnoclast-context',
+  'cortex-author-docs': 'agnoclast-author-docs',
+  'cortex-walkthrough': 'agnoclast-walkthrough',
+}
+
+/** PURE. The forwarding stub's SKILL.md body. */
+export function forwardingStub(oldName, newName) {
+  return `---
+name: ${oldName}
+description: Renamed to /${newName}. This forwarding stub keeps the old command working and will be removed in a later release.
+---
+
+This skill is now **${newName}**.
+
+Read \`~/.claude/skills/${newName}/SKILL.md\` and follow it in full. Everything it says applies
+here unchanged — this file exists only so \`/${oldName}\` keeps working for automation and habit
+that still names the old command. Do the work the real skill describes; do not stop at this notice.
+`
+}
+
+/** Write a forwarding stub for every renamed skill whose new form is present. Best-effort: a stub
+ *  that cannot be written is a lost alias, never a failed install. */
+function installForwardingStubs(skillsRoot, log) {
+  for (const [oldName, newName] of Object.entries(RENAMED_SKILLS)) {
+    try {
+      if (!existsSync(join(skillsRoot, newName, 'SKILL.md'))) continue
+      const dir = join(skillsRoot, oldName)
+      const file = join(dir, 'SKILL.md')
+      const body = forwardingStub(oldName, newName)
+      if (existsSync(file) && readFileSync(file, 'utf8') === body) continue
+      ensureDir(file)
+      writeFileSync(file, body)
+      log(`  ✓ ${oldName} → forwards to ${newName}`)
+    } catch { /* an alias is a convenience, never a reason to fail the install */ }
+  }
+}
+
 export function installSkills(opts = {}) {
   const quiet = !!opts.quiet
   const log = (m) => { if (!quiet) process.stdout.write(m + '\n') }
@@ -151,6 +197,7 @@ export function installSkills(opts = {}) {
     summary.unchanged.push(...r.unchanged)
     const changed = [...r.installed, ...r.repaired]
     if (changed.length) log(`  ✓ ${cli.id}: ${changed.join(', ')} → ${skillsRoot}`)
+    installForwardingStubs(skillsRoot, log)
   }
 
   if (quiet && (summary.installed.length || summary.repaired.length)) {

package/package.json

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

package/skills/author-docs/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: cortex-author-docs
+name: agnoclast-author-docs
 description: Push new/changed documentation (specs, plans, design docs) from disk into Agnoclast as authored wiki pages. Run after writing a spec/plan/design doc, when the user asks to sync docs to Agnoclast, or as part of session close-out.
 ---
 
@@ -17,7 +17,7 @@ the doc and author a synthesis. Never dump raw markdown into a page.
 
 - Right after you write or substantially update a spec/plan/design/runbook doc on disk.
 - When the user asks to push/sync docs to Agnoclast.
-- During session close-out (`/cortex-log` runs this as a sweep step).
+- During session close-out (`/agnoclast-log` runs this as a sweep step).
 
 ## Steps
 

package/skills/context/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: cortex-context
+name: agnoclast-context
 description: Automatically hydrate Agnoclast context at the start of a substantive session. Use when Agnoclast MCP is available and the user has made a real request, so the first answer is grounded in query-centered org context instead of the static baseline alone.
 ---
 

package/skills/log/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: cortex-log
+name: agnoclast-log
 description: Close out a work session into Agnoclast — summarize what happened, confirm it reached the org, and surface anything teammates should know. Run at or near the end of any working session.
 ---
 
@@ -62,7 +62,7 @@ No arguments. Read the conversation context.
    already authored a node mid-session and nothing changed since, `author` will report "no change" —
    that's fine.
 6. **Sweep pending documentation** — run `npx -y @theronap/cortex-mcp docs-scan --json`; if any
-   docs are pending, follow the `cortex-author-docs` skill (author each into its page, then
+   docs are pending, follow the `agnoclast-author-docs` skill (author each into its page, then
    `docs-scan --mark`). Specs/plans written to disk this session must not die on disk — a spec IS
    a page. If no roots are registered or nothing is pending, skip silently.
 7. **Reconcile the sweep (don't trust it).** Step 5 relies on your in-the-moment judgment of "what

package/skills/walkthrough/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: cortex-walkthrough
+name: agnoclast-walkthrough
 description: Run the guided Agnoclast walkthrough for someone new. Use when the person asks for the walkthrough, a tutorial, or getting started — "give me the walkthrough", "walk me through this", "how do I use this", "show me around", "what can this do", "remind me how this works" — or when a brand-new user needs orienting for the first time.
 ---