@vellumai/assistant 0.11.7 → 0.11.8-staging.1

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

@@ -1,26 +1,8 @@
-import { randomUUID } from "node:crypto";
-import { unlinkSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
 import { safeStringSlice } from "../../util/unicode.js";
 
 export const MAX_OUTPUT_LENGTH = 20_000;
 
-/** Tracks temp files created for truncated shell output so they can be cleaned up on shutdown. */
-const trackedTempFiles = new Set<string>();
-
-/** Remove all tracked truncated-output temp files. Safe to call multiple times. */
-export function cleanupShellOutputTempFiles(): void {
-  for (const filePath of trackedTempFiles) {
-    try {
-      unlinkSync(filePath);
-    } catch {
-      // File may already be gone — ignore.
-    }
-  }
-  trackedTempFiles.clear();
-}
+export const OUTPUT_TRUNCATED_TAG = `<output_truncated limit="20K" />`;
 
 export interface ShellOutputResult {
   content: string;
@@ -28,11 +10,20 @@ export interface ShellOutputResult {
   isError: boolean;
 }
 
+type StdioStream = "stdout" | "stderr";
+
+type DataListener = (data: Buffer | string) => void;
+
+type ReadableLike = {
+  on(event: "data", listener: DataListener): unknown;
+};
+
 /**
- * Format the raw stdout/stderr/exit-code from a spawned shell command into the
- * final tool result.  Both `shell.ts` (sandbox bash) and `host-shell.ts`
- * (host_bash) must produce identical output formatting - this shared function
- * is the single source of truth for that logic.
+ * Format already-materialized stdout/stderr into the tool result. Spawn sites
+ * that read pipes should collect through {@link BoundedStdioCollector} so the
+ * oversized tail never lands in memory. This helper still truncates a string
+ * that is already over the cap (desktop host-bash payloads) without writing
+ * the discarded tail to disk.
  */
 export function formatShellOutput(
   stdout: string,
@@ -40,6 +31,7 @@ export function formatShellOutput(
   code: number | null,
   timedOut: boolean,
   timeoutSec: number,
+  options?: { truncated?: boolean },
 ): ShellOutputResult {
   let output = stdout;
   if (stderr) {
@@ -54,22 +46,13 @@ export function formatShellOutput(
     statusParts.push(msg);
   }
 
-  if (output.length > MAX_OUTPUT_LENGTH) {
-    let fullOutputPath: string | undefined;
-    try {
-      fullOutputPath = join(
-        tmpdir(),
-        `vellum-shell-output-${randomUUID()}.txt`,
-      );
-      writeFileSync(fullOutputPath, output, { encoding: "utf-8", mode: 0o600 });
-      trackedTempFiles.add(fullOutputPath);
-    } catch {
-      fullOutputPath = undefined;
-    }
-    const fileAttr = fullOutputPath ? ` file="${fullOutputPath}"` : "";
-    const msg = `<output_truncated limit="20K"${fileAttr} />`;
-    output = safeStringSlice(output, 0, MAX_OUTPUT_LENGTH) + `\n${msg}`;
-    statusParts.push(msg);
+  const truncated =
+    options?.truncated === true || output.length > MAX_OUTPUT_LENGTH;
+  if (truncated) {
+    output =
+      safeStringSlice(output, 0, MAX_OUTPUT_LENGTH) +
+      `\n${OUTPUT_TRUNCATED_TAG}`;
+    statusParts.push(OUTPUT_TRUNCATED_TAG);
   }
 
   if (!output.trim()) {
@@ -90,3 +73,93 @@ export function formatShellOutput(
     isError: code !== 0 || timedOut,
   };
 }
+
+function toBuffer(data: Buffer | string): Buffer {
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  return Buffer.from(data);
+}
+
+/**
+ * Caps bash stdout/stderr while they stream. Bytes past {@link MAX_OUTPUT_LENGTH}
+ * are dropped (the process is left running so the pipe can drain). stdout and
+ * stderr share one budget, matching the concatenated tool-result cap.
+ */
+export class BoundedStdioCollector {
+  private readonly stdoutParts: Buffer[] = [];
+  private readonly stderrParts: Buffer[] = [];
+  private keptBytes = 0;
+  private truncated = false;
+
+  consume(
+    stream: StdioStream,
+    chunk: Buffer,
+    onOutput?: (text: string) => void,
+  ): void {
+    if (this.truncated || chunk.length === 0) {
+      return;
+    }
+
+    const remaining = MAX_OUTPUT_LENGTH - this.keptBytes;
+    if (remaining <= 0) {
+      this.truncated = true;
+      return;
+    }
+
+    // Copy a prefix so a single oversized chunk can be GC'd. subarray()
+    // would keep the whole allocation alive through the kept view.
+    const kept =
+      chunk.length <= remaining
+        ? chunk
+        : Buffer.from(chunk.subarray(0, remaining));
+    if (stream === "stdout") {
+      this.stdoutParts.push(kept);
+    } else {
+      this.stderrParts.push(kept);
+    }
+    this.keptBytes += kept.length;
+    if (kept.length < chunk.length) {
+      this.truncated = true;
+    }
+    onOutput?.(kept.toString());
+  }
+
+  get keptByteLength(): number {
+    return this.keptBytes;
+  }
+
+  get didTruncate(): boolean {
+    return this.truncated;
+  }
+
+  format(
+    code: number | null,
+    timedOut: boolean,
+    timeoutSec: number,
+  ): ShellOutputResult {
+    return formatShellOutput(
+      Buffer.concat(this.stdoutParts).toString(),
+      Buffer.concat(this.stderrParts).toString(),
+      code,
+      timedOut,
+      timeoutSec,
+      { truncated: this.truncated },
+    );
+  }
+}
+
+/** Attach a shared-budget collector to a child's stdout and stderr pipes. */
+export function attachBoundedStdio(
+  child: { stdout?: ReadableLike | null; stderr?: ReadableLike | null },
+  options?: { onOutput?: (text: string) => void },
+): BoundedStdioCollector {
+  const collector = new BoundedStdioCollector();
+  child.stdout?.on("data", (data) => {
+    collector.consume("stdout", toBuffer(data), options?.onOutput);
+  });
+  child.stderr?.on("data", (data) => {
+    collector.consume("stderr", toBuffer(data), options?.onOutput);
+  });
+  return collector;
+}

package/src/tools/skills/sandbox-runner.ts

@@ -161,6 +161,7 @@ function spawnRunner(
       env,
       stdio: ["ignore", "pipe", "pipe"],
       detached: true,
+      windowsHide: true,
     });
 
     const timer = setTimeout(() => {

package/src/tools/system/request-permission.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+
+import type { ToolContext } from "../types.js";
+import { requestSystemPermissionTool } from "./request-permission.js";
+
+const ctx = (clientOs?: string): ToolContext =>
+  ({ conversationId: "c", workingDir: "/", clientOs }) as ToolContext;
+
+describe("request_system_permission", () => {
+  test("uses Windows Settings URIs for Windows clients", async () => {
+    const result = await requestSystemPermissionTool.execute(
+      { permission_type: "microphone" },
+      ctx("windows"),
+    );
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("ms-settings:privacy-microphone");
+  });
+
+  test("errors for kinds the Windows client cannot route", async () => {
+    const result = await requestSystemPermissionTool.execute(
+      { permission_type: "camera" },
+      ctx("windows"),
+    );
+    expect(result.isError).toBe(true);
+  });
+
+  test("defaults to macOS System Settings", async () => {
+    const result = await requestSystemPermissionTool.execute(
+      { permission_type: "camera" },
+      ctx(),
+    );
+    expect(result.content).toContain("x-apple.systempreferences");
+  });
+});

package/src/tools/system/request-permission.ts

@@ -25,7 +25,7 @@ const PERMISSION_TYPES = [
 
 type PermissionType = (typeof PERMISSION_TYPES)[number];
 
-const SETTINGS_URLS: Record<PermissionType, string> = {
+const MACOS_SETTINGS_URLS: Record<PermissionType, string> = {
   full_disk_access:
     "x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles",
   accessibility:
@@ -46,6 +46,21 @@ const SETTINGS_URLS: Record<PermissionType, string> = {
     "x-apple.systempreferences:com.apple.preference.security?Privacy_Camera",
 };
 
+// Only the pages the Windows desktop client can route through its
+// permissions bridge; other kinds have no in-app remediation there yet.
+const WINDOWS_SETTINGS_URLS: Partial<Record<PermissionType, string>> = {
+  screen_recording: "ms-settings:privacy-graphicscaptureprogrammatic",
+  microphone: "ms-settings:privacy-microphone",
+};
+
+export const resolveSystemPermissionSettingsUrl = (
+  permType: PermissionType,
+  clientOs: string | undefined,
+): string | undefined =>
+  clientOs === "windows"
+    ? WINDOWS_SETTINGS_URLS[permType]
+    : MACOS_SETTINGS_URLS[permType];
+
 const FRIENDLY_NAMES: Record<PermissionType, string> = {
   full_disk_access: "Full Disk Access",
   accessibility: "Accessibility",
@@ -68,7 +83,7 @@ const FRIENDLY_NAMES: Record<PermissionType, string> = {
 export const requestSystemPermissionInputSchema = z.looseObject({
   permission_type: z
     .enum(PERMISSION_TYPES)
-    .describe("The macOS system permission to request"),
+    .describe("The system permission (macOS or Windows) to request"),
   activity: z
     .string()
     .describe(
@@ -81,7 +96,7 @@ export const requestSystemPermissionInputSchema = z.looseObject({
 export const requestSystemPermissionTool = {
   name: "request_system_permission",
   description:
-    "Request a macOS system permission via System Settings. " +
+    "Request a system permission via macOS System Settings or Windows Settings. " +
     "Use when a tool fails with a permission/access error (e.g. 'Operation not permitted', 'EACCES', sandbox denial). " +
     "Do not explain how to open System Settings manually - this tool handles it with a clickable button.",
   category: "system",
@@ -94,7 +109,7 @@ export const requestSystemPermissionTool = {
 
   async execute(
     input: Record<string, unknown>,
-    _context: ToolContext,
+    context: ToolContext,
   ): Promise<ToolExecutionResult> {
     const parsed = requestSystemPermissionInputSchema.safeParse(input);
     if (!parsed.success) {
@@ -103,7 +118,16 @@ export const requestSystemPermissionTool = {
     const permType = parsed.data.permission_type;
 
     const friendly = FRIENDLY_NAMES[permType];
-    const settingsUrl = SETTINGS_URLS[permType];
+    const settingsUrl = resolveSystemPermissionSettingsUrl(
+      permType,
+      context.clientOs,
+    );
+    if (!settingsUrl) {
+      return {
+        content: `${friendly} cannot be requested in-app on ${context.clientOs}. Ask the user to check the matching Privacy page in Windows Settings.`,
+        isError: true,
+      };
+    }
 
     return {
       content: [

package/src/tools/terminal/shell.test.ts

@@ -1,6 +1,13 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { setConfig } from "../../__tests__/helpers/set-config.js";
+import {
+  MAX_OUTPUT_LENGTH,
+  OUTPUT_TRUNCATED_TAG,
+} from "../shared/shell-output.js";
 import type { ToolContext } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -199,3 +206,59 @@ describe("foreground stdin handling", () => {
     expect(result.content).not.toContain("ENXIO");
   });
 });
+
+describe("streaming stdout cap", () => {
+  let tmpDir = "";
+
+  beforeEach(async () => {
+    events.length = 0;
+    _clearRegistryForTesting();
+    tmpDir = await mkdtemp(join(tmpdir(), "bash-cap-"));
+  });
+
+  afterEach(async () => {
+    _clearRegistryForTesting();
+    if (tmpDir) {
+      await rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  test("foreground drops stdout past the cap and lets the process finish", async () => {
+    const result = await shellTool.execute(
+      {
+        command: `${process.execPath} -e "process.stdout.write('x'.repeat(100000)); require('node:fs').writeFileSync('sentinel.txt','done')"`,
+        activity: "test",
+      },
+      { ...makeContext(), workingDir: tmpDir },
+    );
+
+    expect(result.isError).toBeFalsy();
+    expect(result.content).toContain(OUTPUT_TRUNCATED_TAG);
+    expect(result.content).not.toContain("file=");
+    expect(result.content.length).toBeLessThan(MAX_OUTPUT_LENGTH + 80);
+    expect(await readFile(join(tmpDir, "sentinel.txt"), "utf-8")).toBe("done");
+  });
+
+  test("background drops stdout past the cap and lets the process finish", async () => {
+    const result = await shellTool.execute(
+      {
+        command: `${process.execPath} -e "process.stdout.write('x'.repeat(100000)); require('node:fs').writeFileSync('sentinel.txt','done')"`,
+        activity: "test",
+        background: true,
+      },
+      { ...makeContext(), workingDir: tmpDir },
+    );
+    expect(result.isError).toBeFalsy();
+
+    await waitFor(() => completedEvents().length > 0);
+    const completed = completedEvents();
+    expect(completed).toHaveLength(1);
+    expect(completed[0]).toMatchObject({ status: "completed", exitCode: 0 });
+    expect(String(completed[0]?.output)).toContain(OUTPUT_TRUNCATED_TAG);
+    expect(String(completed[0]?.output)).not.toContain("file=");
+    expect(String(completed[0]?.output).length).toBeLessThan(
+      MAX_OUTPUT_LENGTH + 80,
+    );
+    expect(await readFile(join(tmpDir, "sentinel.txt"), "utf-8")).toBe("done");
+  });
+});

package/src/tools/terminal/shell.ts

@@ -32,7 +32,7 @@ import {
   getSessionEnv,
 } from "../network/script-proxy/index.js";
 import {
-  formatShellOutput,
+  attachBoundedStdio,
   MAX_OUTPUT_LENGTH,
 } from "../shared/shell-output.js";
 import {
@@ -316,8 +316,6 @@ export const shellTool = {
       }
 
       const bgId = generateBackgroundToolId();
-      const stdoutChunks: Buffer[] = [];
-      const stderrChunks: Buffer[] = [];
       let timedOut = false;
       let aborted = false;
       const startedAt = Date.now();
@@ -327,7 +325,9 @@ export const shellTool = {
         env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: true,
+        windowsHide: true,
       });
+      const collector = attachBoundedStdio(child);
 
       const killTree = buildKillTree(child, {
         toolName: "bash",
@@ -342,14 +342,6 @@ export const shellTool = {
         killTree("timeout");
       }, timeoutMs);
 
-      child.stdout.on("data", (data: Buffer) => {
-        stdoutChunks.push(data);
-      });
-
-      child.stderr.on("data", (data: Buffer) => {
-        stderrChunks.push(data);
-      });
-
       // Guard against double-wake: when spawn fails (e.g. invalid cwd),
       // Node emits both 'error' and 'close' for the same child process.
       // Only the first handler to fire should wake the agent.
@@ -375,15 +367,7 @@ export const shellTool = {
           timedOut,
         });
 
-        const stdout = Buffer.concat(stdoutChunks).toString();
-        const stderr = Buffer.concat(stderrChunks).toString();
-        const fmtResult = formatShellOutput(
-          stdout,
-          stderr,
-          code,
-          timedOut,
-          timeoutSec,
-        );
+        const fmtResult = collector.format(code, timedOut, timeoutSec);
 
         const status: BackgroundToolCompletedEvent["status"] = aborted
           ? "cancelled"
@@ -392,7 +376,7 @@ export const shellTool = {
             : code === 0
               ? "completed"
               : "failed";
-        // A cancelled command exits with a null code, which formatShellOutput
+        // A cancelled command exits with a null code, which the formatter
         // frames as "failed"; surface the cancellation instead.
         const output =
           status === "cancelled"
@@ -427,8 +411,8 @@ export const shellTool = {
           untrustedOutput: {
             content: output,
             source: "tool_result",
-            // Already bounded + recovery-marked by formatShellOutput; a larger
-            // budget keeps wrapUntrustedContent from re-truncating the marker.
+            // Bounded output plus the truncation marker; a larger budget
+            // keeps wrapUntrustedContent from slicing the marker off.
             maxChars: MAX_OUTPUT_LENGTH * 2,
           },
         });
@@ -538,8 +522,6 @@ export const shellTool = {
     // Foreground mode: await the process and return its output.
     // -----------------------------------------------------------------------
     const result = await new Promise<ToolExecutionResult>((resolve) => {
-      const stdoutChunks: Buffer[] = [];
-      const stderrChunks: Buffer[] = [];
       let timedOut = false;
       const startedAt = Date.now();
 
@@ -548,6 +530,10 @@ export const shellTool = {
         env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: true,
+        windowsHide: true,
+      });
+      const collector = attachBoundedStdio(child, {
+        onOutput: context.onOutput,
       });
 
       const killTree = buildKillTree(child, {
@@ -572,16 +558,6 @@ export const shellTool = {
         }
       }
 
-      child.stdout.on("data", (data: Buffer) => {
-        stdoutChunks.push(data);
-        context.onOutput?.(data.toString());
-      });
-
-      child.stderr.on("data", (data: Buffer) => {
-        stderrChunks.push(data);
-        context.onOutput?.(data.toString());
-      });
-
       child.on("close", (code, signal) => {
         clearTimeout(timer);
         context.signal?.removeEventListener("abort", onAbort);
@@ -597,15 +573,7 @@ export const shellTool = {
           timedOut,
         });
 
-        const stdout = Buffer.concat(stdoutChunks).toString();
-        const stderr = Buffer.concat(stderrChunks).toString();
-        const fmtResult = formatShellOutput(
-          stdout,
-          stderr,
-          code,
-          timedOut,
-          timeoutSec,
-        );
+        const fmtResult = collector.format(code, timedOut, timeoutSec);
 
         resolve({
           content: fmtResult.content,

package/src/tools/tool-input-schemas.ts

@@ -1,6 +1,7 @@
 import type { z } from "zod";
 
 import { askQuestionInputSchema } from "./ask-question/ask-question-tool.js";
+import { reactToMessageInputSchema } from "./channel/react-to-message.js";
 import { fileEditInputSchema } from "./filesystem/edit.js";
 import { fileListInputSchema } from "./filesystem/list.js";
 import { fileReadInputSchema } from "./filesystem/read.js";
@@ -56,6 +57,7 @@ export const TOOL_INPUT_SCHEMAS: Readonly<Record<string, z.ZodType>> = {
   host_file_read: hostFileReadInputSchema,
   host_file_write: hostFileWriteInputSchema,
   notify_parent: notifyParentInputSchema,
+  react_to_message: reactToMessageInputSchema,
   request_system_permission: requestSystemPermissionInputSchema,
 };
 

package/src/tools/tool-manifest.ts

@@ -12,6 +12,7 @@ import {
   rememberTool,
 } from "../plugins/defaults/memory/tools.js";
 import { askQuestionTool } from "./ask-question/ask-question-tool.js";
+import { reactToMessageTool } from "./channel/react-to-message.js";
 import { fileEditTool } from "./filesystem/edit.js";
 import { fileListTool } from "./filesystem/list.js";
 import { fileReadTool } from "./filesystem/read.js";
@@ -65,6 +66,7 @@ export const explicitTools: ToolDefinition[] = [
   deleteMemoryPageTool,
   notifyParentTool,
   askQuestionTool,
+  reactToMessageTool,
   hostFileReadTool,
   hostFileWriteTool,
   hostFileEditTool,

package/src/usage/attribution.ts

@@ -19,6 +19,13 @@ export type UsageAttributionProfileSource =
 
 export interface UsageAttributionInput {
   callSite: LLMCallSite | null;
+  /**
+   * Call site used to pick the winning profile. Defaults to {@link callSite}.
+   * Compaction invokes the provider as `mainAgent` (prefix cache) but tags
+   * the usage row as `compactionAgent`; pass `mainAgent` here so
+   * `appliedProfile` / `profileSource` match the request that ran.
+   */
+  profileResolutionCallSite?: LLMCallSite | null;
   overrideProfile?: string | null;
   /**
    * Mirrors `ResolveCallSiteOpts.forceOverrideProfile`: the override profile
@@ -130,9 +137,10 @@ export function resolveUsageAttribution(
 ): UsageAttributionSnapshot {
   const llm = getConfig().llm;
   const callSite = input.callSite;
+  const resolutionCallSite = input.profileResolutionCallSite ?? callSite;
   const overrideProfile = normalizeProfileId(input.overrideProfile);
 
-  if (callSite == null) {
+  if (resolutionCallSite == null) {
     const resolvedMainAgent = resolveCallSiteConfig("mainAgent", llm, {
       ...(input.selectionSeed != null
         ? { selectionSeed: input.selectionSeed }
@@ -158,7 +166,7 @@ export function resolveUsageAttribution(
   // Capture which arm each expanded mix resolved to so we can attribute usage
   // to the arm behind the applied (mix) profile below.
   const mixSelections = new Map<string, string>();
-  const resolved = resolveCallSiteConfig(callSite, llm, {
+  const resolved = resolveCallSiteConfig(resolutionCallSite, llm, {
     ...(overrideProfile != null ? { overrideProfile } : {}),
     ...(input.forceOverrideProfile === true
       ? { forceOverrideProfile: true }
@@ -171,13 +179,13 @@ export function resolveUsageAttribution(
   });
   const activeProfile = normalizeProfileId(llm.activeProfile);
   const callSiteProfile = normalizeProfileId(
-    llm.callSites?.[callSite]?.profile,
+    llm.callSites?.[resolutionCallSite]?.profile,
   );
   // The resolver's own winner selection is the single source of truth for which
   // profile applied — attribution must never re-derive precedence and drift
   // from dispatch.
   const profile = appliedProfileFromWinnerSelection(
-    callSite,
+    resolutionCallSite,
     llm,
     overrideProfile,
     input,

package/src/util/__tests__/worker-ownership.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+
+import { isDaemonCommand } from "../worker-ownership.js";
+
+// This predicate authorises an irreversible signal in killStaleDaemon, so it
+// judges argv shape rather than substring. The negative cases are the
+// collision cli/src/lib/orphan-detection.test.ts already pins as something we
+// must not claim.
+describe("isDaemonCommand", () => {
+  test("source daemon: bun with the entry script as an argument", () => {
+    expect(
+      isDaemonCommand(
+        "bun run /app/runtime/0.11.7/node_modules/@vellumai/assistant/src/daemon/main.ts",
+      ),
+    ).toBe(true);
+  });
+
+  test("packaged daemon as argv0", () => {
+    expect(isDaemonCommand("/Applications/Vellum/vellum-daemon")).toBe(true);
+  });
+
+  // The ordinary Windows install path contains a space, so splitting on
+  // whitespace before honouring quotes would yield argv0 "Program" and make
+  // the packaged daemon invisible to the recovery path this predicate serves.
+  test("packaged Windows daemon under an install path containing spaces", () => {
+    expect(
+      isDaemonCommand(
+        '"C:\\Program Files\\Vellum\\resources\\cli-runtime\\vellum-daemon.exe"',
+      ),
+    ).toBe(true);
+    expect(
+      isDaemonCommand(
+        '"C:\\Program Files\\Vellum\\resources\\cli-runtime\\vellum-daemon.exe" --serve',
+      ),
+    ).toBe(true);
+  });
+
+  test("quoted bun entry-script argument under a path containing spaces", () => {
+    expect(
+      isDaemonCommand(
+        '"C:\\Program Files\\bun\\bun.exe" run "C:\\Program Files\\Vellum\\src\\daemon\\main.ts"',
+      ),
+    ).toBe(true);
+  });
+
+  // POSIX joins argv with spaces, so an entry path containing a space arrives
+  // pre-split; the tail token still carries the entry, which is what matches.
+  test("unquoted POSIX entry path containing a space", () => {
+    expect(
+      isDaemonCommand(
+        "/home/mary/.bun/bin/bun run /home/Mary Jane/runtime/src/daemon/main.ts",
+      ),
+    ).toBe(true);
+  });
+
+  // process.title rewrites the source daemon's argv on Linux.
+  test("a daemon that renamed its own process title", () => {
+    expect(isDaemonCommand("vellum-daemon")).toBe(true);
+  });
+
+  test("unrelated service whose argv merely contains a daemon/main path", () => {
+    expect(isDaemonCommand("node /opt/unrelated-service/daemon/main.ts")).toBe(
+      false,
+    );
+  });
+
+  test("an editor or tool holding a recycled PID", () => {
+    expect(isDaemonCommand("vim /app/runtime/0.11.7/src/daemon/main.ts")).toBe(
+      false,
+    );
+  });
+
+  test("unreadable or empty command line", () => {
+    expect(isDaemonCommand(null)).toBe(false);
+    expect(isDaemonCommand("")).toBe(false);
+  });
+});