@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/messaging/providers/telegram-bot/render.ts

@@ -43,7 +43,9 @@ import { parseMarkdown } from "../../content/parse.js";
  * path entirely.
  */
 export function renderTelegramHtml(text: string): string | undefined {
-  if (!text || text.trim().length === 0) return undefined;
+  if (!text || text.trim().length === 0) {
+    return undefined;
+  }
 
   const hast = toHast(parseMarkdown(text), {
     handlers: {
@@ -61,7 +63,9 @@ export function renderTelegramHtml(text: string): string | undefined {
 
   // `toHast` is typed to return any hast node, but a root input always yields a
   // root; the guard narrows the type without changing behaviour.
-  if (hast.type !== "root") return undefined;
+  if (hast.type !== "root") {
+    return undefined;
+  }
 
   telegramizeHast(hast);
 
@@ -116,7 +120,9 @@ function telegramizeHast(root: Root): void {
 
 function processNode(node: Root | Element): void {
   for (const child of node.children) {
-    if (child.type === "element") processNode(child);
+    if (child.type === "element") {
+      processNode(child);
+    }
   }
 
   if (node.type === "element") {
@@ -128,7 +134,9 @@ function processNode(node: Root | Element): void {
         normalizeCodeBlock(node);
         break;
       case "input":
-        if (node.properties) delete node.properties.disabled;
+        if (node.properties) {
+          delete node.properties.disabled;
+        }
         break;
       case "ul":
       case "ol":
@@ -166,7 +174,9 @@ function normalizeCodeBlock(pre: Element): void {
     (child): child is Element =>
       child.type === "element" && child.tagName === "code",
   );
-  if (!code) return;
+  if (!code) {
+    return;
+  }
 
   const last = code.children[code.children.length - 1];
   if (last?.type === "text" && last.value.endsWith("\n")) {
@@ -189,7 +199,9 @@ function normalizeCodeBlock(pre: Element): void {
 
 function stripTaskListClasses(element: Element): void {
   const className = element.properties?.className;
-  if (!Array.isArray(className) || !element.properties) return;
+  if (!Array.isArray(className) || !element.properties) {
+    return;
+  }
   const kept = className.filter(
     (name) => name !== "contains-task-list" && name !== "task-list-item",
   );
@@ -250,7 +262,9 @@ function isImageOnlyParagraph(paragraph: Element): boolean {
   let hasImage = false;
   for (const child of paragraph.children) {
     if (child.type === "text") {
-      if (child.value.trim().length > 0) return false;
+      if (child.value.trim().length > 0) {
+        return false;
+      }
     } else if (child.type === "element" && child.tagName === "img") {
       hasImage = true;
     } else {
@@ -269,11 +283,15 @@ function isImageOnlyParagraph(paragraph: Element): boolean {
  * always left untouched.
  */
 function stripStructuralWhitespace(node: Root | Element): void {
-  if (node.type === "element" && PREFORMATTED_TAGS.has(node.tagName)) return;
+  if (node.type === "element" && PREFORMATTED_TAGS.has(node.tagName)) {
+    return;
+  }
 
   const children = node.children;
   node.children = children.filter((child, index) => {
-    if (child.type !== "text" || child.value.trim().length > 0) return true;
+    if (child.type !== "text" || child.value.trim().length > 0) {
+      return true;
+    }
     const prev = children[index - 1];
     const next = children[index + 1];
     return (
@@ -286,7 +304,11 @@ function stripStructuralWhitespace(node: Root | Element): void {
 }
 
 function isInlineContent(node: RootContent | ElementContent): boolean {
-  if (node.type === "text") return node.value.trim().length > 0;
-  if (node.type === "element") return !BLOCK_TAGS.has(node.tagName);
+  if (node.type === "text") {
+    return node.value.trim().length > 0;
+  }
+  if (node.type === "element") {
+    return !BLOCK_TAGS.has(node.tagName);
+  }
   return false;
 }

package/src/messaging/providers/telegram-bot/send.ts

@@ -70,7 +70,9 @@ function threadIdPayloadFields(
 // ---------------------------------------------------------------------------
 
 function splitText(text: string, maxLen: number): string[] {
-  if (text.length <= maxLen) return [text];
+  if (text.length <= maxLen) {
+    return [text];
+  }
 
   const chunks: string[] = [];
   let cursor = 0;

package/src/messaging/providers/whatsapp/adapter.ts

@@ -28,7 +28,9 @@ async function hasWhatsAppCredentials(): Promise<boolean> {
   const phoneNumberId = await getSecureKeyAsync(
     credentialKey("whatsapp", "phone_number_id"),
   );
-  if (!phoneNumberId) return false;
+  if (!phoneNumberId) {
+    return false;
+  }
   const accessToken = await getSecureKeyAsync(
     credentialKey("whatsapp", "access_token"),
   );

package/src/messaging/providers/whatsapp/api.ts

@@ -67,7 +67,9 @@ function computeDelay(
     const targetTime = new Date(retryAfterHeader).getTime();
     if (Number.isFinite(targetTime)) {
       const delayMs = targetTime - Date.now();
-      if (delayMs > 0) return Math.min(delayMs, 2_147_483_647);
+      if (delayMs > 0) {
+        return Math.min(delayMs, 2_147_483_647);
+      }
     }
   }
   const exponential = initialBackoffMs * Math.pow(2, attempt - 1);
@@ -259,8 +261,12 @@ export async function sendWhatsAppMediaMessage(
   const { phoneNumberId, accessToken } = await resolveCredentials();
 
   const mediaPayload: Record<string, unknown> = { id: mediaId };
-  if (caption) mediaPayload.caption = caption;
-  if (mediaType === "document" && filename) mediaPayload.filename = filename;
+  if (caption) {
+    mediaPayload.caption = caption;
+  }
+  if (mediaType === "document" && filename) {
+    mediaPayload.filename = filename;
+  }
 
   return retryableFetch<WhatsAppSendMessageResult>("sendMediaMessage", () =>
     fetch(`${WHATSAPP_API_BASE}/${phoneNumberId}/messages`, {

package/src/messaging/registry.ts

@@ -29,7 +29,9 @@ export async function getConnectedProviders(): Promise<MessagingProvider[]> {
     const connected = p.isConnected
       ? await p.isConnected()
       : await isProviderConnected(p.credentialService);
-    if (connected) results.push(p);
+    if (connected) {
+      results.push(p);
+    }
   }
   return results;
 }

package/src/messaging/style-analyzer.ts

@@ -103,7 +103,9 @@ const storeStyleAnalysisTool = {
 function buildCorpus(messages: ProviderMessage[]): string[] {
   const entries: string[] = [];
   for (const msg of messages) {
-    if (!msg.text.trim()) continue;
+    if (!msg.text.trim()) {
+      continue;
+    }
     const to = msg.conversationId;
     const truncatedBody = truncate(msg.text, 500, "");
     entries.push(`To: ${to}\n\n${truncatedBody}`);

package/src/monitoring/__tests__/db-integrity-sample.test.ts

@@ -0,0 +1,96 @@
+/**
+ * Tests for the quick_check probe. The corruption seed writes junk over a
+ * b-tree page of a rollback-journal database (WAL would keep the data in the
+ * -wal file, leaving the main file a bare header the check would pass).
+ */
+
+import { closeSync, mkdtempSync, openSync, rmSync, writeSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, expect, test } from "bun:test";
+
+import { assertNotLiveDb } from "../../__tests__/assert-not-live-db.js";
+import {
+  boundErrors,
+  type IntegritySampleResult,
+  runIntegrityCheck,
+} from "../db-integrity-check.js";
+
+let dir: string;
+let dbPath: string;
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "integrity-sample-"));
+  dbPath = join(dir, "test.db");
+});
+
+afterEach(() => {
+  assertNotLiveDb(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function seedDb(walMode: boolean): void {
+  const db = new Database(dbPath);
+  try {
+    db.exec(`PRAGMA journal_mode=${walMode ? "WAL" : "DELETE"}`);
+    db.exec("CREATE TABLE t (id TEXT PRIMARY KEY, v TEXT)");
+    const ins = db.prepare("INSERT INTO t (id, v) VALUES (?, ?)");
+    for (let i = 0; i < 200; i++) {
+      ins.run(`k-${i}`, `v-${i}`);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+function corruptDb(): void {
+  const fd = openSync(dbPath, "r+");
+  try {
+    writeSync(fd, Buffer.alloc(32 * 1024, 0xff), 0, 32 * 1024, 4096);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+test("returns null when the database does not exist", () => {
+  expect(runIntegrityCheck(dbPath)).toBeNull();
+});
+
+test("reports ok on a healthy database", () => {
+  seedDb(true);
+  const result = runIntegrityCheck(dbPath);
+  expect(result?.ok).toBe(true);
+  expect(result?.errors).toEqual([]);
+  expect(result?.pageCount).toBeGreaterThan(0);
+});
+
+test("reports corruption instead of throwing", () => {
+  seedDb(false);
+  corruptDb();
+  const result = runIntegrityCheck(dbPath);
+  expect(result?.ok).toBe(false);
+  expect(result?.errors.length).toBeGreaterThan(0);
+});
+
+test("boundErrors caps by UTF-8 bytes without splitting code points", () => {
+  const bounded = boundErrors(Array(20).fill("é".repeat(200)));
+  expect(bounded.length).toBe(10);
+  for (const msg of bounded) {
+    expect(Buffer.byteLength(msg, "utf8")).toBeLessThanOrEqual(160);
+    expect(msg.includes("�")).toBe(false);
+  }
+});
+
+test("subprocess entry prints the JSON verdict", () => {
+  seedDb(false);
+  corruptDb();
+  const entry = new URL("../db-integrity-check.ts", import.meta.url).pathname;
+  const proc = Bun.spawnSync({ cmd: ["bun", "run", entry, dbPath] });
+  expect(proc.exitCode).toBe(0);
+  const result = JSON.parse(
+    proc.stdout.toString(),
+  ) as IntegritySampleResult | null;
+  expect(result?.ok).toBe(false);
+  expect(result?.errors.length).toBeGreaterThan(0);
+});

package/src/monitoring/__tests__/sample-ring-buffer.test.ts

@@ -30,21 +30,27 @@ afterEach(() => {
 describe("SampleRingBuffer", () => {
   test("readRecent returns records oldest-first", () => {
     const buf = new SampleRingBuffer<{ n: number }>(bufPath, 100);
-    for (let n = 0; n < 5; n++) buf.append({ n });
+    for (let n = 0; n < 5; n++) {
+      buf.append({ n });
+    }
     expect(buf.readRecent().map((r) => r.n)).toEqual([0, 1, 2, 3, 4]);
     expect(buf.readLast()).toEqual({ n: 4 });
   });
 
   test("readRecent honours the limit, keeping the most recent", () => {
     const buf = new SampleRingBuffer<{ n: number }>(bufPath, 100);
-    for (let n = 0; n < 10; n++) buf.append({ n });
+    for (let n = 0; n < 10; n++) {
+      buf.append({ n });
+    }
     expect(buf.readRecent(3).map((r) => r.n)).toEqual([7, 8, 9]);
   });
 
   test("rotates at capacity and keeps history across the boundary", () => {
     // capacity 3: after 3 appends the active file rotates to <name>.1.
     const buf = new SampleRingBuffer<{ n: number }>(bufPath, 3);
-    for (let n = 0; n < 5; n++) buf.append({ n });
+    for (let n = 0; n < 5; n++) {
+      buf.append({ n });
+    }
 
     // Two files exist at most: active + rotated.
     const files = readdirSync(tmpDir).sort();
@@ -57,7 +63,9 @@ describe("SampleRingBuffer", () => {
 
   test("never keeps more than two files, bounding disk use", () => {
     const buf = new SampleRingBuffer<{ n: number }>(bufPath, 2);
-    for (let n = 0; n < 20; n++) buf.append({ n });
+    for (let n = 0; n < 20; n++) {
+      buf.append({ n });
+    }
     expect(readdirSync(tmpDir).length).toBeLessThanOrEqual(2);
     // The most recent record is always retained.
     expect(buf.readLast()).toEqual({ n: 19 });

package/src/monitoring/db-integrity-check.ts

@@ -0,0 +1,163 @@
+/**
+ * `PRAGMA quick_check` probe for a SQLite database file, runnable as a
+ * standalone subprocess (`bun run db-integrity-check.ts <db-path>`) so the
+ * synchronous page walk never blocks the monitor's event loop. Prints the
+ * JSON-encoded {@link IntegritySampleResult} (or `null`) to stdout.
+ *
+ * quick_check rather than the full `integrity_check` the `assistant db
+ * repair` step runs: quick_check skips the index ↔ table cross-verification,
+ * which is the expensive half on a multi-GB database, while still walking
+ * every page and catching the b-tree damage that makes a database unusable.
+ * A background sweep nobody asked for has to stay cheap.
+ */
+
+import { existsSync } from "node:fs";
+import { Database } from "bun:sqlite";
+
+/** Cap on quick_check error rows — a wrecked DB reports thousands. */
+const MAX_ERRORS = 10;
+
+/**
+ * Cap on each error message's UTF-8 byte length. With MAX_ERRORS rows this
+ * bounds the whole error payload well under the 4096-byte watchdog `detail`
+ * limit (WATCHDOG_DETAIL_MAX_JSON_BYTES) — an oversized detail is silently
+ * dropped by the platform, which would selectively erase the most-corrupted
+ * databases from the prevalence metric. Bytes, not `String.length`: ten
+ * 160-character CJK messages would otherwise serialize to ~4.9 KB.
+ */
+const MAX_ERROR_BYTES = 160;
+
+/** Truncate to at most `maxBytes` of UTF-8 without splitting a code point. */
+function truncateToBytes(s: string, maxBytes: number): string {
+  let bytes = 0;
+  let out = "";
+  for (const ch of s) {
+    const b = Buffer.byteLength(ch, "utf8");
+    if (bytes + b > maxBytes) {
+      break;
+    }
+    out += ch;
+    bytes += b;
+  }
+  return out;
+}
+
+export function boundErrors(messages: string[]): string[] {
+  return messages
+    .slice(0, MAX_ERRORS)
+    .map((m) => truncateToBytes(m, MAX_ERROR_BYTES));
+}
+
+export interface IntegritySampleResult {
+  ok: boolean;
+  errors: string[];
+  pageCount: number;
+  durationMs: number;
+}
+
+function errCode(err: unknown): unknown {
+  return (err as { code?: unknown }).code;
+}
+
+/**
+ * Lock contention with the daemon (checkpoint restarts, WAL recovery) is not
+ * corruption — mapping it to `ok: false` would inflate the very prevalence
+ * number this probe exists to measure. Busy maps to "no sample" instead.
+ */
+function isBusy(err: unknown): boolean {
+  const code = errCode(err);
+  return code === "SQLITE_BUSY" || code === "SQLITE_LOCKED";
+}
+
+/**
+ * True only for errors that establish structural corruption. Operational
+ * failures (I/O errors, permissions, out-of-memory) say nothing about the
+ * database's integrity and must not count as corrupt samples.
+ */
+function isCorruption(err: unknown): boolean {
+  const code = errCode(err);
+  if (code === "SQLITE_CORRUPT" || code === "SQLITE_NOTADB") {
+    return true;
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  return msg.includes("malformed") || msg.includes("not a database");
+}
+
+/**
+ * Run `PRAGMA quick_check` against `dbPath` on a read-only handle.
+ *
+ * Only genuine corruption signals come back as `ok: false`: quick_check
+ * error rows, or an open/query failure whose error identifies the file as
+ * structurally invalid ("database disk image is malformed", "file is not a
+ * database"). Returns null — "no sample" — when the file does not exist,
+ * the database is locked past the busy timeout, or the failure is
+ * operational (I/O, permissions, memory); the caller stays due and retries
+ * next poll.
+ */
+export function runIntegrityCheck(
+  dbPath: string,
+): IntegritySampleResult | null {
+  if (!existsSync(dbPath)) {
+    return null;
+  }
+  const startedAt = Date.now();
+  let db: Database;
+  try {
+    db = new Database(dbPath, { readonly: true });
+  } catch (err) {
+    if (!isCorruption(err) || isBusy(err)) {
+      return null;
+    }
+    return {
+      ok: false,
+      errors: boundErrors([err instanceof Error ? err.message : String(err)]),
+      pageCount: 0,
+      durationMs: Date.now() - startedAt,
+    };
+  }
+  try {
+    db.exec("PRAGMA busy_timeout=5000");
+    const rows = db
+      .query<{ quick_check: string }, []>(`PRAGMA quick_check(${MAX_ERRORS})`)
+      .all();
+    const messages = rows.map((r) => r.quick_check);
+    const healthy = messages.length === 1 && messages[0] === "ok";
+    return {
+      ok: healthy,
+      errors: healthy ? [] : boundErrors(messages),
+      pageCount: pageCount(db),
+      durationMs: Date.now() - startedAt,
+    };
+  } catch (err) {
+    if (!isCorruption(err) || isBusy(err)) {
+      return null;
+    }
+    return {
+      ok: false,
+      errors: boundErrors([err instanceof Error ? err.message : String(err)]),
+      pageCount: pageCount(db),
+      durationMs: Date.now() - startedAt,
+    };
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * `PRAGMA page_count` is cheap and works even on damaged DBs (it reads from
+ * the header), but on truly malformed files it can throw too.
+ */
+function pageCount(db: Database): number {
+  try {
+    return (
+      db.query<{ page_count: number }, []>("PRAGMA page_count").get()
+        ?.page_count ?? 0
+    );
+  } catch {
+    return 0;
+  }
+}
+
+if (import.meta.main) {
+  console.log(JSON.stringify(runIntegrityCheck(process.argv[2] ?? "")));
+}

package/src/monitoring/db-integrity-sample.ts

@@ -0,0 +1,171 @@
+/**
+ * Periodic database integrity sample, reported as a `db_integrity` watchdog
+ * event so the platform can read corruption prevalence across the fleet.
+ *
+ * The `PRAGMA quick_check` itself runs in a short-lived subprocess
+ * (`db-integrity-check.ts`) — bun:sqlite's page walk is synchronous, and a
+ * multi-second scan inside this process would stall the resource sampler and
+ * signal handling, the exact things the monitor exists to keep responsive.
+ * The check opens a read-only handle and never mutates the database.
+ *
+ * At most one sample per 24h per install (stamped on disk), so the
+ * denominator is "installs that reported today" rather than "daemon
+ * restarts". The stamp is written only after the event is queued: a failed
+ * enqueue leaves the install due, so it retries next poll instead of
+ * silently dropping out of the day's denominator.
+ */
+
+import { existsSync, statSync, writeFileSync } from "node:fs";
+import { 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 { getDbPath, getMonitoringDataDir } from "../util/platform.js";
+import type { IntegritySampleResult } from "./db-integrity-check.js";
+
+const log = getLogger("db-integrity-sample");
+
+/** Watchdog `check_name` carrying the quick_check outcome. */
+const CHECK_NAME = "db_integrity";
+
+/** Minimum spacing between samples on one install. */
+const SAMPLE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+
+/** How often the sampler re-tests the 24h stamp (covers long-uptime installs). */
+const POLL_INTERVAL_MS = 6 * 60 * 60 * 1000;
+
+/** Delay before the first attempt, keeping the scan off the boot I/O path. */
+const BOOT_DELAY_MS = 60_000;
+
+/** Kill switch for a check subprocess wedged on pathological I/O. */
+const CHECK_TIMEOUT_MS = 10 * 60 * 1000;
+
+const STAMP_FILENAME = "db-integrity-last-run-at";
+
+/**
+ * Run the quick_check probe in a subprocess and parse its JSON verdict.
+ * Returns null — "no sample" — on a non-zero exit, unparseable output, or
+ * timeout (the child is killed).
+ */
+/**
+ * The in-flight check subprocess, retained so sampler shutdown can kill it —
+ * a non-detached child survives the monitor's exit and would otherwise hold
+ * its SQLite read snapshot for up to CHECK_TIMEOUT_MS while the daemon
+ * restarts.
+ */
+let activeChild: ReturnType<typeof Bun.spawn> | null = null;
+
+async function runCheckSubprocess(
+  dbPath: string,
+): Promise<IntegritySampleResult | null> {
+  const entry = new URL("./db-integrity-check.ts", import.meta.url).pathname;
+  const child = Bun.spawn({
+    cmd: ["bun", "--smol", "run", entry, dbPath],
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  activeChild = child;
+  const killTimer = setTimeout(() => child.kill(), CHECK_TIMEOUT_MS);
+  killTimer.unref?.();
+  try {
+    const stdout = await new Response(child.stdout).text();
+    if ((await child.exited) !== 0) {
+      return null;
+    }
+    return JSON.parse(stdout) as IntegritySampleResult | null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(killTimer);
+    activeChild = null;
+  }
+}
+
+function stampPath(): string {
+  return join(getMonitoringDataDir(), STAMP_FILENAME);
+}
+
+function due(): boolean {
+  try {
+    return Date.now() - statSync(stampPath()).mtimeMs >= SAMPLE_INTERVAL_MS;
+  } catch {
+    return true; // never sampled (or unreadable stamp) — sample now
+  }
+}
+
+/**
+ * Sample once if the install is due, emitting one `db_integrity` watchdog
+ * event. Never throws. Skips entirely on a confirmed analytics opt-out,
+ * where the event would be dropped at record time anyway and the scan would
+ * be pure wasted I/O.
+ */
+export async function sampleDbIntegrityIfDue(): Promise<void> {
+  if (getRawShareAnalytics() === false || !due()) {
+    return;
+  }
+  try {
+    if (!existsSync(getDbPath())) {
+      return; // no database yet — stay due, retry next poll
+    }
+    const result = await runCheckSubprocess(getDbPath());
+    if (!result) {
+      return; // locked, operational failure, or timeout — stay due
+    }
+    const queued = recordWatchdogEvent({
+      checkName: CHECK_NAME,
+      value: result.errors.length,
+      detail: {
+        ok: result.ok,
+        mode: "quick_check",
+        page_count: result.pageCount,
+        duration_ms: result.durationMs,
+        errors: result.errors,
+      },
+    });
+    if (queued) {
+      writeFileSync(stampPath(), "");
+    }
+    if (!result.ok) {
+      log.warn(
+        { errors: result.errors, pageCount: result.pageCount },
+        "Database integrity sample reported corruption",
+      );
+    }
+  } catch (err) {
+    log.warn({ err }, "Database integrity sample failed (non-fatal)");
+  }
+}
+
+let bootTimer: ReturnType<typeof setTimeout> | null = null;
+let pollTimer: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * Start the integrity sampler in the monitor process. No-op in dev mode
+ * (VELLUM_DEV=1) and idempotent if already started.
+ */
+export function startDbIntegritySampler(): void {
+  if (process.env.VELLUM_DEV === "1" || pollTimer) {
+    return;
+  }
+  bootTimer = setTimeout(() => void sampleDbIntegrityIfDue(), BOOT_DELAY_MS);
+  bootTimer.unref?.();
+  pollTimer = setInterval(
+    () => void sampleDbIntegrityIfDue(),
+    POLL_INTERVAL_MS,
+  );
+  pollTimer.unref?.();
+}
+
+/** Stop the sampler loop and any in-flight check subprocess. Idempotent. */
+export function stopDbIntegritySampler(): void {
+  if (bootTimer) {
+    clearTimeout(bootTimer);
+    bootTimer = null;
+  }
+  if (pollTimer) {
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
+  activeChild?.kill();
+  activeChild = null;
+}

package/src/monitoring/process-memory.ts

@@ -107,7 +107,8 @@ export function topProcessesByMemory(limit: number): ProcessMemory[] {
     let command: string;
     try {
       const raw = readFileSync(`/proc/${pid}/cmdline`, "utf-8");
-      command = deriveName(raw.split("\0").filter(Boolean).join(" ")) || `pid ${pid}`;
+      command =
+        deriveName(raw.split("\0").filter(Boolean).join(" ")) || `pid ${pid}`;
     } catch {
       // Process exited between readdir and read — skip.
       continue;