kennel 0.2.2 → 0.2.5

package/kernel/plugins/mail/test/mailos.test.mjs

@@ -1,752 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test"
-
-import {
-  conversationLimits,
-  createMailosService,
-  MailosCommandError,
-  MailSendFailure,
-  resetConversationCache,
-  runMailos,
-  validateSendContract,
-} from "../src/mailos.ts"
-
-const REV = "a".repeat(64)
-const BIN = "/tmp/mailos-test-bin"
-const DRAFT_DIR = "/tmp/mailos-test-drafts"
-
-function readMarkdown(id) {
-  return [
-    `# Subject ${id}`,
-    "",
-    "**From:** sender@example.com  ",
-    "**To:** to@example.com  ",
-    "**Date:** September 21, 2026 3:04 PM  ",
-    "**ID:** 42  ",
-    "",
-    "---",
-    "",
-    `Body of ${id}`,
-    "",
-  ].join("\n")
-}
-
-const defaultHandler = () => ({
-  stdout: readMarkdown("x"),
-  stderr: "",
-})
-
-function recordingRunner(handlers = [], fallback = defaultHandler) {
-  const calls = []
-  let index = 0
-  const runner = async (file, args, options) => {
-    const call = {
-      args,
-      cwd: options.cwd,
-      file,
-      signal: options.signal,
-      timeout: options.timeout,
-    }
-    calls.push(call)
-    const handler = handlers[index] ?? fallback
-    index += 1
-    return handler(call)
-  }
-  return { calls, runner }
-}
-
-function service(handlers = [], options = {}) {
-  const { calls, runner } = recordingRunner(handlers)
-  const svc = createMailosService({
-    execFile: runner,
-    mailosBin: BIN,
-    globalDraftDir: DRAFT_DIR,
-    ...options,
-  })
-  return { calls, svc }
-}
-
-function notFoundError(id) {
-  return new MailosCommandError("not-found", `Message ${id} not found`)
-}
-
-beforeEach(() => {
-  resetConversationCache()
-})
-
-describe("runMailos lifecycle", () => {
-  test("maps killed children to timeout with the exit code", async () => {
-    const runner = async () => {
-      throw Object.assign(new Error("boom"), { killed: true, code: 1 })
-    }
-    await expect(
-      runMailos(runner, BIN, ["x"], { cwd: "/f", timeoutMs: 100 }),
-    ).rejects.toMatchObject({ code: "timeout", timedOut: true, exitCode: 1 })
-  })
-
-  test("maps AbortError to aborted", async () => {
-    const runner = async () => {
-      const error = new Error("aborted")
-      error.name = "AbortError"
-      throw error
-    }
-    await expect(
-      runMailos(runner, BIN, ["x"], { cwd: "/f", timeoutMs: 100 }),
-    ).rejects.toMatchObject({ code: "aborted", aborted: true })
-  })
-
-  test("redacts command output from error messages", async () => {
-    const runner = async () => {
-      throw new Error("stderr contained secret-token-xyz and body content")
-    }
-    await expect(
-      runMailos(runner, BIN, ["x"], { cwd: "/f", timeoutMs: 100 }),
-    ).rejects.toMatchObject({
-      code: "failed",
-      message: "MailOS command failed to complete",
-    })
-  })
-
-  test("passes the abort signal to the child", async () => {
-    const seen = {}
-    const runner = async (_file, _args, options) => {
-      seen.signal = options.signal
-      return { stdout: "", stderr: "" }
-    }
-    const controller = new AbortController()
-    await runMailos(runner, BIN, ["x"], {
-      cwd: "/f",
-      signal: controller.signal,
-      timeoutMs: 100,
-    })
-    expect(seen.signal).toBe(controller.signal)
-  })
-
-  test("rejects immediately when the signal is already aborted", async () => {
-    const controller = new AbortController()
-    controller.abort()
-    const runner = async () => ({ stdout: "", stderr: "" })
-    await expect(
-      runMailos(runner, BIN, ["x"], {
-        cwd: "/f",
-        signal: controller.signal,
-        timeoutMs: 100,
-      }),
-    ).rejects.toMatchObject({ code: "aborted" })
-  })
-})
-
-describe("identity", () => {
-  test("parses Effective From and From Name, never errors the row", async () => {
-    const { svc, calls } = service([
-      () => ({
-        stdout: "From Name: Jane Doe\nEffective From: jane@example.com\n",
-        stderr: "",
-      }),
-    ])
-    const identity = await svc.identity("/f")
-    expect(identity).toEqual({
-      from: "jane@example.com",
-      name: "Jane Doe",
-      ok: true,
-    })
-    expect(calls[0].args).toEqual(["whoami"])
-    expect(calls[0].cwd).toBe("/f")
-  })
-
-  test('normalizes "(not set)" placeholders to null instead of a fake identity', async () => {
-    const { svc } = service([
-      () => ({
-        stdout: "From Name: (not set)\nEffective From: (not set)\n",
-        stderr: "",
-      }),
-    ])
-    expect(await svc.identity("/f")).toEqual({
-      from: null,
-      name: null,
-      ok: false,
-    })
-  })
-
-  test("treats a blank identity as unset", async () => {
-    const { svc } = service([
-      () => ({ stdout: "From Name:\nEffective From:\n", stderr: "" }),
-    ])
-    expect(await svc.identity("/f")).toEqual({
-      from: null,
-      name: null,
-      ok: false,
-    })
-  })
-
-  test("CLI failure yields a graceful null identity", async () => {
-    const { svc } = service([
-      () => {
-        throw new Error("boom")
-      },
-    ])
-    expect(await svc.identity("/f")).toEqual({
-      from: null,
-      name: null,
-      ok: false,
-    })
-  })
-})
-
-describe("signature", () => {
-  test("resolves the folder signature with exact args", async () => {
-    const { svc, calls } = service([
-      () => ({
-        stdout: "**Example User**\nDirector, Example Company\n",
-        stderr: "",
-      }),
-    ])
-    expect(await svc.signature("/f/clients")).toBe(
-      "**Example User**\nDirector, Example Company",
-    )
-    expect(calls[0].args).toEqual(["sig", "/f/clients"])
-    expect(calls[0].cwd).toBe("/f/clients")
-  })
-
-  test("returns null when the folder has no signature configured", async () => {
-    const { svc } = service([
-      () => ({ stdout: "(no signature configured)\n", stderr: "" }),
-    ])
-    expect(await svc.signature("/f")).toBeNull()
-  })
-
-  test("returns null for an empty signature", async () => {
-    const { svc } = service([
-      () => ({ stdout: "(signature is empty)\n", stderr: "" }),
-    ])
-    expect(await svc.signature("/f")).toBeNull()
-  })
-
-  test("blank output degrades to null", async () => {
-    const { svc } = service([() => ({ stdout: "", stderr: "" })])
-    expect(await svc.signature("/f")).toBeNull()
-  })
-
-  test("CLI failure yields a graceful null signature", async () => {
-    const { svc } = service([
-      () => {
-        throw new Error("boom")
-      },
-    ])
-    expect(await svc.signature("/f")).toBeNull()
-  })
-})
-
-describe("conversation", () => {
-  test("reads references with exact args and returns ok items in order", async () => {
-    const { svc, calls } = service([
-      () => ({ stdout: readMarkdown("r1"), stderr: "" }),
-      () => ({ stdout: readMarkdown("r2"), stderr: "" }),
-    ])
-    const result = await svc.conversation("/f", ["r1", "r2"])
-    expect(result.outcome).toBe("ok")
-    expect(result.items.map((item) => item.id)).toEqual(["r1", "r2"])
-    expect(result.items[0]).toMatchObject({
-      subject: "Subject r1",
-      from: "sender@example.com",
-      to: "to@example.com",
-      date: "September 21, 2026 3:04 PM",
-    })
-    expect(result.items[0].body).toBe("Body of r1")
-    expect(calls.map((call) => call.args)).toEqual([
-      ["read", "r1", "--markdown"],
-      ["read", "r2", "--markdown"],
-    ])
-  })
-
-  test("empty references do not invoke the CLI", async () => {
-    const { svc, calls } = service([])
-    const result = await svc.conversation("/f", [])
-    expect(result).toEqual({ items: [], missing: [], outcome: "empty" })
-    expect(calls.length).toBe(0)
-  })
-
-  test("bounds references to the configured maximum", async () => {
-    const ids = Array.from({ length: 20 }, (_, index) => `r${index}`)
-    const { svc, calls } = service([])
-    const result = await svc.conversation("/f", ids)
-    expect(result.items.length).toBe(conversationLimits.maxReferences)
-    expect(calls.length).toBe(conversationLimits.maxReferences)
-  })
-
-  test("deduplicates duplicate references within one request", async () => {
-    const { svc, calls } = service([])
-    const result = await svc.conversation("/f", ["r1", "r1", "r1"])
-    expect(result.items.length).toBe(1)
-    expect(calls.length).toBe(1)
-  })
-
-  test("classifies a partially resolved thread", async () => {
-    const { svc } = service([
-      () => ({ stdout: readMarkdown("a"), stderr: "" }),
-      () => {
-        throw notFoundError("b")
-      },
-      () => ({ stdout: readMarkdown("c"), stderr: "" }),
-    ])
-    const result = await svc.conversation("/f", ["a", "b", "c"])
-    expect(result.outcome).toBe("partial")
-    expect(result.items.map((item) => item.id)).toEqual(["a", "c"])
-    expect(result.missing).toEqual(["b"])
-  })
-
-  test("classifies an entirely unresolved thread as not-found", async () => {
-    const { svc } = service([
-      () => {
-        throw notFoundError("a")
-      },
-      () => {
-        throw notFoundError("b")
-      },
-    ])
-    const result = await svc.conversation("/f", ["a", "b"])
-    expect(result.outcome).toBe("not-found")
-    expect(result.items).toEqual([])
-    expect(result.missing).toEqual(["a", "b"])
-  })
-
-  test("classifies a timed-out read as timeout without retrying", async () => {
-    const { svc, calls } = service([
-      () => ({ stdout: readMarkdown("a"), stderr: "" }),
-      () => {
-        throw new MailosCommandError("timeout", "read timed out", {
-          timedOut: true,
-        })
-      },
-    ])
-    const result = await svc.conversation("/f", ["a", "b"])
-    expect(result.outcome).toBe("timeout")
-    expect(result.items.map((item) => item.id)).toEqual(["a"])
-    // One attempt per reference; never a retry loop.
-    expect(calls.length).toBe(2)
-  })
-
-  test(
-    "long-delay fixture: a read slower than the old 8s cap still succeeds on real timers",
-    { timeout: 60_000 },
-    async () => {
-      const startedAt = performance.now()
-      const slowDelayMs = 9_500
-      const { svc } = service([
-        () => {
-          return Bun.sleep(slowDelayMs).then(() => ({
-            stdout: readMarkdown("slow-real"),
-            stderr: "",
-          }))
-        },
-      ])
-      const result = await svc.conversation("/f", ["slow-real"])
-      const elapsed = performance.now() - startedAt
-      // The per-read cap (60s) sits above the measured 22-26s success envelope
-      // and above this 9.5s fixture; the old 8s cap would have killed it.
-      expect(result.outcome).toBe("ok")
-      expect(result.items.map((item) => item.id)).toEqual(["slow-real"])
-      expect(elapsed).toBeGreaterThanOrEqual(slowDelayMs)
-    },
-  )
-
-  test("keeps slow-but-successful reads above the old 8s cap (20s per read)", async () => {
-    const realNow = Date.now
-    let now = 0
-    Date.now = () => now
-    try {
-      const { svc } = service([
-        () => {
-          now += 20_500 // a slow-but-successful MailOS read (~20.5s)
-          return { stdout: readMarkdown("slow-a"), stderr: "" }
-        },
-        () => {
-          now += 20_500
-          return { stdout: readMarkdown("slow-b"), stderr: "" }
-        },
-      ])
-      const result = await svc.conversation("/f", ["slow-a", "slow-b"])
-      // Two ~20.5s reads fit inside the 75s budget with 60s per-read caps.
-      expect(result.outcome).toBe("ok")
-      expect(result.items.map((item) => item.id)).toEqual(["slow-a", "slow-b"])
-    } finally {
-      Date.now = realNow
-    }
-  })
-
-  test("stops once the total time budget is exhausted", async () => {
-    const realNow = Date.now
-    let now = 0
-    Date.now = () => now
-    try {
-      const { svc, calls } = service([
-        () => {
-          now += 40_000 // within the 60s per-read cap
-          return { stdout: readMarkdown("a"), stderr: "" }
-        },
-        () => {
-          now += 40_000 // 80s total now exceeds the 75s budget
-          return { stdout: readMarkdown("b"), stderr: "" }
-        },
-        () => ({ stdout: readMarkdown("c"), stderr: "" }),
-      ])
-      const result = await svc.conversation("/f", ["a", "b", "c"])
-      expect(result.outcome).toBe("timeout")
-      expect(result.items.length).toBeGreaterThanOrEqual(1)
-      // No blind retry loop: each reference gets at most one attempt.
-      expect(calls.length).toBe(3)
-    } finally {
-      Date.now = realNow
-    }
-  })
-
-  test("per-read cap and budget sit above the measured 22-26s success envelope", () => {
-    expect(conversationLimits.perReadTimeoutMs).toBeGreaterThanOrEqual(60_000)
-    expect(conversationLimits.totalBudgetMs).toBeGreaterThanOrEqual(75_000)
-    expect(conversationLimits.perReadTimeoutMs).toBeLessThan(
-      conversationLimits.totalBudgetMs,
-    )
-  })
-
-  test("deduplicates in-flight reads across concurrent callers", async () => {
-    const { svc, calls } = service([])
-    const [left, right] = await Promise.all([
-      svc.conversation("/f", ["shared", "left"]),
-      svc.conversation("/f", ["shared", "right"]),
-    ])
-    expect(left.outcome).toBe("ok")
-    expect(right.outcome).toBe("ok")
-    const sharedCalls = calls.filter((call) => call.args[1] === "shared")
-    expect(sharedCalls.length).toBe(1)
-    expect(calls.length).toBe(3)
-  })
-
-  test("serves repeated requests from the bounded success cache per scope", async () => {
-    const { svc, calls } = service([])
-    await svc.conversation("/f", ["hot"])
-    const afterFirst = calls.length
-    const cached = await svc.conversation("/f", ["hot"])
-    expect(cached.outcome).toBe("ok")
-    expect(calls.length).toBe(afterFirst)
-
-    // A different folder scope must not reuse the cached read.
-    await svc.conversation("/g", ["hot"])
-    expect(calls.length).toBe(afterFirst + 1)
-  })
-
-  test("evicts oldest successes when the cache is full", async () => {
-    const { svc, calls } = service([])
-    const batches = Array.from({ length: 5 }, (_, batch) =>
-      Array.from(
-        { length: conversationLimits.maxReferences },
-        (_, index) => `k${batch}-${index}`,
-      ),
-    )
-    for (const batch of batches) await svc.conversation("/f", batch)
-    const afterBulk = calls.length
-    expect(afterBulk).toBeGreaterThan(conversationLimits.successCacheSize)
-    // The oldest success was evicted: it must hit the CLI again.
-    await svc.conversation("/f", ["k0-0"])
-    expect(calls.length).toBe(afterBulk + 1)
-    // A recently cached id is still served from memory.
-    await svc.conversation("/f", ["k4-11"])
-    expect(calls.length).toBe(afterBulk + 1)
-  })
-
-  test("cancels the child on caller disconnect without touching shared consumers", async () => {
-    const { svc } = service([])
-    const cancelled = new AbortController()
-    cancelled.abort()
-    await expect(
-      svc.conversation("/f", ["x"], cancelled.signal),
-    ).rejects.toMatchObject({
-      code: "aborted",
-    })
-  })
-
-  test("one canceled subscriber never kills another consumer of the same read", async () => {
-    // A gated runner keeps the shared read in flight until the test decides:
-    // with an instantly-resolving fake the read would be done (and cached)
-    // before the abort, so this must deliberately hold the child open.
-    const calls = []
-    let gateResolve = null
-    const gate = new Promise((resolveGate) => {
-      gateResolve = resolveGate
-    })
-    const runner = async (_file, args) => {
-      calls.push(args)
-      if (args[1] === "shared") await gate
-      return { stdout: readMarkdown(args[1]), stderr: "" }
-    }
-    const svc = createMailosService({
-      execFile: runner,
-      mailosBin: BIN,
-      globalDraftDir: DRAFT_DIR,
-    })
-    const first = new AbortController()
-    const second = new AbortController()
-    const pending = svc.conversation("/f", ["shared"], first.signal)
-    const sharedCall = new Promise((resolveCall) => {
-      const started = () => resolveCall(undefined)
-      const check = () => {
-        if (calls.some((args) => args[1] === "shared")) started()
-      }
-      check()
-      const timer = setInterval(check, 1)
-      setTimeout(() => clearInterval(timer), 1000)
-    })
-    await sharedCall
-    const other = svc.conversation("/f", ["shared", "other"], second.signal)
-    // Let the second worker subscribe to the shared in-flight read.
-    await Bun.sleep(5)
-
-    // Aborting just the first consumer must not abort the shared child.
-    first.abort()
-    await expect(pending).rejects.toMatchObject({ code: "aborted" })
-
-    // Release the shared read: the second subscriber still completes and
-    // both consumers shared one read call.
-    gateResolve()
-    const result = await other
-    expect(result.outcome).toBe("ok")
-    // Two workers resolve the two ids independently; order is not part of
-    // the guarantee, both messages must be present.
-    expect(result.items.map((item) => item.id).sort()).toEqual([
-      "other",
-      "shared",
-    ])
-    const sharedCalls = calls.filter((args) => args[1] === "shared")
-    expect(sharedCalls.length).toBe(1)
-  })
-
-  test("production path (with signal) still reuses cache and in-flight reads", async () => {
-    const { svc, calls } = service([])
-    const controller = new AbortController()
-    const first = await svc.conversation("/f", ["hot"], controller.signal)
-    expect(first.outcome).toBe("ok")
-    const afterFirst = calls.length
-
-    // A second production-style request with its own signal hits the cache.
-    const second = await svc.conversation(
-      "/f",
-      ["hot"],
-      new AbortController().signal,
-    )
-    expect(second.outcome).toBe("ok")
-    expect(calls.length).toBe(afterFirst)
-  })
-})
-
-describe("send preview and confirm", () => {
-  function previewOutput() {
-    return [
-      "📋 PREVIEW - Would send draft: d_abc.md",
-      `Revision: ${REV}`,
-      "=== EMAIL PREVIEW ===",
-      "To: to@example.com",
-      "Subject: Hi",
-      "",
-      "--- Body ---",
-      "Hello",
-      "=== END PREVIEW ===",
-      "Send now: mailos send draft d_abc --draft-revision ...",
-      "",
-    ].join("\n")
-  }
-
-  test("preview targets the authorized draft directory with exact args", async () => {
-    const { svc, calls } = service([
-      () => ({ stdout: previewOutput(), stderr: "" }),
-    ])
-    const preview = await svc.sendPreview("/f", "d_abc", {
-      draftDir: DRAFT_DIR,
-    })
-    expect(preview.dryRun).toBe(true)
-    expect(preview.revision).toBe(REV)
-    expect(calls[0].args).toEqual([
-      "send",
-      "draft",
-      "d_abc",
-      "--draft-dir",
-      DRAFT_DIR,
-      "--preview",
-    ])
-    expect(calls[0].cwd).toBe("/f")
-  })
-
-  test("preview refuses to run without an explicit authorized draft directory", async () => {
-    const { svc, calls } = service([])
-    await expect(svc.sendPreview("/f", "d_abc")).rejects.toMatchObject({
-      name: "MailSendFailure",
-      reason: "invalid-draft",
-    })
-    expect(calls.length).toBe(0)
-  })
-
-  test("preview without a revision reports an unsendable draft", async () => {
-    const { svc } = service([
-      () => ({ stdout: "no revision here", stderr: "" }),
-    ])
-    await expect(
-      svc.sendPreview("/f", "d_abc", { draftDir: DRAFT_DIR }),
-    ).rejects.toMatchObject({
-      name: "MailSendFailure",
-      reason: "invalid-draft",
-    })
-  })
-
-  test("confirm send uses the revision, the draft dir, and retains the draft", async () => {
-    const { svc, calls } = service([
-      () => ({
-        stdout:
-          "📤 Sending draft: d_abc.md ✅ Sent\n\n📊 Draft sending complete:\n  ✅ Sent: 1\n  📁 Processed: 1 total drafts\n",
-        stderr: "",
-      }),
-    ])
-    const result = await svc.confirmSend("/f", "d_abc", REV, {
-      draftDir: DRAFT_DIR,
-    })
-    expect(result.dryRun).toBe(false)
-    expect(calls[0].args).toEqual([
-      "send",
-      "draft",
-      "d_abc",
-      "--draft-dir",
-      DRAFT_DIR,
-      "--draft-revision",
-      REV,
-      "--delete-after=false",
-    ])
-  })
-
-  test("a malformed revision is rejected before any command runs", async () => {
-    const { svc, calls } = service([])
-    await expect(
-      svc.confirmSend("/f", "d_abc", "not-a-hash", { draftDir: DRAFT_DIR }),
-    ).rejects.toMatchObject({
-      name: "MailSendFailure",
-      reason: "revision-match",
-    })
-    expect(calls.length).toBe(0)
-  })
-
-  test("a send-time revision change is a revision conflict, not a generic failure", async () => {
-    const { svc, calls } = service([
-      () => ({
-        stdout:
-          "❌ Draft d_abc.md changed after preview\n  Expected revision: aaa…\n  Current revision:  bbb…\n\n📊 Draft sending complete:\n  ✅ Sent: 0\n  ❌ Errors: 1\n  📁 Processed: 1 total drafts\n",
-        stderr: "",
-      }),
-    ])
-    await expect(
-      svc.confirmSend("/f", "d_abc", REV, { draftDir: DRAFT_DIR }),
-    ).rejects.toMatchObject({
-      name: "MailSendFailure",
-      reason: "revision-match",
-    })
-    expect(calls.length).toBe(1)
-  })
-
-  test("exit-0 output that reports skips or failures fails the contract", async () => {
-    const { svc } = service([
-      () => ({
-        stdout:
-          "⏭️  Skipped sent draft: d_abc.md\n\n📊 Draft sending complete:\n  ✅ Sent: 0\n  📁 Processed: 1 total drafts\n",
-        stderr: "",
-      }),
-    ])
-    await expect(
-      svc.confirmSend("/f", "d_abc", REV, { draftDir: DRAFT_DIR }),
-    ).rejects.toMatchObject({
-      name: "MailSendFailure",
-      reason: "contract",
-    })
-  })
-
-  test("cancellation aborts a send", async () => {
-    const { svc } = service([])
-    const controller = new AbortController()
-    controller.abort()
-    await expect(
-      svc.confirmSend("/f", "d_abc", REV, {
-        draftDir: DRAFT_DIR,
-        signal: controller.signal,
-      }),
-    ).rejects.toMatchObject({
-      code: "aborted",
-    })
-  })
-})
-
-describe("archive", () => {
-  test("archives by canonical draft id in the global draft dir", async () => {
-    const { svc, calls } = service([() => ({ stdout: "", stderr: "" })])
-    await svc.archive("/f", "d_abc", { draftDir: DRAFT_DIR })
-    expect(calls[0].args).toEqual(["drafts", "archive", "d_abc"])
-    expect(calls[0].cwd).toBe("/f")
-  })
-
-  test("rejects a non-canonical archive target before any spawn", async () => {
-    const { svc, calls } = service([])
-    await expect(
-      svc.archive("/f", "d_abc", { draftDir: "/tmp/elsewhere/drafts" }),
-    ).rejects.toMatchObject({
-      name: "MailSendFailure",
-      reason: "unsupported-draft-dir",
-    })
-    // The CLI never ran: it would have mutated a same-named home draft.
-    expect(calls.length).toBe(0)
-  })
-})
-
-describe("validateSendContract", () => {
-  test("accepts a confirmed single-draft send", () => {
-    const output = [
-      "📤 Sending draft: d_abc.md ✅ Sent",
-      "",
-      "📊 Draft sending complete:",
-      "  ✅ Sent: 1",
-      "  📁 Processed: 1 total drafts",
-    ].join("\n")
-    expect(validateSendContract(output)).toEqual({ ok: true })
-  })
-
-  test("accepts a previewed run", () => {
-    const output =
-      "📊 Draft sending complete:\n  ✅ Previewed: 1\n  📁 Processed: 1 total drafts\n"
-    expect(validateSendContract(output)).toEqual({ ok: true })
-  })
-
-  test("rejects failure markers even with exit 0", () => {
-    const output =
-      "❌ Invalid draft d_abc: missing recipients\n📊 Draft sending complete:\n  ✅ Sent: 0\n  ❌ Errors: 1\n"
-    expect(validateSendContract(output)).toMatchObject({ ok: false })
-  })
-
-  test("rejects skipped drafts", () => {
-    expect(
-      validateSendContract("⏭️  Skipped sent draft: d_abc.md\n  ✅ Sent: 0\n"),
-    ).toMatchObject({ ok: false })
-  })
-
-  test("rejects when no draft was found", () => {
-    expect(
-      validateSendContract("No draft files found to send\n  ✅ Sent: 0\n"),
-    ).toMatchObject({
-      ok: false,
-    })
-  })
-
-  test("rejects zero sent drafts", () => {
-    expect(
-      validateSendContract("📊 Draft sending complete:\n  ✅ Sent: 0\n"),
-    ).toMatchObject({
-      ok: false,
-    })
-  })
-})
-
-test("MailSendFailure is an Error subclass", () => {
-  const failure = new MailSendFailure("contract", "nope")
-  expect(failure).toBeInstanceOf(Error)
-  expect(failure.message).toBe("nope")
-})