kennel 0.2.0 → 0.2.2

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

@@ -0,0 +1,752 @@
+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")
+})