@vellumai/assistant 0.12.5-dev.202609281913.10969f6 → 0.12.5-dev.202609282115.bb92e6d

package/ARCHITECTURE.md

@@ -49,7 +49,7 @@ 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.
+**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 log is shared by every container on that kernel, so a kill is attributed by the cgroup path in the kernel's `oom-kill:` header, matched against the container's own id, which it reads from the runtime-named mounts in `/proc/self/mountinfo` because `/proc/self/cgroup` reads `/` inside a cgroup namespace (`attribution: "cgroup"`). The kernel rate-limits that header in a burst, so header-less kills are attributed by the counter, re-read after the log: credit left after the header-attributed kills names header-less kills oldest first, header-less kills beyond the credit are another container's, and credit for a kill counted but not yet logged is spent on the next scan or reported unnamed (`attribution: "cgroup_counter"`). The first scan and hosts without the counter claim every new kill not assigned elsewhere by a header (`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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.5-dev.202609281913.10969f6",
+  "version": "0.12.5-dev.202609282115.bb92e6d",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/cli/lib/bundled-marketplace.json

@@ -135,6 +135,19 @@
       "homepage": "https://github.com/topoteretes/cognee-integrations/tree/main/integrations/vellum-assistant",
       "icon": "\ud83d\udd78\ufe0f"
     },
+    {
+      "name": "contractor-missed-call-dispatcher",
+      "description": "Captures missed trade contractor inbound calls, fires an instant 5-second SMS qualification text-back, triages emergencies, and stages draft jobs in Jobber or ServiceTitan.",
+      "category": "commerce",
+      "icon": "📲",
+      "license": "MIT",
+      "homepage": "https://github.com/ZeebBoyBlue/contractor-missed-call-dispatcher",
+      "source": {
+        "source": "github",
+        "repo": "ZeebBoyBlue/contractor-missed-call-dispatcher",
+        "ref": "2d293cdcb68af03d446b61a9915a0ee3dc842d4e"
+      }
+    },
     {
       "name": "contractor-voice-invoicer",
       "description": "Converts 20-second truck voice memos and job photos into itemized client invoices with custom labor rates, material markups, and one-click accounting staging.",

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

@@ -9,21 +9,41 @@ import {
   oomKillsFromEntries,
   parseDmesgJson,
   parseDmesgText,
+  parseOwnContainerIds,
 } 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 OUR_ID =
+  "de939a251b36f11a400aab40a43b756ca376056239227aec2795953ca219e7d5";
+const OTHER_ID =
+  "0f4c3b2a1908f7e6d5c4b3a29180f7e6d5c4b3a29180f7e6d5c4b3a29180f7e6";
+const memcg = (id: string) =>
+  `/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-poda5d2033b.slice/cri-containerd-${id}.scope`;
+
+const header = (pid: number, comm: string, id: string) =>
+  `oom-kill:constraint=CONSTRAINT_MEMCG,nodemask=(null),cpuset=cri-containerd-${id}.scope,mems_allowed=0,oom_memcg=${memcg(id)},task_memcg=${memcg(id)},task=${comm},pid=${pid},uid=0`;
+const killed = (
+  pid: number,
+  comm: string,
+  adj: number | null,
+  anonKb = 409600,
+) =>
+  `Memory cgroup out of memory: Killed process ${pid} (${comm}) total-vm:1263184kB, anon-rss:${anonKb}kB, file-rss:1024kB, shmem-rss:0kB, UID:0 pgtables:900kB${adj == null ? "" : ` oom_score_adj:${adj}`}`;
 
 const entry = (time: number, msg: string): KernelLogEntry => ({ time, msg });
+/** A kill with its header, as the kernel logs it when not rate-limited. */
+const ourKill = (time: number, pid: number, adj = 1000): KernelLogEntry[] => [
+  entry(time - 0.00001, header(pid, "python3", OUR_ID)),
+  entry(time, killed(pid, "python3", adj)),
+];
+const theirKill = (time: number, pid: number): KernelLogEntry[] => [
+  entry(time - 0.00001, header(pid, "node", OTHER_ID)),
+  entry(time, killed(pid, "node", 0)),
+];
+/** A kill whose header the kernel rate-limited away. */
+const bareKill = (time: number, pid: number): KernelLogEntry[] => [
+  entry(time, killed(pid, "python3", 1000)),
+];
 
 function sample(
   oomKillDelta: number | null,
@@ -57,18 +77,22 @@ function sample(
 
 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`;
+    const msg = killed(4242, "python3", 1000);
+    const json = `{"dmesg":[{"pri":3,"time":  44170.542000,"msg":${JSON.stringify(msg)}},{"pri":6,"time":44171.0,"msg":"x"}]}`;
+    const text = `[44170.542000] ${msg}\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", () => {
+  test("pairs each kill with its header and tolerates missing headers and noise", () => {
     const kills = oomKillsFromEntries([
-      entry(30, NOISE[0]),
-      entry(50, LEGACY_KILL),
-      entry(31, TOOL_KILL),
-      entry(32, NOISE[1]),
+      entry(
+        30,
+        "bun invoked oom-killer: gfp_mask=0xcc0(GFP_KERNEL), order=0, oom_score_adj=-700",
+      ),
+      ...ourKill(31, 4242),
+      entry(32, "oom_reaper: reaped process 4242 (python3), now anon-rss:0kB"),
+      entry(50, killed(77, "node", null, 300000)),
     ]);
     expect(kills).toEqual([
       {
@@ -78,6 +102,7 @@ describe("kernel log parsing", () => {
         oomScoreAdj: 1000,
         anonRssKb: 409600,
         totalVmKb: 1263184,
+        memcg: memcg(OUR_ID),
       },
       {
         time: 50,
@@ -85,10 +110,22 @@ describe("kernel log parsing", () => {
         comm: "node",
         oomScoreAdj: null,
         anonRssKb: 300000,
-        totalVmKb: 500000,
+        totalVmKb: 1263184,
+        memcg: null,
       },
     ]);
   });
+
+  test("finds the container id in the runtime-named mounts only", () => {
+    const layer =
+      "aaaa000000000000000000000000000000000000000000000000000000000000";
+    const mountinfo = [
+      `151 137 0:34 /${OUR_ID}-1f3ead8083566ffb-hosts /etc/hosts rw,relatime - virtiofs kataShared rw`,
+      `152 139 0:34 /${OUR_ID}-175b29da4eda0e77-termination-log /dev/termination-log rw,relatime - virtiofs kataShared rw`,
+      `140 120 0:30 / / rw,relatime - overlay overlay rw,lowerdir=/var/lib/x/${layer}/fs`,
+    ].join("\n");
+    expect(parseOwnContainerIds(mountinfo)).toEqual(new Set([OUR_ID]));
+  });
 });
 
 describe("createOomKillReporter", () => {
@@ -97,6 +134,8 @@ describe("createOomKillReporter", () => {
   let reads: number;
   let recordOk: boolean;
   let consent: boolean | null;
+  let killCounter: number | null;
+  let entries: KernelLogEntry[] | null;
 
   beforeEach(() => {
     dir = mkdtempSync(join(tmpdir(), "oom-kill-reporter-"));
@@ -104,21 +143,22 @@ describe("createOomKillReporter", () => {
     reads = 0;
     recordOk = true;
     consent = true;
+    killCounter = 0;
+    entries = [];
   });
 
   afterEach(() => {
     rmSync(dir, { recursive: true, force: true });
   });
 
-  function reporter(
-    log: () => KernelLogEntry[] | null,
-    bootId: string | null = "boot-a",
-  ) {
+  function reporter(bootId: string | null = "boot-a") {
     return createOomKillReporter({
       readKernelLog: async () => {
         reads++;
-        return log();
+        return entries;
       },
+      readKillCounter: () => killCounter,
+      readOwnContainerIds: () => new Set([OUR_ID]),
       readBootId: () => bootId,
       shareAnalytics: () => consent,
       cursorPath: join(dir, "cursor.json"),
@@ -132,32 +172,93 @@ describe("createOomKillReporter", () => {
     });
   }
 
-  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]);
+  const pids = (report: { victims: { pid: number }[] } | null) =>
+    report?.victims.map((v) => v.pid) ?? [];
+
+  test("attributes by the header's cgroup regardless of order or count", async () => {
+    const r = reporter();
+    await r.check(sample(0), 0, 1);
+
+    entries = [...theirKill(70, 900), ...ourKill(80, 4242)];
+    killCounter = 1;
+    const report = await r.check(sample(1), 1_000, 1);
+    expect(report?.attribution).toBe("cgroup");
+    expect(pids(report)).toEqual([4242]);
+    expect(recorded[0].detail).toMatchObject({ killed_daemon: false });
+  });
+
+  test("uses the counter for header-less kills, oldest first; the rest are neighbours'", async () => {
+    const r = reporter();
+    await r.check(sample(0), 0, 1);
+
+    entries = [...bareKill(20, 1), ...bareKill(21, 2), ...bareKill(22, 3)];
+    killCounter = 2;
+    const first = await r.check(sample(2), 1_000, 1);
+    expect(first).toMatchObject({ attribution: "cgroup_counter", unnamed: 0 });
+    expect(pids(first)).toEqual([1, 2]);
+
+    // The third was logged but not counted, so it was another container's.
+    expect(await r.check(sample(0), 61_000, 1)).toBeNull();
     expect(recorded).toHaveLength(1);
-    expect(recorded[0].value).toBe(2);
+  });
+  test("spends counter credit on the next scan and reports it unnamed only if unspent", async () => {
+    const r = reporter();
+    await r.check(sample(0), 0, 1);
+
+    // The kill is counted but its line is not yet visible: nothing to say yet.
+    killCounter = 1;
+    expect(await r.check(sample(1), 1_000, 1)).toBeNull();
+
+    entries = [...bareKill(5, 1)];
+    const spent = await r.check(sample(0), 61_000, 1);
+    expect(spent).toMatchObject({ attribution: "cgroup_counter", unnamed: 0 });
+    expect(pids(spent)).toEqual([1]);
+
+    // Credit that never finds a line is reported unnamed after one scan.
+    killCounter = 2;
+    expect(await r.check(sample(1), 62_000, 1)).toBeNull();
+    const expired = await r.check(sample(0), 123_000, 1);
+    expect(expired).toEqual({
+      attribution: "cgroup_counter",
+      victims: [],
+      unnamed: 1,
+    });
+  });
+  test("names every victim of a burst where the kernel rate-limits headers", async () => {
+    const r = reporter();
+    await r.check(sample(0), 0, 1);
+
+    const victims = [468, 472, 474, 477, 476, 467, 480, 471, 478, 473, 481];
+    const headerless = new Set([474, 468]);
+    const perKill = victims.map((pid, i) =>
+      headerless.has(pid)
+        ? bareKill(216386 + i * 0.15, pid)
+        : ourKill(216386 + i * 0.15, pid),
+    );
+    // Kills visible in the log, then the counter read after them, per tick.
+    const ticks: Array<[number, number]> = [
+      [2, 2],
+      [5, 6],
+      [8, 8],
+      [11, 11],
+    ];
+    const named: number[] = [];
+    let t = 1_000;
+    for (const [visible, counter] of ticks) {
+      entries = perKill.slice(0, visible).flat();
+      killCounter = counter;
+      const report = await r.check(sample(1), (t += 250), 1);
+      named.push(...pids(report));
+    }
+    expect([...named].sort((a, b) => a - b)).toEqual(
+      [...victims].sort((a, b) => a - b),
+    );
+    expect(recorded.reduce((n, e) => n + (e.value ?? 0), 0)).toBe(11);
   });
 
   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);
+    entries = [...ourKill(5, 1, -700)];
+    const report = await reporter().check(sample(0), 0, 999);
     expect(report?.attribution).toBe("kernel_log");
     expect(recorded[0].detail).toMatchObject({
       killed_daemon: true,
@@ -165,90 +266,101 @@ describe("createOomKillReporter", () => {
       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();
+    // A second incarnation on the same kernel sees the same log: nothing new.
+    expect(await reporter().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);
+  test("first scan still excludes kills the header assigns elsewhere", async () => {
+    entries = [...theirKill(4, 900), ...ourKill(5, 1)];
+    expect(pids(await reporter().check(sample(0), 0, 1))).toEqual([1]);
+  });
 
-    entries = [entry(70, LEGACY_KILL)];
+  test("ignores header-less neighbours' kills when the local counter did not move", async () => {
+    const r = reporter();
+    await r.check(sample(0), 0, 1);
+    entries = [...bareKill(70, 900)];
     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);
+    killCounter = null;
+    entries = [...bareKill(5, 1)];
+    await reporter().check(sample(null, false), 0, 1);
+    entries = [...bareKill(5, 1), ...bareKill(9, 2)];
+    const report = await reporter().check(sample(null, false), 61_000, 1);
     expect(report?.attribution).toBe("kernel_log");
-    expect(report?.victims.map((v) => v.pid)).toEqual([77]);
+    expect(pids(report)).toEqual([2]);
   });
 
-  test("a counter move with no readable log still produces an event", async () => {
-    const report = await reporter(() => null).check(sample(3), 0, 1);
+  test("skips a scan when a counter that exists fails to read", async () => {
+    const r = reporter();
+    await r.check(sample(0), 0, 1);
+    entries = [...bareKill(70, 900)];
+    killCounter = null;
+    expect(await r.check(sample(1), 1_000, 1)).toBeNull();
+    expect(recorded).toHaveLength(0);
+    // The scan was not consumed: the kill is still claimable once the counter reads.
+    killCounter = 1;
+    expect(pids(await r.check(sample(0), 1_250, 1))).toEqual([900]);
+  });
+
+  test("a counter move with no readable log still produces an event, and does not double-count later", async () => {
+    entries = null;
+    killCounter = 3;
+    const r = reporter();
+    const report = await r.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,
-    });
+
+    entries = [...bareKill(1, 1), ...bareKill(2, 2), ...bareKill(3, 3)];
+    expect(await r.check(sample(0), 61_000, 1)).toBeNull();
+    expect(recorded).toHaveLength(1);
   });
 
   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,
-    );
+    entries = [...bareKill(500, 1)];
+    await reporter(null).check(sample(0), 0, 1);
+    entries = [...bareKill(5, 1)];
+    const report = await reporter(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 () => {
+    const r = reporter();
+    await r.check(sample(0), 0, 1);
     recordOk = false;
-    const r = reporter(() => [entry(5, TOOL_KILL)]);
-    expect(await r.check(sample(1), 0, 1)).not.toBeNull();
+    entries = [...ourKill(5, 1)];
+    killCounter = 1;
+    expect(await r.check(sample(1), 1_000, 1)).not.toBeNull();
     expect(recorded).toHaveLength(0);
 
     recordOk = true;
-    await r.check(sample(0), 1_000, 1);
+    await r.check(sample(0), 2_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();
+    // Durably acknowledged: a new incarnation does not repeat it.
+    expect(await reporter().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);
+    entries = [...ourKill(5, 1)];
+    await reporter().check(sample(0), 0, 1);
     consent = true;
-    expect(
-      await reporter(() => [entry(5, TOOL_KILL)]).check(sample(0), 0, 1),
-    ).toBeNull();
+    expect(await reporter().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(() => []);
+    const r = reporter();
     await r.check(sample(0), 0, 1);
     await r.check(sample(0), 1_000, 1);
     expect(reads).toBe(1);

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

@@ -3,9 +3,12 @@
  *
  * 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.
+ * allowed. The log is per kernel, not per container. A kill is this
+ * container's when the kernel's `oom-kill:` header names a cgroup carrying
+ * this container's id, which the container learns from its own mount table
+ * since `/proc/self/cgroup` reads `/` inside a cgroup namespace. The kernel
+ * rate-limits that header in a burst, so header-less kills fall back to the
+ * cgroup `memory.events` counter.
  */
 
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -13,6 +16,7 @@ import { dirname, join } from "node:path";
 
 import { getRawShareAnalytics } from "../platform/consent-cache.js";
 import { recordWatchdogEvent } from "../telemetry/watchdog-events-store.js";
+import { getContainerMemoryEvents } from "../util/cgroup-memory.js";
 import { getLogger } from "../util/logger.js";
 import { DAEMON_OOM_SCORE_ADJ } from "../util/oom-priority.js";
 import { getMonitoringDataDir } from "../util/platform.js";
@@ -27,6 +31,13 @@ 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;
+/** Mounts whose source path the container runtime names after the container. */
+const CONTAINER_ID_MOUNTPOINTS = new Set([
+  "/etc/hosts",
+  "/etc/hostname",
+  "/etc/resolv.conf",
+  "/dev/termination-log",
+]);
 
 export interface KernelLogEntry {
   /** Seconds since boot, monotonic for the life of the kernel. */
@@ -41,9 +52,11 @@ export interface OomKill {
   oomScoreAdj: number | null;
   anonRssKb: number | null;
   totalVmKb: number | null;
+  /** Victim's cgroup from the `oom-kill:` header; null when the header was rate-limited away. */
+  memcg: string | null;
 }
 
-type Attribution = "cgroup_counter" | "kernel_log";
+type Attribution = "cgroup" | "cgroup_counter" | "kernel_log";
 
 /** `dmesg --json`: `{"dmesg":[{"pri":3,"time":44170.542,"msg":"..."}]}`. */
 export function parseDmesgJson(text: string): KernelLogEntry[] | null {
@@ -79,6 +92,7 @@ export function parseDmesgText(text: string): KernelLogEntry[] {
 }
 
 const OOM_KILL_RE = /[Oo]ut of memory: Killed process (\d+) \(([^)]*)\)(.*)$/;
+const OOM_HEADER_RE = /^oom-kill:.*task_memcg=([^,]*),task=[^,]*,pid=(\d+)/;
 
 function kb(fields: string, key: string): number | null {
   const match = new RegExp(`${key}:(\\d+)kB`).exec(fields);
@@ -86,24 +100,35 @@ function kb(fields: string, key: string): number | null {
 }
 
 export function oomKillsFromEntries(entries: KernelLogEntry[]): OomKill[] {
+  const sorted = [...entries].sort((a, b) => a.time - b.time);
+  // The header precedes its "Killed process" line and names the same pid.
+  const memcgByPid = new Map<number, string>();
   const kills: OomKill[] = [];
-  for (const entry of entries) {
+  for (const entry of sorted) {
+    const header = OOM_HEADER_RE.exec(entry.msg);
+    if (header) {
+      memcgByPid.set(parseInt(header[2], 10), header[1]);
+      continue;
+    }
     const kill = OOM_KILL_RE.exec(entry.msg);
     if (!kill) {
       continue;
     }
+    const pid = parseInt(kill[1], 10);
     const fields = kill[3];
     const adj = /oom_score_adj:(-?\d+)/.exec(fields);
     kills.push({
       time: entry.time,
-      pid: parseInt(kill[1], 10),
+      pid,
       comm: kill[2],
       oomScoreAdj: adj ? parseInt(adj[1], 10) : null,
       anonRssKb: kb(fields, "anon-rss"),
       totalVmKb: kb(fields, "total-vm"),
+      memcg: memcgByPid.get(pid) ?? null,
     });
+    memcgByPid.delete(pid);
   }
-  return kills.sort((a, b) => a.time - b.time);
+  return kills;
 }
 
 /** Null when `dmesg` is absent or lacks CAP_SYSLOG. */
@@ -134,6 +159,33 @@ export async function readKernelLog(): Promise<KernelLogEntry[] | null> {
   return text != null ? parseDmesgText(text) : null;
 }
 
+/**
+ * Container ids from `/proc/self/mountinfo`: the runtime names the source of
+ * the hosts, hostname, resolv.conf and termination-log mounts after the
+ * container (Kata: `<id>-<hash>-hosts`; Docker: `.../containers/<id>/hosts`).
+ */
+export function parseOwnContainerIds(mountinfo: string): Set<string> {
+  const ids = new Set<string>();
+  for (const line of mountinfo.split("\n")) {
+    const fields = line.split(" ");
+    if (fields.length < 5 || !CONTAINER_ID_MOUNTPOINTS.has(fields[4])) {
+      continue;
+    }
+    for (const id of line.match(/[0-9a-f]{64}/g) ?? []) {
+      ids.add(id);
+    }
+  }
+  return ids;
+}
+
+function readOwnContainerIds(): Set<string> {
+  try {
+    return parseOwnContainerIds(readFileSync("/proc/self/mountinfo", "utf-8"));
+  } catch {
+    return new Set();
+  }
+}
+
 function readBootId(): string | null {
   try {
     return readFileSync("/proc/sys/kernel/random/boot_id", "utf-8").trim();
@@ -164,8 +216,20 @@ function writeCursor(path: string, cursor: Cursor): void {
   writeFileSync(path, JSON.stringify(cursor));
 }
 
+function memcgIsOurs(memcg: string, ids: ReadonlySet<string>): boolean {
+  for (const id of ids) {
+    if (memcg.includes(id)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 export interface OomKillReporterOptions {
   readKernelLog?: () => Promise<KernelLogEntry[] | null>;
+  /** Cumulative cgroup oom_kill count, read after the log so it covers every logged kill. */
+  readKillCounter?: () => number | null;
+  readOwnContainerIds?: () => ReadonlySet<string>;
   readBootId?: () => string | null;
   shareAnalytics?: () => boolean | null;
   cursorPath?: string;
@@ -192,6 +256,10 @@ export function createOomKillReporter(
   options: OomKillReporterOptions = {},
 ): OomKillReporter {
   const read = options.readKernelLog ?? readKernelLog;
+  const readKillCounter =
+    options.readKillCounter ??
+    (() => getContainerMemoryEvents()?.oomKill ?? null);
+  const ownIds = options.readOwnContainerIds ?? readOwnContainerIds;
   const bootId = options.readBootId ?? readBootId;
   const shareAnalytics = options.shareAnalytics ?? getRawShareAnalytics;
   const cursorPath =
@@ -200,6 +268,17 @@ export function createOomKillReporter(
 
   let firstScan = true;
   let lastScanAt = 0;
+  let lastKillCounter: number | null = null;
+  /**
+   * Counter credit with no log line yet: the kernel prints the kill line
+   * before it increments the counter, so a kill between the log read and the
+   * counter read is counted but not yet visible. Credit is spent on the next
+   * scan and reported as unnamed if still unspent, so a kill that never logs
+   * a line cannot claim a neighbour's later.
+   */
+  let owed = 0;
+  /** A scan was skipped mid-way; the next tick scans regardless of the sampler. */
+  let scanDue = false;
   /** A report the telemetry store refused; retried before the next scan. */
   let pending: {
     report: OomKillReport;
@@ -269,29 +348,30 @@ export function createOomKillReporter(
         pending = null;
       }
 
-      const counterDelta = sample.deltas?.events?.oomKill ?? 0;
-      const countersAvailable = sample.events != null;
+      const sampleDelta = sample.deltas?.events?.oomKill ?? 0;
       if (
         !firstScan &&
-        counterDelta === 0 &&
+        !scanDue &&
+        sampleDelta === 0 &&
         now - lastScanAt < FALLBACK_SCAN_INTERVAL_MS
       ) {
         return null;
       }
-      const isFirstScan = firstScan;
-      firstScan = false;
-      lastScanAt = now;
+      scanDue = false;
 
       const entries = await read();
       const currentBootId = bootId();
       if (entries == null) {
-        if (counterDelta === 0) {
+        firstScan = false;
+        lastScanAt = now;
+        lastKillCounter = readKillCounter() ?? lastKillCounter;
+        if (sampleDelta === 0) {
           return null;
         }
         const report: OomKillReport = {
           attribution: "cgroup_counter",
           victims: [],
-          unnamed: counterDelta,
+          unnamed: sampleDelta,
         };
         const cursor = { bootId: currentBootId, lastTime: 0 };
         if (!queue(report, sample, daemonPid, cursor)) {
@@ -300,6 +380,23 @@ export function createOomKillReporter(
         return report;
       }
 
+      // Read after the log so the count covers every line the log holds.
+      const killCounter = readKillCounter();
+      if (killCounter == null && sample.events != null) {
+        // One failed read of a counter that exists: try again next tick
+        // rather than treating every kill on the kernel as ours.
+        scanDue = true;
+        return null;
+      }
+      const isFirstScan = firstScan;
+      firstScan = false;
+      lastScanAt = now;
+      const counterDelta =
+        killCounter != null && lastKillCounter != null
+          ? Math.max(0, killCounter - lastKillCounter)
+          : null;
+      lastKillCounter = killCounter ?? lastKillCounter;
+
       const all = oomKillsFromEntries(entries);
       const maxTime = all.length > 0 ? all[all.length - 1].time : 0;
       const stored = readCursor(cursorPath);
@@ -315,19 +412,46 @@ export function createOomKillReporter(
         bootId: currentBootId,
         lastTime: Math.max(sinceTime, maxTime),
       };
+      const ids = ownIds();
 
       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) {
+      if (counterDelta == null || isFirstScan) {
         // 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 };
+        const ours = fresh.filter(
+          (kill) => kill.memcg == null || memcgIsOurs(kill.memcg, ids),
+        );
+        if (ours.length > 0) {
+          report = { attribution: "kernel_log", victims: ours, unnamed: 0 };
+        }
+        owed = 0;
+      } else {
+        const byHeader = fresh.filter(
+          (kill) => kill.memcg != null && memcgIsOurs(kill.memcg, ids),
+        );
+        const unknown = fresh.filter((kill) => kill.memcg == null);
+        // Header-attributed kills spend counter credit first; what is left
+        // names header-less kills oldest first. Header-less kills beyond the
+        // credit are neighbours', since our counter would have covered ours.
+        const carry = owed;
+        let credit = counterDelta + carry - byHeader.length;
+        const byCounter = unknown.slice(0, Math.max(0, credit));
+        credit = Math.max(0, credit - byCounter.length);
+        owed = Math.min(credit, counterDelta);
+        const unnamed = credit - owed;
+        const victims = [...byHeader, ...byCounter].sort(
+          (a, b) => a.time - b.time,
+        );
+        if (victims.length > 0 || unnamed > 0) {
+          report = {
+            attribution:
+              byCounter.length === 0 && unnamed === 0
+                ? "cgroup"
+                : "cgroup_counter",
+            victims,
+            unnamed,
+          };
+        }
       }
 
       if (report == null) {