@vellumai/assistant 0.12.3-staging.2 → 0.12.4-staging.1

package/src/runtime/routes/__tests__/global-search-routes.test.ts

@@ -8,7 +8,10 @@
  *
  * Also covers the search-query parser: `is:archived` and its synonyms in the
  * `q` string flip the conversation arm to `includeArchived: true`, and the
- * filter token is stripped from the term before any backend is called.
+ * filter token is stripped from the term before any backend is called. Under
+ * the `sidebar-done` flag the unfiltered default is `true` instead and
+ * `is:unarchived` is the opt-out, so the flag-on twins assert the mirror
+ * image of the default ones.
  */
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -30,9 +33,13 @@ const searchConversationsMock = mock(
   },
 );
 
+let sidebarDoneEnabled = false;
+
 const actualContactStore = await import("../../../contacts/contact-store.js");
 const actualConvQueries =
   await import("../../../persistence/conversation-queries.js");
+const actualSidebarDoneGate =
+  await import("../../../config/sidebar-done-gate.js");
 
 mock.module("../../../contacts/contact-store.js", () => ({
   ...actualContactStore,
@@ -42,6 +49,10 @@ mock.module("../../../persistence/conversation-queries.js", () => ({
   ...actualConvQueries,
   searchConversations: searchConversationsMock,
 }));
+mock.module("../../../config/sidebar-done-gate.js", () => ({
+  ...actualSidebarDoneGate,
+  isSidebarDoneEnabled: () => sidebarDoneEnabled,
+}));
 
 const { ROUTES } = await import("../global-search-routes.js");
 
@@ -69,6 +80,7 @@ afterEach(() => {
   searchConversationsCalls = [];
   searchConversationsResult = [];
   searchConversationsMock.mockClear();
+  sidebarDoneEnabled = false;
 });
 
 describe("global-search contacts recency source", () => {
@@ -268,3 +280,64 @@ describe("global-search q parser", () => {
     expect(result.queryTokens).toEqual(["alpha", "beta"]);
   });
 });
+
+describe("global-search q parser under sidebar-done", () => {
+  test("plain term reaches done chats by default", async () => {
+    sidebarDoneEnabled = true;
+
+    await handler({
+      queryParams: { q: "shema", categories: "conversations" },
+    });
+
+    expect(searchConversationsCalls[0]?.query).toBe("shema");
+    expect(searchConversationsCalls[0]?.opts).toMatchObject({
+      includeArchived: true,
+    });
+  });
+
+  test("is:unarchived (and archive:no / archive:false) narrows back to live chats", async () => {
+    for (const filter of ["is:unarchived", "archive:no", "archive:false"]) {
+      sidebarDoneEnabled = true;
+      searchConversationsCalls = [];
+      searchConversationsMock.mockClear();
+
+      await handler({
+        queryParams: {
+          q: `${filter} shema`,
+          categories: "conversations",
+        },
+      });
+
+      expect(searchConversationsCalls[0]?.query).toBe("shema");
+      expect(searchConversationsCalls[0]?.opts).toMatchObject({
+        includeArchived: false,
+      });
+    }
+  });
+
+  test("is:archived stays a no-op the term is still stripped of", async () => {
+    sidebarDoneEnabled = true;
+
+    await handler({
+      queryParams: { q: "is:archived shema", categories: "conversations" },
+    });
+
+    expect(searchConversationsCalls[0]?.query).toBe("shema");
+    expect(searchConversationsCalls[0]?.opts).toMatchObject({
+      includeArchived: true,
+    });
+  });
+
+  test("unknown filter tokens stay in the term and do not narrow the default", async () => {
+    sidebarDoneEnabled = true;
+
+    await handler({
+      queryParams: { q: "is:starred shema", categories: "conversations" },
+    });
+
+    expect(searchConversationsCalls[0]?.query).toBe("is:starred shema");
+    expect(searchConversationsCalls[0]?.opts).toMatchObject({
+      includeArchived: true,
+    });
+  });
+});

package/src/runtime/routes/conversation-list-routes.ts

@@ -31,16 +31,14 @@ import {
 import { resolveConversationId } from "../../persistence/conversation-key-store.js";
 import {
   type ConversationListFilter,
+  type ConversationListTypeFilter,
   countConversations,
   countConversationSections,
   countUnreadConversations,
   listConversations,
   listPinnedConversations,
 } from "../../persistence/conversation-queries.js";
-import {
-  ASSISTANT_INITIATED_GROUP_ID,
-  type ConversationType,
-} from "../../persistence/conversation-types.js";
+import { ASSISTANT_INITIATED_GROUP_ID } from "../../persistence/conversation-types.js";
 import { getBindingsForConversations } from "../../persistence/external-conversation-store.js";
 import { listGroups } from "../../persistence/group-crud.js";
 import { UserError } from "../../util/errors.js";
@@ -252,12 +250,14 @@ function handleListConversations({
   const limit = Number(queryParams.limit ?? 50);
   const offset = Number(queryParams.offset ?? 0);
   // "background" is the back-compat umbrella (background + scheduled); newer
-  // clients can pass "scheduled" to load only the Scheduled section. Absent
-  // defaults to the standard foreground list.
-  const conversationType: ConversationType =
+  // clients can pass "scheduled" to load only the Scheduled section, or "all"
+  // to page a user's whole history in one cursor. Absent defaults to the
+  // standard foreground list.
+  const conversationType: ConversationListTypeFilter =
     parseEnumQueryParam(queryParams, "conversationType", [
       "background",
       "scheduled",
+      "all",
     ]) ?? "standard";
   // Defaults to `active` so sidebar restores no longer pull archived rows.
   // The Archive page opts into `archived` to render only archived rows
@@ -294,7 +294,9 @@ function handleListConversations({
      read withholds them, so they appear in their own section and nowhere
      else. Confined to `standard`: the background and scheduled buckets are
      back-compat umbrellas addressed by conversation type, and narrowing them
-     by source would drop rows their callers still page through. Confined to
+     by source would drop rows their callers still page through, while `all`
+     is a whole-history read with no second section to defer those rows to,
+     so withholding there would simply lose them. Confined to
      active reads too: the Archive view asks `archiveStatus=archived` with no
      `groupId`, and the section only ever lists active rows, so withholding
      there would leave an archived section thread visible nowhere. */
@@ -584,10 +586,7 @@ function handleMarkUnread({ body = {}, headers }: RouteHandlerArgs) {
   }
 }
 
-function handleGetConversation({
-  pathParams = {},
-  headers,
-}: RouteHandlerArgs) {
+function handleGetConversation({ pathParams = {}, headers }: RouteHandlerArgs) {
   const detail = buildConversationDetailResponse(
     pathParams.id!,
     localeFromAcceptLanguage(headers?.["accept-language"]),
@@ -633,8 +632,11 @@ export const ROUTES: RouteDefinition[] = [
         type: "string",
         required: false,
         description:
-          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), or "scheduled" to list only scheduled conversations.',
-        schema: { type: "string", enum: ["background", "scheduled"] },
+          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), "scheduled" to list only scheduled conversations, or "all" for the union of the standard listing and that umbrella, so one paginated cursor spans every type. Combine "all" with archiveStatus=all for a whole-history read; rows are recency-ordered (COALESCE(last_message_at, updated_at) descending) like every other list read, and pinned rows are never appended to it.',
+        schema: {
+          type: "string",
+          enum: ["background", "scheduled", "all"],
+        },
       },
       {
         name: "archiveStatus",

package/src/runtime/routes/conversation-query-routes.ts

@@ -65,6 +65,7 @@ import {
 } from "../../config/schemas/llm.js";
 import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
 import { ServiceModeSchema } from "../../config/schemas/services.js";
+import { isSidebarDoneEnabled } from "../../config/sidebar-done-gate.js";
 import {
   describeShadowedConfigSet,
   findSubstrateShadowing,
@@ -2108,6 +2109,9 @@ async function handleSearchConversations({
     query: q,
     limit,
     maxMessagesPerConversation: maxMessages,
+    // Under `sidebar-done` a done chat is filed rather than hidden, so the
+    // agent's own history search reaches it the same way the user's does.
+    includeArchived: isSidebarDoneEnabled(),
   });
   return { query: q, results };
 }

package/src/runtime/routes/global-search-routes.ts

@@ -11,6 +11,7 @@
 import { z } from "zod";
 
 import { getConfig } from "../../config/loader.js";
+import { isSidebarDoneEnabled } from "../../config/sidebar-done-gate.js";
 import { searchContacts } from "../../contacts/contact-store.js";
 import { searchConversations } from "../../persistence/conversation-queries.js";
 import { getMemorySqlite } from "../../persistence/db-connection.js";
@@ -123,23 +124,32 @@ function parseCategories(raw: string | undefined): Set<Category> {
  * cleaned term as a literal query, so unknown filters are visible to lexical
  * matching rather than silently dropped.
  *
- * Examples:
+ * `defaultArchived` is what an unfiltered query means. It is `false` by
+ * default and `true` under the `sidebar-done` flag, where a done chat is a
+ * filed chat rather than a hidden one and search is how the user reaches it.
+ * Either way both filters still say exactly what they say, so `is:unarchived`
+ * is the opt-out whenever the default is on.
+ *
+ * Examples (with `defaultArchived: false`):
  *   "foo bar"            -> { term: "foo bar",        archived: false }
  *   "is:archived foo"    -> { term: "foo",            archived: true  }
  *   "foo is:archived"    -> { term: "foo",            archived: true  }
  *   "is:archived"        -> { term: "",               archived: true  }
  *   "is:starred foo"     -> { term: "is:starred foo", archived: false }
  */
-function parseSearchQuery(rawQ: string | undefined): {
+function parseSearchQuery(
+  rawQ: string | undefined,
+  defaultArchived: boolean,
+): {
   term: string;
   archived: boolean;
 } {
   if (!rawQ) {
-    return { term: "", archived: false };
+    return { term: "", archived: defaultArchived };
   }
   const tokens = rawQ.split(/\s+/).filter((t) => t.length > 0);
   const termTokens: string[] = [];
-  let archived = false;
+  let archived = defaultArchived;
   for (const tok of tokens) {
     const lower = tok.toLowerCase();
     if (
@@ -291,11 +301,16 @@ async function handleGlobalSearch({
     throw new BadRequestError("q query parameter is required");
   }
 
-  // Pull the archive opt-in out of the query string itself (`is:archived` /
+  // Pull the archive filter out of the query string itself (`is:archived` /
   // `archive:yes` / etc.) so the user controls it the same way they control
   // every other modifier: by typing it into the search box. The cleaned term
-  // is what the backends actually search on.
-  const { term, archived: includeArchived } = parseSearchQuery(rawQ);
+  // is what the backends actually search on. Under `sidebar-done` the
+  // unfiltered default flips to including done chats, and `is:unarchived`
+  // becomes the token that narrows back to the live set.
+  const { term, archived: includeArchived } = parseSearchQuery(
+    rawQ,
+    isSidebarDoneEnabled(),
+  );
 
   const limit = Math.max(1, Math.min(Number(queryParams.limit ?? 20), 100));
   const categories = parseCategories(queryParams.categories);

package/src/runtime/sync/documents-sidecar-publish.test.ts

@@ -1,22 +1,32 @@
 /**
- * A scheduled, heartbeat, or background turn runs its document tools in a
- * sidecar worker, whose local hub has no SSE subscriber. The documents-changed
- * broadcast has to be handed to the daemon there, or the document edited while
- * the user was not looking stays invisible on every client.
+ * A scheduled, heartbeat, or background turn runs its document tools and its
+ * conversation writes in a sidecar worker, whose local hub has no SSE
+ * subscriber. Those broadcasts have to be handed to the daemon there, or the
+ * document edited and the conversation changed while the user was not looking
+ * stay invisible on every client.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let notifyCount = 0;
+const listHandoffs: Array<{ reason: string; conversationIds: string[] }> = [];
 
 mock.module("./worker-daemon-notify.js", () => ({
   NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD:
     "notify_conversation_persisted_externally",
+  NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD:
+    "notify_conversation_list_changed_externally",
   NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD: "notify_documents_changed_externally",
   NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD:
     "notify_activation_progress_changed_externally",
   notifyDaemonActivationProgressChanged: async () => {},
   notifyDaemonConversationPersisted: async () => {},
+  notifyDaemonConversationListChanged: async (
+    reason: string,
+    conversationIds: string[],
+  ) => {
+    listHandoffs.push({ reason, conversationIds });
+  },
   notifyDaemonDocumentsChanged: async () => {
     notifyCount++;
   },
@@ -30,6 +40,7 @@ import {
 } from "../assistant-stream-state.js";
 import {
   DOCUMENTS_CHANGED_COALESCE_MS,
+  publishConversationListAndMetadataChanged,
   publishDocumentsChanged,
 } from "./resource-sync-events.js";
 
@@ -66,6 +77,7 @@ describe("publishDocumentsChanged in a sidecar worker", () => {
   beforeEach(async () => {
     await settle();
     notifyCount = 0;
+    listHandoffs.length = 0;
     _resetStreamStateForTesting();
   });
 
@@ -102,3 +114,37 @@ describe("publishDocumentsChanged in a sidecar worker", () => {
     expect(events[0].message).toMatchObject({ type: "sync_changed" });
   });
 });
+
+describe("publishConversationListAndMetadataChanged in a sidecar worker", () => {
+  beforeEach(async () => {
+    await settle();
+    listHandoffs.length = 0;
+    _resetStreamStateForTesting();
+  });
+
+  test("hands the list invalidation to the daemon instead of publishing into a void", async () => {
+    disableStreamSeqStamping();
+
+    const events = await captureLocalPublishes(() => {
+      publishConversationListAndMetadataChanged("reordered", "conv-1");
+    });
+
+    expect(listHandoffs).toEqual([
+      { reason: "reordered", conversationIds: ["conv-1"] },
+    ]);
+    expect(events).toEqual([]);
+  });
+
+  test("publishes on the local hub in the daemon, where subscribers live", async () => {
+    const events = await captureLocalPublishes(() => {
+      publishConversationListAndMetadataChanged("reordered", "conv-1");
+    });
+
+    expect(listHandoffs).toEqual([]);
+    expect(events).toHaveLength(1);
+    expect(events[0].message).toMatchObject({
+      type: "sync_changed",
+      tags: ["conversations:list", "conversation:conv-1:metadata"],
+    });
+  });
+});

package/src/runtime/sync/resource-sync-events.ts

@@ -12,6 +12,7 @@ import { isStreamSeqStampingDisabled } from "../assistant-stream-state.js";
 import { publishSyncInvalidation } from "./sync-publisher.js";
 import {
   notifyDaemonActivationProgressChanged,
+  notifyDaemonConversationListChanged,
   notifyDaemonConversationPersisted,
   notifyDaemonDocumentsChanged,
 } from "./worker-daemon-notify.js";
@@ -236,6 +237,16 @@ export function publishConversationListAndMetadataChanged(
     ? conversationIds
     : [conversationIds];
 
+  // In a sidecar worker the local hub has no SSE subscribers, so a publish
+  // here reaches nobody and the sidebar keeps showing a list the worker has
+  // already changed. Hand off to the daemon, which republishes on the hub
+  // clients actually subscribe to. A background worker turn has no
+  // originating client, so no `originClientId` is forwarded.
+  if (isStreamSeqStampingDisabled()) {
+    void notifyDaemonConversationListChanged(reason, ids);
+    return;
+  }
+
   // Shape-changing reasons (`created`, `deleted`, `reordered`) add or
   // remove rows or change the order of the paginated window — web must
   // refetch the list, so include the `conversationsList` umbrella tag.

package/src/runtime/sync/worker-daemon-notify.test.ts

@@ -33,13 +33,43 @@ mock.module("../../ipc/cli-client.js", () => ({
 
 import {
   NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD,
+  NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD,
   NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD,
   NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD,
   notifyDaemonActivationProgressChanged,
+  notifyDaemonConversationListChanged,
   notifyDaemonConversationPersisted,
   notifyDaemonDocumentsChanged,
 } from "./worker-daemon-notify.js";
 
+describe("notifyDaemonConversationListChanged", () => {
+  beforeEach(() => {
+    calls.length = 0;
+    nextResult = { ok: true };
+    shouldThrow = false;
+  });
+
+  test("hands the reason and ids to the daemon over the shared IPC method", async () => {
+    await notifyDaemonConversationListChanged("reordered", ["conv-1"]);
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.method).toBe(NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD);
+    expect(calls[0]!.params).toEqual({
+      body: { reason: "reordered", conversationIds: ["conv-1"] },
+    });
+  });
+
+  test("swallows a thrown IPC error (best-effort, no throw)", async () => {
+    shouldThrow = true;
+
+    const result = await notifyDaemonConversationListChanged("reordered", [
+      "conv-1",
+    ]);
+    expect(result).toBeUndefined();
+    expect(calls).toHaveLength(1);
+  });
+});
+
 describe("notifyDaemonConversationPersisted", () => {
   beforeEach(() => {
     calls.length = 0;

package/src/runtime/sync/worker-daemon-notify.ts

@@ -31,6 +31,14 @@ export const NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD =
 export const NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD =
   "notify_documents_changed_externally";
 
+/**
+ * IPC method the daemon exposes for the conversation-list hand-off. Shared by
+ * the worker caller and the daemon route registration so the wire name cannot
+ * drift.
+ */
+export const NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD =
+  "notify_conversation_list_changed_externally";
+
 /**
  * IPC method the daemon exposes for the activation-progress hand-off. Shared
  * by the worker caller and the daemon route registration so the wire name
@@ -79,6 +87,42 @@ export async function notifyDaemonConversationPersisted(
   }
 }
 
+/**
+ * Ask the daemon to republish a conversation-list-and-metadata invalidation.
+ *
+ * A worker turn can change which rows the sidebar should hold, not just what
+ * one row contains: clearing `archived_at` on a Done conversation the turn
+ * woke is the case that matters. The list tag has to reach real subscribers
+ * for the conversation to reappear, and the worker's own hub has none.
+ *
+ * Best-effort by design, like the other hand-offs: an unreachable daemon is
+ * logged at debug and swallowed, and the client picks the change up on its
+ * next list fetch.
+ */
+export async function notifyDaemonConversationListChanged(
+  reason: string,
+  conversationIds: string[],
+): Promise<void> {
+  try {
+    const result = await cliIpcCall(
+      NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD,
+      { body: { reason, conversationIds } },
+      { timeoutMs: NOTIFY_TIMEOUT_MS },
+    );
+    if (!result.ok) {
+      log.debug(
+        { reason, conversationIds, error: result.error },
+        "daemon conversation-list-changed notify was not acknowledged",
+      );
+    }
+  } catch (err) {
+    log.debug(
+      { err, reason, conversationIds },
+      "daemon conversation-list-changed notify failed",
+    );
+  }
+}
+
 /**
  * Ask the daemon to republish the documents-list invalidation.
  *

package/src/runtime/verification-outbound-actions.ts

@@ -278,7 +278,7 @@ async function startOutboundTelegram(
       success: false,
       error: "already_bound",
       message:
-        "A guardian is already bound for this channel. Set rebind: true to replace.",
+        "A guardian is already bound for this channel. To verify a different account, revoke the existing binding first. Set rebind: true only to verify the same account again.",
       channel,
     };
   }
@@ -820,7 +820,7 @@ async function startOutboundTextChannel(
       success: false,
       error: "already_bound",
       message:
-        "A guardian is already bound for this channel. Set rebind: true to replace.",
+        "A guardian is already bound for this channel. To verify a different account, revoke the existing binding first. Set rebind: true only to verify the same account again.",
       channel,
     };
   }

package/src/tools/ask-question/ask-question-tool.test.ts

@@ -200,6 +200,44 @@ describe("AskQuestionTool.execute", () => {
     expect(result.isError).toBe(false);
   });
 
+  test("says so when the user answered in the chat instead of the card", async () => {
+    const q2 = {
+      question: "Preferred time?",
+      options: [
+        { id: "morning", label: "Morning" },
+        { id: "afternoon", label: "Afternoon" },
+      ],
+    };
+    setNextResult({
+      entries: [
+        {
+          questionId: "q1",
+          decision: "free_text",
+          text: "banana, after lunch",
+        },
+        { questionId: "q2", decision: "skipped" },
+      ],
+      overall: "completed",
+      answeredInChat: true,
+    });
+
+    const result = await askQuestionTool.execute(
+      { questions: [singleQ, q2] },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const lines = String(result.content).split("\n");
+    // The model is told where the answer came from, then reads the batch: the
+    // typed text on the first question, the rest unanswered, so it can map the
+    // reply onto them itself.
+    expect(lines[0]).toContain("replied in the chat");
+    expect(lines.slice(1)).toEqual([
+      `Question "${singleQ.question}" → Free text: banana, after lunch`,
+      `Question "${q2.question}" → Skipped`,
+    ]);
+  });
+
   test("formats skipped result", async () => {
     setNextResult(singleCompleted({ decision: "skipped" }));
     const result = await askQuestionTool.execute(validInput, makeContext());

package/src/tools/ask-question/ask-question-tool.ts

@@ -243,6 +243,15 @@ export function toAnsweredQuestion(
   };
 }
 
+/**
+ * Model-facing note prepended when the user answered by typing in the chat
+ * instead of using the card. The text lands as free text on the first
+ * question and every other question reads as skipped, so the model is told
+ * plainly what happened and left to map the reply onto the batch itself.
+ */
+const CHAT_REPLY_PREAMBLE =
+  "The user replied in the chat instead of using the question card, so their message is recorded as free text on the first question below and the remaining questions are unanswered. Read their reply as the answer to whichever questions it covers, and ask again only for what it genuinely leaves open.";
+
 // ── Tool ────────────────────────────────────────────────────────────
 
 /**
@@ -389,7 +398,9 @@ export const askQuestionTool = {
 
     switch (result.overall) {
       case "completed": {
-        let content = lines.join("\n");
+        let content = result.answeredInChat
+          ? [CHAT_REPLY_PREAMBLE, ...lines].join("\n")
+          : lines.join("\n");
         if (desktopHelp) {
           const entry = result.entries[0];
           if (entry?.decision === "free_text") {

package/src/util/worker-pipe.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { writeWorkerLine } from "./worker-pipe.js";
+
+/** Comfortably larger than any OS pipe buffer, so the write cannot complete. */
+const OVERSIZED_LINE = "x".repeat(4 * 1024 * 1024);
+
+const spawned: { kill(signal?: NodeJS.Signals): void }[] = [];
+
+afterEach(() => {
+  for (const proc of spawned.splice(0)) {
+    try {
+      proc.kill("SIGKILL");
+    } catch {
+      /* already gone */
+    }
+  }
+});
+
+/** A live child that never reads stdin, the way a worker busy in ONNX does not. */
+function spawnBusyWorker() {
+  const proc = Bun.spawn({
+    cmd: [process.execPath, "-e", "setTimeout(() => {}, 60_000)"],
+    windowsHide: true,
+    stdin: "pipe",
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+  spawned.push(proc);
+  return proc;
+}
+
+describe("writeWorkerLine", () => {
+  /**
+   * The production failure: the payload outruns the pipe buffer, Bun returns a
+   * pending promise, and the worker dies before draining it. Unobserved, that
+   * rejection is an `unhandledRejection`, which `bun test` reports as a failure
+   * of this test.
+   */
+  test("reports a write still pending when the worker dies", async () => {
+    const proc = spawnBusyWorker();
+    const failure = Promise.withResolvers<unknown>();
+
+    writeWorkerLine(proc.stdin, OVERSIZED_LINE, failure.resolve);
+    proc.kill("SIGKILL");
+
+    const err = await failure.promise;
+    expect(err).toBeInstanceOf(Error);
+    expect((err as NodeJS.ErrnoException).code).toBe("EPIPE");
+  });
+
+  test("reports a synchronous throw", () => {
+    const failures: unknown[] = [];
+    const epipe = Object.assign(new Error("EPIPE: broken pipe, write"), {
+      code: "EPIPE",
+    });
+    const stdin = {
+      write() {
+        throw epipe;
+      },
+      flush: () => 0,
+    };
+
+    writeWorkerLine(stdin, "line", (err) => failures.push(err));
+
+    expect(failures).toEqual([epipe]);
+  });
+
+  /** `write` and `flush` both report the same broken pipe. */
+  test("reports one failure when write and flush both reject", async () => {
+    const failures: unknown[] = [];
+    const epipe = new Error("EPIPE: broken pipe, send");
+    const stdin = {
+      write: () => Promise.reject(epipe),
+      flush: () => Promise.reject(epipe),
+    };
+
+    writeWorkerLine(stdin, "line", (err) => failures.push(err));
+    await Bun.sleep(0);
+
+    expect(failures).toEqual([epipe]);
+  });
+
+  test("stays silent when the line is delivered", async () => {
+    const failures: unknown[] = [];
+    const proc = Bun.spawn({
+      cmd: [process.execPath, "-e", "process.stdin.on('data', () => {})"],
+      windowsHide: true,
+      stdin: "pipe",
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    spawned.push(proc);
+
+    writeWorkerLine(proc.stdin, "hello", (err) => failures.push(err));
+    await Bun.sleep(50);
+
+    expect(failures).toEqual([]);
+  });
+});