@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

package/src/cli/commands/{memory-v2.ts → memory/memory-v2.ts}

@@ -18,8 +18,8 @@
 
 import type { Command } from "commander";
 
-import { cliIpcCall } from "../../ipc/cli-client.js";
-import type { ComparisonReport } from "../../memory/v2/harness/runner.js";
+import { cliIpcCall } from "../../../ipc/cli-client.js";
+import type { ComparisonReport } from "../../../memory/v2/harness/runner.js";
 import type {
   MemoryV2BackfillOp,
   MemoryV2BackfillResult,
@@ -27,9 +27,9 @@ import type {
   MemoryV2ReembedSkillsResult,
   MemoryV2SimulateRouterResult,
   MemoryV2ValidateResult,
-} from "../../runtime/routes/memory-v2-routes.js";
-import { registerCommand } from "../lib/register-command.js";
-import { log } from "../logger.js";
+} from "../../../runtime/routes/memory-v2-routes.js";
+import { registerCommand } from "../../lib/register-command.js";
+import { log } from "../../logger.js";
 import {
   renderComparisonReport,
   renderTurnTrace,
@@ -63,16 +63,7 @@ async function runBackfillOp(op: MemoryV2BackfillOp): Promise<void> {
 // Registration
 // ---------------------------------------------------------------------------
 
-export function registerMemoryV2Command(program: Command): void {
-  // Reuse an existing `memory` parent if some other registrar attached to it
-  // first; otherwise create one. This keeps the registration order between
-  // sibling memory registrars unconstrained.
-  const memory =
-    program.commands.find((c) => c.name() === "memory") ??
-    program
-      .command("memory")
-      .description("Manage the v2 memory subsystem (concept-page model)");
-
+export function registerMemoryV2Command(memory: Command): void {
   registerCommand(memory, {
     name: "v2",
     transport: "ipc",

package/src/cli/commands/{memory-v3.ts → memory/memory-v3.ts}

@@ -17,13 +17,14 @@
 
 import type { Command } from "commander";
 
-import { cliIpcCall } from "../../ipc/cli-client.js";
+import { cliIpcCall } from "../../../ipc/cli-client.js";
+import type { MemoryEvalRunResult } from "../../../runtime/routes/memory-eval-routes.js";
 import type {
   MemoryV3BackfillSectionsResult,
   MemoryV3RebuildIndexResult,
-} from "../../runtime/routes/memory-v3-routes.js";
-import { registerCommand } from "../lib/register-command.js";
-import { log } from "../logger.js";
+} from "../../../runtime/routes/memory-v3-routes.js";
+import { registerCommand } from "../../lib/register-command.js";
+import { log } from "../../logger.js";
 
 /**
  * IPC timeout for `backfill-sections`. The one-time full-corpus section embed
@@ -34,14 +35,14 @@ import { log } from "../logger.js";
  */
 const BACKFILL_IPC_TIMEOUT_MS = 30 * 60 * 1000;
 
-export function registerMemoryV3Command(program: Command): void {
-  // Reuse an existing `memory` parent if some other registrar attached to it
-  // first; otherwise create one. This keeps the registration order between
-  // sibling memory registrars unconstrained.
-  const memory =
-    program.commands.find((c) => c.name() === "memory") ??
-    program.command("memory").description("Manage the memory subsystem");
+/**
+ * IPC timeout for `eval`. Embedding both corpora's sections runs through the
+ * embedder and easily outlasts the default 60s, so allow the same generous
+ * ceiling as the backfill.
+ */
+const EVAL_IPC_TIMEOUT_MS = 30 * 60 * 1000;
 
+export function registerMemoryV3Command(memory: Command): void {
   registerCommand(memory, {
     name: "v3",
     transport: "ipc",
@@ -134,6 +135,91 @@ Examples:
                 : "."),
           );
         });
+
+      // ── eval ──────────────────────────────────────────────────────────────
+
+      v3.command("eval")
+        .description(
+          "Build blinded A/B retrieval-eval packets (snapshot corpus vs staged wiki)",
+        )
+        .requiredOption(
+          "--staging <dir>",
+          "Staged v3 wiki dir (relative to the workspace, or absolute)",
+        )
+        .requiredOption(
+          "--snapshot <dir>",
+          "Read-only v2 snapshot dir (relative to the workspace, or absolute)",
+        )
+        .requiredOption("--out <dir>", "Output dir for packets.json + key.json")
+        .option("--turns <n>", "Number of recent turns to mine", "30")
+        .option("--k <n>", "Pages per memory set", "8")
+        .option(
+          "--seed <n>",
+          "Blinding seed (reproducible A/B assignment)",
+          "1",
+        )
+        .option(
+          "--no-dense",
+          "Needle-only: skip section embedding (fast, cheaper, lower fidelity)",
+        )
+        .option("--json", "Emit raw JSON instead of a formatted summary")
+        .addHelpText(
+          "after",
+          `
+Mines recent user turns, retrieves the top pages from each corpus per turn, and
+writes blinded A/B packets (plus a separate unblinding key) for a blind-judge
+workflow. Both corpora are read in memory — nothing in the live lanes or Qdrant
+is touched. With the dense lane on (default) it embeds every section of both
+corpora, which can take a while on a large corpus; use --no-dense for a fast
+lexical-only pass.
+
+Examples:
+  $ assistant memory v3 eval --snapshot .mv3/snapshot/concepts --staging .mv3/staging --out .mv3/eval
+  $ assistant memory v3 eval --snapshot .mv3/snapshot/concepts --staging .mv3/staging --out .mv3/eval --turns 50 --no-dense`,
+        )
+        .action(
+          async (opts: {
+            staging: string;
+            snapshot: string;
+            out: string;
+            turns: string;
+            k: string;
+            seed: string;
+            dense: boolean;
+            json?: boolean;
+          }) => {
+            const result = await cliIpcCall<MemoryEvalRunResult>(
+              "memory_eval_run",
+              {
+                body: {
+                  stagingDir: opts.staging,
+                  snapshotDir: opts.snapshot,
+                  outDir: opts.out,
+                  turns: Number(opts.turns),
+                  k: Number(opts.k),
+                  seed: Number(opts.seed),
+                  dense: opts.dense,
+                },
+              },
+              { timeoutMs: EVAL_IPC_TIMEOUT_MS },
+            );
+            if (!result.ok) {
+              log.error(result.error ?? "Failed to build eval packets");
+              process.exitCode = 1;
+              return;
+            }
+            const payload = result.result!;
+            if (opts.json === true) {
+              log.info(JSON.stringify(payload, null, 2));
+              return;
+            }
+            log.info(
+              `Wrote ${payload.packetsWritten} packets from ${payload.turnsMined} turns ` +
+                `(snapshot ${payload.snapshotPages} pages vs staged ${payload.stagingPages} pages, ` +
+                `dense=${payload.dense}).\n  packets: ${payload.packetsPath}\n  key:     ${payload.keyPath}`,
+            );
+          },
+        );
     },
   });
 }

package/src/cli/commands/oauth/status.test.ts

@@ -0,0 +1,36 @@
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { noConnectionsMessage } from "./status.js";
+
+const original = process.env.__RESOLVED_MODEL;
+
+afterEach(() => {
+  if (original === undefined) delete process.env.__RESOLVED_MODEL;
+  else process.env.__RESOLVED_MODEL = original;
+});
+
+describe("noConnectionsMessage", () => {
+  test("capable models get the terse default", () => {
+    process.env.__RESOLVED_MODEL = "claude-opus-4-8";
+    const msg = noConnectionsMessage("google");
+    expect(msg).toBe(
+      "No active connections for google.\n" +
+        "Connect with `assistant oauth connect google`.\n",
+    );
+  });
+
+  test("no resolved model falls back to the terse default", () => {
+    delete process.env.__RESOLVED_MODEL;
+    expect(noConnectionsMessage("google")).toContain(
+      "Connect with `assistant oauth connect google`.",
+    );
+  });
+
+  test("weak open models are steered to the oauth_connect surface", () => {
+    process.env.__RESOLVED_MODEL = "accounts/fireworks/models/minimax-m3";
+    const msg = noConnectionsMessage("google");
+    expect(msg).toContain('surface_type "oauth_connect"');
+    expect(msg).toContain('data.providerKey "google"');
+    expect(msg).not.toContain("assistant oauth connect google");
+  });
+});

package/src/cli/commands/oauth/status.ts

@@ -1,8 +1,30 @@
 import type { Command } from "commander";
 
 import { cliIpcCall, exitFromIpcResult } from "../../../ipc/cli-client.js";
+import { isWeakOpenModel } from "../../../providers/weak-open-model.js";
 import { shouldOutputJson, writeOutput } from "../../output.js";
 
+/**
+ * Message shown when a provider has no active connections. Weak open models
+ * loop through redundant discovery commands (channel checks, `oauth providers
+ * get`, loading the OAuth setup skill) before rendering the connect button, so
+ * they get an explicit single next action: render the core `oauth_connect`
+ * surface directly. Capable models keep the terse default.
+ */
+export function noConnectionsMessage(provider: string): string {
+  const base = `No active connections for ${provider}.`;
+  if (isWeakOpenModel(process.env.__RESOLVED_MODEL)) {
+    return (
+      `${base}\nTo let the user connect, render the connect button: call ` +
+      `\`ui_show\` with surface_type "oauth_connect" and ` +
+      `data.providerKey "${provider}". That surface is always available — do ` +
+      `not run further \`oauth\`/\`channels\` commands or load a setup skill ` +
+      `just to display it.\n`
+    );
+  }
+  return `${base}\nConnect with \`assistant oauth connect ${provider}\`.\n`;
+}
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -91,9 +113,7 @@ Examples:
 
           // Text output
           if (connections.length === 0) {
-            process.stdout.write(
-              `No active connections for ${provider}.\nConnect with \`assistant oauth connect ${provider}\`.\n`,
-            );
+            process.stdout.write(noConnectionsMessage(provider));
             return;
           }
 

package/src/cli/commands/plugins.ts

@@ -46,7 +46,6 @@ import {
   PluginNotUpgradableError,
   type PluginUpgradeResult,
   type PluginUpgradeStrategy,
-  PluginUpgradeStrategyUnsupportedError,
   upgradePlugin,
 } from "../lib/upgrade-plugin.js";
 import { getCliLogger } from "../logger.js";
@@ -76,6 +75,7 @@ Examples:
   $ assistant plugins upgrade example --dry-run
   $ assistant plugins upgrade example --strategy ours
   $ assistant plugins upgrade example --strategy theirs
+  $ assistant plugins upgrade example --strategy assistant
   $ assistant plugins search example
   $ assistant plugins search "^example"
   $ assistant plugins search example --json
@@ -180,7 +180,7 @@ Examples:
       plugins
         .command("inspect <name>")
         .description(
-          "Show a plugin's local install metadata and the marketplace pin, and whether an update is available",
+          "Show a plugin's local install metadata, the marketplace pin, whether an update is available, and the surfaces (skills, hooks, tools) it contributes",
         )
         .option("--json", "Emit machine-readable JSON instead of a summary")
         .action(async (name: string, opts: { json?: boolean }) => {
@@ -465,7 +465,6 @@ Examples:
               if (
                 err instanceof PluginNotInstalledError ||
                 err instanceof PluginNotUpgradableError ||
-                err instanceof PluginUpgradeStrategyUnsupportedError ||
                 err instanceof PluginMergeBaselineError ||
                 err instanceof InvalidPluginNameError
               ) {
@@ -550,12 +549,20 @@ function remoteLocation(remote: PluginRemoteInfo): string {
  * `location`, with a `drift` line under the installed copy.
  */
 function formatInspection(inspection: PluginInspection): string[] {
-  const { name, status, local, remote, remoteError } = inspection;
+  const { name, status, local, remote, remoteError, surfaces } = inspection;
   const lines: string[] = [name, "─".repeat(44)];
   const topRow = (label: string, value: string) =>
     lines.push(`${label.padEnd(11)} ${value}`);
   const blockRow = (label: string, value: string) =>
     lines.push(`  ${label.padEnd(9)} ${value}`);
+  // A surface block: the surface type as a heading, then its items indented
+  // under it. Omitted entirely when the plugin contributes none of that type,
+  // so the listing only ever shows what the plugin actually contributes.
+  const surfaceBlock = (label: string, items: readonly string[]) => {
+    if (items.length === 0) return;
+    lines.push(label);
+    for (const item of items) lines.push(`  ${item}`);
+  };
 
   topRow("status", statusLine(status));
 
@@ -590,6 +597,12 @@ function formatInspection(inspection: PluginInspection): string[] {
   const description = remote?.description ?? local?.description ?? null;
   if (description) topRow("description", description);
 
+  if (surfaces) {
+    surfaceBlock("skills", surfaces.skills);
+    surfaceBlock("hooks", surfaces.hooks);
+    surfaceBlock("tools", surfaces.tools);
+  }
+
   for (const issue of local?.issues ?? []) topRow("issue", issue);
 
   return lines;
@@ -628,10 +641,49 @@ function formatUpgrade(result: PluginUpgradeResult): string[] {
         result.fileCount === null
           ? ""
           : `(${result.fileCount} file${result.fileCount === 1 ? "" : "s"}) `;
+      const hasConflicts =
+        result.conflicts.length > 0 || result.binaryConflicts.length > 0;
+
+      // Under `assistant`, an unresolved merge leaves conflicts in the tree —
+      // the plugin would fail to load while any remain, so the usual "restart
+      // now" guidance is replaced with resolution instructions. Most conflicts
+      // carry git markers, but a modify/delete divergence (a file edited on one
+      // side and deleted on the other) keeps the surviving content with no
+      // markers, so the guidance covers both rather than assuming markers.
+      if (result.strategy === "assistant" && hasConflicts) {
+        const lines = [
+          `Merged "${name}" ${move} with conflicts`,
+          "",
+          `${count}→ ${result.target}`,
+        ];
+        if (result.conflicts.length > 0) {
+          lines.push(
+            "",
+            `Resolve ${result.conflicts.length} conflicted file${result.conflicts.length === 1 ? "" : "s"} (open each: resolve its git conflict markers, or — if a modify/delete divergence kept the file with none — decide whether to keep or remove it):`,
+            ...result.conflicts.map((p) => `  ${p}`),
+          );
+        }
+        if (result.binaryConflicts.length > 0) {
+          lines.push(
+            "",
+            `Binary conflict${result.binaryConflicts.length === 1 ? "" : "s"} (kept the local copy — choose a version manually):`,
+            ...result.binaryConflicts.map((p) => `  ${p}`),
+          );
+        }
+        lines.push(
+          "",
+          "Resolve the conflicts, then restart the assistant to pick up the upgrade.",
+        );
+        if (provenanceNote) lines.push(provenanceNote);
+        return lines;
+      }
+
       const mergeNote =
         result.strategy === "ours" || result.strategy === "theirs"
           ? `Local edits were merged (--strategy ${result.strategy}).`
-          : null;
+          : result.strategy === "assistant"
+            ? "Local edits were merged with no conflicts (--strategy assistant)."
+            : null;
       const lines = [
         `Upgraded "${name}" ${move}`,
         "",

package/src/cli/lib/__tests__/inspect-plugin.test.ts

@@ -90,6 +90,8 @@ function installPlugin(
     } | null;
     /** Embed a content fingerprint of the materialized tree in the sidecar. */
     fingerprint?: boolean;
+    /** Materialize surface directories (`hooks/<name>.ts`, `skills/<id>/SKILL.md`). */
+    surfaces?: { hooks?: string[]; tools?: string[]; skills?: string[] };
   } = {},
 ): void {
   const dir = join(workspace, name);
@@ -102,6 +104,18 @@ function installPlugin(
       description: "Installed copy.",
     }),
   );
+  for (const hook of opts.surfaces?.hooks ?? []) {
+    mkdirSync(join(dir, "hooks"), { recursive: true });
+    writeFileSync(join(dir, "hooks", `${hook}.ts`), "export default () => {};");
+  }
+  for (const tool of opts.surfaces?.tools ?? []) {
+    mkdirSync(join(dir, "tools"), { recursive: true });
+    writeFileSync(join(dir, "tools", `${tool}.ts`), "export default {};");
+  }
+  for (const skill of opts.surfaces?.skills ?? []) {
+    mkdirSync(join(dir, "skills", skill), { recursive: true });
+    writeFileSync(join(dir, "skills", skill, "SKILL.md"), `# ${skill}`);
+  }
   if (opts.sidecar !== null) {
     const sidecar = opts.sidecar ?? { commit: SHA_A };
     // Mirror install: fingerprint the tree before the sidecar is written so it
@@ -367,6 +381,46 @@ describe("inspectPlugin", () => {
     expect(result.local?.localChanges).toBeNull();
   });
 
+  test("reports the surfaces an installed copy contributes", async () => {
+    // GIVEN an installed plugin shipping hooks and skills but no tools
+    installPlugin(workspace, "level-up", {
+      sidecar: { commit: SHA_A },
+      surfaces: {
+        hooks: ["post-model-call", "init"],
+        skills: ["second-skill", "first-skill"],
+      },
+    });
+    const fetch = makeFetch({ marketplace: manifestWith("level-up", SHA_A) });
+
+    // WHEN it is inspected
+    const result = await inspectPlugin(
+      { name: "level-up" },
+      { fetch, workspacePluginsDir: workspace },
+    );
+
+    // THEN the contributed surfaces are listed (sorted) and tools is empty
+    expect(result.surfaces).toEqual({
+      skills: ["first-skill", "second-skill"],
+      hooks: ["init", "post-model-call"],
+      tools: [],
+    });
+  });
+
+  test("leaves surfaces null when the plugin is not installed", async () => {
+    // GIVEN a marketplace entry with no local copy to walk
+    const fetch = makeFetch({ marketplace: manifestWith("level-up", SHA_B) });
+
+    // WHEN it is inspected
+    const result = await inspectPlugin(
+      { name: "level-up" },
+      { fetch, workspacePluginsDir: workspace },
+    );
+
+    // THEN there is no tree to read surfaces from
+    expect(result.installed).toBe(false);
+    expect(result.surfaces).toBeNull();
+  });
+
   test("throws when the plugin is neither installed nor in the marketplace", async () => {
     // GIVEN no local copy and an empty catalog
     const fetch = makeFetch({ marketplace: undefined });

package/src/cli/lib/__tests__/merge-plugin-tree.test.ts

@@ -4,8 +4,9 @@
  * The merge is exercised against three real temp directories (base/ours/theirs)
  * and the merged tree is read back from a fourth (dest). `git merge-file` runs
  * for real — these tests assert the line-level merge behavior (non-conflicting
- * hunks from both sides survive; conflicts resolve toward the strategy), the
- * file-level add/delete resolution, and binary whole-file handling.
+ * hunks from both sides survive; conflicts resolve toward `ours`/`theirs` or
+ * get conflict markers under `assistant`), the file-level add/delete
+ * resolution, and binary whole-file handling.
  */
 
 import {
@@ -97,7 +98,9 @@ describe("mergePluginTree", () => {
     expect(read("local-only.txt")).toBe("local\n");
     expect(read("remote-only.txt")).toBe("remote\n");
     expect(read("conflict.txt")).toBe("ours\n");
-    expect(count).toBe(4);
+    expect(count.fileCount).toBe(4);
+    expect(count.conflicts).toEqual([]);
+    expect(count.binaryConflicts).toEqual([]);
   });
 
   test("resolves conflicts toward the pin under the theirs strategy", async () => {
@@ -289,7 +292,7 @@ describe("mergePluginTree", () => {
 
     // THEN the sidecar is never carried through (the caller rewrites it)
     expect(read("install-meta.json")).toBeNull();
-    expect(count).toBe(1);
+    expect(count.fileCount).toBe(1);
   });
 
   test("merges files in nested directories", async () => {
@@ -310,4 +313,131 @@ describe("mergePluginTree", () => {
     // THEN the nested path is preserved and resolved
     expect(read("src/a/b.txt")).toBe("ours\n");
   });
+
+  test("writes git conflict markers and reports the path under the assistant strategy", async () => {
+    // GIVEN a file edited on disjoint lines by each side plus one true conflict
+    writeTree(baseDir, { "common.txt": "a\nb\nc\n", "conflict.txt": "base\n" });
+    writeTree(oursDir, { "common.txt": "A\nb\nc\n", "conflict.txt": "ours\n" });
+    writeTree(theirsDir, {
+      "common.txt": "a\nb\nC\n",
+      "conflict.txt": "theirs\n",
+    });
+
+    // WHEN merged with the `assistant` strategy
+    const result = await mergePluginTree({
+      baseDir,
+      oursDir,
+      theirsDir,
+      destDir,
+      strategy: "assistant",
+    });
+
+    // THEN the non-conflicting edits still auto-merge and only the true
+    // conflict carries markers naming both sides, and its path is reported
+    expect(read("common.txt")).toBe("A\nb\nC\n");
+    const conflict = read("conflict.txt") ?? "";
+    expect(conflict).toContain("<<<<<<<");
+    expect(conflict).toContain("=======");
+    expect(conflict).toContain(">>>>>>>");
+    expect(conflict).toContain("ours\n");
+    expect(conflict).toContain("theirs\n");
+    expect(result.conflicts).toEqual(["conflict.txt"]);
+    expect(result.binaryConflicts).toEqual([]);
+  });
+
+  test("uses the supplied conflict labels in the markers", async () => {
+    // GIVEN a true conflict and custom marker labels
+    writeTree(baseDir, { "f.txt": "base\n" });
+    writeTree(oursDir, { "f.txt": "ours\n" });
+    writeTree(theirsDir, { "f.txt": "theirs\n" });
+
+    // WHEN merged with the `assistant` strategy and explicit labels
+    await mergePluginTree({
+      baseDir,
+      oursDir,
+      theirsDir,
+      destDir,
+      strategy: "assistant",
+      conflictLabels: {
+        ours: "local edits (was abc1234)",
+        base: "install baseline abc1234",
+        theirs: "upgrade pin def5678",
+      },
+    });
+
+    // THEN the marker lines carry those labels
+    const merged = read("f.txt") ?? "";
+    expect(merged).toContain("<<<<<<< local edits (was abc1234)");
+    expect(merged).toContain(">>>>>>> upgrade pin def5678");
+  });
+
+  test("auto-merges with no markers when the assistant strategy hits no true conflict", async () => {
+    // GIVEN edits on disjoint lines of the same file (no overlapping hunk)
+    writeTree(baseDir, { "f.txt": "a\nb\nc\n" });
+    writeTree(oursDir, { "f.txt": "A\nb\nc\n" });
+    writeTree(theirsDir, { "f.txt": "a\nb\nC\n" });
+
+    // WHEN merged with the `assistant` strategy
+    const result = await mergePluginTree({
+      baseDir,
+      oursDir,
+      theirsDir,
+      destDir,
+      strategy: "assistant",
+    });
+
+    // THEN both edits merge cleanly with no markers and nothing is reported
+    const merged = read("f.txt") ?? "";
+    expect(merged).toBe("A\nb\nC\n");
+    expect(merged).not.toContain("<<<<<<<");
+    expect(result.conflicts).toEqual([]);
+    expect(result.binaryConflicts).toEqual([]);
+  });
+
+  test("keeps the local copy and reports a binary conflict under the assistant strategy", async () => {
+    // GIVEN a binary file (NUL bytes) diverged on both sides
+    const base = Buffer.from([0x00, 0x01, 0x02]);
+    const ours = Buffer.from([0x00, 0xaa, 0xbb]);
+    const theirs = Buffer.from([0x00, 0xcc, 0xdd]);
+    writeTree(baseDir, { "img.bin": base });
+    writeTree(oursDir, { "img.bin": ours });
+    writeTree(theirsDir, { "img.bin": theirs });
+
+    // WHEN merged with the `assistant` strategy
+    const result = await mergePluginTree({
+      baseDir,
+      oursDir,
+      theirsDir,
+      destDir,
+      strategy: "assistant",
+    });
+
+    // THEN the local copy is kept byte-for-byte (markers are impossible) and
+    // the path is surfaced as a binary conflict, not a marker conflict
+    expect(readFileSync(join(destDir, "img.bin")).equals(ours)).toBe(true);
+    expect(result.binaryConflicts).toEqual(["img.bin"]);
+    expect(result.conflicts).toEqual([]);
+  });
+
+  test("keeps the surviving content and reports a modify/delete conflict under the assistant strategy", async () => {
+    // GIVEN a file edited locally but deleted at the pin
+    writeTree(baseDir, { "f.txt": "base\n" });
+    writeTree(oursDir, { "f.txt": "local edit\n" });
+    writeTree(theirsDir, {});
+
+    // WHEN merged with the `assistant` strategy
+    const result = await mergePluginTree({
+      baseDir,
+      oursDir,
+      theirsDir,
+      destDir,
+      strategy: "assistant",
+    });
+
+    // THEN the local edit is preserved (never silently dropped) and the
+    // modify/delete divergence is reported for resolution
+    expect(read("f.txt")).toBe("local edit\n");
+    expect(result.conflicts).toEqual(["f.txt"]);
+    expect(result.binaryConflicts).toEqual([]);
+  });
 });