@openparachute/vault 0.7.3-rc.13 → 0.7.3-rc.3

package/core/src/search-title-boost.test.ts

@@ -1,125 +0,0 @@
-/**
- * Search title-boost (title axis, ratified 2026-07-17): literal-mode
- * search results whose `displayTitle` (first non-empty content line, NOT
- * `path`) contains every query term are post-ranked ahead of body-only
- * matches. No-migration — an in-memory re-rank of the already-fetched
- * page, not a `notes_fts` schema change (see `applySearchTitleBoost` /
- * `boostTitleMatches` in `notes.ts`).
- *
- * This is a DIFFERENT axis from the existing `path`-weighted bm25 ranking
- * covered in `search-fts-v25.test.ts` — a note's title here is its first
- * CONTENT line, not its `path`.
- */
-import { describe, it, expect, beforeEach } from "bun:test";
-import { Database } from "bun:sqlite";
-import { SqliteStore } from "./store.js";
-
-let store: SqliteStore;
-let db: Database;
-
-beforeEach(() => {
-  db = new Database(":memory:");
-  store = new SqliteStore(db);
-});
-
-describe("search title-boost", () => {
-  it("ranks a first-line (title) match above a body-only match", async () => {
-    // Body-only match: "budget" appears only deep in the body, first line
-    // is unrelated.
-    await store.createNote(
-      "Weekly Standup\nlots of unrelated notes here, but somewhere we discuss the budget in passing",
-      { path: "standup-notes" },
-    );
-    // First-line (title) match: "Budget" is the first line itself.
-    await store.createNote("Budget Review\nQ3 numbers", { path: "budget-review" });
-
-    const hits = await store.searchNotes("budget");
-    expect(hits.length).toBeGreaterThanOrEqual(2);
-    expect(hits[0].path).toBe("budget-review");
-  });
-
-  it("requires ALL query terms to be present in the first line to boost (a partial title match doesn't qualify)", async () => {
-    // "budget" is in the title but "review" is only in the body — a
-    // PARTIAL title match, which stays in the body-only tier.
-    await store.createNote("Budget notes\nsee the quarterly review for details", { path: "partial" });
-    // Both "budget" and "review" are in the title — a FULL title match.
-    await store.createNote("Budget Review\nQ3 numbers", { path: "full-match" });
-
-    const hits = await store.searchNotes("budget review");
-    expect(hits.map((n) => n.path)).toEqual(["full-match", "partial"]);
-  });
-
-  it("ties (both notes in the same tier) keep the existing relevance order", async () => {
-    // Two title-matching notes plus one body-only note. Comparing literal
-    // mode (boosted) against advanced mode with the same plain-word query
-    // (identical FTS5 syntax, so identical underlying bm25 order, but no
-    // boost pass) isolates the boost's effect: within the title-match
-    // tier, the boost must preserve whatever relative order the
-    // underlying relevance ranking already gave — a stable sort, not a
-    // fresh comparator that could reshuffle ties.
-    await store.createNote("Project Widget\nfirst, mentions widget again for relevance", { path: "w1" });
-    await store.createNote("Project Widget\nsecond", { path: "w2" });
-    await store.createNote("Unrelated\nbody-only mention of widget project", { path: "body-only" });
-
-    const boosted = await store.searchNotes("widget project");
-    const rawOrder = await store.searchNotes("widget project", { mode: "advanced" });
-
-    const titleTierBoosted = boosted.map((n) => n.path).filter((p) => p === "w1" || p === "w2");
-    const titleTierRaw = rawOrder.map((n) => n.path).filter((p) => p === "w1" || p === "w2");
-    expect(titleTierBoosted).toEqual(titleTierRaw);
-    // The title-match tier precedes the body-only note in the boosted result.
-    expect(boosted.map((n) => n.path).indexOf("body-only")).toBeGreaterThan(
-      Math.max(...["w1", "w2"].map((p) => boosted.map((n) => n.path).indexOf(p))),
-    );
-  });
-
-  it("does not disturb ordering when an explicit sort is requested", async () => {
-    await store.createNote("Zebra body-only mention of gadget", { path: "z" });
-    await store.createNote("Gadget Launch\nfirst line title match", { path: "a" });
-
-    const asc = await store.searchNotes("gadget", { sort: "asc" });
-    // created_at ASC means "z" (created first) comes before "a" — the
-    // title-boost must NOT override an explicit sort.
-    expect(asc.map((n) => n.path)).toEqual(["z", "a"]);
-  });
-
-  it("does not apply the boost under search_mode: advanced (raw FTS5 syntax, not naively tokenizable)", async () => {
-    await store.createNote("Body only mentions gadget in passing text here", { path: "body-only" });
-    await store.createNote("Gadget\nfirst line title match", { path: "title-match" });
-
-    const advanced = await store.searchNotes("gadget", { mode: "advanced" });
-    const literal = await store.searchNotes("gadget");
-
-    // Literal mode boosts the title match to the front.
-    expect(literal[0].path).toBe("title-match");
-    // Advanced mode is unaffected by the boost — order comes from bm25
-    // relevance alone (title-match still likely ranks first via the
-    // EXISTING path-weighted bm25, but that's a different mechanism; the
-    // test here just confirms advanced mode doesn't throw and returns
-    // both notes, not that ordering matches/mismatches literal mode).
-    expect(advanced.map((n) => n.path).sort()).toEqual(["body-only", "title-match"]);
-  });
-
-  it("a query with no results is unaffected (empty array in, empty array out)", async () => {
-    const hits = await store.searchNotes("nonexistent_term_xyz");
-    expect(hits).toEqual([]);
-  });
-
-  it("boosts on the post-frontmatter title line, not the `---` delimiter (shares computeDisplayTitle's frontmatter skip)", async () => {
-    // Direct-create misuse path: raw frontmatter-bearing content. Without
-    // the frontmatter skip, the derived "title" would be the literal
-    // string "---", which never matches any query term, so this note
-    // would wrongly land in the body-only tier.
-    await store.createNote(
-      "---\ntitle: irrelevant\n---\n# Budget Review\nQ3 numbers",
-      { path: "frontmatter-led" },
-    );
-    await store.createNote(
-      "Weekly Standup\nsomewhere we discuss the budget in passing",
-      { path: "body-only" },
-    );
-
-    const hits = await store.searchNotes("budget review");
-    expect(hits[0].path).toBe("frontmatter-led");
-  });
-});

package/src/attachment-bytes.ts

@@ -1,68 +0,0 @@
-/**
- * Attachment bytes — bun's filesystem implementation of the model-lane
- * (Wave 2) `AttachmentBytesProvider` seam (`core/src/attachment/bytes-provider.ts`).
- *
- * Stateless by design (unlike the ticket provider, there's no in-memory
- * state to share across requests) — a fresh instance per MCP session is
- * cheap, so `createFsAttachmentBytesProvider` is a plain factory, not a
- * shared singleton.
- *
- * `readRange` uses `Bun.file(path).slice(start, end)` — a bounded,
- * positional read (Bun resolves the slice lazily via `pread` under the
- * hood), never the whole-file `readFileSync` this design explicitly moves
- * away from (see `handleStorage`'s REST `Range` support in `src/routes.ts`
- * for the sibling fix on the byte-serve side).
- */
-
-import { existsSync, statSync } from "fs";
-import { join, normalize } from "path";
-import type { Attachment } from "../core/src/types.ts";
-import type { AttachmentBytesProvider } from "../core/src/attachment/bytes-provider.ts";
-import { assetsDir } from "./config.ts";
-import { transcriptPathFor } from "./transcript-note.ts";
-import { getVaultStore } from "./vault-store.ts";
-
-/**
- * Resolve + confine an attachment's on-disk path under this vault's assets
- * dir. Same guard as the ticket download spend route (`src/attachment-tickets.ts`)
- * and the REST byte-serve route (`src/routes.ts`): normalize, then require
- * the result to still start with the (normalized) assets root — a stored
- * `path` can never resolve outside it, but a defense-in-depth check costs
- * nothing. Returns `null` on a traversal attempt (treated identically to
- * "file doesn't exist" by every caller here).
- */
-function resolveConfinedPath(vaultName: string, attachment: Attachment): string | null {
-  const assets = assetsDir(vaultName);
-  const filePath = normalize(join(assets, attachment.path));
-  if (!filePath.startsWith(normalize(assets))) return null;
-  return filePath;
-}
-
-class FsAttachmentBytesProvider implements AttachmentBytesProvider {
-  constructor(private readonly vaultName: string) {}
-
-  async stat(attachment: Attachment): Promise<{ size: number } | null> {
-    const filePath = resolveConfinedPath(this.vaultName, attachment);
-    if (!filePath || !existsSync(filePath)) return null;
-    return { size: statSync(filePath).size };
-  }
-
-  async readRange(attachment: Attachment, start: number, end: number): Promise<Uint8Array> {
-    const filePath = resolveConfinedPath(this.vaultName, attachment);
-    if (!filePath) return new Uint8Array(0);
-    const slice = Bun.file(filePath).slice(start, end);
-    return new Uint8Array(await slice.arrayBuffer());
-  }
-
-  async resolveTranscriptNote(attachment: Attachment): Promise<{ id: string; path: string } | null> {
-    const store = getVaultStore(this.vaultName);
-    const note = await store.getNoteByPath(transcriptPathFor(attachment.path));
-    if (!note) return null;
-    return { id: note.id, path: note.path ?? transcriptPathFor(attachment.path) };
-  }
-}
-
-/** Build a fresh `AttachmentBytesProvider` scoped to one vault. Cheap — safe to call per-request. */
-export function createFsAttachmentBytesProvider(vaultName: string): AttachmentBytesProvider {
-  return new FsAttachmentBytesProvider(vaultName);
-}

package/src/attachment-tickets.test.ts

@@ -1,475 +0,0 @@
-/**
- * Attachment tickets — end-to-end lifecycle (mint via the real MCP tool
- * call path, spend via the real unauthenticated `/vault/<name>/tickets/<id>`
- * route dispatched through `routing.ts`'s `route()`). Covers the Wave 1
- * security posture: single-use, TTL/expiry, size-cap, wrong-vault scoping,
- * uniform 404, upload→row+transcribe, download streaming + path
- * confinement, and the connect-time instructions block.
- */
-
-import { describe, test, expect } from "bun:test";
-import { join } from "path";
-import { tmpdir } from "os";
-
-const testDir = join(
-  tmpdir(),
-  `vault-attachment-tickets-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-);
-process.env.PARACHUTE_HOME = testDir;
-// Deliberately NOT setting ASSETS_DIR (unlike storage.test.ts, which wants a
-// single shared assets root for its own reasons): that env var is global to
-// the whole `bun test` process (all files share one Node process), so
-// setting it here would leak into every OTHER test file's assetsDir() calls
-// too. Each vault below gets a unique, unset-ASSETS_DIR-default assets dir
-// (`vaultDir(name)/assets`) scoped under this file's own unique
-// PARACHUTE_HOME — fully isolated without needing the override.
-
-const { route } = await import("./routing.ts");
-const { handleScopedMcp } = await import("./mcp-http.ts");
-const { getServerInstruction } = await import("./mcp-tools.ts");
-const { writeVaultConfig } = await import("./config.ts");
-const { getVaultStore } = await import("./vault-store.ts");
-const {
-  getSharedAttachmentTicketProvider,
-  InProcessAttachmentTicketProvider,
-  sweepExpiredAttachmentTickets,
-  startAttachmentTicketSweep,
-  stopAttachmentTicketSweep,
-} = await import("./attachment-tickets.ts");
-const { generateTicketId } = await import("../core/src/attachment/tickets.ts");
-import type { AttachmentTicket } from "../core/src/attachment/tickets.ts";
-const { attachmentsInstructionBlock } = await import("../core/src/vault-projection.ts");
-
-/** `route()` takes the pathname as a separate arg (server.ts derives it from `req.url`) — this wrapper matches that call shape everywhere below. */
-async function routeReq(req: Request): Promise<Response> {
-  return route(req, new URL(req.url).pathname);
-}
-
-function freshVault(prefix: string): string {
-  const name = `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  writeVaultConfig({ name, api_keys: [], created_at: new Date().toISOString() });
-  return name;
-}
-
-/** Bypasses `authenticateVaultRequest` the same way vault.test.ts's scope-tier tests do — a fabricated already-resolved auth object. */
-function mcpAuth(scopes: string[]) {
-  return {
-    permission: scopes.includes("vault:write") || scopes.includes("vault:admin") ? "full" : "read",
-    scopes,
-    legacyDerived: false,
-    scoped_tags: null,
-  } as any;
-}
-
-async function callTool(vaultName: string, name: string, args: Record<string, unknown>): Promise<any> {
-  const req = new Request(`http://localhost:1940/vault/${vaultName}/mcp`, {
-    method: "POST",
-    headers: { "content-type": "application/json", accept: "application/json, text/event-stream" },
-    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }),
-  });
-  const res = await handleScopedMcp(req, vaultName, mcpAuth(["vault:read", "vault:write"]));
-  const body = (await res.json()) as any;
-  if (body.error) {
-    const err = new Error(body.error.message);
-    Object.assign(err, body.error.data ?? {});
-    throw err;
-  }
-  return JSON.parse(body.result.content[0].text);
-}
-
-describe("attachment tickets — upload lifecycle", () => {
-  test("mint → spend → row registered with size + original_name; second spend of the same ticket 404s", async () => {
-    const vaultName = freshVault("tickets-upload");
-    const store = getVaultStore(vaultName);
-    const note = await store.createNote("# Target\n", { path: "target" });
-
-    const mint = await callTool(vaultName, "request-attachment-upload", {
-      note: note.id,
-      filename: "photo.png",
-      size_bytes: 5,
-      mime_type: "image/png",
-    });
-    expect(mint.method).toBe("PUT");
-    expect(mint.url).toContain(`/vault/${vaultName}/tickets/`);
-    expect(mint.max_bytes).toBe(5);
-
-    const bytes = new Uint8Array([1, 2, 3, 4, 5]);
-    const spendRes = await routeReq(
-      new Request(mint.url, { method: "PUT", headers: { "content-type": "image/png" }, body: bytes }),
-    );
-    expect(spendRes.status).toBe(201);
-    const attachment = (await spendRes.json()) as any;
-    expect(attachment.noteId).toBe(note.id);
-    expect(attachment.mimeType).toBe("image/png");
-    expect(attachment.metadata.original_name).toBe("photo.png");
-    expect(attachment.metadata.size).toBe(5);
-
-    const rows = await store.getAttachments(note.id);
-    expect(rows.length).toBe(1);
-    expect(rows[0]!.id).toBe(attachment.id);
-
-    // Single-use: the ticket is gone after one spend — uniform 404, no
-    // oracle distinguishing "spent" from "never existed".
-    const secondRes = await routeReq(
-      new Request(mint.url, { method: "PUT", headers: { "content-type": "image/png" }, body: new Uint8Array([9]) }),
-    );
-    expect(secondRes.status).toBe(404);
-    const secondBody = (await secondRes.json()) as any;
-    expect(secondBody.error_type).toBe("not_found");
-    expect(typeof secondBody.how_to).toBe("string");
-
-    // A second upload wasn't registered.
-    expect((await store.getAttachments(note.id)).length).toBe(1);
-  });
-
-  test("POST also spends an upload ticket (accepted alongside the advertised PUT)", async () => {
-    const vaultName = freshVault("tickets-upload-post");
-    const store = getVaultStore(vaultName);
-    const note = await store.createNote("# T\n", { path: "t" });
-    const mint = await callTool(vaultName, "request-attachment-upload", {
-      note: note.id,
-      filename: "a.txt",
-      size_bytes: 3,
-    });
-    const res = await routeReq(
-      new Request(mint.url, { method: "POST", headers: { "content-type": "text/plain" }, body: new Uint8Array([1, 2, 3]) }),
-    );
-    expect(res.status).toBe(201);
-  });
-
-  test("size-cap: an upload exceeding the ticket's declared size_bytes is rejected 413 and no row is created", async () => {
-    const vaultName = freshVault("tickets-size-cap");
-    const store = getVaultStore(vaultName);
-    const note = await store.createNote("# T\n", { path: "t" });
-    const mint = await callTool(vaultName, "request-attachment-upload", {
-      note: note.id,
-      filename: "small.bin",
-      size_bytes: 3,
-    });
-    const res = await routeReq(
-      new Request(mint.url, {
-        method: "PUT",
-        headers: { "content-type": "application/octet-stream" },
-        body: new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]),
-      }),
-    );
-    expect(res.status).toBe(413);
-    const body = (await res.json()) as any;
-    expect(body.error_type).toBe("file_too_large");
-    expect(body.limit).toBe(3);
-    expect(typeof body.how_to).toBe("string");
-    expect((await store.getAttachments(note.id)).length).toBe(0);
-  });
-
-  test("a mismatched Content-Length header alone is rejected 413 before the body is even read", async () => {
-    const vaultName = freshVault("tickets-cl-cap");
-    const store = getVaultStore(vaultName);
-    const note = await store.createNote("# T\n", { path: "t" });
-    const mint = await callTool(vaultName, "request-attachment-upload", {
-      note: note.id,
-      filename: "small.bin",
-      size_bytes: 3,
-    });
-    const res = await routeReq(
-      new Request(mint.url, {
-        method: "PUT",
-        headers: { "content-type": "application/octet-stream", "content-length": "1000000" },
-        body: new Uint8Array([1, 2, 3]),
-      }),
-    );
-    expect(res.status).toBe(413);
-  });
-
-  test("expiry: a ticket past its expires_at is rejected 404 even though it was never spent", async () => {
-    const vaultName = freshVault("tickets-expiry");
-    const store = getVaultStore(vaultName);
-    const note = await store.createNote("# T\n", { path: "t" });
-
-    const provider = getSharedAttachmentTicketProvider();
-    const id = "e".repeat(64);
-    await provider.put({
-      id,
-      kind: "upload",
-      vaultName,
-      createdAt: Date.now() - 1000,
-      expiresAt: Date.now() - 1, // already expired
-      noteId: note.id,
-      filename: "late.bin",
-      mimeType: "application/octet-stream",
-      sizeBytes: 10,
-    });
-
-    const res = await routeReq(
-      new Request(`http://localhost:1940/vault/${vaultName}/tickets/${id}`, {
-        method: "PUT",
-        headers: { "content-type": "application/octet-stream" },
-        body: new Uint8Array([1]),
-      }),
-    );
-    expect(res.status).toBe(404);
-    expect((await store.getAttachments(note.id)).length).toBe(0);
-  });
-
-  test("wrong-vault scope: a ticket minted for vault A can't be spent against vault B's URL", async () => {
-    const vaultA = freshVault("tickets-vault-a");
-    const vaultB = freshVault("tickets-vault-b");
-    const storeA = getVaultStore(vaultA);
-    const note = await storeA.createNote("# T\n", { path: "t" });
-
-    const mint = await callTool(vaultA, "request-attachment-upload", {
-      note: note.id,
-      filename: "a.bin",
-      size_bytes: 3,
-    });
-    const ticketId = mint.url.split("/tickets/")[1] as string;
-
-    const crossVaultRes = await routeReq(
-      new Request(`http://localhost:1940/vault/${vaultB}/tickets/${ticketId}`, {
-        method: "PUT",
-        headers: { "content-type": "application/octet-stream" },
-        body: new Uint8Array([1, 2, 3]),
-      }),
-    );
-    expect(crossVaultRes.status).toBe(404);
-
-    // `take()` deletes on lookup regardless of which vault asked — a
-    // wrong-vault spend attempt still burns the ticket (single-use is
-    // enforced by the delete, vault-match is a SEPARATE check layered on
-    // top). Documenting this: the ticket is gone even for the correct
-    // vault after the cross-vault probe above.
-    const correctRes = await routeReq(
-      new Request(mint.url, {
-        method: "PUT",
-        headers: { "content-type": "application/octet-stream" },
-        body: new Uint8Array([1, 2, 3]),
-      }),
-    );
-    expect(correctRes.status).toBe(404);
-  });
-
-  test("transcribe: true rides through to the attachment row and stamps the note's transcribe_stub", async () => {
-    const vaultName = freshVault("tickets-transcribe");
-    const store = getVaultStore(vaultName);
-    const note = await store.createNote("# Voice memo\n", { path: "memo" });
-
-    const mint = await callTool(vaultName, "request-attachment-upload", {
-      note: note.id,
-      filename: "memo.wav",
-      size_bytes: 4,
-      transcribe: true,
-    });
-    const res = await routeReq(
-      new Request(mint.url, { method: "PUT", headers: { "content-type": "audio/wav" }, body: new Uint8Array([1, 2, 3, 4]) }),
-    );
-    expect(res.status).toBe(201);
-    const attachment = (await res.json()) as any;
-    expect(attachment.metadata.transcribe_status).toBe("pending");
-    expect(attachment.metadata.transcribe_origin).toBe("legacy");
-
-    const updatedNote = await store.getNote(note.id);
-    expect((updatedNote!.metadata as any)?.transcribe_stub).toBe(true);
-  });
-
-  test("blocked extension is refused at MINT — no ticket is ever created", async () => {
-    const vaultName = freshVault("tickets-blocked-ext");
-    const store = getVaultStore(vaultName);
-    const note = await store.createNote("# T\n", { path: "t" });
-    await expect(
-      callTool(vaultName, "request-attachment-upload", { note: note.id, filename: "evil.svg", size_bytes: 10 }),
-    ).rejects.toThrow();
-  });
-});
-
-describe("attachment tickets — download lifecycle", () => {
-  test("mint → spend streams the exact bytes with the attachment's content-type", async () => {
-    const vaultName = freshVault("tickets-download");
-    const store = getVaultStore(vaultName);
-    const note = await store.createNote("# T\n", { path: "t" });
-
-    const uploadMint = await callTool(vaultName, "request-attachment-upload", {
-      note: note.id,
-      filename: "data.bin",
-      size_bytes: 4,
-      mime_type: "application/octet-stream",
-    });
-    const uploadRes = await routeReq(
-      new Request(uploadMint.url, {
-        method: "PUT",
-        headers: { "content-type": "application/octet-stream" },
-        body: new Uint8Array([10, 20, 30, 40]),
-      }),
-    );
-    const attachment = (await uploadRes.json()) as any;
-
-    const downloadMint = await callTool(vaultName, "request-attachment-download", {
-      attachment_id: attachment.id,
-    });
-    expect(downloadMint.method).toBe("GET");
-    expect(downloadMint.mime_type).toBe("application/octet-stream");
-
-    const downloadRes = await routeReq(new Request(downloadMint.url, { method: "GET" }));
-    expect(downloadRes.status).toBe(200);
-    expect(downloadRes.headers.get("content-type")).toBe("application/octet-stream");
-    expect(downloadRes.headers.get("x-content-type-options")).toBe("nosniff");
-    const body = new Uint8Array(await downloadRes.arrayBuffer());
-    expect(Array.from(body)).toEqual([10, 20, 30, 40]);
-
-    // Single-use on the download side too.
-    const secondRes = await routeReq(new Request(downloadMint.url, { method: "GET" }));
-    expect(secondRes.status).toBe(404);
-  });
-
-  test("path confinement: an attachment row pointing outside assetsDir can't be walked to via a download ticket", async () => {
-    const vaultName = freshVault("tickets-confinement");
-    const store = getVaultStore(vaultName);
-    const note = await store.createNote("# T\n", { path: "t" });
-    // A row with a traversal path could only arrive via a bug elsewhere
-    // (tickets themselves never accept a caller-supplied path) — this pins
-    // the download spend route's OWN confinement guard as defense-in-depth.
-    const attachment = await store.addAttachment(note.id, "../../../../etc/passwd", "text/plain");
-
-    const downloadMint = await callTool(vaultName, "request-attachment-download", {
-      attachment_id: attachment.id,
-    });
-    const res = await routeReq(new Request(downloadMint.url, { method: "GET" }));
-    expect(res.status).toBe(404);
-  });
-});
-
-describe("attachment tickets — discoverability", () => {
-  test("attachmentsInstructionBlock teaches the ticket tools when enabled, and omits them when not", () => {
-    const enabled = attachmentsInstructionBlock({ ticketsEnabled: true });
-    expect(enabled).toContain("request-attachment-upload");
-    expect(enabled).toContain("request-attachment-download");
-    expect(enabled).toContain("curl_example");
-
-    const disabled = attachmentsInstructionBlock({ ticketsEnabled: false });
-    expect(disabled).not.toContain("request-attachment-upload");
-    // The REST fallback recipe is always present, wired or not.
-    expect(disabled).toContain("/storage/upload");
-  });
-
-  test("bun's connect-time getServerInstruction includes the Attachments section and teaches the ticket tools", async () => {
-    const vaultName = freshVault("tickets-instructions");
-    const md = await getServerInstruction(vaultName);
-    expect(md).toContain("## Attachments");
-    expect(md).toContain("request-attachment-upload");
-  });
-
-  test("attachmentsInstructionBlock teaches read-attachment when readEnabled, and omits it when not", () => {
-    const enabled = attachmentsInstructionBlock({ ticketsEnabled: true, readEnabled: true });
-    expect(enabled).toContain("read-attachment");
-
-    const disabled = attachmentsInstructionBlock({ ticketsEnabled: true, readEnabled: false });
-    expect(disabled).not.toContain("read-attachment");
-  });
-
-  test("bun's connect-time getServerInstruction teaches read-attachment too", async () => {
-    const vaultName = freshVault("tickets-instructions-read");
-    const md = await getServerInstruction(vaultName);
-    expect(md).toContain("read-attachment");
-  });
-});
-
-describe("attachment ticket sweep (vault#612)", () => {
-  // Isolated instance — no risk of touching the one process-wide provider
-  // every OTHER test in this file (and every other test FILE, via
-  // getSharedAttachmentTicketProvider) also shares.
-  function ticketExpiringAt(id: string, expiresAt: number): AttachmentTicket {
-    return {
-      id,
-      kind: "download",
-      vaultName: "sweep-unit-test",
-      createdAt: expiresAt - 60_000,
-      expiresAt,
-      attachmentId: "att-1",
-    };
-  }
-
-  test("sweepExpired drops only expired-unspent tickets and returns the count dropped", async () => {
-    const provider = new InProcessAttachmentTicketProvider();
-    const now = Date.now();
-    await provider.put(ticketExpiringAt("expired-1", now - 5000));
-    await provider.put(ticketExpiringAt("expired-2", now - 1));
-    await provider.put(ticketExpiringAt("fresh-1", now + 60_000));
-    expect(provider.size()).toBe(3);
-
-    const dropped = provider.sweepExpired(now);
-    expect(dropped).toBe(2);
-    expect(provider.size()).toBe(1);
-
-    // Dropped tickets are gone — take() returns null, same as "never existed".
-    expect(await provider.take("expired-1")).toBeNull();
-    expect(await provider.take("expired-2")).toBeNull();
-    // The unexpired ticket survived the sweep and is still spendable.
-    const fresh = await provider.take("fresh-1");
-    expect(fresh?.id).toBe("fresh-1");
-  });
-
-  test("a ticket expiring exactly `now` counts as expired (< comparison, not <=)", async () => {
-    const provider = new InProcessAttachmentTicketProvider();
-    const now = Date.now();
-    await provider.put(ticketExpiringAt("boundary", now));
-    expect(provider.sweepExpired(now)).toBe(0); // expiresAt === now is NOT yet expired
-    expect(provider.sweepExpired(now + 1)).toBe(1); // one ms later, it is
-  });
-
-  test("a no-op sweep (nothing expired) drops nothing", () => {
-    const provider = new InProcessAttachmentTicketProvider();
-    expect(provider.sweepExpired(Date.now())).toBe(0);
-    expect(provider.size()).toBe(0);
-  });
-
-  test("sweepExpiredAttachmentTickets delegates to the shared provider (unique ids — safe alongside concurrent tests)", async () => {
-    const provider = getSharedAttachmentTicketProvider();
-    const now = Date.now();
-    const expiredId = generateTicketId();
-    const freshId = generateTicketId();
-    await provider.put(ticketExpiringAt(expiredId, now - 1));
-    await provider.put(ticketExpiringAt(freshId, now + 60_000));
-
-    sweepExpiredAttachmentTickets(now);
-
-    expect(await provider.take(expiredId)).toBeNull();
-    const fresh = await provider.take(freshId);
-    expect(fresh?.id).toBe(freshId);
-  });
-
-  test("sweepExpiredAttachmentTickets always returns a number (the `?? 0` fallback path never throws)", () => {
-    // By this point in the suite the shared provider already exists (other
-    // tests above created it) — this doesn't re-prove the true
-    // never-created case in isolation, but pins the return type/no-throw
-    // contract the periodic sweep timer depends on every tick.
-    expect(typeof sweepExpiredAttachmentTickets()).toBe("number");
-  });
-
-  test("start/stop the periodic sweep: idempotent start, a short-interval real timer actually drops an expired ticket, clean stop", async () => {
-    // Poll via `size()`, NOT `take(id)` — `take()` deletes unconditionally
-    // on any lookup (expired or not; see its own doc comment), so polling
-    // with it would consume the ticket itself on the FIRST poll — before
-    // the timer ever fires — and the test would pass for the wrong reason.
-    const provider = getSharedAttachmentTicketProvider() as InstanceType<typeof InProcessAttachmentTicketProvider>;
-    const now = Date.now();
-    const id = generateTicketId();
-    await provider.put(ticketExpiringAt(id, now - 1)); // already expired
-    const baseline = provider.size();
-
-    startAttachmentTicketSweep(15); // 15ms — short enough to observe within the test timeout
-    startAttachmentTicketSweep(15); // idempotent — no-op, doesn't create a second timer
-
-    // Poll briefly rather than a single fixed sleep — bounded by the test
-    // runner's own timeout.
-    let sizeDropped = false;
-    for (let i = 0; i < 20 && !sizeDropped; i++) {
-      await new Promise((r) => setTimeout(r, 15));
-      if (provider.size() < baseline) sizeDropped = true;
-    }
-    stopAttachmentTicketSweep();
-    stopAttachmentTicketSweep(); // idempotent — no-op on an already-stopped sweep
-
-    expect(sizeDropped).toBe(true);
-    // Confirm it was genuinely OUR ticket the sweep dropped, not a
-    // coincidental size change from something else.
-    expect(await provider.take(id)).toBeNull();
-  });
-});