@vellumai/assistant 0.12.5-dev.202609252115.c8e1713 → 0.12.5-dev.202609252215.b94bc6c

package/ARCHITECTURE.md

@@ -49,6 +49,8 @@ Resource pressure monitoring reports sustained CPU/memory pressure on platform-h
 
 When the container hits its memory limit, the kernel kills the process with the highest `oom_score` (memory share plus `oom_score_adj`). `src/util/oom-priority.ts` steers that choice so the assistant is never the victim of a runaway tool: the daemon sets itself to -700 as the first thing in `runDaemon`, before any spawn. Children inherit the parent's value at fork, so every spawn path resets its child: shell children get +1000 from the Linux prefix in `buildShellInvocation` (`packages/environments`), desktop children and ACP agents and terminals get +1000 from `withOomScoreAdj`, an `sh -c ... exec` wrapper that keeps pid and process group, and workers, the embedding worker, and Qdrant get 0 from a parent-side write right after spawn (the resource monitor gets -500 so it outlives everything but the daemon and records the kill). The monitor also sweeps the daemon's descendants every few seconds (`src/monitoring/oom-inheritance-sweep.ts`) and writes 0 over any negative value it finds, logging the comm, so a spawn path that forgets the reset degrades to a few seconds of inherited protection instead of a protected runaway. Bundled plugins (the memory plugin's rerank worker, for one) rely on the sweep rather than importing the helper, since the plugin import boundary forbids reaching outside the plugin. Raising never needs a capability; lowering needs `CAP_SYS_RESOURCE`, which the platform grants and self-hosted Docker does not, where the daemon simply stays at 0. Nothing here caps a single process or acts early: it only decides who dies once the kernel has to kill.
 
+**Verification telemetry:** the resource monitor reports kernel OOM kills in the container as a `watchdog` event with `check_name` `oom_kill` (`src/monitoring/oom-kill-reporter.ts`). It reads the kernel log through `dmesg` (the `/dev/kmsg` device is not mounted in the container; `dmesg` uses the syslog syscall, which the Kata profile permits) when the cgroup `memory.events` kill counter moves, on its first scan after start (the kill that took the daemon down restarts the monitor with it), and once a minute as a fallback. The kernel log is shared by every container on that kernel and cgroup paths read `/` from inside, so attribution is by the counter: a move of N claims the N most recent new kills; the first scan and hosts without the counter claim every new kill and say so with `attribution: "kernel_log"`. The `detail` bag lists each victim's comm, `oom_score_adj` and resident size, the cgroup memory figures at the time, and `killed_daemon`, detected by the daemon's -700 score rather than a pid the restart has since replaced; where the log is unreadable a counter move still yields a victimless event. A cursor (kernel boot id plus last log timestamp) on the monitor data dir advances only after the event is queued, so a telemetry store outage delays a report rather than losing one, and resets when the kernel reboots.
+
 ### Single-Header JWT Auth Model
 
 All HTTP API requests use a single `Authorization: Bearer <jwt>` header for authentication. The JWT carries identity, permissions, and policy versioning in a unified token.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.5-dev.202609252115.c8e1713",
+  "version": "0.12.5-dev.202609252215.b94bc6c",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/cli/commands/browser.ts

@@ -214,8 +214,7 @@ function attachOperationAction(
       opts.output &&
       result.screenshots?.length
     ) {
-      const screenshot = result.screenshots[0];
-      const buffer = Buffer.from(screenshot.data, "base64");
+      const buffer = Buffer.from(result.screenshots[0].data, "base64");
       try {
         writeFileSync(String(opts.output), buffer);
       } catch (err) {

package/src/cli/lib/plugin-artifact.ts

@@ -89,8 +89,9 @@ export function parsePluginArtifact(
   if (typeof vellum !== "object" || vellum === null || Array.isArray(vellum)) {
     return null;
   }
-  const artifact = (vellum as Record<string, unknown>).artifact;
-  const parsed = PluginArtifactSchema.safeParse(artifact);
+  const parsed = PluginArtifactSchema.safeParse(
+    (vellum as Record<string, unknown>).artifact,
+  );
   if (!parsed.success) {
     return null;
   }

package/src/monitoring/__tests__/oom-kill-reporter.test.ts

@@ -0,0 +1,262 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  createOomKillReporter,
+  type KernelLogEntry,
+  oomKillsFromEntries,
+  parseDmesgJson,
+  parseDmesgText,
+} from "../oom-kill-reporter.js";
+import type { ResourceSample } from "../resource-sample-types.js";
+
+const TOOL_KILL =
+  "Memory cgroup out of memory: Killed process 4242 (python3) total-vm:1263184kB, anon-rss:409600kB, file-rss:1024kB, shmem-rss:0kB, UID:0 pgtables:900kB oom_score_adj:1000";
+const DAEMON_KILL =
+  "Memory cgroup out of memory: Killed process 1 (bun) total-vm:3000000kB, anon-rss:2000000kB, file-rss:0kB, shmem-rss:0kB, UID:0 pgtables:5000kB oom_score_adj:-700";
+const LEGACY_KILL =
+  "Out of memory: Killed process 77 (node) total-vm:500000kB, anon-rss:300000kB, file-rss:0kB, shmem-rss:0kB";
+const NOISE = [
+  "bun invoked oom-killer: gfp_mask=0xcc0(GFP_KERNEL), order=0, oom_score_adj=-700",
+  "oom_reaper: reaped process 4242 (python3), now anon-rss:0kB, file-rss:0kB, shmem-rss:0kB",
+];
+
+const entry = (time: number, msg: string): KernelLogEntry => ({ time, msg });
+
+function sample(
+  oomKillDelta: number | null,
+  countersAvailable = true,
+): ResourceSample {
+  const events = { low: 0, high: 0, max: 0, oom: 0, oomKill: 0 };
+  return {
+    ts: 0,
+    memory: {
+      currentBytes: 3_000_000_000,
+      limitBytes: 3_221_225_472,
+      peakBytes: 3_221_000_000,
+      ratio: 0.93,
+    },
+    memoryStat: null,
+    reclaim: null,
+    cpu: null,
+    events: countersAvailable ? events : null,
+    deltas:
+      oomKillDelta == null
+        ? null
+        : {
+            events: { ...events, oomKill: oomKillDelta },
+            reclaim: null,
+            cpu: null,
+          },
+    disk: null,
+    activeConversations: null,
+  };
+}
+
+describe("kernel log parsing", () => {
+  test("parses dmesg --json and plain dmesg into the same entries", () => {
+    const json = `{"dmesg":[{"pri":3,"time":  44170.542000,"msg":${JSON.stringify(TOOL_KILL)}},{"pri":6,"time":44171.0,"msg":"x"}]}`;
+    const text = `[44170.542000] ${TOOL_KILL}\n[   44171.000000] x\n`;
+    expect(parseDmesgJson(json)).toEqual(parseDmesgText(text));
+    expect(parseDmesgJson("not json")).toBeNull();
+  });
+
+  test("extracts victims, sizes and oom_score_adj, oldest first, ignoring noise", () => {
+    const kills = oomKillsFromEntries([
+      entry(30, NOISE[0]),
+      entry(50, LEGACY_KILL),
+      entry(31, TOOL_KILL),
+      entry(32, NOISE[1]),
+    ]);
+    expect(kills).toEqual([
+      {
+        time: 31,
+        pid: 4242,
+        comm: "python3",
+        oomScoreAdj: 1000,
+        anonRssKb: 409600,
+        totalVmKb: 1263184,
+      },
+      {
+        time: 50,
+        pid: 77,
+        comm: "node",
+        oomScoreAdj: null,
+        anonRssKb: 300000,
+        totalVmKb: 500000,
+      },
+    ]);
+  });
+});
+
+describe("createOomKillReporter", () => {
+  let dir: string;
+  let recorded: Array<{ value?: number | null; detail?: unknown }>;
+  let reads: number;
+  let recordOk: boolean;
+  let consent: boolean | null;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "oom-kill-reporter-"));
+    recorded = [];
+    reads = 0;
+    recordOk = true;
+    consent = true;
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  function reporter(
+    log: () => KernelLogEntry[] | null,
+    bootId: string | null = "boot-a",
+  ) {
+    return createOomKillReporter({
+      readKernelLog: async () => {
+        reads++;
+        return log();
+      },
+      readBootId: () => bootId,
+      shareAnalytics: () => consent,
+      cursorPath: join(dir, "cursor.json"),
+      record: (record) => {
+        if (!recordOk) {
+          return null;
+        }
+        recorded.push(record);
+        return { id: "evt", createdAt: 0 };
+      },
+    });
+  }
+
+  test("attributes the last N new kills to a counter move of N", async () => {
+    const log = () => [
+      entry(10, LEGACY_KILL), // a neighbour container's, before ours
+      entry(20, TOOL_KILL),
+      entry(21, TOOL_KILL),
+    ];
+    const r = reporter(log);
+    await r.check(sample(0), 0, 1); // first scan on an empty-counter container reports what it finds
+    recorded.length = 0;
+
+    const r2 = reporter(() => [
+      ...log(),
+      entry(30, TOOL_KILL),
+      entry(31, TOOL_KILL),
+    ]);
+    // Fresh reporter, same cursor: only the two new kills are fresh, counter says 2.
+    const report = await r2.check(sample(2), 1_000, 1);
+    expect(report).toMatchObject({ attribution: "cgroup_counter", unnamed: 0 });
+    expect(report?.victims.map((v) => v.time)).toEqual([30, 31]);
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0].value).toBe(2);
+  });
+
+  test("first scan reports the kill that preceded the monitor and flags the daemon by score", async () => {
+    const r = reporter(() => [entry(5, DAEMON_KILL)]);
+    const report = await r.check(sample(0), 0, 999);
+    expect(report?.attribution).toBe("kernel_log");
+    expect(recorded[0].detail).toMatchObject({
+      killed_daemon: true,
+      victim_count: 1,
+      memory_limit_bytes: 3_221_225_472,
+    });
+
+    // A second monitor incarnation on the same kernel sees the same log: nothing new.
+    expect(
+      await reporter(() => [entry(5, DAEMON_KILL)]).check(sample(0), 0, 999),
+    ).toBeNull();
+    expect(recorded).toHaveLength(1);
+  });
+
+  test("ignores neighbours' kills when the local counter did not move", async () => {
+    let entries: KernelLogEntry[] = [];
+    const r = reporter(() => entries);
+    await r.check(sample(0), 0, 1);
+
+    entries = [entry(70, LEGACY_KILL)];
+    expect(await r.check(sample(0), 61_000, 1)).toBeNull();
+    expect(recorded).toHaveLength(0);
+
+    // A later local kill is still found, and the neighbour's is not swept in.
+    entries = [entry(70, LEGACY_KILL), entry(80, TOOL_KILL)];
+    const report = await r.check(sample(1), 122_000, 1);
+    expect(report?.victims.map((v) => v.pid)).toEqual([4242]);
+  });
+  test("reports every new kill when there is no counter at all", async () => {
+    const r = reporter(() => [entry(5, TOOL_KILL)]);
+    await r.check(sample(null, false), 0, 1);
+    const r2 = reporter(() => [entry(5, TOOL_KILL), entry(9, LEGACY_KILL)]);
+    const report = await r2.check(sample(null, false), 61_000, 1);
+    expect(report?.attribution).toBe("kernel_log");
+    expect(report?.victims.map((v) => v.pid)).toEqual([77]);
+  });
+
+  test("a counter move with no readable log still produces an event", async () => {
+    const report = await reporter(() => null).check(sample(3), 0, 1);
+    expect(report).toEqual({
+      attribution: "cgroup_counter",
+      victims: [],
+      unnamed: 3,
+    });
+    expect(recorded[0]).toMatchObject({ value: 3 });
+    expect(recorded[0].detail).toMatchObject({
+      unnamed_victims: 3,
+      killed_daemon: false,
+    });
+  });
+
+  test("a rebooted kernel resets the cursor even when the boot id is unreadable", async () => {
+    await reporter(() => [entry(500, TOOL_KILL)], null).check(sample(0), 0, 1);
+    const report = await reporter(() => [entry(5, TOOL_KILL)], null).check(
+      sample(0),
+      0,
+      1,
+    );
+    expect(report?.victims).toHaveLength(1);
+    expect(recorded).toHaveLength(2);
+  });
+
+  test("keeps the cursor and retries when the telemetry store refuses the event", async () => {
+    recordOk = false;
+    const r = reporter(() => [entry(5, TOOL_KILL)]);
+    expect(await r.check(sample(1), 0, 1)).not.toBeNull();
+    expect(recorded).toHaveLength(0);
+
+    recordOk = true;
+    await r.check(sample(0), 1_000, 1);
+    expect(recorded).toHaveLength(1);
+
+    // Now durably acknowledged: a new incarnation does not repeat it.
+    expect(
+      await reporter(() => [entry(5, TOOL_KILL)]).check(sample(0), 0, 1),
+    ).toBeNull();
+    expect(recorded).toHaveLength(1);
+  });
+
+  test("an analytics opt-out advances the cursor without recording", async () => {
+    consent = false;
+    await reporter(() => [entry(5, TOOL_KILL)]).check(sample(1), 0, 1);
+    consent = true;
+    expect(
+      await reporter(() => [entry(5, TOOL_KILL)]).check(sample(0), 0, 1),
+    ).toBeNull();
+    expect(recorded).toHaveLength(0);
+  });
+
+  test("scans on the first tick, on a counter move, and on the fallback cadence", async () => {
+    const r = reporter(() => []);
+    await r.check(sample(0), 0, 1);
+    await r.check(sample(0), 1_000, 1);
+    expect(reads).toBe(1);
+    await r.check(sample(1), 2_000, 1);
+    expect(reads).toBe(2);
+    await r.check(sample(0), 61_999, 1);
+    expect(reads).toBe(2);
+    await r.check(sample(0), 62_000, 1);
+    expect(reads).toBe(3);
+  });
+});

package/src/monitoring/oom-kill-reporter.ts

@@ -0,0 +1,345 @@
+/**
+ * Reports kernel OOM kills in this container as `oom_kill` watchdog events.
+ *
+ * The log comes from `dmesg`, not `/dev/kmsg`: the device is not mounted in
+ * the container, while `dmesg` uses the syslog syscall the container is
+ * allowed. The log is per kernel, not per container, and `/proc/self/cgroup`
+ * reads `/` inside the container, so kills are attributed by the cgroup
+ * `memory.events` counter rather than by cgroup path.
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { getRawShareAnalytics } from "../platform/consent-cache.js";
+import { recordWatchdogEvent } from "../telemetry/watchdog-events-store.js";
+import { getLogger } from "../util/logger.js";
+import { DAEMON_OOM_SCORE_ADJ } from "../util/oom-priority.js";
+import { getMonitoringDataDir } from "../util/platform.js";
+import type { ResourceSample } from "./resource-sample-types.js";
+
+const log = getLogger("oom-kill-reporter");
+
+export const OOM_KILL_CHECK_NAME = "oom_kill";
+const CURSOR_FILENAME = "oom-kill-cursor.json";
+/** Cadence for hosts without `memory.events`. */
+const FALLBACK_SCAN_INTERVAL_MS = 60_000;
+/** The detail bag is capped at 4 KiB server-side. */
+const MAX_VICTIMS_IN_DETAIL = 10;
+const DMESG_TIMEOUT_MS = 5_000;
+
+export interface KernelLogEntry {
+  /** Seconds since boot, monotonic for the life of the kernel. */
+  time: number;
+  msg: string;
+}
+
+export interface OomKill {
+  time: number;
+  pid: number;
+  comm: string;
+  oomScoreAdj: number | null;
+  anonRssKb: number | null;
+  totalVmKb: number | null;
+}
+
+type Attribution = "cgroup_counter" | "kernel_log";
+
+/** `dmesg --json`: `{"dmesg":[{"pri":3,"time":44170.542,"msg":"..."}]}`. */
+export function parseDmesgJson(text: string): KernelLogEntry[] | null {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    const rows = (parsed as { dmesg?: unknown }).dmesg;
+    if (!Array.isArray(rows)) {
+      return null;
+    }
+    const entries: KernelLogEntry[] = [];
+    for (const row of rows) {
+      const { time, msg } = row as { time?: unknown; msg?: unknown };
+      if (typeof time === "number" && typeof msg === "string") {
+        entries.push({ time, msg });
+      }
+    }
+    return entries;
+  } catch {
+    return null;
+  }
+}
+
+/** Plain `dmesg`: `[   44170.542000] message` per line. */
+export function parseDmesgText(text: string): KernelLogEntry[] {
+  const entries: KernelLogEntry[] = [];
+  for (const line of text.split("\n")) {
+    const match = /^\[\s*(\d+\.\d+)\]\s?(.*)$/.exec(line);
+    if (match) {
+      entries.push({ time: parseFloat(match[1]), msg: match[2] });
+    }
+  }
+  return entries;
+}
+
+const OOM_KILL_RE = /[Oo]ut of memory: Killed process (\d+) \(([^)]*)\)(.*)$/;
+
+function kb(fields: string, key: string): number | null {
+  const match = new RegExp(`${key}:(\\d+)kB`).exec(fields);
+  return match ? parseInt(match[1], 10) : null;
+}
+
+export function oomKillsFromEntries(entries: KernelLogEntry[]): OomKill[] {
+  const kills: OomKill[] = [];
+  for (const entry of entries) {
+    const kill = OOM_KILL_RE.exec(entry.msg);
+    if (!kill) {
+      continue;
+    }
+    const fields = kill[3];
+    const adj = /oom_score_adj:(-?\d+)/.exec(fields);
+    kills.push({
+      time: entry.time,
+      pid: parseInt(kill[1], 10),
+      comm: kill[2],
+      oomScoreAdj: adj ? parseInt(adj[1], 10) : null,
+      anonRssKb: kb(fields, "anon-rss"),
+      totalVmKb: kb(fields, "total-vm"),
+    });
+  }
+  return kills.sort((a, b) => a.time - b.time);
+}
+
+/** Null when `dmesg` is absent or lacks CAP_SYSLOG. */
+export async function readKernelLog(): Promise<KernelLogEntry[] | null> {
+  if (process.platform !== "linux") {
+    return null;
+  }
+  const run = async (args: string[]): Promise<string | null> => {
+    try {
+      const proc = Bun.spawn(["dmesg", ...args], {
+        stdout: "pipe",
+        stderr: "ignore",
+        windowsHide: true,
+        timeout: DMESG_TIMEOUT_MS,
+      });
+      const text = await new Response(proc.stdout).text();
+      return (await proc.exited) === 0 ? text : null;
+    } catch {
+      return null;
+    }
+  };
+  const json = await run(["--json"]);
+  const fromJson = json != null ? parseDmesgJson(json) : null;
+  if (fromJson) {
+    return fromJson;
+  }
+  const text = await run([]);
+  return text != null ? parseDmesgText(text) : null;
+}
+
+function readBootId(): string | null {
+  try {
+    return readFileSync("/proc/sys/kernel/random/boot_id", "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+
+interface Cursor {
+  bootId: string | null;
+  lastTime: number;
+}
+
+function readCursor(path: string): Cursor | null {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as Partial<Cursor>;
+    if (typeof parsed.lastTime === "number") {
+      return { bootId: parsed.bootId ?? null, lastTime: parsed.lastTime };
+    }
+  } catch {
+    // Missing or unreadable.
+  }
+  return null;
+}
+
+function writeCursor(path: string, cursor: Cursor): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(cursor));
+}
+
+export interface OomKillReporterOptions {
+  readKernelLog?: () => Promise<KernelLogEntry[] | null>;
+  readBootId?: () => string | null;
+  shareAnalytics?: () => boolean | null;
+  cursorPath?: string;
+  record?: typeof recordWatchdogEvent;
+}
+
+export interface OomKillReport {
+  attribution: Attribution;
+  victims: OomKill[];
+  /** Kills the counter saw that the log could not name. */
+  unnamed: number;
+}
+
+export interface OomKillReporter {
+  /** Returns what was queued, for tests. */
+  check(
+    sample: ResourceSample,
+    now: number,
+    daemonPid: number | null,
+  ): Promise<OomKillReport | null>;
+}
+
+export function createOomKillReporter(
+  options: OomKillReporterOptions = {},
+): OomKillReporter {
+  const read = options.readKernelLog ?? readKernelLog;
+  const bootId = options.readBootId ?? readBootId;
+  const shareAnalytics = options.shareAnalytics ?? getRawShareAnalytics;
+  const cursorPath =
+    options.cursorPath ?? join(getMonitoringDataDir(), CURSOR_FILENAME);
+  const record = options.record ?? recordWatchdogEvent;
+
+  let firstScan = true;
+  let lastScanAt = 0;
+  /** A report the telemetry store refused; retried before the next scan. */
+  let pending: {
+    report: OomKillReport;
+    sample: ResourceSample;
+    daemonPid: number | null;
+    cursor: Cursor;
+  } | null = null;
+
+  const queue = (
+    report: OomKillReport,
+    sample: ResourceSample,
+    daemonPid: number | null,
+    cursor: Cursor,
+  ): boolean => {
+    if (shareAnalytics() === false) {
+      writeCursor(cursorPath, cursor);
+      return true;
+    }
+    const killedDaemon = report.victims.some(
+      (kill) =>
+        kill.oomScoreAdj === DAEMON_OOM_SCORE_ADJ ||
+        (daemonPid != null && kill.pid === daemonPid),
+    );
+    const detail = {
+      attribution: report.attribution,
+      victim_count: report.victims.length + report.unnamed,
+      unnamed_victims: report.unnamed,
+      victims: report.victims.slice(-MAX_VICTIMS_IN_DETAIL).map((kill) => ({
+        pid: kill.pid,
+        comm: kill.comm,
+        oom_score_adj: kill.oomScoreAdj,
+        anon_rss_kb: kill.anonRssKb,
+        total_vm_kb: kill.totalVmKb,
+      })),
+      daemon_pid: daemonPid,
+      killed_daemon: killedDaemon,
+      memory_current_bytes: sample.memory?.currentBytes ?? null,
+      memory_limit_bytes: sample.memory?.limitBytes ?? null,
+      memory_peak_bytes: sample.memory?.peakBytes ?? null,
+    };
+    const queued = record({
+      checkName: OOM_KILL_CHECK_NAME,
+      value: detail.victim_count,
+      detail,
+    });
+    if (!queued) {
+      return false;
+    }
+    writeCursor(cursorPath, cursor);
+    log.warn(detail, "Kernel OOM kill in the assistant container");
+    return true;
+  };
+
+  return {
+    async check(sample, now, daemonPid) {
+      if (pending) {
+        if (
+          !queue(
+            pending.report,
+            pending.sample,
+            pending.daemonPid,
+            pending.cursor,
+          )
+        ) {
+          return null;
+        }
+        pending = null;
+      }
+
+      const counterDelta = sample.deltas?.events?.oomKill ?? 0;
+      const countersAvailable = sample.events != null;
+      if (
+        !firstScan &&
+        counterDelta === 0 &&
+        now - lastScanAt < FALLBACK_SCAN_INTERVAL_MS
+      ) {
+        return null;
+      }
+      const isFirstScan = firstScan;
+      firstScan = false;
+      lastScanAt = now;
+
+      const entries = await read();
+      const currentBootId = bootId();
+      if (entries == null) {
+        if (counterDelta === 0) {
+          return null;
+        }
+        const report: OomKillReport = {
+          attribution: "cgroup_counter",
+          victims: [],
+          unnamed: counterDelta,
+        };
+        const cursor = { bootId: currentBootId, lastTime: 0 };
+        if (!queue(report, sample, daemonPid, cursor)) {
+          pending = { report, sample, daemonPid, cursor };
+        }
+        return report;
+      }
+
+      const all = oomKillsFromEntries(entries);
+      const maxTime = all.length > 0 ? all[all.length - 1].time : 0;
+      const stored = readCursor(cursorPath);
+      // A different boot id, or a log that has not yet reached the stored
+      // timestamp, means the kernel restarted and the cursor is stale.
+      const sameBoot =
+        stored != null &&
+        stored.bootId === currentBootId &&
+        maxTime >= stored.lastTime;
+      const sinceTime = sameBoot ? stored.lastTime : -1;
+      const fresh = all.filter((kill) => kill.time > sinceTime);
+      const cursor: Cursor = {
+        bootId: currentBootId,
+        lastTime: Math.max(sinceTime, maxTime),
+      };
+
+      let report: OomKillReport | null = null;
+      // The counter says how many were ours; older new kills are neighbours'.
+      if (counterDelta > 0) {
+        report = {
+          attribution: "cgroup_counter",
+          victims: fresh.slice(-counterDelta),
+          unnamed: Math.max(0, counterDelta - fresh.length),
+        };
+      } else if ((isFirstScan || !countersAvailable) && fresh.length > 0) {
+        // No counter to lean on: a kill that took the daemon down restarted
+        // this monitor with it, and the new container's counter starts at 0.
+        report = { attribution: "kernel_log", victims: fresh, unnamed: 0 };
+      }
+
+      if (report == null) {
+        if (!sameBoot || cursor.lastTime !== stored?.lastTime) {
+          writeCursor(cursorPath, cursor);
+        }
+        return null;
+      }
+      if (!queue(report, sample, daemonPid, cursor)) {
+        pending = { report, sample, daemonPid, cursor };
+      }
+      return report;
+    },
+  };
+}

package/src/monitoring/resource-sampler.ts

@@ -47,6 +47,7 @@ import { readActiveConversations } from "./active-conversations.js";
 import { readDaemonHeartbeat } from "./daemon-heartbeat.js";
 import { topProcessesByFd } from "./file-descriptors.js";
 import { sweepInheritedOomProtection } from "./oom-inheritance-sweep.js";
+import { createOomKillReporter } from "./oom-kill-reporter.js";
 import { getTrackedDataFiles, readFileResidency } from "./page-cache.js";
 import { topProcessesByMemory } from "./process-memory.js";
 import {
@@ -267,6 +268,7 @@ export function startResourceSampler(
   // thread's kernel state mid-stall when the heartbeat goes stale.
   const stallCapture = createStallCaptureMonitor(dataDir);
   const processUsage = createProcessUsageTracker();
+  const oomKills = createOomKillReporter();
   let lastOomSweepAt = 0;
 
   // Skip ticks while a sample is in flight: the disk measurement can take
@@ -306,6 +308,12 @@ export function startResourceSampler(
       log.warn({ err }, "Daemon stall check failed");
     }
 
+    try {
+      await oomKills.check(sample, now, readDaemonHeartbeat(now)?.pid ?? null);
+    } catch (err) {
+      log.warn({ err }, "OOM kill report failed");
+    }
+
     if (now - lastOomSweepAt >= OOM_SWEEP_INTERVAL_MS) {
       lastOomSweepAt = now;
       const daemonPid = readDaemonHeartbeat(now)?.pid;

package/src/runtime/routes/notification-routes.ts

@@ -94,8 +94,7 @@ async function handleEmitSignal({ body = {} }: RouteHandlerArgs) {
       parsed.error.issues[0]?.message ?? "Invalid signal parameters",
     );
   }
-  const validated = parsed.data;
-  const result = await emitNotificationSignal(validated);
+  const result = await emitNotificationSignal(parsed.data);
   return {
     signalId: result.signalId,
     dispatched: result.dispatched,

package/src/runtime/verification-templates.ts

@@ -174,8 +174,7 @@ export function composeVerificationText(
   templateKey: TextVerifyTemplateKey,
   vars: GuardianVerifyTemplateVars,
 ): string {
-  const composer = templates[templateKey];
-  return composer(vars);
+  return templates[templateKey](vars);
 }
 
 // ---------------------------------------------------------------------------

package/src/tools/browser/browser-execution.ts

@@ -287,8 +287,7 @@ export const EXTRACT_LINKS_EXPRESSION = `
 export function parseBrowserMode(
   input: Record<string, unknown>,
 ): { ok: true; mode: BrowserMode } | { ok: false; error: string } {
-  const raw = input.browser_mode;
-  const result = normalizeBrowserMode(raw);
+  const result = normalizeBrowserMode(input.browser_mode);
   if ("error" in result) {
     return { ok: false, error: `Error: ${result.error}` };
   }
@@ -2672,9 +2671,11 @@ async function checkExtensionModeStatus(
   context: ToolContext,
   autoCandidate: boolean,
 ): Promise<BrowserStatusModeResult> {
-  const proxy = HostBrowserProxy.instance;
-
-  if (!proxy.hasExtensionClient(context.sourceActorPrincipalId)) {
+  if (
+    !HostBrowserProxy.instance.hasExtensionClient(
+      context.sourceActorPrincipalId,
+    )
+  ) {
     return {
       mode: BROWSER_STATUS_MODE.EXTENSION,
       available: false,

package/src/tools/executor.ts

@@ -482,8 +482,7 @@ export function computePerToolTimeoutMs(
     const { questionResponseTimeoutSec } = getConfig().timeouts;
     return (questionResponseTimeoutSec + 5) * 1000;
   }
-  const rawTimeoutSec = getConfig().timeouts.toolExecutionTimeoutSec;
-  return safeTimeoutMs(rawTimeoutSec);
+  return safeTimeoutMs(getConfig().timeouts.toolExecutionTimeoutSec);
 }
 
 /**

package/src/tools/network/web-fetch.ts

@@ -1530,9 +1530,8 @@ export async function executeFastcrwScrape(
   input: Record<string, unknown>,
   options: { apiKey: string; signal?: AbortSignal },
 ): Promise<ToolExecutionResult> {
-  const apiBase = getConfig().services["web-fetch"]?.apiBase;
   const endpoint = resolveProviderApiUrl(
-    apiBase,
+    getConfig().services["web-fetch"]?.apiBase,
     FASTCRW_SCRAPE_PATH,
     FASTCRW_DEFAULT_API_BASE,
   );
@@ -1587,9 +1586,8 @@ export async function executeTinyfishFetch(
     1,
     MAX_TIMEOUT_SECONDS,
   );
-  const apiBase = getConfig().services["web-fetch"]?.apiBase;
   const endpoint = resolveProviderApiUrl(
-    apiBase,
+    getConfig().services["web-fetch"]?.apiBase,
     "/",
     TINYFISH_DEFAULT_FETCH_API_BASE,
   );

package/src/tools/network/web-search.ts

@@ -236,8 +236,11 @@ function getWebSearchProvider(): WebSearchProvider {
 async function getApiKey(
   provider: WebSearchProvider,
 ): Promise<string | undefined> {
-  const adapter = WEB_SEARCH_ADAPTERS[provider];
-  return (await getProviderKeyAsync(adapter.providerKeyName)) ?? undefined;
+  return (
+    (await getProviderKeyAsync(
+      WEB_SEARCH_ADAPTERS[provider].providerKeyName,
+    )) ?? undefined
+  );
 }
 
 function fallbackProvidersFor(
@@ -1517,9 +1520,8 @@ function executeFastcrwSearch(
   apiKey: string,
   signal?: AbortSignal,
 ): Promise<ToolExecutionResult> {
-  const apiBase = getConfig().services["web-search"]?.apiBase;
   const endpoint = resolveProviderApiUrl(
-    apiBase,
+    getConfig().services["web-search"]?.apiBase,
     FASTCRW_SEARCH_PATH,
     FASTCRW_DEFAULT_API_BASE,
   );
@@ -1779,9 +1781,8 @@ async function executeTinyfishSearch(
   signal?: AbortSignal,
 ): Promise<ToolExecutionResult> {
   const startedAt = Date.now();
-  const apiBase = getConfig().services["web-search"]?.apiBase;
   const endpoint = resolveProviderApiUrl(
-    apiBase,
+    getConfig().services["web-search"]?.apiBase,
     "/",
     TINYFISH_DEFAULT_SEARCH_API_BASE,
   );
@@ -2274,8 +2275,10 @@ export const webSearchTool = {
         // `mode: "managed"` did for installs that never configured a search
         // key. Read the configured provider off config — the local `provider`
         // has already been coerced to "perplexity".
-        const configured = getConfig().services["web-search"].provider;
-        if (configured === "inference-provider-native") {
+        if (
+          getConfig().services["web-search"].provider ===
+          "inference-provider-native"
+        ) {
           const { managedSearchAvailable } =
             await import("./managed-search-proxy.js");
           if (await managedSearchAvailable()) {

package/src/tools/shared/filesystem/format-diff.ts

@@ -23,6 +23,5 @@ export function formatWriteSummary(
   if (isNewFile) {
     return `(new file, ${newLineCount} line${newLineCount !== 1 ? "s" : ""})`;
   }
-  const oldLineCount = oldContent.split("\n").length;
-  return `(${oldLineCount} → ${newLineCount} lines)`;
+  return `(${oldContent.split("\n").length} → ${newLineCount} lines)`;
 }

package/src/tools/ui-surface/visual-validation.ts

@@ -302,8 +302,7 @@ function collectSurfaceFillOnTextProblems(html: string): string[] {
   const offenders: string[] = [];
   for (const rule of html.matchAll(/([^{}<>]{1,120})\{([^{}]*)\}/g)) {
     const selector = rule[1].trim();
-    const body = rule[2];
-    if (!/fill\s*:\s*var\(--surface-/.test(body)) {
+    if (!/fill\s*:\s*var\(--surface-/.test(rule[2])) {
       continue;
     }
     if (SHAPE_SCOPED_SELECTOR_PATTERN.test(selector)) {