@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

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

@@ -46,6 +46,10 @@ const FIRECRAWL_API_URL = "https://api.firecrawl.dev/v2/search";
 const FASTCRW_SEARCH_PATH = "/v1/search";
 const TINYFISH_DEFAULT_SEARCH_API_BASE = "https://api.search.tinyfish.ai";
 const EXA_API_URL = "https://api.exa.ai/search";
+const SERPLY_API_URL = "https://api.serply.io/v1/search";
+// Serply returns at most 10 organic results per call; larger counts are
+// clamped on request and trimmed on response.
+const SERPLY_MAX_RESULTS = 10;
 // Keenable is keyless by default: the public path needs no key (rate-limited);
 // a key switches to the authenticated path and lifts the cap.
 const KEENABLE_API_BASE_URL = "https://api.keenable.ai";
@@ -61,7 +65,8 @@ type WebSearchProvider =
   | "fastcrw"
   | "searxng"
   | "tinyfish"
-  | "exa";
+  | "exa"
+  | "serply";
 
 /**
  * Arguments passed to every {@link WebSearchAdapter}. The full superset is
@@ -213,6 +218,19 @@ interface ExaSearchResponse {
   results?: ExaSearchResult[];
 }
 
+interface SerplySearchResult {
+  title?: string | null;
+  link?: string;
+  description?: string | null;
+  position?: number;
+}
+
+interface SerplySearchResponse {
+  query?: string;
+  total?: number;
+  results?: SerplySearchResult[];
+}
+
 const SEARXNG_MISSING_INSTANCE_MESSAGE =
   "SearXNG needs an instance URL. Set API Base in Settings under Web Search.";
 const SEARXNG_JSON_DISABLED_MESSAGE =
@@ -236,8 +254,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(
@@ -810,6 +831,81 @@ function exaStartPublishedDateForFreshness(
   return new Date(now - days * 24 * 60 * 60 * 1000).toISOString();
 }
 
+function formatSerplyResults(
+  data: SerplySearchResponse,
+  query: string,
+): string {
+  const results = data.results ?? [];
+  if (results.length === 0) {
+    return `No results found for "${query}".`;
+  }
+
+  const lines: string[] = [`Web search results for "${query}":\n`];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const title =
+      result.title?.trim() || result.link?.trim() || "Untitled result";
+    lines.push(`${i + 1}. ${title}`);
+    if (result.link) {
+      lines.push(`   URL: ${result.link}`);
+    }
+    const snippet = result.description?.trim();
+    if (snippet) {
+      lines.push(`   ${snippet}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+function buildSerplyMetadata(
+  data: SerplySearchResponse,
+  query: string,
+  durationMs: number,
+): WebSearchMetadata {
+  const results = data.results ?? [];
+  const items: WebSearchResultItem[] = results.map((result, index) => {
+    const url = result.link ?? "";
+    const domain = extractDomain(url);
+    return {
+      rank: index + 1,
+      title: result.title?.trim() || url.trim() || "Untitled result",
+      url,
+      domain,
+      faviconUrl: faviconUrlForDomain(domain),
+      snippet: result.description?.trim() || undefined,
+    };
+  });
+  return {
+    query,
+    provider: "serply",
+    resultCount: items.length,
+    durationMs,
+    results: items,
+  };
+}
+
+/**
+ * Serply passes Google's `tbs` time filter through unchanged, so the tool's
+ * freshness buckets map onto the `qdr:` values Google understands.
+ */
+function serplyTbsForFreshness(
+  freshness: string | undefined,
+): string | undefined {
+  switch (freshness) {
+    case "pd":
+      return "qdr:d";
+    case "pw":
+      return "qdr:w";
+    case "pm":
+      return "qdr:m";
+    case "py":
+      return "qdr:y";
+    default:
+      return undefined;
+  }
+}
+
 function tinyfishRecencyMinutesForFreshness(
   freshness: string | undefined,
 ): number | undefined {
@@ -1517,9 +1613,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 +1874,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,
   );
@@ -2023,6 +2117,128 @@ async function executeExaSearch(
   );
 }
 
+async function executeSerplySearch(
+  query: string,
+  count: number,
+  freshness: string | undefined,
+  apiKey: string,
+  signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+  const startedAt = Date.now();
+  const params = new URLSearchParams({
+    q: query,
+    num: String(Math.min(count, SERPLY_MAX_RESULTS)),
+  });
+  const tbs = serplyTbsForFreshness(freshness);
+  if (tbs !== undefined) {
+    params.set("tbs", tbs);
+  }
+  const url = `${SERPLY_API_URL}?${params.toString()}`;
+
+  const headers = {
+    Accept: "application/json",
+    "X-Api-Key": apiKey.trim(),
+    "User-Agent": "vellum-assistant",
+  };
+
+  for (let attempt = 0; attempt <= DEFAULT_MAX_RETRIES; attempt++) {
+    let response: Response;
+    try {
+      response = await fetch(url, { method: "GET", headers, signal });
+    } catch (err) {
+      return networkFailureResult(query, "serply", startedAt, err, signal);
+    }
+
+    const bodyText = await response.text();
+    if (response.ok) {
+      let data: SerplySearchResponse;
+      try {
+        data = JSON.parse(bodyText) as SerplySearchResponse;
+      } catch {
+        return errorResult(
+          query,
+          "serply",
+          startedAt,
+          "Serply Search returned an invalid JSON payload.",
+        );
+      }
+      if (data.results && data.results.length > count) {
+        data.results = data.results.slice(0, count);
+      }
+      const durationMs = Date.now() - startedAt;
+      return {
+        content:
+          wrapUntrustedContent(formatSerplyResults(data, query), {
+            source: "search",
+            sourceDetail: "serply",
+          }) + CITATION_INSTRUCTION,
+        isError: false,
+        activityMetadata: {
+          webSearch: buildSerplyMetadata(data, query, durationMs),
+        },
+      };
+    }
+
+    if (response.status === 401) {
+      return errorResult(
+        query,
+        "serply",
+        startedAt,
+        "Invalid or expired Serply API key",
+      );
+    }
+    if (response.status === 402) {
+      return errorResult(
+        query,
+        "serply",
+        startedAt,
+        "Serply account has no remaining credits.",
+      );
+    }
+    if (response.status === 403) {
+      return errorResult(
+        query,
+        "serply",
+        startedAt,
+        "Serply Search request was forbidden by the upstream service.",
+      );
+    }
+
+    if (response.status === 429 && attempt < DEFAULT_MAX_RETRIES) {
+      const delayMs = getHttpRetryDelay(
+        response,
+        attempt,
+        DEFAULT_BASE_DELAY_MS,
+      );
+      log.warn(
+        { attempt: attempt + 1, delayMs },
+        "Serply Search rate limited, retrying",
+      );
+      await sleep(delayMs);
+      continue;
+    }
+
+    log.warn({ status: response.status }, "Serply Search API error");
+    return backendFailureResult(
+      query,
+      "serply",
+      startedAt,
+      { statusCode: response.status, error: rawBodyDetail(bodyText) },
+      response.status === 429
+        ? "Serply Search rate limit exceeded after retries. Try again shortly."
+        : `Serply Search API returned status ${response.status}`,
+    );
+  }
+
+  return backendFailureResult(
+    query,
+    "serply",
+    startedAt,
+    { statusCode: 429 },
+    "Serply Search rate limit exceeded after retries. Try again shortly.",
+  );
+}
+
 // ----------------------------------------------------------------------------
 // Adapter registry
 //
@@ -2114,6 +2330,14 @@ const exaSearchAdapter: WebSearchAdapter = {
     executeExaSearch(query, count, freshness, apiKey, signal),
 };
 
+const serplySearchAdapter: WebSearchAdapter = {
+  id: "serply",
+  providerKeyName: "serply",
+  fallbackOrder: 10,
+  execute: ({ query, count, freshness, apiKey, signal }) =>
+    executeSerplySearch(query, count, freshness, apiKey, signal),
+};
+
 /**
  * All built-in web-search adapters keyed by provider id. The
  * `Record<WebSearchProvider, ...>` shape forces TypeScript to flag any
@@ -2129,6 +2353,7 @@ const WEB_SEARCH_ADAPTERS: Record<WebSearchProvider, WebSearchAdapter> = {
   searxng: searxngSearchAdapter,
   tinyfish: tinyfishSearchAdapter,
   exa: exaSearchAdapter,
+  serply: serplySearchAdapter,
 };
 
 /**
@@ -2160,7 +2385,7 @@ export const webSearchTool = {
       count: {
         type: "number",
         description:
-          "Number of results to return (1-20, default 10). Used with Brave, Tavily, Firecrawl, Keenable, fastCRW, SearXNG, TinyFish, and Exa providers.",
+          "Number of results to return (1-20, default 10). Used with Brave, Tavily, Firecrawl, Keenable, fastCRW, SearXNG, TinyFish, Exa, and Serply providers.",
       },
       offset: {
         type: "number",
@@ -2170,7 +2395,7 @@ export const webSearchTool = {
       freshness: {
         type: "string",
         description:
-          'Filter by recency: "pd" (past day), "pw" (past week), "pm" (past month), "py" (past year). Used with Brave, Tavily, Firecrawl, Keenable, fastCRW, SearXNG, TinyFish, and Exa providers. SearXNG maps day/month/year and omits week.',
+          'Filter by recency: "pd" (past day), "pw" (past week), "pm" (past month), "py" (past year). Used with Brave, Tavily, Firecrawl, Keenable, fastCRW, SearXNG, TinyFish, Exa, and Serply providers. SearXNG maps day/month/year and omits week.',
       },
     },
     required: ["query"],
@@ -2274,8 +2499,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()) {
@@ -2286,7 +2513,7 @@ export const webSearchTool = {
           query,
           provider,
           startedAt,
-          "No web search API key configured. Set it via `keys set perplexity <key>`, `keys set brave <key>`, `keys set tavily <key>`, `keys set firecrawl <key>`, or `keys set fastcrw <key>`, or `keys set tinyfish <key>`, or `keys set exa <key>`, or configure it from the Settings page under API Keys. Or switch the web-search provider to Keenable, which works without a key, or SearXNG with your instance URL.",
+          "No web search API key configured. Set it via `keys set perplexity <key>`, `keys set brave <key>`, `keys set tavily <key>`, `keys set firecrawl <key>`, or `keys set fastcrw <key>`, or `keys set tinyfish <key>`, or `keys set exa <key>`, or `keys set serply <key>`, or configure it from the Settings page under API Keys. Or switch the web-search provider to Keenable, which works without a key, or SearXNG with your instance URL.",
         );
       }
     }

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/shared/shell-output.test.ts

@@ -112,3 +112,45 @@ describe("formatShellOutput truncation", () => {
     expect(result.content).toContain(OUTPUT_TRUNCATED_TAG);
   });
 });
+
+describe("formatShellOutput kill reporting", () => {
+  test("names the signal and hints at memory for a SIGKILL", () => {
+    const result = formatShellOutput("", "", null, false, 120, {
+      signal: "SIGKILL",
+    });
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('<command_killed signal="SIGKILL" />');
+    expect(result.content).toContain("out of memory");
+    expect(result.content).not.toContain('code="null"');
+    expect(result.status).toBe('<command_killed signal="SIGKILL" />');
+  });
+
+  test("keeps the output produced before the kill", () => {
+    const result = formatShellOutput("partial", "", null, false, 120, {
+      signal: "SIGTERM",
+    });
+    expect(result.content.startsWith("partial\n")).toBe(true);
+    expect(result.content).toContain("killed by SIGTERM");
+    expect(result.content).not.toContain("out of memory");
+  });
+
+  test("does not infer a kill from a 128 + n exit code", () => {
+    const result = formatShellOutput("", "Killed", 137, false, 120);
+    expect(result.content).toBe("Killed");
+    expect(result.status).toBe('<command_exit code="137" />');
+  });
+
+  test("leaves a timeout framed as a timeout", () => {
+    const result = formatShellOutput("", "", null, true, 120, {
+      signal: "SIGKILL",
+    });
+    expect(result.content).toContain("<command_timeout");
+    expect(result.content).not.toContain("command_killed");
+  });
+
+  test("leaves an ordinary failure unchanged", () => {
+    const result = formatShellOutput("", "boom", 1, false, 120);
+    expect(result.content).toBe("boom");
+    expect(result.status).toBe('<command_exit code="1" />');
+  });
+});

package/src/tools/shared/shell-output.ts

@@ -13,6 +13,15 @@ export interface ShellOutputResult {
   isError: boolean;
 }
 
+function describeKill(signal: NodeJS.Signals): string {
+  const tag = `<command_killed signal="${signal}" />`;
+  const hint =
+    signal === "SIGKILL"
+      ? " A SIGKILL the command did not send itself usually means the system ran out of memory."
+      : "";
+  return `${tag}\nCommand was killed by ${signal} before it finished.${hint}`;
+}
+
 type StdioStream = "stdout" | "stderr";
 
 type DataListener = (data: Buffer | string) => void;
@@ -34,7 +43,11 @@ export function formatShellOutput(
   code: number | null,
   timedOut: boolean,
   timeoutSec: number,
-  options?: { truncated?: boolean; started?: boolean },
+  options?: {
+    truncated?: boolean;
+    started?: boolean;
+    signal?: NodeJS.Signals | null;
+  },
 ): ShellOutputResult {
   if (options?.started === false) {
     return {
@@ -66,6 +79,12 @@ export function formatShellOutput(
     statusParts.push(OUTPUT_TRUNCATED_TAG);
   }
 
+  const killSignal = timedOut ? null : (options?.signal ?? null);
+  if (killSignal) {
+    output += (output ? "\n" : "") + describeKill(killSignal);
+    statusParts.push(`<command_killed signal="${killSignal}" />`);
+  }
+
   if (!output.trim()) {
     if (code === 0) {
       output = "<command_completed />";
@@ -74,7 +93,7 @@ export function formatShellOutput(
       output = `${exitTag}\nCommand failed with exit code ${code}. No stdout or stderr output was produced.`;
       statusParts.push(exitTag);
     }
-  } else if (code !== 0 && !timedOut) {
+  } else if (code !== 0 && !timedOut && !killSignal) {
     statusParts.push(`<command_exit code="${code}" />`);
   }
 
@@ -148,7 +167,7 @@ export class BoundedStdioCollector {
     code: number | null,
     timedOut: boolean,
     timeoutSec: number,
-    options?: { started?: boolean },
+    options?: { started?: boolean; signal?: NodeJS.Signals | null },
   ): ShellOutputResult {
     return formatShellOutput(
       Buffer.concat(this.stdoutParts).toString(),
@@ -156,7 +175,11 @@ export class BoundedStdioCollector {
       code,
       timedOut,
       timeoutSec,
-      { truncated: this.truncated, started: options?.started },
+      {
+        truncated: this.truncated,
+        started: options?.started,
+        signal: options?.signal,
+      },
     );
   }
 }

package/src/tools/skills/execute.ts

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 import { RiskLevel } from "../../permissions/types.js";
 import { isUnparseableToolArgs } from "../../providers/unparseable-tool-args.js";
 import { declareDaemonActivityField } from "../schema-transforms.js";
@@ -9,6 +11,9 @@ import type {
 
 /** Envelope keys consumed by `skill_execute` itself, never inner-tool params. */
 const SKILL_EXECUTE_ENVELOPE_KEYS = new Set(["tool", "input", "activity"]);
+const recoveredSkillExecuteEnvelopeSchema = z
+  .object({ tool: z.string() })
+  .passthrough();
 
 /**
  * Recover a `skill_execute` envelope that the provider layer wrapped under the
@@ -30,13 +35,11 @@ export function recoverSkillExecuteEnvelope(
     return envelope;
   }
   try {
-    const parsed: unknown = JSON.parse(envelope._raw);
-    if (
-      parsed != null &&
-      typeof parsed === "object" &&
-      !Array.isArray(parsed)
-    ) {
-      return parsed as Record<string, unknown>;
+    const recovered = recoveredSkillExecuteEnvelopeSchema.safeParse(
+      JSON.parse(envelope._raw),
+    );
+    if (recovered.success) {
+      return recovered.data;
     }
   } catch {
     // Genuinely malformed/truncated — leave wrapped for the retryable error.

package/src/tools/terminal/shell.ts

@@ -374,6 +374,7 @@ export const shellTool = {
 
         const fmtResult = collector.format(code, timedOut, timeoutSec, {
           started: launch.didStart(),
+          signal: aborted ? null : signal,
         });
 
         const status: BackgroundToolCompletedEvent["status"] = aborted
@@ -531,7 +532,7 @@ export const shellTool = {
     // -----------------------------------------------------------------------
     // Foreground mode: await the process and return its output.
     // -----------------------------------------------------------------------
-    const result = await new Promise<ToolExecutionResult>((resolve) => {
+    return await new Promise<ToolExecutionResult>((resolve) => {
       let timedOut = false;
       const startedAt = Date.now();
 
@@ -585,6 +586,7 @@ export const shellTool = {
 
         const fmtResult = collector.format(code, timedOut, timeoutSec, {
           started: launch.didStart(),
+          signal: context.signal?.aborted ? null : signal,
         });
 
         resolve({
@@ -620,8 +622,6 @@ export const shellTool = {
         });
       });
     });
-
-    return result;
   },
 } satisfies ToolDefinition;
 

package/src/tools/tool-approval-handler.ts

@@ -27,6 +27,7 @@ import {
   isWorkspaceWriteTool,
 } from "../permissions/workspace-policy.js";
 import {
+  boundUnparseableToolArgs,
   isUnparseableToolArgs,
   unparseableToolArgsMessage,
 } from "../providers/unparseable-tool-args.js";
@@ -797,7 +798,14 @@ export class ToolApprovalHandler {
     // mangled. Fail loudly instead so the model retries.
     if (isUnparseableToolArgs(input)) {
       const msg = unparseableToolArgsMessage(name, input._raw);
-      this.auditGateError(context, name, input, riskLevel, startTime, msg);
+      this.auditGateError(
+        context,
+        name,
+        boundUnparseableToolArgs(input),
+        riskLevel,
+        startTime,
+        msg,
+      );
       return { allowed: false, result: { content: msg, isError: true } };
     }
 

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)) {

package/src/usage/attribution.ts

@@ -10,11 +10,15 @@ import { safeStringSlice } from "../util/unicode.js";
 
 const MAX_METADATA_VALUE_LENGTH = 128;
 
+/** `profileSource` reported for a turn whose profile the Auto router chose. */
+export const AUTO_PROFILE_SOURCE = "auto";
+
 export type UsageAttributionProfileSource =
   | "call_site"
   | "conversation"
   | "active"
   | "default"
+  | typeof AUTO_PROFILE_SOURCE
   | "unknown";
 
 export interface UsageAttributionInput {
@@ -27,6 +31,12 @@ export interface UsageAttributionInput {
    */
   profileResolutionCallSite?: LLMCallSite | null;
   overrideProfile?: string | null;
+  /**
+   * Who chose `overrideProfile`. `"auto"` marks a profile the Auto profile's
+   * router picked for the turn, so usage rows can tell an Auto pick from a
+   * user pin that landed on the same profile. Absent for a user pin.
+   */
+  overrideProfileOrigin?: "auto" | null;
   /**
    * Mirrors `ResolveCallSiteOpts.forceOverrideProfile`: the override profile
    * was floated above the call-site layers for this request, so attribution
@@ -227,9 +237,16 @@ function appliedProfileFromWinnerSelection(
     call_site: "call_site",
     default: "default",
   } as const;
+  // An override the Auto router chose is reported as its own source: the
+  // applied profile is the routed arm, so without this a routed turn would
+  // be indistinguishable from a user who pinned that arm.
+  const profileSource =
+    selection.source === "override" && input.overrideProfileOrigin === "auto"
+      ? AUTO_PROFILE_SOURCE
+      : sourceBySelection[selection.source];
   return {
     appliedProfile: selection.profileName,
-    profileSource: sourceBySelection[selection.source],
+    profileSource,
   };
 }
 

package/src/util/__tests__/oom-priority.test.ts

@@ -0,0 +1,55 @@
+import { mkdirSync, mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { setOomScoreAdj, withOomScoreAdj } from "../oom-priority.js";
+
+function fakeProc(pid: number): string {
+  const procRoot = mkdtempSync(join(tmpdir(), "oom-priority-"));
+  mkdirSync(join(procRoot, String(pid)));
+  return procRoot;
+}
+
+describe("setOomScoreAdj", () => {
+  test("writes the value for a pid on Linux", () => {
+    const procRoot = fakeProc(42);
+    expect(setOomScoreAdj(1000, 42, { procRoot, platform: "linux" })).toBe(
+      true,
+    );
+    expect(readFileSync(join(procRoot, "42", "oom_score_adj"), "utf-8")).toBe(
+      "1000",
+    );
+  });
+
+  test("is a no-op off Linux", () => {
+    const procRoot = fakeProc(42);
+    expect(setOomScoreAdj(1000, 42, { procRoot, platform: "darwin" })).toBe(
+      false,
+    );
+  });
+
+  test("reports failure for a pid that is gone", () => {
+    const procRoot = fakeProc(42);
+    expect(setOomScoreAdj(0, 43, { procRoot, platform: "linux" })).toBe(false);
+  });
+});
+
+describe("withOomScoreAdj", () => {
+  test("execs the command through a shell that raises its own score on Linux", () => {
+    expect(withOomScoreAdj(["chrome", "--flag"], 1000, "linux")).toEqual([
+      "sh",
+      "-c",
+      'echo 1000 2>/dev/null >/proc/self/oom_score_adj; exec "$0" "$@"',
+      "chrome",
+      "--flag",
+    ]);
+  });
+
+  test("returns the command unchanged off Linux", () => {
+    expect(withOomScoreAdj(["chrome", "--flag"], 1000, "darwin")).toEqual([
+      "chrome",
+      "--flag",
+    ]);
+  });
+});