@theronap/agnoclast-mcp 0.9.225 → 0.9.227

package/lib/diagnose.mjs

@@ -579,6 +579,78 @@ let reachabilityProbe = async () => {
 }
 /** Tests: replace the internet-reachability probe. Returns the previous one. */
 export function setReachabilityProbe(fn) { const prev = reachabilityProbe; reachabilityProbe = fn; return prev }
+/** Is the internet itself reachable right now? Never throws. The heartbeat asks this on EVERY failed beat. */
+export async function internetReachable() {
+  try { return Boolean(await reachabilityProbe()) } catch { return false }
+}
+
+// ⚠ A LAPTOP THAT SLEPT LOOKS LIKE A SERVER THAT TIMED OUT. Measured 2026-10-08 on Theron's Mac
+// (obligation f7eccd9d): 20 session_ping outages filed 16:55–17:26 MDT while the lid was shut and the Mac
+// DarkWoke every 1-3 minutes on a dying battery, then 2 more after a 2-minute Wi-Fi drop at 20:39. Production
+// answered every request it received. The 1.1.1.1 probe above did not catch it: during a DarkWake, and the
+// moment the network is back, the probe passes, while a request that was in flight when the lid closed
+// "times out" on wake because its 15 s budget ran out while the lid was shut.
+//
+// THE TELL IS LATENESS, NOT A CLOCK. A frozen process runs no timers, so a timer that should have fired
+// every WATCH_TICK_MS fires late, and late is measurable on whichever clock counts the sleep:
+//   * macOS: performance.now() is mach_CONTINUOUS_time, which COUNTS sleep (libuv's darwin uv__hrtime;
+//     measured on Theron's Mac 2026-10-10, Node 24.11/libuv 1.51 and Node 26.4/libuv 1.52: hrtime matched
+//     mach_continuous_time to 0.0 s and sat 11.69 h ahead of mach_absolute_time). So the monotonic gap
+//     between ticks is the sleep itself.
+//   * Linux: CLOCK_MONOTONIC STOPS in suspend, so the monotonic gap stays small and the wall clock runs ahead.
+// ⚠ #1453's first version compared wall to monotonic only, which is the Linux half: inert on every Mac,
+// the one platform that filed these. Codex caught it on review; never assume which half a platform is.
+// Accepted costs (Codex, both passes on #1453), each at worst one skipped report or one reset beat, against
+// 20 false outages per closed lid:
+//   * an awake clock STEPPED forward > SLEEP_GAP_MS (a manual change; NTP slews) reads as a freeze;
+//   * an awake event loop stalled > WATCH_TICK_MS + SLEEP_GAP_MS reads as one too (its timers fired late,
+//     so a timeout inside it does not measure Agnoclast either);
+//   * a Mac sleep SHORTER than that is not caught; the request still had most of its 15 s budget awake.
+export const SLEEP_GAP_MS = 5_000
+export const WATCH_TICK_MS = 2_000
+let clocks = { wall: () => Date.now(), mono: () => globalThis.performance.now() }
+let watch = { last: null, freezes: 0, timer: null }
+
+/** PURE. Was the process frozen between two consecutive readings of both clocks? */
+export function frozeBetween(prev, now, gapMs = SLEEP_GAP_MS, tickMs = WATCH_TICK_MS) {
+  if (!prev || !now) return false
+  const mono = now.mono - prev.mono
+  const wall = now.wall - prev.wall
+  return mono > tickMs + gapMs      // no timer ran for this long: sleep on macOS (or a stalled loop)
+    || wall - mono > gapMs          // the wall clock ran ahead while monotonic time stood still: Linux suspend
+}
+
+function observe() {
+  const now = { wall: clocks.wall(), mono: clocks.mono() }
+  if (frozeBetween(watch.last, now)) watch.freezes++
+  watch.last = now
+  return now
+}
+
+/** Tests: replace the two clocks, and start the watch over. Returns the previous pair. */
+export function setClocks(c) {
+  const prev = clocks
+  clocks = c
+  if (watch.timer) clearInterval(watch.timer)
+  watch = { last: null, freezes: 0, timer: null }
+  return prev
+}
+
+/**
+ * A reading for sleptBetween. The first one starts the watch (unref'd, so a short-lived hook still exits).
+ * It also checks the gap itself, because on wake the failing request's callback can run before the overdue tick.
+ */
+export function clockMark() {
+  if (!watch.timer) { watch.timer = setInterval(observe, WATCH_TICK_MS); watch.timer.unref?.() }
+  const now = observe()
+  return { wall: now.wall, mono: now.mono, freezes: watch.freezes }
+}
+
+/** PURE. Was the process frozen at any point between two clockMark()s? */
+export function sleptBetween(a, b) {
+  if (!a || !b) return false
+  return (b.freezes ?? 0) > (a.freezes ?? 0)
+}
 
 /** Auto-filing is off under `bun test` unless the test points the spool somewhere (never the real home). */
 function autofileEnabled(env = process.env) {
@@ -636,6 +708,19 @@ export function heartbeatPolicy(consecutiveFailures) {
   return { fileOutage: consecutiveFailures + 1 >= HEARTBEAT_OUTAGE_AFTER }
 }
 
+/**
+ * PURE. The heartbeat's consecutive-failure count after one beat. Only a failure that says something about
+ * AGNOCLAST counts: a beat that spanned a sleep, or failed while the internet itself was unreachable, resets
+ * the streak instead (2026-10-08, obligation f7eccd9d). A RESPONSE proves the network worked, so a non-OK
+ * response counts unless the machine slept.
+ */
+export function nextPingFailures(prev, { ok, slept = false, internetUp = true }) {
+  if (ok) return 0
+  if (slept) return 0
+  if (internetUp === false) return 0
+  return prev + 1
+}
+
 /**
  * fetch with the D9 retry policy (see fetchCortexOnce), plus the ADR-0070 outage hook. Returns the
  * Response (possibly a non-OK one, after retries are exhausted or refused); throws a clear "Could not
@@ -649,11 +734,13 @@ export function heartbeatPolicy(consecutiveFailures) {
 export async function fetchCortex(url, opts = {}, policy = {}) {
   const hook = !policy.skipAutofile && autofileEnabled() && authOf(opts)
   const file = hook && policy.fileOutage !== false
+  const started = clockMark()
   let res
   try {
     res = await fetchCortexOnce(url, opts, policy)
   } catch (e) {
-    if (file && e?.retryClass) {
+    // A request the machine slept through is not an outage (see SLEEP_GAP_MS): file nothing, probe nothing.
+    if (file && e?.retryClass && !sleptBetween(started, clockMark())) {
       const r = outageReport({ thrownClass: e.retryClass }, { tool: toolForUrl(url) })
       // 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.

package/lib/server.mjs

@@ -6,7 +6,7 @@ import { homedir } from 'os'
 import { join } from 'path'
 import { createHash, randomUUID } from 'crypto'
 import { seatChargeRefusal, seatChargeQuestion } from './seat_charge.mjs'
-import { fetchCortex, classify, resolveBase, resolveEnvToken, setSessionKey, setClientVersion, runWithTool, heartbeatPolicy } from './diagnose.mjs'
+import { fetchCortex, classify, resolveBase, resolveEnvToken, setSessionKey, setClientVersion, runWithTool, heartbeatPolicy, nextPingFailures, clockMark, sleptBetween, internetReachable } from './diagnose.mjs'
 import { REPORT_KINDS, REPORT_ISSUE_DESCRIPTION, fileIssue } from './report_issue.mjs'
 import { folderClaimLine } from './folder_claims.mjs'
 import { renderFolderClaimOffers, renderIdentifierResolution, renderUnroutedPathStamps } from './identifier_routes.mjs'
@@ -281,8 +281,14 @@ export async function runServer(version) {
   }
   // Consecutive heartbeat failures. A lone slow beat is not an outage (see HEARTBEAT_OUTAGE_AFTER);
   // three in a row is, and that beat files through fetchCortex's normal path, probe included.
+  // ⚠ Only failures that say something about Agnoclast count (nextPingFailures, 2026-10-08): a beat the
+  // laptop slept through, a sleep between beats, or a failure while the internet itself is down resets it.
   let pingFailures = 0
+  let lastBeat = null
   async function pingSession() {
+    const started = clockMark()
+    if (lastBeat && sleptBetween(lastBeat, started)) pingFailures = 0   // the lid closed since the last beat
+    lastBeat = started
     try {
       const res = await fetchCortex(`${BASE}/api/session-ping`, {
         method: 'POST',
@@ -316,9 +322,18 @@ export async function runServer(version) {
           authored: currentAuthored(),
         }),
       }, heartbeatPolicy(pingFailures))
-      pingFailures = res.ok ? 0 : pingFailures + 1
+      // A response proves the network worked; it still does not count if the machine slept through it.
+      pingFailures = nextPingFailures(pingFailures, { ok: res.ok, slept: sleptBetween(started, clockMark()) })
       try { await res.body?.cancel() } catch { /* nothing to drain */ }
-    } catch { pingFailures++ /* best-effort heartbeat — never disrupt the session */ }
+    } catch {
+      // best-effort heartbeat — never disrupt the session. A thrown connect/timeout counts only when the
+      // machine stayed awake AND the internet answers: otherwise the fault is the lid or the Wi-Fi.
+      try {
+        const slept = sleptBetween(started, clockMark())
+        const internetUp = slept ? true : await internetReachable()
+        pingFailures = nextPingFailures(pingFailures, { ok: false, slept, internetUp })
+      } catch { pingFailures = 0 }
+    }
   }
   void pingSession()
   const _hb = setInterval(() => void pingSession(), 60_000)
@@ -4685,6 +4700,49 @@ function renderNudge(payload) {
     },
   )
 
+  // relabel_record_people — put a real name where a text record names its person by a bare phone number
+  // (records filed before desktop 0.1.40 could not read Contacts). Owner-only; labels, never identifiers or
+  // message bodies; dry run unless apply: true; the server keeps each before-state in record history.
+  server.registerTool(
+    'relabel_record_people',
+    {
+      title: 'Put a name on texts that show a bare phone number',
+      description:
+        'On YOUR OWN text-message records, replace a bare phone number standing as a person\'s name ("1 message with ' +
+        '+18015550100") with the name you give: the summary, the thread label and the "who:" speaker prefix of each ' +
+        'message. Never changes the number itself as an identifier, message wording, or who can see the record. ' +
+        'Dry run by default (reports how many records would change); pass apply: true to write. Safe to repeat.',
+      inputSchema: {
+        mappings: z.array(z.object({
+          phone: z.string().describe('E.164, e.g. +18015550100 (a "phone:" prefix is fine)'),
+          name: z.string().describe('the display name to show instead'),
+        })).min(1).max(50).describe('one or more number → name pairs'),
+        apply: z.boolean().optional().describe('true = write; omitted/false = dry run'),
+      },
+    },
+    async ({ mappings, apply }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/records/relabel-people`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ mappings, dry_run: apply !== true }),
+        })
+      } catch (e) {
+        return toolError(`Could not reach Agnoclast: ${e.message}`)
+      }
+      const body = await res.json().catch(() => ({}))
+      if (res.status === 404 && !body?.error) return toolError('This server does not relabel records yet. Nothing was written.')
+      if (res.status === 422) return toolError(`Not done: ${body?.detail ?? 'the mappings were refused'}.`)
+      if (!res.ok || !body?.ok) return toolError(`Could not relabel: HTTP ${res.status} ${JSON.stringify(body)}`)
+      const ids = (body.recordIds ?? []).join(', ')
+      const text = body.dryRun
+        ? `Dry run: ${body.changed} of your text records would be relabelled (${body.matched} mention the number${body.matched === 1 ? '' : 's'}).${ids ? ` Records: ${ids}.` : ''} Nothing was written; pass apply: true to write.`
+        : `Relabelled ${body.changed} of your text records.${ids ? ` Records: ${ids}.` : ''} Each before-state is kept in record history.`
+      return { content: [{ type: 'text', text }] }
+    },
+  )
+
   // ── the questions agents used to answer with SQL (Agnoclast page "Agent SQL gap", 2026-10-07) ──────
   // Theron, 2026-10-07: "any information that I have felt the need to get about my own brains, but was
   // not able to do it with Agnoclast tools … we either need to make tools for that, or …". Measured the

package/package.json

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