@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/config/schemas/__tests__/voice.test.ts

@@ -1,148 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { VoiceConfigSchema, VoiceFrontModelConfigSchema } from "../voice.js";
-
-const PROGRESS_DEFAULTS = {
-  enabled: true,
-  opsThreshold: 3,
-  idleIntervalMs: 5_000,
-  maxSilenceMs: 35_000,
-  longOpMs: 15_000,
-  minGapMs: 6_000,
-  generationTimeoutMs: 1_500,
-};
-
-const FRONT_MODEL_DEFAULTS = {
-  endpointDecisionTimeoutMs: 1200,
-  endpointExtensionMs: 1500,
-  endpointMaxExtensions: 2,
-  progress: PROGRESS_DEFAULTS,
-};
-
-describe("VoiceFrontModelConfigSchema", () => {
-  test("empty object parses to defaults", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({});
-    expect(parsed).toEqual(FRONT_MODEL_DEFAULTS);
-  });
-
-  test("accepts overrides", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({
-      endpointDecisionTimeoutMs: 400,
-      endpointMaxExtensions: 0,
-    });
-    expect(parsed.endpointDecisionTimeoutMs).toBe(400);
-    expect(parsed.endpointMaxExtensions).toBe(0);
-    // Unspecified fields still get defaults
-    expect(parsed.endpointExtensionMs).toBe(1500);
-  });
-
-  test("strips retired generated-ack settings", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({
-      ackFirstDeltaTimeoutMs: 2500,
-      ackGenerationTimeoutMs: 600,
-    });
-    expect(parsed).not.toHaveProperty("ackFirstDeltaTimeoutMs");
-    expect(parsed).not.toHaveProperty("ackGenerationTimeoutMs");
-  });
-
-  test("rejects non-positive endpointDecisionTimeoutMs", () => {
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      endpointDecisionTimeoutMs: 0,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects negative endpointMaxExtensions", () => {
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      endpointMaxExtensions: -1,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("absent progress namespace parses to full progress defaults", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({});
-    expect(parsed.progress).toEqual(PROGRESS_DEFAULTS);
-  });
-
-  test("partial progress overrides merge with defaults", () => {
-    const parsed = VoiceFrontModelConfigSchema.parse({
-      progress: { enabled: false, opsThreshold: 5 },
-    });
-    expect(parsed.progress.enabled).toBe(false);
-    expect(parsed.progress.opsThreshold).toBe(5);
-    // Unspecified progress fields still get defaults
-    expect(parsed.progress.idleIntervalMs).toBe(5_000);
-    expect(parsed.progress.maxSilenceMs).toBe(35_000);
-    expect(parsed.progress.longOpMs).toBe(15_000);
-    expect(parsed.progress.minGapMs).toBe(6_000);
-    expect(parsed.progress.generationTimeoutMs).toBe(1_500);
-  });
-
-  test("a stale maxPerTurn key is stripped, not rejected", () => {
-    // The cap was removed; configs written while it existed must still parse.
-    const parsed = VoiceFrontModelConfigSchema.parse({
-      progress: { maxPerTurn: 3 },
-    });
-    expect("maxPerTurn" in parsed.progress).toBe(false);
-  });
-
-  test("rejects non-positive progress.opsThreshold", () => {
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      progress: { opsThreshold: 0 },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects a heartbeat ceiling shorter than the idle tick interval", () => {
-    // The heartbeat is only checked on the idle tick, so a shorter ceiling
-    // could be overshot by a full interval.
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      progress: { idleIntervalMs: 60_000, maxSilenceMs: 10_000 },
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      const msgs = result.error.issues.map((issue) => issue.message);
-      expect(
-        msgs.some((msg) =>
-          msg.includes("voice.frontModel.progress.maxSilenceMs"),
-        ),
-      ).toBe(true);
-    }
-    // The floor itself is allowed: the tick is exactly on the ceiling.
-    expect(
-      VoiceFrontModelConfigSchema.safeParse({
-        progress: { idleIntervalMs: 60_000, maxSilenceMs: 60_000 },
-      }).success,
-    ).toBe(true);
-  });
-
-  test("rejects a non-boolean progress.enabled", () => {
-    const result = VoiceFrontModelConfigSchema.safeParse({
-      progress: { enabled: "yes" },
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      const msgs = result.error.issues.map((i) => i.message);
-      expect(
-        msgs.some((m) => m.includes("voice.frontModel.progress.enabled")),
-      ).toBe(true);
-    }
-  });
-});
-
-describe("VoiceConfigSchema", () => {
-  test("empty object parses to front-model defaults", () => {
-    expect(VoiceConfigSchema.parse({})).toEqual({
-      frontModel: FRONT_MODEL_DEFAULTS,
-    });
-  });
-
-  test("partial frontModel overrides merge with defaults", () => {
-    const parsed = VoiceConfigSchema.parse({
-      frontModel: { endpointDecisionTimeoutMs: 300 },
-    });
-    expect(parsed.frontModel.endpointDecisionTimeoutMs).toBe(300);
-    expect(parsed.frontModel.endpointExtensionMs).toBe(1500);
-    expect(parsed.frontModel.progress).toEqual(PROGRESS_DEFAULTS);
-  });
-});

package/src/config/schemas/voice.ts

@@ -1,150 +0,0 @@
-import { z } from "zod";
-
-export const VoiceProgressConfigSchema = z
-  .object({
-    enabled: z
-      .boolean({
-        error: "voice.frontModel.progress.enabled must be a boolean",
-      })
-      .default(true)
-      .describe(
-        "Speak short progress updates during long-running tool-heavy turns; the opt-out for progress narration",
-      ),
-    opsThreshold: z
-      .number({
-        error: "voice.frontModel.progress.opsThreshold must be a number",
-      })
-      .int("voice.frontModel.progress.opsThreshold must be an integer")
-      .positive(
-        "voice.frontModel.progress.opsThreshold must be a positive integer",
-      )
-      .default(3)
-      .describe(
-        "Narrate after this many tool operations since the last narration",
-      ),
-    idleIntervalMs: z
-      .number({
-        error: "voice.frontModel.progress.idleIntervalMs must be a number",
-      })
-      .int("voice.frontModel.progress.idleIntervalMs must be an integer")
-      .positive(
-        "voice.frontModel.progress.idleIntervalMs must be a positive integer",
-      )
-      .default(5_000)
-      .describe(
-        "How often (ms) a running turn's silence is checked, and so the soonest new tool activity is narrated",
-      ),
-    maxSilenceMs: z
-      .number({
-        error: "voice.frontModel.progress.maxSilenceMs must be a number",
-      })
-      .int("voice.frontModel.progress.maxSilenceMs must be an integer")
-      .positive(
-        "voice.frontModel.progress.maxSilenceMs must be a positive integer",
-      )
-      .default(35_000)
-      .describe(
-        "Heartbeat ceiling (ms): narrate after this much unbroken silence even when nothing new has happened. Evaluated on the idle tick, so its resolution is idleIntervalMs and it must be at least that long",
-      ),
-    longOpMs: z
-      .number({
-        error: "voice.frontModel.progress.longOpMs must be a number",
-      })
-      .int("voice.frontModel.progress.longOpMs must be an integer")
-      .positive("voice.frontModel.progress.longOpMs must be a positive integer")
-      .default(15_000)
-      .describe(
-        "A tool operation that ran at least this long (ms) narrates the moment it completes, without waiting for opsThreshold",
-      ),
-    minGapMs: z
-      .number({
-        error: "voice.frontModel.progress.minGapMs must be a number",
-      })
-      .int("voice.frontModel.progress.minGapMs must be an integer")
-      .positive("voice.frontModel.progress.minGapMs must be a positive integer")
-      .default(6_000)
-      .describe(
-        "Minimum spacing (ms) from any spoken floor-holder (ack or narration)",
-      ),
-    generationTimeoutMs: z
-      .number({
-        error: "voice.frontModel.progress.generationTimeoutMs must be a number",
-      })
-      .int("voice.frontModel.progress.generationTimeoutMs must be an integer")
-      .positive(
-        "voice.frontModel.progress.generationTimeoutMs must be a positive integer",
-      )
-      .default(1_500)
-      .describe(
-        "Budget (ms) for LLM-generated progress text. Not latency-critical: it speaks into dead air",
-      ),
-  })
-  // The heartbeat is checked when the idle tick finds the turn silent, so a
-  // ceiling shorter than the tick interval would be missed by up to a full
-  // interval, a promise the cadence cannot keep. Rejecting the combination
-  // beats silently overshooting it.
-  .refine((progress) => progress.maxSilenceMs >= progress.idleIntervalMs, {
-    error:
-      "voice.frontModel.progress.maxSilenceMs must be at least idleIntervalMs: the heartbeat is evaluated on the idle tick",
-  })
-  .describe(
-    "Progress-narration tuning for live voice sessions (spoken updates during long-running turns)",
-  );
-
-export const VoiceFrontModelConfigSchema = z
-  .object({
-    endpointDecisionTimeoutMs: z
-      .number({
-        error: "voice.frontModel.endpointDecisionTimeoutMs must be a number",
-      })
-      .int("voice.frontModel.endpointDecisionTimeoutMs must be an integer")
-      .positive(
-        "voice.frontModel.endpointDecisionTimeoutMs must be a positive integer",
-      )
-      .default(1200)
-      .describe(
-        "Hard budget (ms) for the endpoint decision LLM call. This adds to end-of-turn latency when semantic endpointing is on, so keep it as tight as the decider model's real roundtrip allows. Measured Haiku roundtrips through the managed proxy run ~670-1130ms (dev), so tighter budgets turn the feature into a fail-open no-op.",
-      ),
-    endpointExtensionMs: z
-      .number({
-        error: "voice.frontModel.endpointExtensionMs must be a number",
-      })
-      .int("voice.frontModel.endpointExtensionMs must be an integer")
-      .positive(
-        "voice.frontModel.endpointExtensionMs must be a positive integer",
-      )
-      .default(1500)
-      .describe(
-        "How long (ms) a 'hold' decision keeps the turn open before turn-end replays",
-      ),
-    endpointMaxExtensions: z
-      .number({
-        error: "voice.frontModel.endpointMaxExtensions must be a number",
-      })
-      .int("voice.frontModel.endpointMaxExtensions must be an integer")
-      .nonnegative(
-        "voice.frontModel.endpointMaxExtensions must be a nonnegative integer",
-      )
-      .default(2)
-      .describe("Cap on consecutive 'hold' extensions per utterance"),
-    progress: VoiceProgressConfigSchema.default(
-      VoiceProgressConfigSchema.parse({}),
-    ),
-  })
-  .describe(
-    "Voice front-door endpointing and long-turn progress narration tuning, shared by live voice and phone calls",
-  );
-
-export const VoiceConfigSchema = z
-  .object({
-    frontModel: VoiceFrontModelConfigSchema.default(
-      VoiceFrontModelConfigSchema.parse({}),
-    ),
-  })
-  .describe(
-    "Transport-agnostic voice configuration shared by live voice and phone calls: front-door routing and progress narration tuning",
-  );
-
-export type VoiceConfig = z.infer<typeof VoiceConfigSchema>;
-export type VoiceFrontModelConfig = z.infer<typeof VoiceFrontModelConfigSchema>;
-export type VoiceProgressConfig = z.infer<typeof VoiceProgressConfigSchema>;

package/src/daemon/__tests__/skill-memory-refresh-mtime.test.ts

@@ -1,133 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
-
-const WORKSPACE_DIR = mkdtempSync(join(tmpdir(), "skill-md-mtime-refresh-"));
-process.env.VELLUM_WORKSPACE_DIR = WORKSPACE_DIR;
-
-const seedGraphCalls: number[] = [];
-const seedV2Calls: number[] = [];
-
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => ({}),
-}));
-
-mock.module("../../plugins/defaults/memory/graph/capability-seed.js", () => ({
-  seedSkillGraphNodes: () => {
-    seedGraphCalls.push(Date.now());
-  },
-  seedUninstalledCatalogSkillMemories: async () => {},
-}));
-
-mock.module(
-  "../../plugins/defaults/memory/substrate/boot-maintenance.js",
-  () => ({
-    maybeSeedCapabilitySkills: () => {
-      seedV2Calls.push(Date.now());
-    },
-    maybeSeedCliCommandCards: () => {},
-  }),
-);
-
-const {
-  _resetSkillMdMtimeStateForTests,
-  maybeRefreshSkillCapabilityMemoriesFromMtime,
-  refreshSkillCapabilityMemories,
-  startWorkspaceSkillMdMtimePoll,
-  stopWorkspaceSkillMdMtimePoll,
-} = await import("../skill-memory-refresh.js");
-
-const SKILLS_DIR = join(WORKSPACE_DIR, "skills");
-
-function writeSkill(id: string): string {
-  const dir = join(SKILLS_DIR, id);
-  mkdirSync(dir, { recursive: true });
-  const skillMd = join(dir, "SKILL.md");
-  writeFileSync(
-    skillMd,
-    `---\nname: ${id}\ndescription: ${id}\n---\nbody\n`,
-  );
-  return skillMd;
-}
-
-describe("maybeRefreshSkillCapabilityMemoriesFromMtime", () => {
-  beforeEach(() => {
-    rmSync(SKILLS_DIR, { recursive: true, force: true });
-    mkdirSync(SKILLS_DIR, { recursive: true });
-    seedGraphCalls.length = 0;
-    seedV2Calls.length = 0;
-    _resetSkillMdMtimeStateForTests();
-  });
-
-  afterEach(() => {
-    _resetSkillMdMtimeStateForTests();
-  });
-
-  test("first call reseeds, a second call with unchanged SKILL.md does not", () => {
-    writeSkill("alpha");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-    expect(seedGraphCalls).toHaveLength(1);
-    expect(seedV2Calls).toHaveLength(1);
-
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(false);
-    expect(seedGraphCalls).toHaveLength(1);
-  });
-
-  test("explicit refresh remembers the signature so the next poll is a no-op", () => {
-    writeSkill("alpha");
-    refreshSkillCapabilityMemories();
-    expect(seedGraphCalls).toHaveLength(1);
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(false);
-  });
-
-  test("SKILL.md mtime change reseeds", () => {
-    const skillMd = writeSkill("alpha");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-
-    const later = new Date(Date.now() + 5_000);
-    utimesSync(skillMd, later, later);
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-    expect(seedGraphCalls).toHaveLength(2);
-  });
-
-  test("TOOLS.json change without a SKILL.md mtime change does not reseed", () => {
-    writeSkill("alpha");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-
-    writeFileSync(
-      join(SKILLS_DIR, "alpha", "TOOLS.json"),
-      JSON.stringify({ version: 1, tools: [] }),
-    );
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(false);
-    expect(seedGraphCalls).toHaveLength(1);
-  });
-
-  test("adding or removing a skill directory reseeds", () => {
-    writeSkill("alpha");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-
-    writeSkill("bravo");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-
-    rmSync(join(SKILLS_DIR, "bravo"), { recursive: true, force: true });
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-    expect(seedGraphCalls).toHaveLength(3);
-  });
-
-  test("startWorkspaceSkillMdMtimePoll runs once immediately and is idempotent", () => {
-    writeSkill("alpha");
-    startWorkspaceSkillMdMtimePoll();
-    expect(seedGraphCalls).toHaveLength(1);
-    startWorkspaceSkillMdMtimePoll();
-    expect(seedGraphCalls).toHaveLength(1);
-    stopWorkspaceSkillMdMtimePoll();
-  });
-});

package/src/daemon/app-change-notify.ts

@@ -1,45 +0,0 @@
-/**
- * Fan out an app change to open conversation surfaces, connected clients,
- * and the publish pipeline.
- *
- * Compilation is the caller's responsibility. This module only notifies:
- * it must not call `compileApp()` because that begins with `rm -rf dist/`
- * and would race a compile already in flight.
- */
-
-import { broadcastMessage } from "../runtime/assistant-event-hub.js";
-import { publishAppsChanged } from "../runtime/sync/resource-sync-events.js";
-import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
-import type { Conversation } from "./conversation.js";
-import { allConversations } from "./conversation-registry.js";
-import { refreshSurfacesForApp } from "./conversation-surfaces.js";
-
-export function broadcastAppFilesChanged(appId: string): void {
-  broadcastMessage({ type: "app_files_changed", appId });
-  publishAppsChanged();
-}
-
-/**
- * Refresh every in-memory conversation that has this app open, then broadcast
- * and re-deploy. Pass `alsoRefresh` when the calling conversation might not
- * yet be in the registry (tool post-execution hooks).
- */
-export function notifyAppSurfacesChanged(
-  appId: string,
-  opts?: { fileChange?: boolean; status?: string },
-  alsoRefresh?: Conversation,
-): void {
-  const seen = new Set<string>();
-  if (alsoRefresh) {
-    refreshSurfacesForApp(alsoRefresh, appId, opts);
-    seen.add(alsoRefresh.conversationId);
-  }
-  for (const conversation of allConversations()) {
-    if (seen.has(conversation.conversationId)) {
-      continue;
-    }
-    refreshSurfacesForApp(conversation, appId, opts);
-  }
-  broadcastAppFilesChanged(appId);
-  void updatePublishedAppDeployment(appId);
-}

package/src/desktop/__tests__/fake-desktop.ts

@@ -1,119 +0,0 @@
-import { join } from "node:path";
-
-import { sleep } from "../../util/retry.js";
-import {
-  type DesktopChild,
-  type DesktopChildRole,
-  type DesktopLoss,
-  DesktopSessionManager,
-  type DesktopSpawnRequest,
-} from "../desktop-session-manager.js";
-
-/** A child the test exits by hand. */
-class FakeChild implements DesktopChild {
-  private static nextPid = 1000;
-  readonly pid = FakeChild.nextPid++;
-  readonly exited: Promise<number>;
-  private settle!: (code: number) => void;
-
-  constructor(
-    readonly role: DesktopChildRole,
-    readonly request: DesktopSpawnRequest,
-  ) {
-    this.exited = new Promise((resolve) => {
-      this.settle = resolve;
-    });
-  }
-
-  kill(): void {}
-
-  exit(code = 0): void {
-    this.settle(code);
-  }
-}
-
-export const LINGER_MS = 20;
-export const KILL_GRACE_MS = 20;
-
-export interface FakeDesktopOptions {
-  profileDir: string;
-  /** Defaults inside `profileDir`, for tests that ignore the dock's config. */
-  panelConfigDir?: string;
-  /** Roles whose spawn throws, to exercise a start that fails partway. */
-  failSpawn?: DesktopChildRole[];
-  /** Binaries `which` cannot find. */
-  missingBinaries?: string[];
-  /** Whether a SIGTERM makes the fake child exit on its own. */
-  exitOnTerm?: boolean;
-  /** Whether a SIGKILL does; without either the child survives both. */
-  exitOnKill?: boolean;
-  sourceEnv?: NodeJS.ProcessEnv;
-  renderWallpaper?: (width: number, height: number) => Promise<Buffer | null>;
-}
-
-export function newFakeDesktop(options: FakeDesktopOptions) {
-  const spawned: FakeChild[] = [];
-  const killed: { child: FakeChild; signal: string }[] = [];
-  let vncReady = true;
-  let chromiumPath: () => Promise<string> = async () => "/fake/chromium";
-  const manager = new DesktopSessionManager({
-    spawn: (role, request) => {
-      if (options.failSpawn?.includes(role)) {
-        throw new Error(`spawn ${role} failed`);
-      }
-      const child = new FakeChild(role, request);
-      spawned.push(child);
-      return child;
-    },
-    which: (binary) =>
-      options.missingBinaries?.includes(binary) ? null : `/usr/bin/${binary}`,
-    probeVncPort: async () => vncReady,
-    resolveChromePath: () => chromiumPath(),
-    renderWallpaper: options.renderWallpaper ?? (async () => null),
-    killProcessGroup: (child, signal) => {
-      killed.push({ child: child as FakeChild, signal });
-      const exits =
-        signal === "SIGTERM" ? options.exitOnTerm : options.exitOnKill;
-      if (exits) {
-        (child as FakeChild).exit(0);
-      }
-    },
-    lingerMs: LINGER_MS,
-    readyDeadlineMs: 30,
-    killGraceMs: KILL_GRACE_MS,
-    profileDir: options.profileDir,
-    panelConfigDir:
-      options.panelConfigDir ?? join(options.profileDir, "desktop-panel"),
-    sourceEnv: options.sourceEnv,
-  });
-  return {
-    manager,
-    spawned,
-    killed,
-    /** Children that got a SIGTERM, in order. */
-    terminated: () =>
-      killed.filter((k) => k.signal === "SIGTERM").map((k) => k.child),
-    setVncReady: (ready: boolean) => {
-      vncReady = ready;
-    },
-    setChromiumPath: (resolve: () => Promise<string>) => {
-      chromiumPath = resolve;
-    },
-    child: (role: DesktopChildRole) =>
-      spawned.filter((c) => c.role === role).at(-1)!,
-    roles: () => spawned.map((c) => c.role),
-    count: (role: DesktopChildRole) =>
-      spawned.filter((c) => c.role === role).length,
-  };
-}
-
-/** Let one awaited step (a path resolution, an exit callback) land. */
-export const settle = (): Promise<void> => sleep(0);
-
-export function newViewer() {
-  const lost: DesktopLoss[] = [];
-  return {
-    lost,
-    viewer: { onDesktopLost: (loss: DesktopLoss) => lost.push(loss) },
-  };
-}

package/src/desktop/desktop-chrome-policy.test.ts

@@ -1,71 +0,0 @@
-import {
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, expect, test } from "bun:test";
-
-import { writeDesktopChromePolicy } from "./desktop-chrome-policy.js";
-
-const directories: string[] = [];
-function policyDirectory(): string {
-  const path = mkdtempSync(join(tmpdir(), "desktop-chrome-policy-"));
-  directories.push(path);
-  return path;
-}
-
-afterEach(() => {
-  for (const path of directories.splice(0)) {
-    rmSync(path, { recursive: true, force: true });
-  }
-});
-
-test("preserves unrelated policies and does not rewrite on repeated startup", () => {
-  const directory = policyDirectory();
-  const path = join(directory, "vellum-desktop.json");
-  const otherPath = join(directory, "organization.json");
-  const unrelated = '{ "HomepageLocation": "https://example.com" }\n';
-  writeFileSync(otherPath, unrelated);
-  writeFileSync(path, JSON.stringify({ DownloadRestrictions: 1 }));
-
-  writeDesktopChromePolicy(directory);
-  const content = readFileSync(path, "utf8");
-  expect(JSON.parse(content).DownloadRestrictions).toBe(1);
-  expect(readFileSync(otherPath, "utf8")).toBe(unrelated);
-  expect(readdirSync(directory).sort()).toEqual([
-    "organization.json",
-    "vellum-desktop.json",
-  ]);
-
-  const before = statSync(path);
-  writeDesktopChromePolicy(directory);
-  expect(readFileSync(path, "utf8")).toBe(content);
-  expect(statSync(path).ino).toBe(before.ino);
-  expect(statSync(path).mtimeMs).toBe(before.mtimeMs);
-});
-
-test("creates missing policy directories for a fresh desktop", () => {
-  const directory = join(policyDirectory(), "policies", "managed");
-  writeDesktopChromePolicy(directory);
-  expect(readdirSync(directory)).toEqual(["vellum-desktop.json"]);
-  expect(statSync(join(directory, "vellum-desktop.json")).mode & 0o777).toBe(
-    0o644,
-  );
-});
-
-test.each(["{broken", "[]", "null", "false"])(
-  "leaves invalid existing policy content untouched: %s",
-  (content) => {
-    const directory = policyDirectory();
-    const path = join(directory, "vellum-desktop.json");
-    writeFileSync(path, content);
-    expect(() => writeDesktopChromePolicy(directory)).toThrow();
-    expect(readFileSync(path, "utf8")).toBe(content);
-    expect(readdirSync(directory)).toEqual(["vellum-desktop.json"]);
-  },
-);