@cohortapp/agent-sdk 2.6.2 → 2.8.0

package/lib/telemetry/collect.mjs

@@ -19,9 +19,11 @@
  *       memUsedPct: number,             // 1 - free/total
  *       cpuPct?: number,                // powermetrics if root, else loadavg/cores
  *       cpuSource?: "powermetrics"|"sudo-powermetrics"|"loadavg",
- *       tempC?: number,                 // best-effort (powermetrics; needs root)
- *       tempSource?: "powermetrics"|"sudo-powermetrics",
- *       tempDetail?: string,            // why there is no tempC (never silent)
+ *       tempC?: number,                 // real die °C — unprivileged, via IOHIDEventSystem
+ *       tempSource?: "iohid"|"powermetrics"|"sudo-powermetrics",
+ *       thermalState?: "nominal"|"fair"|"serious"|"critical",  // coarse; ALWAYS available on darwin
+ *       thermalSource?: "processinfo"|"sudo-powermetrics"|"pmset",
+ *       tempDetail?: string,            // NOTE ONLY — never the value (see collectThermal)
  *       diskUsedPct?: number,
  *       uptimeDays?: number,
  *       spend24h?: number,              // rolling 24h billable USD off the cost ledger
@@ -60,6 +62,7 @@ import os from "node:os";
 import { execFile } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
 import { list as listPresence } from "../collective/presence.mjs";
 import { billableUsd } from "../cost/ledger-row.mjs";
@@ -233,7 +236,8 @@ function humanActivity(intent, taskClass) {
  *
  * @returns {Promise<{
  *   loadavg:number[], memUsedPct:number, cpuPct?:number, cpuSource?:string,
- *   tempC?:number, tempSource?:string, tempDetail?:string, diskUsedPct?:number,
+ *   tempC?:number, tempSource?:string, thermalState?:string, thermalSource?:string,
+ *   tempDetail?:string, diskUsedPct?:number,
  *   uptimeDays?:number, spend24h?:number, device?:string, ram?:string, cores?:number
  * }>}
  */
@@ -279,15 +283,37 @@ export async function collectMachine(o = {}) {
     if (Number.isFinite(secs) && secs >= 0) machine.uptimeDays = round1(secs / 86400);
   } catch { /* no uptimeDays */ }
 
-  // Best-effort temp + cpu via powermetrics (guarded, injected, never blocks).
-  // ALWAYS records why it has no answer — see collectPowermetrics.
+  // ── THERMAL ────────────────────────────────────────────────────────────────
+  // Real °C where the hardware gives it up unprivileged, a coarse state word
+  // everywhere else, and `tempDetail` as an EXPLANATORY NOTE that rides
+  // ALONGSIDE the reading rather than standing in for it. See collectThermal
+  // for why this no longer runs through powermetrics.
+  // `powermetrics: false` has always been the caller's "fork no probes" switch
+  // (it is how every hermetic test disables the exec seam), so it still governs
+  // thermal unless a caller opts in or out of thermal explicitly.
+  const thermalEnabled = o.thermal !== undefined ? o.thermal !== false : o.powermetrics !== false;
+  if (thermalEnabled) {
+    const th = await collectThermal(o);
+    if (Number.isFinite(th.tempC)) {
+      machine.tempC = round1(th.tempC);
+      if (th.tempSource) machine.tempSource = th.tempSource;
+    }
+    if (th.thermalState) {
+      machine.thermalState = th.thermalState;
+      if (th.thermalSource) machine.thermalSource = th.thermalSource;
+    }
+    if (th.detail) machine.tempDetail = th.detail;
+  }
+
+  // powermetrics is now asked for CPU utilisation only — plus `tempC` on Intel,
+  // where the `smc` sampler genuinely carries a die temperature and the IOHID
+  // path above does not apply. On Apple Silicon it has no temperature to give
+  // at ANY privilege level, so it never gets to answer the thermal question.
   if (o.powermetrics !== false) {
     const pm = await collectPowermetrics(o);
-    if (Number.isFinite(pm.tempC)) {
+    if (machine.tempC === undefined && Number.isFinite(pm.tempC)) {
       machine.tempC = round1(pm.tempC);
       machine.tempSource = pm.source || "powermetrics";
-    } else if (pm.detail) {
-      machine.tempDetail = pm.detail;
     }
     if (Number.isFinite(pm.cpuPct)) {
       machine.cpuPct = pct(pm.cpuPct);
@@ -320,6 +346,212 @@ export async function collectMachine(o = {}) {
   return machine;
 }
 
+// ---------------------------------------------------------------------------
+// Thermal — real °C without root, and a coarse state word that never fails
+// ---------------------------------------------------------------------------
+
+/** The four thermal pressure levels macOS reports, coldest → hottest. */
+export const THERMAL_STATES = Object.freeze(["nominal", "fair", "serious", "critical"]);
+
+/** Normalise any casing/spelling of a pressure level to our enum, or undefined. */
+function normalizeThermalState(raw) {
+  const v = String(raw || "").trim().toLowerCase();
+  return THERMAL_STATES.includes(v) ? v : undefined;
+}
+
+/**
+ * Pure parser for `thermal-probe.swift` stdout → { thermalState?, tempC?, sensors? }.
+ * Format is `key=value` lines; unknown keys are ignored so the probe can grow.
+ */
+export function parseThermalProbe(text) {
+  const out = {};
+  for (const line of String(text || "").split("\n")) {
+    const m = line.match(/^\s*(\w+)\s*=\s*(.+?)\s*$/);
+    if (!m) continue;
+    const [, k, v] = m;
+    if (k === "thermalState") {
+      const st = normalizeThermalState(v);
+      if (st) out.thermalState = st;
+    } else if (k === "tempC") {
+      const n = Number(v);
+      // Band-check AGAIN on this side. The probe filters, but a collector that
+      // trusts a subprocess's arithmetic is how "-9201.14 °C" reaches a dashboard.
+      if (Number.isFinite(n) && n > 0 && n < 150) out.tempC = n;
+    } else if (k === "tempSensors") {
+      const n = Number(v);
+      if (Number.isFinite(n)) out.sensors = n;
+    }
+  }
+  return out;
+}
+
+/**
+ * Pure parser for the `**** Thermal pressure ****` block that `powermetrics
+ * --samplers thermal` prints — the ONE thermal fact that binary has on Apple
+ * Silicon. Root-only, so this is a fallback, not the primary path.
+ */
+export function parseThermalPressure(text) {
+  const m = String(text || "").match(/Current pressure level:\s*(\w+)/i);
+  return m ? normalizeThermalState(m[1]) : undefined;
+}
+
+/**
+ * Pure parser for `pmset -g therm`. Unprivileged and always present, but it
+ * reports a HISTORY of recorded warnings, not a live reading: on a healthy
+ * machine every line is "No … has been recorded". That absence is a weak signal
+ * and this returns `undefined` for it rather than inventing "nominal" — see
+ * collectThermal, which is where the inference is made explicit and labelled.
+ */
+export function parsePmsetTherm(text) {
+  const s = String(text || "");
+  const m = s.match(/CPU_Scheduler_Limit\s*=\s*(\d+)/i) || s.match(/CPU_Speed_Limit\s*=\s*(\d+)/i);
+  if (m) {
+    const limit = Number(m[1]);
+    // 100 = no throttling. Anything below it means the SMC is actively pulling
+    // the CPU back, which is a REAL thermal event, not a recorded memory of one.
+    if (Number.isFinite(limit)) {
+      if (limit >= 100) return "nominal";
+      if (limit >= 75) return "fair";
+      if (limit >= 50) return "serious";
+      return "critical";
+    }
+  }
+  if (/No thermal warning level has been recorded/i.test(s)) return "no-events";
+  return undefined;
+}
+
+/**
+ * Collect the machine's thermal signal — REAL °C when the hardware will give it
+ * up unprivileged, a coarse state word when it will not.
+ *
+ * ── THE ADVICE THIS REPLACES WAS FUTILE ─────────────────────────────────────
+ * This used to emit, on every Apple-Silicon seat: "powermetrics requires root
+ * (agent runs unprivileged); allowlist it NOPASSWD in sudoers and set
+ * TELEMETRY_SUDO_POWERMETRICS=1 to enable". Both halves of that were wrong.
+ *
+ *   - `powermetrics` produces NO die temperature on Apple Silicon at any
+ *     privilege level. Verified on Mac16,11 / macOS 24D70: `sudo powermetrics
+ *     -A` (every sampler, 242 lines) contains no `temperature` line at all. An
+ *     operator who did exactly what the message asked would STILL see a dash.
+ *   - °C does not need root. It needs IOHIDEventSystem, which any uid can read.
+ *
+ * ── THE LADDER ──────────────────────────────────────────────────────────────
+ *   1. `swift thermal-probe.swift` — unprivileged. Yields BOTH a real `tempC`
+ *      (private IOHID sensors) and `thermalState` (public ProcessInfo). This is
+ *      the answer on any Mac with the Xcode command-line tools present.
+ *   2. `sudo -n powermetrics --samplers thermal` — ONLY if the operator opted
+ *      in. No °C, but a true `Current pressure level:`. State-only.
+ *   3. `pmset -g therm` — unprivileged, always present, but only reports a
+ *      live level while the SMC is actually throttling.
+ *
+ * Every rung records WHY it has no better answer in `detail`. Crucially
+ * `detail` is now a NOTE that ships ALONGSIDE a reading, never instead of one:
+ * the old code made them mutually exclusive, so hq had nothing to print in the
+ * value slot and rendered the 118-character sudoers sentence there instead.
+ *
+ * @returns {Promise<{ tempC?:number, tempSource?:string, thermalState?:string,
+ *                     thermalSource?:string, detail?:string }>}
+ */
+export async function collectThermal(o = {}) {
+  const platform = o.platform || (o.os && o.os.platform && o.os.platform()) || process.platform;
+  const execFileImpl = o.execFile || execFile;
+  if (platform !== "darwin" && !o.execFile) {
+    return { detail: `no thermal probe on platform ${platform}` };
+  }
+  const timeoutMs = Number.isFinite(o.thermalTimeoutMs) ? o.thermalTimeoutMs : 4000;
+
+  // ── 1. The unprivileged probe: real °C + public thermal state ─────────────
+  const swiftBin = o.swiftBin || "/usr/bin/swift";
+  const probePath = o.thermalProbePath || defaultThermalProbePath();
+  const haveSwift = Boolean(o.execFile) || (existsSync(swiftBin) && existsSync(probePath));
+  if (haveSwift) {
+    const out = await execFileSafe(execFileImpl, swiftBin, [probePath], timeoutMs);
+    const parsed = parseThermalProbe(out);
+    if (Number.isFinite(parsed.tempC)) {
+      return {
+        tempC: parsed.tempC,
+        tempSource: "iohid",
+        thermalState: parsed.thermalState,
+        thermalSource: parsed.thermalState ? "processinfo" : undefined,
+        detail: parsed.sensors
+          ? `die temperature: hottest of ${parsed.sensors} on-SoC sensors (IOHIDEventSystem, unprivileged)`
+          : "die temperature via IOHIDEventSystem (unprivileged)",
+      };
+    }
+    if (parsed.thermalState) {
+      return {
+        thermalState: parsed.thermalState,
+        thermalSource: "processinfo",
+        detail:
+          "no numeric °C: the IOHID temperature sensors returned nothing on this hardware; " +
+          "showing the OS thermal pressure level instead",
+      };
+    }
+  }
+
+  // ── 2. Opt-in sudo powermetrics — pressure level only, never °C ───────────
+  const sudoEnabled = o.sudoPowermetrics !== undefined
+    ? Boolean(o.sudoPowermetrics)
+    : String(process.env.TELEMETRY_SUDO_POWERMETRICS || "") === "1";
+  if (sudoEnabled) {
+    const sudoBin = o.sudoBin || "/usr/bin/sudo";
+    const pmBin = o.powermetricsBin || "/usr/bin/powermetrics";
+    const arch = o.arch || (o.os && o.os.arch && o.os.arch()) || process.arch;
+    const out = await execFileSafe(
+      execFileImpl, sudoBin,
+      ["-n", pmBin, "-n", "1", "-i", "200", "--samplers", powermetricsSamplers(arch)],
+      timeoutMs
+    );
+    const level = parseThermalPressure(out);
+    if (level) {
+      return {
+        thermalState: level,
+        thermalSource: "sudo-powermetrics",
+        detail:
+          "no numeric °C: powermetrics reports thermal PRESSURE only — Apple Silicon " +
+          "exposes no die temperature to it even as root",
+      };
+    }
+  }
+
+  // ── 3. pmset — unprivileged, but only speaks up while actually throttling ──
+  const pmsetBin = o.pmsetBin || "/usr/bin/pmset";
+  const out = await execFileSafe(execFileImpl, pmsetBin, ["-g", "therm"], timeoutMs);
+  const therm = parsePmsetTherm(out);
+  if (therm && therm !== "no-events") {
+    return {
+      thermalState: therm,
+      thermalSource: "pmset",
+      detail: "derived from the SMC CPU speed limit reported by `pmset -g therm`",
+    };
+  }
+  if (therm === "no-events") {
+    // NOT reported as `nominal`. "macOS has never recorded a thermal warning"
+    // is a statement about history, and dressing it up as a live reading is
+    // exactly the kind of invented number this rewrite exists to remove.
+    return {
+      detail:
+        "no thermal reading: install the Xcode command-line tools (`xcode-select --install`) " +
+        "to enable the unprivileged °C probe. `pmset` reports no thermal events on record.",
+    };
+  }
+
+  return {
+    detail:
+      "no thermal reading available: the unprivileged °C probe needs `/usr/bin/swift` " +
+      "(Xcode command-line tools) and no fallback thermal source responded",
+  };
+}
+
+/** Absolute path to the shipped swift probe, resolved next to this module. */
+function defaultThermalProbePath() {
+  try {
+    return fileURLToPath(new URL("./thermal-probe.swift", import.meta.url));
+  } catch {
+    return "";
+  }
+}
+
 /**
  * The `powermetrics` sampler that carries die temperature, BY CPU ARCHITECTURE.
  *
@@ -352,16 +584,20 @@ export function powermetricsSamplers(arch) {
  * exit now carries a `detail` sentence that the snapshot ships and the drawer
  * prints.
  *
- * ── ROOT, AND THE ONE HONEST WAY AROUND IT ───────────────────────────────────
- * `powermetrics` requires superuser on macOS, full stop; the daemon runs from a
- * user LaunchAgent. There is NO non-root numeric temperature source on Apple
- * Silicon without a compiled IOKit helper (`ioreg` exposes the PMU/NVMe sensors
- * as HID services whose values are only readable through IOHIDEventSystem, not
- * through the registry), so this does not pretend to have one. Instead it
- * supports an OPT-IN sudo path: set `TELEMETRY_SUDO_POWERMETRICS=1` once the
- * operator has allowlisted the binary NOPASSWD in sudoers. `sudo -n` never
- * prompts — with no allowlist it fails instantly rather than hanging a beat on
- * a password prompt no one will ever see.
+ * ── THIS IS NO LONGER THE TEMPERATURE PATH ───────────────────────────────────
+ * It used to be, and the comment here used to assert that no unprivileged
+ * numeric temperature source existed on Apple Silicon. That was wrong twice
+ * over: powermetrics has no die temperature to give on Apple Silicon EVEN AS
+ * ROOT (`sudo powermetrics -A` contains no `temperature` line), and °C is
+ * readable by any uid through IOHIDEventSystem. `collectThermal` owns that now;
+ * this function is kept for CPU utilisation, for the Intel `smc` sampler that
+ * genuinely does carry a temperature, and for the thermal-pressure line.
+ *
+ * `powermetrics` still requires superuser, and the daemon still runs from a user
+ * LaunchAgent, so the OPT-IN sudo path remains: set
+ * `TELEMETRY_SUDO_POWERMETRICS=1` once the operator has allowlisted the binary
+ * NOPASSWD in sudoers. `sudo -n` never prompts — with no allowlist it fails
+ * instantly rather than hanging a beat on a password prompt no one will see.
  *
  * @returns {Promise<{ tempC?:number, cpuPct?:number, source?:string, detail?:string }>}
  */
@@ -407,14 +643,12 @@ export async function collectPowermetrics(o = {}) {
       }
     }
     return {
-      detail: `${bin} yielded nothing under 'sudo -n' — check the NOPASSWD sudoers allowlist`,
+      detail: `${bin} ran under 'sudo -n' but reported no CPU utilisation this platform can parse`,
     };
   }
 
   return {
-    detail:
-      `${bin} requires root (agent runs unprivileged); ` +
-      "allowlist it NOPASSWD in sudoers and set TELEMETRY_SUDO_POWERMETRICS=1 to enable",
+    detail: `${bin} requires root (agent runs unprivileged); CPU% falls back to the loadavg estimate`,
   };
 }
 
@@ -425,10 +659,33 @@ export function parsePowermetrics(text) {
   // Temperature: "CPU die temperature: 54.21 C" or "GPU die temperature: ..."
   const temp = s.match(/CPU die temperature:\s*([\d.]+)\s*C/i) || s.match(/die temperature:\s*([\d.]+)\s*C/i);
   if (temp) { const v = Number(temp[1]); if (Number.isFinite(v)) out.tempC = v; }
-  // Active CPU%: "CPU Average frequency as fraction of nominal: ..." isn't util;
-  // prefer an explicit "... active residency" total or a "CPU usage" line.
-  const idle = s.match(/CPU\s+(?:Average\s+)?idle\s+residency:\s*([\d.]+)\s*%/i);
-  if (idle) { const v = Number(idle[1]); if (Number.isFinite(v)) out.cpuPct = Math.max(0, 100 - v); }
+  // Thermal pressure — on Apple Silicon this is the ONLY thermal fact in the
+  // whole of powermetrics' output, at any privilege level.
+  const pressure = parseThermalPressure(s);
+  if (pressure) out.pressure = pressure;
+  // Active CPU% = 100 - idle residency.
+  //
+  // ── THE arm64 SHAPE, WHICH NEVER MATCHED ──────────────────────────────────
+  // This only ever looked for a bare `CPU idle residency:` line. Apple Silicon
+  // does not print one: it reports PER-CLUSTER (`E-Cluster idle residency:
+  // 15.69%`, `P-Cluster …`) and per-core (`CPU 0 idle residency: 46.81%`)
+  // lines and no total. `grep -cE "^CPU\s+(Average\s+)?idle residency"` on real
+  // M4 Pro output returns 0, so with sudo enabled this fell through to a detail
+  // string blaming the operator's sudoers file when sudo had worked perfectly.
+  // Fall back to averaging the per-CORE lines, which is the true whole-CPU idle.
+  const idle = s.match(/^CPU\s+(?:Average\s+)?idle\s+residency:\s*([\d.]+)\s*%/im);
+  if (idle) {
+    const v = Number(idle[1]);
+    if (Number.isFinite(v)) out.cpuPct = Math.max(0, 100 - v);
+  } else {
+    const perCore = [...s.matchAll(/^CPU\s+\d+\s+idle\s+residency:\s*([\d.]+)\s*%/gim)]
+      .map((m) => Number(m[1]))
+      .filter((n) => Number.isFinite(n));
+    if (perCore.length > 0) {
+      const avgIdle = perCore.reduce((a, b) => a + b, 0) / perCore.length;
+      out.cpuPct = Math.max(0, 100 - avgIdle);
+    }
+  }
   return out;
 }
 

package/lib/telemetry/collect.test.mjs

@@ -25,6 +25,9 @@ import {
   parseDf,
   collectMachine,
   collectPowermetrics,
+  collectThermal,
+  parseThermalProbe,
+  parseThermalPressure,
   powermetricsSamplers,
   parseSystemProfilerHardware,
   ramLabel,
@@ -319,21 +322,25 @@ test("collectPowermetrics passes the arch-correct sampler to the binary", async
   assert.ok(!samplerArg.includes("smc"), "must not send the Intel-only sampler to arm64");
 });
 
-test("collectPowermetrics ALWAYS says why it has no temperature (fail-open, never silent)", async () => {
+test("collectPowermetrics ALWAYS says why it has no answer (fail-open, never silent)", async () => {
   // The unprivileged reality on every seat: the probe yields nothing.
   const pm = await collectPowermetrics({
     execFile: fakeExecFile({}), platform: "darwin", arch: "arm64", sudoPowermetrics: false,
   });
   assert.equal(pm.tempC, undefined);
   assert.match(pm.detail, /requires root/);
-  assert.match(pm.detail, /TELEMETRY_SUDO_POWERMETRICS/);
+  // It no longer tells the operator to edit sudoers to get a temperature. That
+  // advice was futile: powermetrics has no die temperature on Apple Silicon at
+  // ANY privilege level, so following it to the letter still yielded nothing.
+  assert.ok(!/TELEMETRY_SUDO_POWERMETRICS/.test(pm.detail));
+  assert.ok(!/sudoers/.test(pm.detail));
 
   // A non-darwin host is a DIFFERENT absence and says so.
   const linux = await collectPowermetrics({ platform: "linux" });
   assert.match(linux.detail, /platform linux/);
 });
 
-test("collectMachine surfaces the temperature failure as machine.tempDetail", async () => {
+test("collectMachine surfaces a thermal failure as a NOTE, never as the value", async () => {
   const m = await collectMachine({
     os: fakeOs({}),
     execFile: fakeExecFile({}),
@@ -346,7 +353,11 @@ test("collectMachine surfaces the temperature failure as machine.tempDetail", as
   });
   assert.equal(m.tempC, undefined);
   assert.equal(m.tempSource, undefined);
-  assert.match(m.tempDetail, /requires root/);
+  assert.equal(m.thermalState, undefined);
+  assert.equal(typeof m.tempDetail, "string");
+  // The note must not blame the operator's sudoers file for a limitation of the
+  // hardware — that is the message this whole rewrite exists to delete.
+  assert.ok(!/sudoers/.test(m.tempDetail));
   // And the cpuPct it DOES have is labelled as the estimate it is.
   assert.equal(m.cpuSource, "loadavg");
 });
@@ -380,6 +391,191 @@ test("collectPowermetrics tries the opt-in sudo path only when enabled", async (
   assert.ok(sudoCall >= 0);
 });
 
+// ---------------------------------------------------------------------------
+// Thermal — real °C without root, and a coarse state word that never fails.
+//
+// Every test here stubs the exec seam. NOTHING in this file forks `swift`,
+// `powermetrics` or `pmset`; the probe's real output is pinned as fixture text.
+// ---------------------------------------------------------------------------
+
+/** Verbatim stdout of `swift lib/telemetry/thermal-probe.swift` on a Mac16,11. */
+const PROBE_OK = "thermalState=nominal\ntempC=60.76\ntempSensors=42\n";
+
+/** Verbatim `sudo powermetrics --samplers thermal` — note: NO temperature line. */
+const PM_THERMAL = [
+  "Machine model: Mac16,11",
+  "",
+  "**** Thermal pressure ****",
+  "",
+  "Current pressure level: Nominal",
+  "",
+].join("\n");
+
+/** Route stdout by binary, so a test can say which rung of the ladder answers. */
+const SWIFT = "/usr/bin/swift";
+const SUDO = "/usr/bin/sudo";
+const PMSET = "/usr/bin/pmset";
+
+test("collectThermal reads a REAL °C unprivileged, via the IOHID probe", async () => {
+  // The headline fix. powermetrics cannot produce a die temperature on Apple
+  // Silicon even as root; IOHIDEventSystem hands it over to any uid.
+  const seen = [];
+  const spy = (cmd, args, optsOrCb, maybeCb) => {
+    const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+    seen.push(cmd);
+    queueMicrotask(() => cb(null, cmd === SWIFT ? PROBE_OK : "", ""));
+    return { on() {} };
+  };
+  const th = await collectThermal({ execFile: spy, platform: "darwin", arch: "arm64" });
+  assert.equal(th.tempC, 60.76);
+  assert.equal(th.tempSource, "iohid");
+  assert.equal(th.thermalState, "nominal");
+  assert.equal(th.thermalSource, "processinfo");
+  // No root, no sudo, on the happy path.
+  assert.ok(!seen.includes(SUDO), "the °C path must never need sudo");
+  // The detail is an EXPLANATION riding alongside a real reading, not a
+  // substitute for one — the drawer prints the number and demotes this.
+  assert.equal(typeof th.detail, "string");
+  assert.match(th.detail, /IOHIDEventSystem/);
+});
+
+test("collectThermal falls back to the coarse STATE when there is no °C", async () => {
+  // The probe ran but the sensors gave nothing: state alone is still a useful,
+  // honest answer, and the field semantics say so rather than faking a number.
+  const spy = (cmd, args, optsOrCb, maybeCb) => {
+    const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+    queueMicrotask(() => cb(null, cmd === SWIFT ? "thermalState=serious\n" : "", ""));
+    return { on() {} };
+  };
+  const th = await collectThermal({ execFile: spy, platform: "darwin", arch: "arm64" });
+  assert.equal(th.tempC, undefined);
+  assert.equal(th.thermalState, "serious");
+  assert.equal(th.thermalSource, "processinfo");
+  assert.match(th.detail, /no numeric °C/);
+});
+
+test("collectThermal uses sudo powermetrics for PRESSURE only, and only when opted in", async () => {
+  const seen = [];
+  const spy = (cmd, args, optsOrCb, maybeCb) => {
+    const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+    seen.push(cmd);
+    // swift is absent on this host; sudo powermetrics answers.
+    queueMicrotask(() => cb(null, cmd === SUDO ? PM_THERMAL : "", ""));
+    return { on() {} };
+  };
+  const off = await collectThermal({
+    execFile: spy, platform: "darwin", arch: "arm64", sudoPowermetrics: false,
+  });
+  assert.ok(!seen.includes(SUDO), "must not shell out to sudo unless asked");
+  assert.equal(off.thermalState, undefined);
+
+  seen.length = 0;
+  const on = await collectThermal({
+    execFile: spy, platform: "darwin", arch: "arm64", sudoPowermetrics: true,
+  });
+  assert.ok(seen.includes(SUDO));
+  assert.equal(on.thermalState, "nominal");
+  assert.equal(on.thermalSource, "sudo-powermetrics");
+  // Root buys a pressure LEVEL and nothing more. If this ever starts asserting a
+  // tempC from powermetrics on arm64, the fixture is lying.
+  assert.equal(on.tempC, undefined);
+  assert.match(on.detail, /pressure/i);
+});
+
+test("collectThermal will NOT dress 'no thermal events on record' up as a live reading", async () => {
+  // `pmset -g therm` on a healthy Mac reports history, not temperature. Calling
+  // that "nominal" would be inventing a measurement nobody took.
+  const spy = (cmd, args, optsOrCb, maybeCb) => {
+    const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+    const out = cmd === PMSET ? "Note: No thermal warning level has been recorded\n" : "";
+    queueMicrotask(() => cb(null, out, ""));
+    return { on() {} };
+  };
+  const th = await collectThermal({ execFile: spy, platform: "darwin", arch: "arm64" });
+  assert.equal(th.thermalState, undefined);
+  assert.equal(th.tempC, undefined);
+  assert.match(th.detail, /xcode-select --install/);
+
+  // But a REAL throttle event — a speed limit below 100 — is a live signal.
+  const throttling = (cmd, args, optsOrCb, maybeCb) => {
+    const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+    const out = cmd === PMSET ? "CPU_Speed_Limit \t= 60\n" : "";
+    queueMicrotask(() => cb(null, out, ""));
+    return { on() {} };
+  };
+  const hot = await collectThermal({ execFile: throttling, platform: "darwin", arch: "arm64" });
+  assert.equal(hot.thermalState, "serious");
+  assert.equal(hot.thermalSource, "pmset");
+});
+
+test("parseThermalProbe rejects the sensor that lies (-9201.14 °C)", () => {
+  // `PMU tdev2` returns garbage on real hardware. The probe filters it, and the
+  // collector band-checks AGAIN — trusting a subprocess's arithmetic is how an
+  // absurd number reaches a dashboard.
+  assert.deepEqual(parseThermalProbe("thermalState=nominal\ntempC=-9201.14\n"), {
+    thermalState: "nominal",
+  });
+  assert.equal(parseThermalProbe("tempC=900\n").tempC, undefined);
+  assert.equal(parseThermalProbe("tempC=61.2\n").tempC, 61.2);
+  // Unknown keys are ignored so the probe can grow a field without breaking us.
+  assert.equal(parseThermalProbe("tempC=61.2\nfuture=x\n").tempC, 61.2);
+  assert.deepEqual(parseThermalProbe(""), {});
+  assert.deepEqual(parseThermalProbe(null), {});
+  // Only the four real levels are accepted.
+  assert.equal(parseThermalProbe("thermalState=toasty\n").thermalState, undefined);
+});
+
+test("parseThermalPressure reads the only thermal fact powermetrics has on arm64", () => {
+  assert.equal(parseThermalPressure(PM_THERMAL), "nominal");
+  assert.equal(parseThermalPressure("Current pressure level: Critical"), "critical");
+  assert.equal(parseThermalPressure("no such block"), undefined);
+  assert.equal(parseThermalPressure(""), undefined);
+});
+
+test("parsePowermetrics computes CPU% from the PER-CLUSTER arm64 shape", () => {
+  // The old regex wanted a bare `CPU idle residency:` line. Apple Silicon never
+  // prints one — only per-core and per-cluster lines — so on every seat in the
+  // fleet this silently fell through and then blamed the operator's sudoers.
+  const arm = [
+    "**** Processor usage ****",
+    "E-Cluster idle residency:  78.34%",
+    "CPU 0 idle residency:  90.00%",
+    "CPU 1 idle residency:  80.00%",
+    "CPU 2 idle residency:  70.00%",
+    "CPU 3 idle residency:  60.00%",
+  ].join("\n");
+  const parsed = parsePowermetrics(arm);
+  assert.equal(parsed.cpuPct, 25); // 100 - mean(90,80,70,60)
+  // The Intel/total shape still wins outright where it exists.
+  assert.equal(parsePowermetrics("CPU Average idle residency: 78.0 %").cpuPct, 22);
+});
+
+test("collectMachine ships tempC + thermalState + the note TOGETHER", async () => {
+  // The old collector made the reading and the explanation MUTUALLY EXCLUSIVE
+  // (`else if`), which left hq with nothing to put in the value slot — so it
+  // printed a 118-character sudoers sentence in a column of "62°C" and "41%".
+  const spy = (cmd, args, optsOrCb, maybeCb) => {
+    const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+    queueMicrotask(() => cb(null, cmd === SWIFT ? PROBE_OK : "", ""));
+    return { on() {} };
+  };
+  const m = await collectMachine({
+    os: fakeOs({}),
+    execFile: spy,
+    platform: "darwin",
+    arch: "arm64",
+    sudoPowermetrics: false,
+    disk: false,
+    inventory: false,
+    spend: false,
+  });
+  assert.equal(m.tempC, 60.8); // round1
+  assert.equal(m.tempSource, "iohid");
+  assert.equal(m.thermalState, "nominal");
+  assert.equal(m.thermalSource, "processinfo");
+  assert.equal(typeof m.tempDetail, "string");
+});
+
 // ---------------------------------------------------------------------------
 // spend24h
 // ---------------------------------------------------------------------------

package/lib/telemetry/thermal-probe.swift

@@ -0,0 +1,119 @@
+// thermal-probe.swift — the ONLY unprivileged thermal reading on Apple Silicon.
+//
+// ── WHY THIS FILE EXISTS ────────────────────────────────────────────────────
+// The telemetry collector spent two months telling every operator that
+// `powermetrics` "requires root … allowlist it NOPASSWD in sudoers". That
+// advice was both futile and wrong:
+//
+//   1. `powermetrics` emits NO die temperature on Apple Silicon AT ALL — not
+//      unprivileged, not as root, not with `-A` (every sampler). Verified on a
+//      Mac mini M4 Pro (Mac16,11, macOS 24D70): `sudo powermetrics -A` returns
+//      242 lines and `grep -i temperature` finds nothing. The only thermal fact
+//      in that output is `**** Thermal pressure **** / Current pressure level:
+//      Nominal`. So an operator who followed the advice to the letter would
+//      still get an em-dash.
+//   2. Real °C IS available WITHOUT root — through IOHIDEventSystem, which is
+//      where the SoC's PMU temperature sensors actually publish. `ioreg` shows
+//      those sensors as HID service nodes but carries no values, which is why
+//      the registry looked like a dead end.
+//
+// This probe is invoked as `/usr/bin/swift thermal-probe.swift` and prints two
+// `key=value` lines that `parseThermalProbe()` reads. It requires no root, no
+// entitlement, and triggers no TCC prompt; verified working under `env -i` and
+// detached from any tty, which is the LaunchAgent case the daemon actually runs
+// in.
+//
+// ── THE TWO SIGNALS, AND WHY BOTH ───────────────────────────────────────────
+// `thermalState` comes from ProcessInfo — a PUBLIC, always-present API. It is
+// the floor: it cannot fail, needs no Xcode toolchain beyond running this
+// script, and is a genuinely useful coarse answer (nominal/fair/serious/
+// critical). `tempC` comes from the PRIVATE IOHIDEventSystem symbols; it is the
+// precise answer when it is available. If the private path ever stops working
+// on a future macOS, the state line still prints and the collector degrades to
+// a coarse-but-honest reading rather than to nothing.
+//
+// Output (tempC/tempSensors omitted entirely when the sensor read yields nothing):
+//   thermalState=nominal
+//   tempC=61.24
+//   tempSensors=42
+
+import Foundation
+import IOKit
+
+// ── 1. Thermal state: public API, cannot fail ───────────────────────────────
+let word: String
+switch ProcessInfo.processInfo.thermalState {
+case .nominal: word = "nominal"
+case .fair: word = "fair"
+case .serious: word = "serious"
+case .critical: word = "critical"
+@unknown default: word = "unknown"
+}
+print("thermalState=\(word)")
+
+// ── 2. Die temperature: private IOHIDEventSystem, unprivileged ──────────────
+// Matching dictionary {PrimaryUsagePage: 0xff00, PrimaryUsage: 5} selects the
+// AppleARMPMUTempSensor HID services; kIOHIDEventTypeTemperature = 15 and the
+// float field is (type << 16).
+let kTemperatureEvent: Int32 = 15
+let kHIDPageAppleVendor = 0xff00
+let kHIDUsageAppleVendorTemperatureSensor = 5
+
+guard let iokit = dlopen("/System/Library/Frameworks/IOKit.framework/IOKit", RTLD_NOW) else {
+  exit(0) // state line already printed; that is a complete, honest answer
+}
+
+typealias ClientCreateFn = @convention(c) (CFAllocator?) -> Unmanaged<AnyObject>?
+typealias SetMatchingFn = @convention(c) (AnyObject, CFDictionary) -> Void
+typealias CopyServicesFn = @convention(c) (AnyObject) -> Unmanaged<CFArray>?
+typealias CopyEventFn = @convention(c) (AnyObject, Int32, Int32, Int32) -> Unmanaged<AnyObject>?
+typealias FloatValueFn = @convention(c) (AnyObject, Int32) -> Double
+typealias CopyPropertyFn = @convention(c) (AnyObject, CFString) -> Unmanaged<AnyObject>?
+
+guard
+  let pCreate = dlsym(iokit, "IOHIDEventSystemClientCreate"),
+  let pSetMatching = dlsym(iokit, "IOHIDEventSystemClientSetMatching"),
+  let pCopyServices = dlsym(iokit, "IOHIDEventSystemClientCopyServices"),
+  let pCopyEvent = dlsym(iokit, "IOHIDServiceClientCopyEvent"),
+  let pFloatValue = dlsym(iokit, "IOHIDEventGetFloatValue"),
+  let pCopyProperty = dlsym(iokit, "IOHIDServiceClientCopyProperty")
+else { exit(0) }
+
+let clientCreate = unsafeBitCast(pCreate, to: ClientCreateFn.self)
+let setMatching = unsafeBitCast(pSetMatching, to: SetMatchingFn.self)
+let copyServices = unsafeBitCast(pCopyServices, to: CopyServicesFn.self)
+let copyEvent = unsafeBitCast(pCopyEvent, to: CopyEventFn.self)
+let floatValue = unsafeBitCast(pFloatValue, to: FloatValueFn.self)
+let copyProperty = unsafeBitCast(pCopyProperty, to: CopyPropertyFn.self)
+
+guard let client = clientCreate(kCFAllocatorDefault)?.takeRetainedValue() else { exit(0) }
+setMatching(client, [
+  "PrimaryUsagePage": kHIDPageAppleVendor,
+  "PrimaryUsage": kHIDUsageAppleVendorTemperatureSensor,
+] as CFDictionary)
+guard let services = copyServices(client)?.takeRetainedValue() as? [AnyObject] else { exit(0) }
+
+// SOME SENSORS LIE. `PMU tdev2` reliably returns -9201.14 on this hardware, so
+// every reading is band-checked before it is allowed to influence the answer.
+// Of 70 matching services, 67 return a plausible value.
+var dieTemps: [Double] = []
+var anyTemps: [Double] = []
+for service in services {
+  guard let event = copyEvent(service, kTemperatureEvent, 0, 0)?.takeRetainedValue() else { continue }
+  let value = floatValue(event, kTemperatureEvent << 16)
+  guard value.isFinite, value > 0, value < 150 else { continue }
+  anyTemps.append(value)
+  let name = (copyProperty(service, "Product" as CFString)?.takeRetainedValue() as? String) ?? ""
+  if name.contains("tdie") { dieTemps.append(value) }
+}
+
+// Prefer the SoC die sensors ("PMU tdie<n>"); fall back to whatever plausible
+// sensors exist so a future chip with different naming still reports something.
+let pool = dieTemps.isEmpty ? anyTemps : dieTemps
+guard let hottest = pool.max() else { exit(0) }
+
+// The MAX, not the mean: a fleet dashboard wants the worst core, because that
+// is what throttles. Averaging 42 die sensors hides exactly the spike the
+// operator is looking for.
+print(String(format: "tempC=%.2f", hottest))
+print("tempSensors=\(pool.count)")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.6.2",
+  "version": "2.8.0",
   "description": "Cohort Agent SDK \u2014 autonomous AI colleague runtime. Deploy senior AI colleagues on dedicated Mac minis, wired to the Cohort operating surface.",
   "type": "module",
   "bin": {

package/scripts/daemon/responder-history.test.mjs

@@ -0,0 +1,169 @@
+/**
+ * responder.test.mjs — conversation history behind holding messages / quick replies.
+ * Run: node --test scripts/daemon/responder.test.mjs
+ *
+ * `loadConversationHistory` used to build its candidate directories as
+ * `memory/interactions/slack/<id>` unconditionally, and its writer
+ * (`logInteraction`) early-returns for any service that is not Slack. A Cohort
+ * DM therefore had nothing written and nothing to read, so every holding
+ * message for Cohort was generated from the current message alone. A bare "?"
+ * produced "What's on your mind?" — indistinguishable from amnesia, and the
+ * CEO read it as exactly that (2026-08-13, dm-h001-a016).
+ *
+ * Cohort has an authoritative `messaging.history`. These tests pin that the
+ * cohort branch reads it, orders it oldest-first, and NEVER throws — the
+ * holding path must degrade to "no history" rather than take the send down.
+ */
+"use strict";
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { loadConversationHistory } from "./responder.mjs";
+
+const cohortItem = {
+  sender: "Dana Okafor",
+  service: "cohort",
+  channel: "dm-h001-a016",
+  channel_id: "cmql1802601iihhzpf774vwbk",
+  content: "?",
+};
+
+// Newest-first, the way messaging.history actually returns it.
+const HISTORY = [
+  { id: "m3", createdAt: "2026-08-13T05:47:51Z", authorName: "Dana Okafor", body: "with that in mind, fix these issues you just noted please" },
+  { id: "m2", createdAt: "2026-08-12T13:52:53Z", authorName: "Isla Roselli", body: "Both are merged. #19 went in as 94f227c4." },
+  { id: "m1", createdAt: "2026-08-12T13:47:30Z", authorName: "Dana Okafor", body: "why haven't you merged? please go ahead" },
+];
+
+test("cohort: reads messaging.history and renders it oldest-first", async () => {
+  const seen = [];
+  const text = await loadConversationHistory(cohortItem, {
+    fetchHistory: async (params, o) => {
+      seen.push({ params, hasCfg: Boolean(o && o.cfg) });
+      return HISTORY;
+    },
+    loadOrgConfig: () => ({ org: { cohort: { enabled: true, base: "https://x", token: "t" } } }),
+  });
+
+  assert.ok(text, "expected a transcript, got null");
+  assert.match(text, /Dana Okafor: why haven't you merged/);
+  assert.match(text, /Isla Roselli: Both are merged/);
+  assert.match(text, /Dana Okafor: with that in mind/);
+
+  // Oldest-first: the model reads a conversation, not a reversed one.
+  assert.ok(
+    text.indexOf("why haven't you merged") < text.indexOf("with that in mind"),
+    "history must be rendered oldest-first",
+  );
+
+  // The channel it asks for is the item's channel_id, and cfg is ALWAYS passed:
+  // fetchHistory() fails open to [] when cfg is omitted, which is silently
+  // indistinguishable from an empty channel. That is the bug this file exists for.
+  assert.equal(seen.length, 1);
+  assert.equal(seen[0].params.channel, "cmql1802601iihhzpf774vwbk");
+  assert.equal(seen[0].hasCfg, true, "cfg must be passed or fetchHistory returns [] silently");
+});
+
+test("cohort: an empty channel is null, not an empty transcript", async () => {
+  const text = await loadConversationHistory(cohortItem, {
+    fetchHistory: async () => [],
+    loadOrgConfig: () => ({}),
+  });
+  assert.equal(text, null);
+});
+
+test("cohort: a failing history call degrades to null and never throws", async () => {
+  const text = await loadConversationHistory(cohortItem, {
+    fetchHistory: async () => { throw new Error("cohort unreachable"); },
+    loadOrgConfig: () => ({}),
+  });
+  assert.equal(text, null);
+});
+
+test("cohort: the current message is not fed back as its own history", async () => {
+  const text = await loadConversationHistory(
+    { ...cohortItem, message_id: "m3" },
+    {
+      fetchHistory: async () => HISTORY,
+      loadOrgConfig: () => ({}),
+    },
+  );
+  assert.ok(text);
+  assert.doesNotMatch(text, /with that in mind/, "the inbound message itself must be excluded");
+});
+
+test("slack: still reads the local interaction mirror", async () => {
+  const root = mkdtempSync(join(tmpdir(), "maestro-responder-"));
+  const dir = join(root, "memory", "interactions", "slack", "D099N1JGKRQ");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "2026-08-13.jsonl"),
+    [
+      JSON.stringify({ ts: "2026-08-13T05:00:00Z", from: "Dana Okafor", content: "ship it" }),
+      JSON.stringify({ ts: "2026-08-13T05:01:00Z", from: "agent", content: "shipped" }),
+    ].join("\n"),
+  );
+
+  const text = await loadConversationHistory(
+    { sender: "Dana Okafor", service: "slack", channel: "D099N1JGKRQ", content: "?" },
+    { agentRepoDir: root },
+  );
+
+  assert.ok(text, "expected the slack mirror to still be read");
+  assert.match(text, /Dana Okafor: ship it/);
+  assert.match(text, /agent: shipped/);
+});
+
+test("cohort: falls back to the local mirror when the server is unreachable", async () => {
+  // Isla's original returned null outright for Cohort when messaging.history
+  // failed. Falling through to the mirror means a transient API blip degrades
+  // to cached context instead of to none — the mirror is a poor source of
+  // truth but a perfectly good backstop.
+  const root = mkdtempSync(join(tmpdir(), "maestro-responder-"));
+  const dir = join(root, "memory", "interactions", "cohort", "chan-1");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "2026-08-13.jsonl"),
+    JSON.stringify({ ts: "2026-08-13T05:00:00Z", from: "Dana Okafor", content: "cached line" }),
+  );
+
+  const text = await loadConversationHistory(
+    { sender: "Dana Okafor", service: "cohort", channel: "chan-1", content: "?" },
+    {
+      agentRepoDir: root,
+      loadOrgConfig: () => ({}),
+      fetchHistory: async () => { throw new Error("network down"); },
+    },
+  );
+
+  assert.ok(text, "a server failure must not erase locally cached context");
+  assert.match(text, /Dana Okafor: cached line/);
+});
+
+test("cohort: server history wins over the local mirror", async () => {
+  const root = mkdtempSync(join(tmpdir(), "maestro-responder-"));
+  const dir = join(root, "memory", "interactions", "cohort", "chan-1");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "2026-08-13.jsonl"),
+    JSON.stringify({ ts: "2026-08-13T05:00:00Z", from: "stale", content: "outdated mirror line" }),
+  );
+
+  const text = await loadConversationHistory(
+    { sender: "Dana Okafor", service: "cohort", channel: "chan-1", content: "?" },
+    {
+      agentRepoDir: root,
+      loadOrgConfig: () => ({}),
+      fetchHistory: async () => ([
+        { id: "m2", authorName: "Dana Okafor", body: "authoritative line", createdAt: "2026-08-13T06:00:00Z" },
+      ]),
+    },
+  );
+
+  assert.match(text, /authoritative line/, "the server is the source of truth");
+  assert.doesNotMatch(text, /outdated mirror line/, "the stale mirror must not be mixed in");
+});

package/scripts/daemon/responder.mjs

@@ -523,23 +523,105 @@ function loadUserProfile(sender) {
 // Load recent conversation history for context
 // ---------------------------------------------------------------------------
 
+/** Cohort's message ids as this item carries them, so history can drop itself. */
+function inboundMessageIds(item) {
+  const ids = new Set();
+  const add = (v) => { if (v) ids.add(String(v)); };
+  add(item.message_id);
+  // Inbox filenames prefix the service: "cohort-cmsr45u91…" → "cmsr45u91…".
+  if (item.id) { add(item.id); add(String(item.id).replace(/^[a-z]+-/, "")); }
+  // raw_ref is "cohort:dm:<messageId>:<seq>".
+  const m = typeof item.raw_ref === "string" ? item.raw_ref.match(/^cohort:[^:]+:([^:]+)/) : null;
+  if (m) add(m[1]);
+  return ids;
+}
+
+const COHORT_HISTORY_LIMIT = 12;
+const COHORT_HISTORY_CHARS = 400;
+
+/**
+ * Cohort history straight from the server, via the same `messaging.history` the
+ * replies are posted to.
+ *
+ * The local mirror below is a cache the agent populates itself, so it carries
+ * context only if the agent has already been talking AND logging correctly.
+ * When the write half broke (logInteraction early-returned for every non-Slack
+ * service), the read half silently returned nothing, memory/interactions/ was
+ * never even created, and holding messages were composed from the inbound
+ * message alone — a bare "?" came back as "What's on your mind?" mid-thread.
+ *
+ * Asking the authority that stores the message removes that coupling: a fresh
+ * agent, or one whose mirror was wiped, still answers with full context.
+ *
+ * Fails open to null on every path. No amount of history is worth failing a send.
+ */
+async function loadCohortHistory(item, deps = {}) {
+  const channel = item.channel_id || item.channel || "";
+  if (!channel) return null;
+
+  try {
+    const fetchHistory = deps.fetchHistory
+      || (await import("../../lib/org/messaging.mjs")).fetchHistory;
+    const loadOrgConfig = deps.loadOrgConfig
+      || (await import("../../lib/org/client.mjs")).loadOrgConfig;
+    const agentRoot = deps.agentRepoDir || process.env.AGENT_ROOT || process.env.AGENT_DIR || AGENT_REPO_DIR;
+
+    // cfg is mandatory. configFromAgent() reads base+token ONLY from the object
+    // handed in — it never loads config/org.yaml — so omitting it returns a
+    // fail-open [] that looks exactly like an empty channel.
+    const messages = await fetchHistory(
+      { channel, limit: COHORT_HISTORY_LIMIT + 1 },
+      { cfg: loadOrgConfig(agentRoot), agentRoot },
+    );
+    if (!Array.isArray(messages) || messages.length === 0) return null;
+
+    const self = inboundMessageIds(item);
+    const rows = messages
+      .filter((m) => m && !self.has(String(m.id)))
+      .slice(0, COHORT_HISTORY_LIMIT)
+      .reverse() // messaging.history is newest-first; a conversation reads the other way
+      .map((m) => {
+        const from = m.authorName || m.author?.name || m.authorId || "unknown";
+        const text = String(m.body ?? m.content ?? "").trim();
+        return `[${m.createdAt || ""}] ${from}: ${text.substring(0, COHORT_HISTORY_CHARS)}`;
+      });
+
+    return rows.length > 0 ? rows.join("\n") : null;
+  } catch (err) {
+    console.warn(`[responder] cohort history unavailable for ${item.sender}: ${err.message}`);
+    return null;
+  }
+}
+
 /**
  * The reader half of `logInteraction`. It looked ONLY under
  * `memory/interactions/slack/…`, so even once a Cohort exchange was written it
  * would not have been found. Both halves are now keyed on the item's service.
+ *
+ * Cohort asks the server first (see loadCohortHistory) and falls back to the
+ * local mirror, so a transient API failure degrades to cached context rather
+ * than to none.
  */
-function loadConversationHistory(item) {
+export async function loadConversationHistory(item, deps = {}) {
   if (!item || !item.sender || !item.service) return null;
 
   const service = String(item.service);
+
+  if (service === "cohort") {
+    const remote = await loadCohortHistory(item, deps);
+    if (remote) return remote;
+  }
+  // Test seam: the mirror's location is a parameter, so a test can point at a
+  // tmpdir instead of mutating process.env for the whole worker.
+  const repoDir = deps.agentRepoDir || AGENT_REPO_DIR;
   const senderSlug = item.sender.replace(/\s+/g, "-").toLowerCase();
   const channelId = service === "slack"
     ? resolveSlackChannel(item)
     : (item.channel_id || item.channel || null);
 
   const candidateDirs = [];
-  if (channelId) candidateDirs.push(join(AGENT_REPO_DIR, "memory", "interactions", service, String(channelId)));
-  candidateDirs.push(join(AGENT_REPO_DIR, "memory", "interactions", service, `dm-${senderSlug}`));
+  if (channelId) candidateDirs.push(join(repoDir, "memory", "interactions", service, String(channelId)));
+  candidateDirs.push(join(repoDir, "memory", "interactions", service, `dm-${senderSlug}`));
 
   const entries = [];
   for (const dir of candidateDirs) {
@@ -621,7 +703,7 @@ Keep responses focused — 1-4 sentences for simple items, up to a short paragra
 Match the sender's tone and urgency level.
 ${profile ? `\nSender profile:\n${profile}` : ""}`;
 
-  const conversationHistory = loadConversationHistory(item);
+  const conversationHistory = await loadConversationHistory(item);
 
   const userContent = [
     `From: ${item.sender} (${item.sender_privilege || "unknown"})`,