@indigoai-us/hq-cloud 6.14.17 → 6.14.19

package/src/s3.ts

@@ -321,6 +321,53 @@ function removeTempPath(tempPath: string): void {
   }
 }
 
+export interface CreateStagedSymlinkOps {
+  platform: NodeJS.Platform;
+  symlink(target: string, linkPath: string, type?: fs.symlink.Type): void;
+  statIsDirectory(absPath: string): boolean | undefined;
+}
+
+const DEFAULT_CREATE_STAGED_SYMLINK_OPS: CreateStagedSymlinkOps = {
+  platform: process.platform,
+  symlink: (target, linkPath, type) =>
+    fs.symlinkSync(target, linkPath, type),
+  statIsDirectory: (absPath) => {
+    try {
+      return fs.statSync(absPath).isDirectory();
+    } catch {
+      return undefined;
+    }
+  },
+};
+
+/**
+ * Create a fully-staged symlink without requiring Windows Developer Mode.
+ * NTFS symlinks fail with EPERM without SeCreateSymbolicLinkPrivilege, while
+ * directory junctions need no privilege but require an absolute target. HQ
+ * vault links are directory overlays, so missing targets default to junctions.
+ * See Sentry HQ-DESKTOP-3M.
+ */
+export function createStagedSymlink(
+  target: string,
+  linkPath: string,
+  ops: CreateStagedSymlinkOps = DEFAULT_CREATE_STAGED_SYMLINK_OPS,
+): void {
+  if (ops.platform !== "win32") {
+    ops.symlink(target, linkPath);
+    return;
+  }
+
+  const absTarget = path.isAbsolute(target)
+    ? target
+    : path.resolve(path.dirname(linkPath), target);
+  if (ops.statIsDirectory(absTarget) === false) {
+    ops.symlink(target, linkPath, "file");
+    return;
+  }
+
+  ops.symlink(absTarget, linkPath, "junction");
+}
+
 export interface ReplaceStagedPathOps {
   lstat(path: string): fs.Stats;
   rename(from: string, to: string): void;
@@ -1053,7 +1100,7 @@ export async function downloadFile(
 
     const tempPath = downloadTempPath(localPath);
     try {
-      fs.symlinkSync(symlinkTarget, tempPath);
+      createStagedSymlink(symlinkTarget, tempPath);
       options.beforeReplace?.();
       replaceStagedPath(tempPath, localPath);
     } catch (err) {

package/src/telemetry.test.ts

@@ -16,6 +16,7 @@ import * as path from "path";
 import {
   collectAndSendTelemetry,
   sanitizeRow,
+  extractServices,
   type CollectTelemetryOptions,
   type TelemetryClientSurface,
 } from "./telemetry.js";
@@ -203,6 +204,133 @@ describe("sanitizeRow", () => {
   });
 });
 
+// ── extractServices + sanitizeRow services emission (US-007) ─────────────────
+
+// An assistant row that invoked the Slack + Figma MCP servers. The tool_use
+// block `input` deliberately carries a URL + secret so the redaction assertions
+// have something dangerous to prove is dropped.
+const MCP_ROW = JSON.stringify({
+  type: "assistant",
+  timestamp: "2026-04-25T10:00:02Z",
+  sessionId: "s1",
+  uuid: "u3",
+  message: {
+    role: "assistant",
+    model: "claude-opus",
+    usage: { input_tokens: 10, output_tokens: 5 },
+    content: [
+      { type: "text", text: "calling tools" },
+      {
+        type: "tool_use",
+        id: "t1",
+        name: "mcp__slack__slack_send_message",
+        input: { channel: "#secret-ops", token: "xoxb-SECRET-TOKEN", text: "hi" },
+      },
+      {
+        type: "tool_use",
+        id: "t2",
+        name: "mcp__slack__slack_read_channel",
+        input: { url: "https://hooks.slack.com/leak", channel: "C123" },
+      },
+      {
+        type: "tool_use",
+        id: "t3",
+        name: "mcp__figma__get_screenshot",
+        input: { fileKey: "https://figma.com/file/PRIVATE" },
+      },
+      // A non-MCP builtin tool must NOT count as a service.
+      { type: "tool_use", id: "t4", name: "Bash", input: { command: "rm -rf /" } },
+    ],
+    id: "msg_3",
+  },
+});
+
+describe("extractServices (US-007)", () => {
+  it("counts MCP servers by name from tool_use block names", () => {
+    const services = extractServices(JSON.parse(MCP_ROW).message);
+    // Slack invoked twice, Figma once; Bash (builtin) excluded.
+    expect(services).toEqual({ slack: 2, figma: 1 });
+  });
+
+  it("returns undefined when the row touched no MCP server", () => {
+    expect(extractServices(JSON.parse(ASST_ROW).message)).toBeUndefined();
+    expect(extractServices(JSON.parse(USER_ROW).message)).toBeUndefined();
+    expect(extractServices(undefined)).toBeUndefined();
+    expect(extractServices({ content: "not an array" })).toBeUndefined();
+  });
+
+  it("preserves multi-underscore server names (mcp__claude_ai_Slack__…)", () => {
+    const msg = {
+      content: [
+        { type: "tool_use", id: "a", name: "mcp__claude_ai_Slack__slack_send_message", input: {} },
+        { type: "tool_use", id: "b", name: "mcp__claude_ai_Figma__get_screenshot", input: {} },
+      ],
+    };
+    // The server segment is everything between the first and the LAST `__`.
+    expect(extractServices(msg)).toEqual({
+      claude_ai_Slack: 1,
+      claude_ai_Figma: 1,
+    });
+  });
+
+  it("preserves a double-underscore in the server name (mcp__foo__bar__run)", () => {
+    const msg = {
+      content: [
+        { type: "tool_use", id: "a", name: "mcp__foo__bar__run", input: {} },
+      ],
+    };
+    // Delimiter is the LAST `__`, so server = `foo__bar`, tool = `run`.
+    expect(extractServices(msg)).toEqual({ "foo__bar": 1 });
+  });
+
+  it("counts servers whose names collide with Object.prototype members", () => {
+    const msg = {
+      content: [
+        { type: "tool_use", id: "a", name: "mcp__constructor__x", input: {} },
+        { type: "tool_use", id: "b", name: "mcp__constructor__y", input: {} },
+        { type: "tool_use", id: "c", name: "mcp__toString__z", input: {} },
+      ],
+    };
+    // A plain-object counter would read these off the prototype and produce a
+    // non-numeric count; the null-prototype map keeps them honest integers.
+    const out = extractServices(msg)!;
+    expect(out).toEqual({ constructor: 2, toString: 1 });
+    expect(typeof out.constructor).toBe("number");
+  });
+
+  // SECURITY-CRITICAL: names + counts ONLY. No args / URLs / payloads / secrets.
+  it("emits NAMES + COUNTS only — no args, URLs, payloads, or secrets", () => {
+    const out = sanitizeRow(JSON.parse(MCP_ROW))!;
+    expect(out.services).toEqual({ slack: 2, figma: 1 });
+
+    // The full serialized wire row must contain NONE of the dangerous input data.
+    const serialized = JSON.stringify(out);
+    expect(serialized).not.toContain("xoxb-SECRET-TOKEN");
+    expect(serialized).not.toContain("hooks.slack.com");
+    expect(serialized).not.toContain("figma.com/file/PRIVATE");
+    expect(serialized).not.toContain("#secret-ops");
+    expect(serialized).not.toContain("rm -rf");
+    // No tool names or input keys leaked — only the server names + counts.
+    expect(serialized).not.toContain("slack_send_message");
+    expect(serialized).not.toContain("get_screenshot");
+    expect(serialized).not.toContain("channel");
+    expect(serialized).not.toContain("token");
+    expect(serialized).not.toContain("url");
+
+    // The services VALUE is a map of string → number (counts) — never objects
+    // or strings that could smuggle structured data.
+    for (const [name, count] of Object.entries(out.services as Record<string, unknown>)) {
+      expect(typeof name).toBe("string");
+      expect(typeof count).toBe("number");
+    }
+  });
+
+  it("omits services entirely for a row with no MCP calls (backward-compatible)", () => {
+    const out = sanitizeRow(JSON.parse(ASST_ROW))!;
+    expect("services" in out).toBe(false);
+  });
+});
+
 // ── collectAndSendTelemetry ───────────────────────────────────────────────────
 
 describe("collectAndSendTelemetry", () => {

package/src/telemetry.ts

@@ -152,6 +152,73 @@ const KEEP_TOP_LEVEL = [
   "userType",
 ] as const;
 
+/**
+ * MCP tool_use blocks name their tool `mcp__<server>__<tool>` in a Claude Code
+ * session row's `message.content[]`. This recovers the SERVER segment only —
+ * the server/connector name (e.g. `slack`, `figma`). The tool segment and the
+ * block's `input` (args/URLs/payloads) are deliberately NEVER read.
+ *
+ * The `__` (double underscore) is the server↔tool delimiter, so the server is
+ * everything between the `mcp__` prefix and the LAST `__`. Using `lastIndexOf`
+ * (rather than a first-`__` split or a single-underscore-only regex) preserves
+ * legal underscores in server names — `_foo`, `foo_`, and `foo__bar` all parse
+ * correctly instead of being truncated or dropped. Returns `undefined` for a
+ * name that is not an `mcp__<server>__<tool>` with a non-empty server segment.
+ */
+const MCP_PREFIX = "mcp__";
+function mcpServerName(toolName: string): string | undefined {
+  if (!toolName.startsWith(MCP_PREFIX)) return undefined;
+  const rest = toolName.slice(MCP_PREFIX.length);
+  const delim = rest.lastIndexOf("__");
+  if (delim <= 0) return undefined; // no tool segment, or empty server
+  return rest.slice(0, delim);
+}
+
+/**
+ * SECURITY-CRITICAL (owner-telemetry-v2 US-007). Extract the MCP servers /
+ * connectors / integrations a session row touched as a NAMES-AND-COUNTS-ONLY map
+ * `{ <serverName>: <count> }` — e.g. `{ slack: 2, figma: 1 }`.
+ *
+ * This mirrors the `hasArgs` redaction precedent in skill-telemetry.ts: we look
+ * ONLY at the tool-use block's `name` (to recover the server segment of
+ * `mcp__<server>__<tool>`) and count occurrences. We NEVER read the block's
+ * `input` (which carries the args/URLs/payloads), never emit the tool name, and
+ * never emit any argument text. So no args, URLs, payloads, or secrets can reach
+ * the wire — only a service name and how many times it was invoked in this row.
+ *
+ * Returns `undefined` when the row touched no MCP server, so the caller omits the
+ * `services` field entirely (backward-compatible: old-shaped rows carry nothing
+ * new, and the server treats absence as "no services").
+ */
+export function extractServices(
+  message: unknown,
+): Record<string, number> | undefined {
+  if (!message || typeof message !== "object" || Array.isArray(message)) {
+    return undefined;
+  }
+  const content = (message as Record<string, unknown>).content;
+  if (!Array.isArray(content)) return undefined;
+
+  // Null-prototype map: server names come from untrusted session content and can
+  // legally be `constructor`, `toString`, etc. A plain `{}` would read those off
+  // Object.prototype, so `counts[server] ?? 0` would yield a function and the
+  // increment would produce a non-numeric count — poisoning the whole row (the
+  // backend then drops it as `invalid-services`, losing its token/session data).
+  const counts: Record<string, number> = Object.create(null);
+  for (const blk of content as unknown[]) {
+    if (!blk || typeof blk !== "object" || Array.isArray(blk)) continue;
+    const b = blk as Record<string, unknown>;
+    // Only tool_use blocks name an MCP tool. We read `name` and NOTHING ELSE —
+    // the block's `input` (args/URLs/payloads) is never touched.
+    if (b.type !== "tool_use" || typeof b.name !== "string") continue;
+    const server = mcpServerName(b.name);
+    if (!server) continue;
+    counts[server] = (counts[server] ?? 0) + 1;
+  }
+
+  return Object.keys(counts).length > 0 ? counts : undefined;
+}
+
 /**
  * Build an outgoing event row matching the server's KEEP allowlist.
  *
@@ -162,6 +229,11 @@ const KEEP_TOP_LEVEL = [
  *      camelCase top-level fields. The original `message` object — which
  *      carries prompt/response text, thinking, and tool data — is dropped.
  *
+ * `services` (US-007): the MCP servers / connectors / integrations this row
+ * touched, as a names-and-counts-only map (see `extractServices`). NAMES + COUNTS
+ * ONLY — never args/URLs/payloads/secrets, matching the `hasArgs` precedent.
+ * Omitted when the row touched no MCP server (the server treats absence as none).
+ *
  * `companyUid` (US-002): when the caller has resolved the row's `cwd` to an
  * owning company (`resolveCompanyForCwd`), it passes that `cmp_*` uid here and
  * it is stamped on the wire row. It is on the server's KEEP allowlist
@@ -213,6 +285,14 @@ export function sanitizeRow(
     }
   }
 
+  // services/integrations touched (US-007). Names + counts only — extracted from
+  // the message's tool_use block NAMES, never their inputs. Omitted when none, so
+  // the wire row is unchanged for rows that touched no MCP server.
+  const services = extractServices(message);
+  if (services !== undefined) {
+    out.services = services;
+  }
+
   return out;
 }
 

package/src/watcher.ts

@@ -263,6 +263,32 @@ interface WatchBackend {
   close(): void;
 }
 
+export type TreeChangeKind =
+  | "add"
+  | "change"
+  | "unlink"
+  | "addDir"
+  | "unlinkDir";
+
+/** Exact journal revision observed when a live watcher reports a deletion. */
+export interface LocalDeleteSnapshot {
+  journalSlug: string;
+  journalPath: string;
+  /** Exact vault-relative root authorized by the originating watcher event. */
+  deleteScopeRoot?: string;
+  absolutePath: string;
+  remoteEtag: string;
+  localHash: string;
+  localKind: "file" | "symlink";
+}
+
+export interface TreeChange {
+  kind: TreeChangeKind;
+  deleteSnapshots?: LocalDeleteSnapshot[];
+}
+
+type BackendChangeKind = TreeChangeKind | "rename";
+
 /**
  * Platforms where Node's `fs.watch(dir, { recursive: true })` is natively
  * supported by a SINGLE OS handle: macOS (FSEvents) and Windows
@@ -277,7 +303,7 @@ function supportsRecursiveWatch(): boolean {
 function startChokidarTreeWatch(
   hqRoot: string,
   shouldEmit: WatchPathFilter,
-  onEvent: (absolutePath: string) => void,
+  onEvent: (absolutePath: string, kind: BackendChangeKind) => void,
   onError: (err: unknown) => void,
 ): WatchBackend {
   const cw = watch(hqRoot, {
@@ -291,11 +317,11 @@ function startChokidarTreeWatch(
       pollInterval: 100,
     },
   });
-  cw.on("add", onEvent)
-    .on("change", onEvent)
-    .on("unlink", onEvent)
-    .on("addDir", onEvent)
-    .on("unlinkDir", onEvent)
+  cw.on("add", (p) => onEvent(p, "add"))
+    .on("change", (p) => onEvent(p, "change"))
+    .on("unlink", (p) => onEvent(p, "unlink"))
+    .on("addDir", (p) => onEvent(p, "addDir"))
+    .on("unlinkDir", (p) => onEvent(p, "unlinkDir"))
     .on("error", onError);
   return {
     close: () => {
@@ -327,7 +353,7 @@ function startChokidarTreeWatch(
 function startTreeWatch(
   hqRoot: string,
   shouldEmit: WatchPathFilter,
-  onEvent: (absolutePath: string) => void,
+  onEvent: (absolutePath: string, kind: BackendChangeKind) => void,
   onError: (err: unknown) => void,
 ): WatchBackend {
   if (supportsRecursiveWatch()) {
@@ -335,14 +361,17 @@ function startTreeWatch(
       const native = fs.watch(
         hqRoot,
         { recursive: true, persistent: true },
-        (_eventType, filename) => {
+        (eventType, filename) => {
           // `filename` is relative to hqRoot (or null/empty if the platform
           // couldn't provide it — nothing actionable then). `String()` coerces
           // both the string and (older @types/node) Buffer shapes.
           if (filename == null) return;
           const rel = String(filename);
           if (rel === "") return;
-          onEvent(path.resolve(hqRoot, rel));
+          onEvent(
+            path.resolve(hqRoot, rel),
+            eventType === "change" ? "change" : "rename",
+          );
         },
       );
       let closed = false;
@@ -534,6 +563,10 @@ export interface TreeWatcherOptions {
   maxPendingBytes?: number;
   /** Backlog overflow signal. Defaults to a console warning. */
   onBacklogOverflow?: (info: TreeWatcherBacklogOverflow) => void;
+  captureLocalDeleteSnapshots?: (
+    relativePath: string,
+    kind: "unlink" | "unlinkDir",
+  ) => LocalDeleteSnapshot[];
 }
 
 /**
@@ -556,6 +589,8 @@ export interface TreeWatcherOptions {
 export interface TreeChangeBatch {
   /** Map of absolutePath → relativePath for every path in the settled burst. */
   paths: Map<string, string>;
+  /** Per-path watcher event and the captured pre-delete journal revision. */
+  changes?: Map<string, TreeChange>;
   /** True when path detail was dropped after the watcher backlog cap was hit. */
   overflowed?: boolean;
   /** Count of paths dropped from the detailed batch after overflow. */
@@ -587,11 +622,14 @@ export class TreeWatcher {
   private readonly maxPendingPaths: number;
   private readonly maxPendingBytes: number;
   private readonly onBacklogOverflow: (info: TreeWatcherBacklogOverflow) => void;
+  private readonly captureLocalDeleteSnapshots?: TreeWatcherOptions["captureLocalDeleteSnapshots"];
   private backend: WatchBackend | null = null;
   private timer: unknown = null;
   private listeners = new Set<TreeChangeListener>();
   /** Paths accumulated for the current (in-flight) debounce window. */
   private pending = new Map<string, string>();
+  private pendingChanges = new Map<string, TreeChange>();
+  private knownKinds = new Map<string, "file" | "directory">();
   private pendingBytes = 0;
   private overflowed = false;
   private overflowLogged = false;
@@ -620,6 +658,7 @@ export class TreeWatcher {
           `TreeWatcher backlog cap exceeded; dropping ${info.droppedPaths} path(s) until the next resync`,
         );
       });
+    this.captureLocalDeleteSnapshots = opts.captureLocalDeleteSnapshots;
   }
 
   /**
@@ -648,12 +687,13 @@ export class TreeWatcher {
     this.backend = startTreeWatch(
       this.hqRoot,
       this.shouldEmit,
-      (absolutePath) => this.handleEvent(absolutePath),
+      (absolutePath, kind) => this.handleEvent(absolutePath, kind),
       (err) => {
         console.error("TreeWatcher error:", err);
         this.signalBackendResync();
       },
     );
+    this.seedKnownKinds();
   }
 
   private signalBackendResync(): void {
@@ -668,13 +708,32 @@ export class TreeWatcher {
    * events route through here too — and for the recursive backend this is the
    * ONLY place filtering happens, so out-of-scope paths are dropped here.
    */
-  handleEvent(absolutePath: string): void {
+  handleEvent(
+    absolutePath: string,
+    backendKind: BackendChangeKind = "change",
+  ): void {
     if (this.disposed) return;
+    const abs = path.resolve(absolutePath);
+    let kind: TreeChangeKind;
+    if (backendKind === "rename") {
+      try {
+        kind = fs.lstatSync(abs).isDirectory() ? "addDir" : "add";
+      } catch (err: unknown) {
+        const code =
+          err && typeof err === "object" && "code" in err
+            ? (err as { code?: string }).code
+            : undefined;
+        if (code !== "ENOENT") return;
+        kind = this.knownKinds.get(abs) === "directory" ? "unlinkDir" : "unlink";
+      }
+    } else {
+      kind = backendKind;
+    }
+    const isDir = kind === "addDir" || kind === "unlinkDir";
     // The recursive backend does no descent-time filtering, so this is the
     // authoritative emit gate; the chokidar backend's `ignored` pre-filters
     // but a slipped-through (or synthetic test) path is re-checked here too.
-    if (!this.shouldEmit(absolutePath, false)) return;
-    const abs = path.resolve(absolutePath);
+    if (!this.shouldEmit(abs, isDir)) return;
     const rel = path.relative(this.hqRoot, abs).split(path.sep).join("/");
     if (!this.pending.has(abs)) {
       const entryBytes = estimatePendingEntryBytes(abs, rel);
@@ -689,9 +748,43 @@ export class TreeWatcher {
       this.pendingBytes += entryBytes;
     }
     this.pending.set(abs, rel);
+    if (kind === "unlink" || kind === "unlinkDir") {
+      const deleteSnapshots =
+        this.captureLocalDeleteSnapshots?.(rel, kind) ?? [];
+      this.pendingChanges.set(abs, {
+        kind,
+        ...(deleteSnapshots.length > 0 ? { deleteSnapshots } : {}),
+      });
+      this.knownKinds.delete(abs);
+    } else {
+      this.pendingChanges.set(abs, { kind });
+      this.knownKinds.set(abs, isDir ? "directory" : "file");
+    }
     this.arm();
   }
 
+  private seedKnownKinds(): void {
+    const visit = (dir: string): void => {
+      let entries: fs.Dirent[];
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        const absolutePath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (!this.shouldEmit(absolutePath, true)) continue;
+          this.knownKinds.set(path.resolve(absolutePath), "directory");
+          visit(absolutePath);
+        } else if (this.shouldEmit(absolutePath, false)) {
+          this.knownKinds.set(path.resolve(absolutePath), "file");
+        }
+      }
+    };
+    visit(this.hqRoot);
+  }
+
   private recordBacklogOverflow(entryBytes: number): void {
     this.overflowed = true;
     this.droppedPaths += 1;
@@ -727,7 +820,10 @@ export class TreeWatcher {
     if (this.disposed) return;
     // Snapshot + clear the accumulated paths so the next window starts fresh
     // even if a listener re-enters synchronously.
-    const batch: TreeChangeBatch = { paths: new Map(this.pending) };
+    const batch: TreeChangeBatch = {
+      paths: new Map(this.pending),
+      changes: new Map(this.pendingChanges),
+    };
     if (this.overflowed) {
       batch.overflowed = true;
       batch.droppedPaths = this.droppedPaths;
@@ -749,6 +845,7 @@ export class TreeWatcher {
 
   private clearPending(): void {
     this.pending.clear();
+    this.pendingChanges.clear();
     this.pendingBytes = 0;
     this.overflowed = false;
     this.overflowLogged = false;

package/test/e2e/watcher-real-chokidar.test.ts

@@ -18,11 +18,11 @@
  *      pinning the exact regression so it can't silently return.
  */
 
-import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, mkdir, rm, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { TreeWatcher } from "../../src/watcher.js";
 
@@ -66,6 +66,66 @@ function waitForEmit(w: TreeWatcher, ms: number): Promise<boolean> {
 }
 
 describe("event-push watcher -- real chokidar scope (regression for 5.26.0)", () => {
+  it(
+    "preserves unlink classification and the captured pre-delete revision",
+    async () => {
+      const localPath = path.join(
+        hqRoot,
+        "companies",
+        "acme",
+        "knowledge",
+        "delete-me.md",
+      );
+      await writeFile(localPath, "# synced\n");
+      const capture = vi.fn(() => [
+        {
+          journalSlug: "acme",
+          journalPath: "knowledge/delete-me.md",
+          deleteScopeRoot: "knowledge/delete-me.md",
+          absolutePath: localPath,
+          remoteEtag: "etag-before-delete",
+          localHash: "hash-before-delete",
+          localKind: "file" as const,
+        },
+      ]);
+      watcher = new TreeWatcher({
+        hqRoot,
+        debounceMs: 250,
+        personalMode: false,
+        captureLocalDeleteSnapshots: capture,
+      });
+      watcher.start();
+      await new Promise((r) => setTimeout(r, 600));
+
+      const emitted = new Promise<Parameters<Parameters<TreeWatcher["onChange"]>[0]>[1]>(
+        (resolve) => {
+          const off = watcher!.onChange((_rel, batch) => {
+            off();
+            resolve(batch);
+          });
+        },
+      );
+      await unlink(localPath);
+      const batch = await emitted;
+      const change = batch?.changes?.get(localPath);
+
+      expect(capture).toHaveBeenCalledWith(
+        "companies/acme/knowledge/delete-me.md",
+        "unlink",
+      );
+      expect(change).toMatchObject({
+        kind: "unlink",
+        deleteSnapshots: [
+          expect.objectContaining({
+            remoteEtag: "etag-before-delete",
+            localHash: "hash-before-delete",
+          }),
+        ],
+      });
+    },
+    8000,
+  );
+
   it(
     "FIRES on a companies/<slug>/knowledge/ edit when personalMode=false (the --companies scope)",
     async () => {