@theronap/agnoclast-mcp 0.9.258 → 0.9.260

package/lib/context_log.mjs

@@ -3,6 +3,7 @@ import { homedir } from 'os'
 import { join } from 'path'
 import { fetchCortex, classify, resolveBase, resolveTokenSource } from './diagnose.mjs'
 import { repoFullNameFrom } from './capture.mjs'
+import { compactBlocks } from './session_start_compact.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
@@ -136,7 +137,12 @@ export async function runSnapshotContext() {
 
   // The action blocks go to STDOUT, which a SessionStart hook injects into the session. Before the
   // "logged" line so a truncated preview shows what needs doing rather than a file path.
-  const blocks = actionableBlocks(context)
+  //
+  // COMPACTED (2026-10-23, session_start_compact.mjs): one line per block with its count and the tool
+  // that lists it, instead of every block whole — this stdout is re-read on every turn, and one block
+  // alone listed ~8 KB of subjects and ids. The full text is in the file named at the end. Onboarding
+  // and the day-one welcome still print whole. actionableBlocks stays as the selection rule's record.
+  const blocks = compactBlocks(context, { fullTextPath: join(dir, 'latest.md') })
   if (blocks) out(blocks + '\n')
 
   out(`Agnoclast: logged startup context → ${file}`)

package/lib/doctor.mjs

@@ -6,6 +6,7 @@ import { renderRenameNotice } from './rename_notice.mjs'
 import { detectSurface, renderSurface } from './surface.mjs'
 import { queueDir, queueStatus, renderQueueNotice } from './capture_queue.mjs'
 import { pendingNotice, renderReportNotice } from './report_spool.mjs'
+import { compactNotice } from './session_start_compact.mjs'
 
 /** ADR-0070 §5: issue reports filed in the BACKGROUND since the last session start. A background
  *  auto-file had no turn to tell anyone in, so this is where the person hears about it. Consumes the
@@ -79,8 +80,13 @@ async function statusLine(out, { capturesStuck = false } = {}) {
       // about the TOKEN, and every reader takes it as a fact about their WORK. Printing both would
       // leave the reassurance that caused four days of silent loss sitting directly above the
       // warning that contradicts it.
+      //
+      // COMPACTED (2026-10-23, session_start_compact.mjs): one line per notice category, with its count
+      // and the tool that lists it. The server stacks several notices into this message, each with its
+      // items inline; that text is re-read on every turn of the session, so the items stay one call away.
       if (r.captureNotice?.message) {
-        out(`Agnoclast: ⚠ ${r.captureNotice.message}`)
+        const compact = compactNotice(r.captureNotice.message) || `⚠ ${r.captureNotice.message}`
+        for (const line of compact.split('\n')) out(`Agnoclast: ${line}`)
         return
       }
       const n = typeof r.projectCount === 'number' ? ` · ${r.projectCount} project${r.projectCount === 1 ? '' : 's'} visible` : ''

package/lib/server.mjs

@@ -1225,12 +1225,13 @@ function renderNudge(payload) {
       description:
         'Claim a lease on private intake items (relevance or cleanup). Returns decrypted payloads for the lease holder only. Requires x-cortex-session-key (set automatically by this MCP server). Aged work never blocks a claim: the response reports cleanupDueCount and how far behind the oldest unit is, and servicing it is expected but always your call. Claiming is a commitment to process — hand back anything you will not finish with intake_release, or intake_defer if it is the owner\'s decision to make. ' +
         'YOU ARE THE JUDGE of every unit you claim (ADR-0062): nothing is published until you materialize, and materializing is when it becomes visible. Each unit carries a `proposal` — the brain its signals point to and, for that brain, the pages it would attach to, the page that would govern it, and the `tier` it would be born with — computed without writing anything. Decide the brain, the pages (confirm, drop or add), which page should govern (the page whose reasons for restricting its audience fit the content, not a person page), and obligations. Pages only tighten a tier; if a record should be LOOSER than `tierReason.baseline`, that is the owner\'s call — intake_defer with the question. ' +
-        'view "compact" (trial, only where the server enables it — otherwise you get the full response): the judge rules, your brains, the lease and the cleanup count come ONCE per response in `rules`/`brains`, not on every unit; each unit carries its full content, only the proposed brain\'s pages as one line each, and up front what intake_materialize would refuse it for (`materialize.otherHomes`, `materialize.folderQuestions`). Read `rules` before judging.',
+        'DEFAULT VIEW IS "compact" where the server enables it (otherwise the server answers with the full response, whatever you ask): the judge rules, your brains, the lease and the cleanup count come ONCE per response in `rules`/`brains`, not on every unit; the proposal is flattened onto each unit — `brain`, the proposed brain\'s `pages` as one line each, `governing`, `tier` (and `baseline` when it differs) — or `candidates` when no brain is proposed; each unit carries its full content, and up front what intake_materialize would refuse it for (`materialize.otherHomes`, `materialize.folderQuestions`). Read `rules` before judging. Pass view "full" for the per-unit `proposal` object with every brain\'s placement.',
       inputSchema: {
         claimKind: z.enum(['relevance', 'cleanup']).optional().describe('default relevance'),
         view: z.enum(['full', 'compact']).optional().describe(
-          'default "full". "compact" sends the rules once per response instead of on every unit, and only the proposed ' +
-          'brain\'s placement. Honoured only where the server enables it; otherwise the response is the full one.',
+          'default "compact": the rules once per response instead of on every unit, and only the proposed ' +
+          'brain\'s placement. Honoured only where the server enables it; otherwise the response is the full one. ' +
+          '"full" asks for the full per-unit `proposal` (every brain\'s placement, the judge text on each unit).',
         ),
         limit: z.number().optional().describe('max items (default 10). Ignored when intakeItemIds is given.'),
         source: z.string().optional().describe('claim only the oldest units of ONE source — e.g. "imessage", "meeting", "email", "github", "claude-code". Reaches texts without first claiming every older GitHub/session unit ahead of them. Ignored when intakeItemIds is given.'),
@@ -1278,8 +1279,11 @@ function renderNudge(payload) {
           // claim into a no-op.
           ...(intakeItemIds ? { intakeItemIds } : {}),
           ...(source ? { source } : {}),
-          // Sent only when asked for: a default claim's request body is exactly what it was.
-          ...(view === 'compact' ? { view } : {}),
+          // Compact by DEFAULT (Theron, 2026-10-23, after a watched real-filing trial: 26 units, 25 filed
+          // correctly, 0 refusals, ~3.9K vs ~10K chars per unit). Always sent, so an explicit "full" is
+          // honoured. The server still gates compact on RELEASE_FLAGS.compact_claim — an account outside
+          // that cohort gets the full response even though this asks for compact.
+          view: view ?? 'compact',
         }),
       })
       if (!res.ok) {

package/lib/session_start_compact.mjs

@@ -0,0 +1,186 @@
+// SESSION-START COMPACTION (Theron, 2026-10-23).
+//
+// The SessionStart hooks (`status`, `snapshot-context`) print into the session, and Claude Code
+// re-reads that text on EVERY turn. Measured on Theron's seat the day this was written: ~20.8 KB per
+// session start, of which ~8 KB was one block listing 19 email subjects and 101 arrival ids inline, and
+// ~1.9 KB was the status notice listing arrivals and per-source remedies. None of it was lost by being
+// listed ONCE as a count — every list it carried is one tool call away, and the full text is saved to
+// ~/.cortex/context-snapshots/latest.md on every start.
+//
+// THE RULE: every notice CATEGORY becomes one line with its count and the tool that lists it. No
+// category is dropped (a new server block with no mapping still gets its own line, from its heading);
+// only the inline items go. Two kinds of block pass through whole, because they are instructions for
+// a NEW person rather than a backlog: the guided-onboarding first steps (the server sends it only while
+// that person's plan is active — onboarding.ts firstStepsContextFor) and the day-one welcome.
+//
+// PURE: no I/O. context_log.mjs and doctor.mjs feed it what the server returned.
+
+/** Blocks printed whole. Matched by ASCII substring of the heading (the welcome heading ends in an emoji). */
+export const PASS_THROUGH_MARKERS = ['First steps this person chose', 'Welcome to Agnoclast']
+
+/** The two static orientation blocks: never printed (unchanged from actionableBlocks). */
+export const ORIENTATION_MARKERS = ['Your place in the org', 'This is a POINTER']
+
+/**
+ * Heading substring -> what to call to see the items. First match wins. A block with no entry falls
+ * back to the first backticked tool name in its own body, so a block added later still names a tool.
+ */
+export const BLOCK_TOOLS = [
+  ['Gate 5', '`gate5_status`'],
+  ['Gate 2', '`gate2_status`'],
+  ['Attribution is being dropped', '`gate2_status`'],
+  ['Open product issues', '/ops'],
+  ['Pages waiting on you as steward', '`transfer_page_ownership`'],
+  ['Name a successor', '`set_successor`'],
+  ['Widening PROPOSED', '`my_retier_notices`'],
+  ['re-tiered by a page demotion', '`my_retier_notices`'],
+  ['File requests awaiting', '`file_requests`'],
+  ['Cleanup queue', '`intake_claim {claimKind:"cleanup"}`'],
+  ['Records waiting for a home', '`pending_records`'],
+  ['Folders in ', '`set_routing_identifier`'],
+  ['Sources nothing has claimed', '`set_routing_identifier`'],
+]
+
+/** Bold sub-counts inside a block that are separate queues with their own verb (mcp_context.ts). */
+const SUB_TOOLS = [
+  [/arrivals? not yet in any brain/i, '`staged_records`'],
+  [/asking THIS session/i, '`intake_changes`'],
+  [/arrived in the last 24h/i, '`pending_records`'],
+]
+
+const MAX_LINE = 240
+
+function cap(s, n = MAX_LINE) {
+  return s.length > n ? s.slice(0, n - 1).trimEnd() + '…' : s
+}
+
+function splitBlocks(context) {
+  const blocks = []
+  let cur = null
+  for (const line of context.split('\n')) {
+    if (line.startsWith('## ')) {
+      if (cur) blocks.push(cur)
+      cur = { heading: line.slice(3).trim(), lines: [line] }
+    } else if (cur) {
+      cur.lines.push(line)
+    }
+    // lines before the first "## " are the title and the clock: orientation, not action
+  }
+  if (cur) blocks.push(cur)
+  return blocks
+}
+
+function firstBacktickedTool(body) {
+  const m = body.match(/`([a-z][a-z0-9]*_[a-z0-9_]+)\b[^`]*`/)
+  return m ? '`' + m[1] + '`' : null
+}
+
+function toolFor(heading, body) {
+  for (const [needle, tool] of BLOCK_TOOLS) if (heading.includes(needle)) return tool
+  return firstBacktickedTool(body)
+}
+
+/** "**141 arrivals not yet in any brain — 19 of them…**" -> "141 arrivals not yet in any brain". */
+function subCounts(lines) {
+  const out = []
+  for (const l of lines) {
+    const m = l.match(/^\s*-\s+\*\*(\d[^*]*)\*\*/)
+    if (!m) continue
+    const text = m[1].split(/\s+—\s+|\.\s|\.$|:$/)[0].trim()
+    const sub = SUB_TOOLS.find(([re]) => re.test(text))
+    out.push(`  - ${cap(text, 120)}${sub ? `: ${sub[1]}` : ''}`)
+  }
+  return out
+}
+
+/**
+ * PURE. The session-start text for the /api/mcp-context body: pass-through blocks whole, then one line
+ * per remaining action block (plus one per bold sub-queue inside it). '' when there is nothing to act on.
+ * `fullTextPath` is where the untrimmed context was saved, named once at the end.
+ */
+export function compactBlocks(context, { fullTextPath } = {}) {
+  if (typeof context !== 'string' || !context) return ''
+  const whole = []
+  const lines = []
+  for (const b of splitBlocks(context)) {
+    if (ORIENTATION_MARKERS.some((m) => b.heading.includes(m))) continue
+    if (PASS_THROUGH_MARKERS.some((m) => b.heading.includes(m))) {
+      const text = b.lines.join('\n').replace(/\s+$/, '')
+      if (text) whole.push(text)
+      continue
+    }
+    const body = b.lines.slice(1).join('\n')
+    const tool = toolFor(b.heading, body)
+    const urgent = /TELL THE USER/.test(body) ? ' — tell the user' : ''
+    lines.push(`- ${cap(b.heading)}${urgent}${tool ? `: ${tool}` : ''}`)
+    lines.push(...subCounts(b.lines.slice(1)))
+  }
+  const parts = [...whole]
+  if (lines.length) {
+    parts.push(
+      '## Agnoclast — waiting on you (one line per queue; call the tool named to see the items)\n' +
+        lines.join('\n') +
+        (fullTextPath ? `\nFull text of every block: ${fullTextPath} (or call \`my_context\`).` : ''),
+    )
+  }
+  return parts.join('\n\n')
+}
+
+// ── The `status` notice (captureNotice.message, server-rendered and stacked by mcp-context's noticesFor) ──
+
+function sectionsOf(message) {
+  const out = []
+  for (const raw of message.split('\n')) {
+    if (!raw.trim()) continue
+    if (/^\s/.test(raw) && out.length) out[out.length - 1].sub.push(raw.trim())
+    else out.push({ head: raw.replace(/^⚠\s*/, '').trim(), sub: [] })
+  }
+  return out
+}
+
+function fixUrl(sub) {
+  for (const s of sub) {
+    const m = s.match(/^Fix:.*?(https?:\/\/\S+)/)
+    if (m) return m[1]
+  }
+  return null
+}
+
+function compactSection({ head, sub }) {
+  let m
+  if ((m = head.match(/^(\d+) arrivals? no session took/))) {
+    const n = Number(m[1])
+    return `⚠ ${n} arrival${n === 1 ? '' : 's'} every session passed on — tell the user: \`intake_changes\``
+  }
+  if ((m = head.match(/^(\d+) captures are NOT being saved/))) {
+    const per = sub
+      .map((s) => s.match(/^·\s*(\d+ .+?)(?:\s+\(oldest [^)]*\))?\s+—/))
+      .filter(Boolean)
+      .map((x) => x[1])
+    return `⚠ ${m[1]} captures are NOT being saved (no brain)${per.length ? ` — ${per.join(', ')}` : ''}: \`staged_records\``
+  }
+  if ((m = head.match(/^(\d+ \S+ captures? (?:is|are) NOT being saved(?: \(oldest [^)]*\))?)/))) {
+    const gated = /claims an identifier/.test(head)
+    return `⚠ ${m[1]}${gated ? ' — held on an unclaimed identifier' : ''}: \`staged_records\``
+  }
+  if ((m = head.match(/^(Mailbox \S+ is NOT syncing — [^.]+)/))) {
+    const url = fixUrl(sub)
+    return `⚠ ${m[1]}${url ? ` — reconnect at ${url}` : ''}`
+  }
+  if ((m = head.match(/^(\d+ mailboxes are NOT syncing)/))) {
+    const accts = sub.map((s) => s.match(/^·\s*(\S+)/)).filter(Boolean).map((x) => x[1])
+    const url = fixUrl(sub)
+    return `⚠ ${m[1]}${accts.length ? ` (${accts.join(', ')})` : ''}${url ? ` — reconnect at ${url}` : ''}`
+  }
+  if ((m = head.match(/^(Your Mac \(.+?\) has not checked in for .+? — .+?NOT being captured\.)/))) {
+    return `⚠ ${m[1]} Tell the user: open Agnoclast on that Mac.`
+  }
+  // Unknown shape: its first line, capped. Never dropped.
+  return `⚠ ${cap(head)}`
+}
+
+/** PURE. One line per notice category in a server captureNotice message. '' for nothing. */
+export function compactNotice(message) {
+  if (typeof message !== 'string' || !message.trim()) return ''
+  return sectionsOf(message).map(compactSection).join('\n')
+}

package/package.json

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