@vellumai/assistant 0.11.4 → 0.11.5-staging.1

package/src/plugins/defaults/memory/substrate/__tests__/consolidation-prompt-flag-gating-guard.test.ts

@@ -26,6 +26,7 @@ import {
   CONSOLIDATION_PROMPT_V3,
   CORE_PAGES_CONSOLIDATION_SECTION,
   renderConsolidationPrompt,
+  renderDanglingLinksSection,
   renderParseFailuresSection,
 } from "../prompts/consolidation.js";
 
@@ -59,6 +60,13 @@ const GATED_SECTIONS: Array<{
     ]),
     marker: "repair unreadable pages",
   },
+  {
+    name: "dangling-link repair step (gate: index-reported dangling links)",
+    section: renderDanglingLinksSection([
+      { from: "example-page", to: "example-target", kind: "links" },
+    ]),
+    marker: "resolve dangling links",
+  },
 ];
 
 /** All `ConsolidationPromptOptions` gates forced off — the v2-only rendering. */

package/src/plugins/defaults/memory/substrate/__tests__/edge-index.test.ts

@@ -15,7 +15,6 @@ import {
   getReachable,
   invalidateEdgeIndex,
   totalEdgeCount,
-  validateEdgeTargets,
 } from "../edge-index.js";
 import { deletePage, writePage } from "../page-store.js";
 import type { ConceptPage } from "../types.js";
@@ -228,35 +227,6 @@ describe("getReachable", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// validateEdgeTargets
-// ---------------------------------------------------------------------------
-
-describe("validateEdgeTargets", () => {
-  test("ok=true when every outgoing target has a known slug", async () => {
-    await writePage(workspaceDir, makePage("alice", ["bob"]));
-    await writePage(workspaceDir, makePage("bob"));
-
-    const idx = await getEdgeIndex(workspaceDir);
-    const result = validateEdgeTargets(idx, new Set(["alice", "bob"]));
-    expect(result).toEqual({ ok: true, missing: [] });
-  });
-
-  test("flags outgoing targets that don't correspond to a known slug", async () => {
-    await writePage(workspaceDir, makePage("alice", ["ghost", "bob"]));
-    await writePage(workspaceDir, makePage("bob", ["phantom"]));
-
-    const idx = await getEdgeIndex(workspaceDir);
-    const result = validateEdgeTargets(idx, new Set(["alice", "bob"]));
-
-    expect(result.ok).toBe(false);
-    expect(result.missing).toEqual([
-      { from: "alice", to: "ghost" },
-      { from: "bob", to: "phantom" },
-    ]);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // totalEdgeCount
 // ---------------------------------------------------------------------------

package/src/plugins/defaults/memory/substrate/__tests__/ingest.test.ts

@@ -12,7 +12,8 @@
  *   - Batch over the cap: RangeError.
  *   - In-batch duplicate slug: later occurrence `invalid`.
  *   - Non-blocking warnings: missing `source`, unparseable `origin_date`,
- *     frontmatter `slug` differing from the storage slug.
+ *     frontmatter `slug` differing from the storage slug, link targets
+ *     neither on disk nor in the batch.
  *   - Under-lock collision snapshot: a page committed between validation and
  *     the write phase is skipped, and `listPages` runs after `tryAcquireLock`.
  *   - Partial write failure: the reindex fan-out still runs for committed
@@ -363,6 +364,77 @@ describe("ingestPages", () => {
     expect(await listPages(workspace)).toEqual(["people/alice", "people/bob"]);
   });
 
+  test("link targets neither on disk nor in the batch warn without blocking the write", async () => {
+    // `people/bob` already exists on disk; `projects/garden` arrives in the
+    // same batch; `atl-1291` and `ghost` exist nowhere.
+    await ingestPages(workspace, [
+      { slug: "people/bob", content: validPage("Bob.") },
+    ]);
+    enqueuedJobs.length = 0;
+
+    const summary = await ingestPages(workspace, [
+      {
+        slug: "people/alice",
+        content:
+          "---\nsource: import:chatgpt\norigin_date: 2025-03-14\n" +
+          "links:\n  - people/bob\n  - projects/garden\n  - atl-1291\n" +
+          "edges: [ghost]\n---\n" +
+          "Alice mentions [[projects/garden]] and [[people/bob]] and [[skills/deploy]].\n",
+      },
+      { slug: "projects/garden", content: validPage("Garden.") },
+    ]);
+
+    expect(summary.written).toBe(2);
+    expect(summary.invalid).toBe(0);
+    const [alice, garden] = summary.results;
+    expect(alice.action).toBe("written");
+    expect(alice.warnings).toHaveLength(1);
+    // Every unresolved target on one line, sorted; targets that resolve on
+    // disk, in the batch, or under a synthetic prefix stay silent.
+    expect(alice.warnings[0]).toContain(
+      "link targets not on disk or in this batch: atl-1291, ghost",
+    );
+    expect(alice.warnings[0]).not.toContain("people/bob");
+    expect(alice.warnings[0]).not.toContain("projects/garden");
+    expect(alice.warnings[0]).not.toContain("skills/deploy");
+    expect(garden.warnings).toEqual([]);
+    // Written regardless, and reindexed.
+    expect(await readPage(workspace, "people/alice")).not.toBeNull();
+    expect(enqueuedJobs.map((j) => j.type).sort()).toEqual([
+      "memory_v2_reembed",
+      "memory_v3_maintain",
+    ]);
+  });
+
+  test("dangling-link warnings are reported on dry-run and skipped for pages the batch will not write", async () => {
+    await ingestPages(workspace, [
+      { slug: "people/bob", content: validPage("Bob.") },
+    ]);
+
+    const summary = await ingestPages(
+      workspace,
+      [
+        {
+          slug: "people/alice",
+          content: validPage("Alice mentions [[nowhere]]."),
+        },
+        // Exists on disk and overwrite is off, so this content is never
+        // written; its dangling link is not this batch's business.
+        {
+          slug: "people/bob",
+          content: validPage("Bob mentions [[also-nowhere]]."),
+        },
+      ],
+      { dryRun: true },
+    );
+
+    expect(summary.results[0].action).toBe("written");
+    expect(summary.results[0].warnings.join(" ")).toContain("nowhere");
+    expect(summary.results[1].action).toBe("skipped_exists");
+    expect(summary.results[1].warnings).toEqual([]);
+    expect(await readPage(workspace, "people/alice")).toBeNull();
+  });
+
   test("a pending reindex job of the same type suppresses its duplicate enqueue", async () => {
     pendingJobTypes = new Set(["memory_v2_reembed"]);
     await ingestPages(workspace, [

package/src/plugins/defaults/memory/substrate/__tests__/page-index.test.ts

@@ -56,6 +56,7 @@ const {
 } = await import("../page-index.js");
 const { writePage } = await import("../page-store.js");
 const { invalidateEdgeIndex } = await import("../edge-index.js");
+const { LINK_SEPARATOR } = await import("../page-links.js");
 
 let workspaceDir: string;
 
@@ -272,6 +273,42 @@ describe("getPageIndex", () => {
     const alice = idx.bySlug.get("alice")!;
     const bob = idx.bySlug.get("bob")!;
     expect(alice.edges).toEqual([bob.id]);
+    // Dropped from the numeric edges, reported on the index.
+    expect(idx.danglingLinks).toEqual([
+      { from: "alice", to: "ghost", kind: "edges" },
+    ]);
+  });
+
+  test("danglingLinks covers links:, body wikilinks, and edges:, resolved against pages and synthetic rows", async () => {
+    skillState.entries = [{ id: "browser", content: "Drive a browser." }];
+    const alice = makePage("alice", {
+      summary: "A",
+      edges: ["bob"],
+      body: "Alice uses [[skills/browser]] and [[bob|Bob]] but also [[nobody#sec]].",
+    });
+    alice.frontmatter.links = [
+      `bob${LINK_SEPARATOR}peer`,
+      `atl-1291${LINK_SEPARATOR}ticket`,
+    ];
+    await writePage(workspaceDir, alice);
+    await writePage(workspaceDir, makePage("bob", { summary: "B" }));
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.danglingLinks).toEqual([
+      { from: "alice", to: "atl-1291", kind: "links" },
+      { from: "alice", to: "nobody", kind: "wikilink" },
+    ]);
+  });
+
+  test("danglingLinks is empty when every reference resolves", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("alice", { summary: "A", edges: ["bob"], body: "See [[bob]]." }),
+    );
+    await writePage(workspaceDir, makePage("bob", { summary: "B" }));
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.danglingLinks).toEqual([]);
   });
 
   test("exposes frontmatter leaves in the index entry", async () => {

package/src/plugins/defaults/memory/substrate/__tests__/page-links.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Tests for `substrate/page-links.ts`: the single owner of `links:` entry and
+ * `[[wikilink]]` parsing, plus the dangling-link finder every write-side
+ * report uses.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  extractWikilinkTargets,
+  findDanglingLinks,
+  LINK_SEPARATOR,
+  parseLinkEntry,
+  WIKILINK_REGEX,
+  wikilinkTarget,
+} from "../page-links.js";
+import { isValidSlug } from "../page-store.js";
+
+/** Build a `"<slug> <sep> <why>"` links entry without spelling the separator. */
+const link = (target: string, why?: string): string =>
+  why === undefined ? target : `${target}${LINK_SEPARATOR}${why}`;
+
+describe("LINK_SEPARATOR", () => {
+  test("is space, U+2014 EM DASH, space", () => {
+    expect(LINK_SEPARATOR).toHaveLength(3);
+    expect(LINK_SEPARATOR.codePointAt(1)).toBe(0x2014);
+    expect(LINK_SEPARATOR[0]).toBe(" ");
+    expect(LINK_SEPARATOR[2]).toBe(" ");
+  });
+});
+
+describe("parseLinkEntry", () => {
+  test("splits target and description on the first separator", () => {
+    expect(parseLinkEntry(link("alice", "the principal"))).toEqual({
+      target: "alice",
+      description: "the principal",
+    });
+  });
+
+  test("keeps later separators inside the description", () => {
+    const why = `why${LINK_SEPARATOR}with a second dash`;
+    expect(parseLinkEntry(link("alice", why))).toEqual({
+      target: "alice",
+      description: why,
+    });
+  });
+
+  test("a bare slug carries no description; whitespace is trimmed", () => {
+    expect(parseLinkEntry("  alice  ")).toEqual({
+      target: "alice",
+      description: undefined,
+    });
+  });
+
+  test("an empty annotation after the separator reads as no description", () => {
+    expect(parseLinkEntry(`alice${LINK_SEPARATOR}  `)).toEqual({
+      target: "alice",
+      description: undefined,
+    });
+  });
+});
+
+describe("wikilinkTarget / extractWikilinkTargets", () => {
+  test("strips |display and #anchor suffixes and trims", () => {
+    expect(wikilinkTarget("alice")).toBe("alice");
+    expect(wikilinkTarget("alice|Alice B.")).toBe("alice");
+    expect(wikilinkTarget("alice#role")).toBe("alice");
+    expect(wikilinkTarget(" tools/vs-code#setup|editor ")).toBe(
+      "tools/vs-code",
+    );
+    expect(wikilinkTarget("|label")).toBe("");
+    expect(wikilinkTarget("#anchor")).toBe("");
+  });
+
+  test("extracts every target in order, dropping empty ones, keeping duplicates", () => {
+    const body =
+      "See [[alice]] and [[bob|Bob]] then [[alice#role]] but not [[|x]] or [[#y]].";
+    expect(extractWikilinkTargets(body)).toEqual(["alice", "bob", "alice"]);
+  });
+
+  test("the regex is global and captures the raw inner text", () => {
+    const matches = [..."[[a|A]] [[b#c]]".matchAll(WIKILINK_REGEX)].map(
+      (m) => m[1],
+    );
+    expect(matches).toEqual(["a|A", "b#c"]);
+  });
+});
+
+describe("findDanglingLinks", () => {
+  const known = new Set(["alice", "bob", "hub", "skills/deploy"]);
+
+  test("reports links:, wikilink, and edges: targets absent from the known set", () => {
+    const result = findDanglingLinks(
+      [
+        {
+          slug: "hub",
+          frontmatter: {
+            links: [link("alice", "principal"), link("atl-1291", "ticket")],
+            edges: ["bob", "ghost-edge"],
+          },
+          body: "Lead mentions [[alice]] and [[ghost-wiki|Ghost]].",
+        },
+      ],
+      known,
+      isValidSlug,
+    );
+    expect(result).toEqual([
+      { from: "hub", to: "atl-1291", kind: "links" },
+      { from: "hub", to: "ghost-edge", kind: "edges" },
+      { from: "hub", to: "ghost-wiki", kind: "wikilink" },
+    ]);
+  });
+
+  test("resolves against synthetic slugs too when the caller counts them as known", () => {
+    expect(
+      findDanglingLinks(
+        [
+          {
+            slug: "alice",
+            frontmatter: { links: [link("skills/deploy")] },
+            body: "",
+          },
+        ],
+        known,
+        isValidSlug,
+      ),
+    ).toEqual([]);
+  });
+
+  test("ignores self-references and empty targets, dedupes per (from, to, kind)", () => {
+    const result = findDanglingLinks(
+      [
+        {
+          slug: "alice",
+          frontmatter: {
+            links: [
+              link("alice", "self"),
+              link("ghost"),
+              link("ghost", "twice"),
+            ],
+          },
+          body: "[[alice]] [[ghost]] [[ghost#sec]] [[|nothing]]",
+        },
+      ],
+      known,
+      isValidSlug,
+    );
+    expect(result).toEqual([
+      { from: "alice", to: "ghost", kind: "links" },
+      { from: "alice", to: "ghost", kind: "wikilink" },
+    ]);
+  });
+
+  test("output is sorted by (from, to, kind) regardless of page order", () => {
+    const pages = [
+      { slug: "zed", frontmatter: { links: [link("nope")] }, body: "[[nope]]" },
+      { slug: "amy", frontmatter: {}, body: "[[zzz]] [[aaa]]" },
+    ];
+    const forward = findDanglingLinks(pages, known, isValidSlug);
+    const reversed = findDanglingLinks(
+      [...pages].reverse(),
+      known,
+      isValidSlug,
+    );
+    expect(forward).toEqual(reversed);
+    expect(forward.map((d) => `${d.from}>${d.to}>${d.kind}`)).toEqual([
+      "amy>aaa>wikilink",
+      "amy>zzz>wikilink",
+      "zed>nope>links",
+      "zed>nope>wikilink",
+    ]);
+  });
+
+  test("targets that are not slug-shaped are not references at all", () => {
+    // Shell tests, code, and prose in double brackets must not be reported
+    // (and so never reach the repair step that would unwrap them).
+    expect(
+      findDanglingLinks(
+        [
+          {
+            slug: "procs/deploy",
+            frontmatter: { links: ["Not A Slug"] },
+            body: "Run `if [[ -f foo ]]; then` and [[ Some Prose ]] then [[real-missing]].",
+          },
+        ],
+        known,
+        isValidSlug,
+      ),
+    ).toEqual([{ from: "procs/deploy", to: "real-missing", kind: "wikilink" }]);
+  });
+
+  test("a fully resolved corpus yields an empty list", () => {
+    expect(
+      findDanglingLinks(
+        [
+          {
+            slug: "alice",
+            frontmatter: { links: [link("bob", "peer")] },
+            body: "[[hub]]",
+          },
+          { slug: "bob", frontmatter: { edges: ["alice"] }, body: "" },
+        ],
+        known,
+        isValidSlug,
+      ),
+    ).toEqual([]);
+  });
+});

package/src/plugins/defaults/memory/substrate/__tests__/prompts-consolidation.test.ts

@@ -66,8 +66,10 @@ const {
   CORE_PAGES_CONSOLIDATION_SECTION,
   CORE_PAGES_PLACEHOLDER,
   CUTOFF_PLACEHOLDER,
+  DANGLING_LINKS_PLACEHOLDER,
   PARSE_FAILURES_PLACEHOLDER,
   renderConsolidationPrompt,
+  renderDanglingLinksSection,
   renderParseFailuresSection,
   resolveConsolidationPrompt,
 } = await import("../prompts/consolidation.js");
@@ -107,7 +109,15 @@ const bundledPrompt = (includeCorePagesSection = false): string =>
         ? (CORE_PAGES_CONSOLIDATION_SECTION as string)
         : "",
     )
-    .replaceAll(PARSE_FAILURES_PLACEHOLDER, "");
+    .replaceAll(PARSE_FAILURES_PLACEHOLDER, "")
+    .replaceAll(DANGLING_LINKS_PLACEHOLDER, "");
+
+/** Sample dangling links for the repair-section tests. */
+const SAMPLE_DANGLING = [
+  { from: "atl-1290", to: "atl-1291", kind: "links" as const },
+  { from: "people/alice", to: "ghost-page", kind: "wikilink" as const },
+  { from: "arcs/day", to: "old-slug", kind: "edges" as const },
+];
 
 beforeEach(() => {
   warnCalls.length = 0;
@@ -316,6 +326,153 @@ describe("resolveConsolidationPrompt — parse-failures repair section", () => {
   });
 });
 
+describe("resolveConsolidationPrompt: dangling-links repair section", () => {
+  test("no dangling links: no section and no placeholder residue, both article shapes", () => {
+    expect(renderDanglingLinksSection([])).toBe("");
+    for (const articleShape of ["v2", "v3"] as const) {
+      const result = renderConsolidationPrompt(CUTOFF, {
+        includeCorePagesSection: false,
+        articleShape,
+      });
+      expect(result).not.toContain("resolve dangling links");
+      expect(result).not.toContain(DANGLING_LINKS_PLACEHOLDER);
+      expect(result).toContain("# The work\n\n## 1. Read the buffer");
+    }
+  });
+
+  test("with dangling links: section renders once, before step 1, one line per reference with its kind", () => {
+    const result = renderConsolidationPrompt(CUTOFF, {
+      ...NO_CORE,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result.split("resolve dangling links").length - 1).toBe(1);
+    const sectionAt = result.indexOf("## 0. FIRST: resolve dangling links");
+    expect(sectionAt).toBeGreaterThan(result.indexOf("# The work"));
+    expect(sectionAt).toBeLessThan(result.indexOf("## 1. Read the buffer"));
+    expect(result).toContain(
+      "- `memory/concepts/atl-1290.md` → `atl-1291` (frontmatter `links:` entry)",
+    );
+    expect(result).toContain(
+      "- `memory/concepts/people/alice.md` → `ghost-page` (inline `[[wikilink]]` in the body)",
+    );
+    expect(result).toContain(
+      "- `memory/concepts/arcs/day.md` → `old-slug` (frontmatter `edges:` entry)",
+    );
+    // The three resolutions the agent must choose between.
+    expect(result).toContain("spawn it, a stub is fine, and keep the link");
+    expect(result).toContain("repoint the reference at the surviving slug");
+    expect(result).toContain("Prose stays prose");
+    expect(result).not.toContain("more, reported next pass");
+  });
+
+  test("renders after the parse-failures section when both are present", () => {
+    const result = renderConsolidationPrompt(CUTOFF, {
+      ...NO_CORE,
+      parseFailures: SAMPLE_FAILURES,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result.indexOf("repair unreadable pages")).toBeLessThan(
+      result.indexOf("resolve dangling links"),
+    );
+    expect(result.indexOf("resolve dangling links")).toBeLessThan(
+      result.indexOf("## 1. Read the buffer"),
+    );
+  });
+
+  test("caps the rendered list at 40 and counts the remainder", () => {
+    const many = Array.from({ length: 45 }, (_, i) => ({
+      from: `page-${String(i).padStart(2, "0")}`,
+      to: `missing-${i}`,
+      kind: "links" as const,
+    }));
+    const section = renderDanglingLinksSection(many);
+    const listLines = section
+      .split("\n")
+      .filter((line) => line.startsWith("- `memory/concepts/"));
+    expect(listLines).toHaveLength(40);
+    expect(section).toContain("`memory/concepts/page-39.md`");
+    expect(section).not.toContain("`memory/concepts/page-40.md`");
+    expect(section).toContain("...and 5 more, reported next pass");
+  });
+
+  test("sanitizes injection-shaped slugs and targets: newlines, backticks, oversize", () => {
+    // Both ends of a dangling link are page content: the source is a
+    // filename, the target is whatever the page wrote inside `[[...]]` or
+    // `links:`. Raw, either could break out of the list item.
+    const section = renderDanglingLinksSection([
+      {
+        from: "evil\n\n## Injected heading\n- `nested`",
+        to: "target`code`\n## also injected",
+        kind: "wikilink",
+      },
+      { from: "s".repeat(500), to: "t".repeat(500), kind: "links" },
+    ]);
+    const listLines = section
+      .split("\n")
+      .filter((line) => line.startsWith("- `memory/concepts/"));
+    expect(listLines).toHaveLength(2);
+    for (const line of listLines) {
+      // Source path, target, and the kind label's own inline-code span:
+      // six template backticks, no injected ones.
+      expect((line.match(/`/g) ?? []).length).toBe(6);
+    }
+    const headingLines = section
+      .split("\n")
+      .filter((line) => line.startsWith("## "));
+    expect(headingLines).toHaveLength(1);
+    expect(section).toContain("memory/concepts/evil ");
+    expect(section).toContain(`${"s".repeat(199)}…`);
+    expect(section).toContain(`${"t".repeat(199)}…`);
+    expect(section).not.toContain("s".repeat(200));
+    expect(section).not.toContain("t".repeat(200));
+  });
+
+  test("override containing the placeholder: substituted in place", () => {
+    const path = join(tmpWorkspace, "custom-prompt.md");
+    writeFileSync(path, "Top\n{{DANGLING_LINKS_SECTION}}Bottom\n");
+
+    const result = resolveConsolidationPrompt(path, CUTOFF, {
+      ...NO_CORE,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result).toContain("## 0. FIRST: resolve dangling links");
+    expect(result.indexOf("resolve dangling links")).toBeLessThan(
+      result.indexOf("Bottom"),
+    );
+    expect(result).not.toContain(DANGLING_LINKS_PLACEHOLDER);
+  });
+
+  test("override without either placeholder: both non-empty repair sections are appended, in order", () => {
+    const path = join(tmpWorkspace, "no-placeholder.md");
+    writeFileSync(path, "My custom prompt {{CUTOFF}}\n");
+
+    const result = resolveConsolidationPrompt(path, CUTOFF, {
+      ...NO_CORE,
+      parseFailures: SAMPLE_FAILURES,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result.startsWith(`My custom prompt ${CUTOFF}`)).toBe(true);
+    const parseAt = result.indexOf("repair unreadable pages");
+    const danglingAt = result.indexOf("resolve dangling links");
+    expect(parseAt).toBeGreaterThan(0);
+    expect(danglingAt).toBeGreaterThan(parseAt);
+    expect(result).toContain("`memory/concepts/atl-1290.md`");
+  });
+
+  test("override with only the parse placeholder + dangling links: dangling section appended", () => {
+    const path = join(tmpWorkspace, "custom-prompt.md");
+    writeFileSync(path, "Top\n{{PARSE_FAILURES_SECTION}}Bottom\n");
+
+    const result = resolveConsolidationPrompt(path, CUTOFF, {
+      ...NO_CORE,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result.indexOf("Bottom")).toBeLessThan(
+      result.indexOf("resolve dangling links"),
+    );
+  });
+});
+
 describe("resolveConsolidationPrompt — with override", () => {
   test("loads an absolute path verbatim and substitutes {{CUTOFF}}", () => {
     const path = join(tmpWorkspace, "custom-prompt.md");

package/src/plugins/defaults/memory/substrate/__tests__/static-context.test.ts

@@ -50,8 +50,7 @@ mock.module("../../config.js", () => ({
   }),
 }));
 
-const { readMemoryV2StaticContent, shouldExposePersonalMemory } =
-  await import("../static-context.js");
+const { readMemoryV2StaticContent } = await import("../static-context.js");
 
 const MEMORY_FILES = [
   "essentials.md",
@@ -361,62 +360,3 @@ describe("readMemoryV2StaticContent Buffer cap", () => {
     expect(lines.some((line) => line.endsWith("entry-0"))).toBe(false);
   });
 });
-
-describe("shouldExposePersonalMemory", () => {
-  test("allows guardian-trusted local conversations", () => {
-    expect(
-      shouldExposePersonalMemory({
-        sourceChannel: "vellum",
-        isTrustedActor: true,
-      }),
-    ).toBe(true);
-  });
-
-  test("allows local-channel conversations even when trust class is unknown (analyze runs, dev)", () => {
-    expect(
-      shouldExposePersonalMemory({
-        sourceChannel: "vellum",
-        isTrustedActor: false,
-      }),
-    ).toBe(true);
-  });
-
-  test("allows turns with no trust context (work-item task runs, internal background)", () => {
-    expect(
-      shouldExposePersonalMemory({
-        sourceChannel: undefined,
-        isTrustedActor: false,
-      }),
-    ).toBe(true);
-  });
-
-  const REMOTE_CHANNELS = [
-    "phone",
-    "slack",
-    "telegram",
-    "whatsapp",
-    "email",
-  ] as const;
-
-  test("allows guardian-trusted remote channels (user's own phone/Slack)", () => {
-    for (const channel of REMOTE_CHANNELS) {
-      expect(
-        shouldExposePersonalMemory({
-          sourceChannel: channel,
-          isTrustedActor: true,
-        }),
-      ).toBe(true);
-    }
-  });
-
-  test("blocks non-guardian remote-channel actors (the leak this gate exists to prevent)", () => {
-    for (const channel of REMOTE_CHANNELS) {
-      expect(
-        shouldExposePersonalMemory({
-          sourceChannel: channel,
-          isTrustedActor: false,
-        }),
-      ).toBe(false);
-    }
-  });
-});