@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/__tests__/channel-readiness-slack-remote.test.ts

@@ -29,6 +29,22 @@ mock.module("./channel-invite-transports/whatsapp.js", () => ({
   resolveWhatsAppDisplayNumber: () => undefined,
 }));
 
+type SocketHealth = {
+  channel: string;
+  status: "connected" | "disconnected" | "not_configured" | "unsupported";
+  lastLivenessAt?: number;
+};
+let socketHealth: SocketHealth | Error;
+
+mock.module("../channels/gateway-channel-socket-health.js", () => ({
+  readChannelSocketHealth: async () => {
+    if (socketHealth instanceof Error) {
+      throw socketHealth;
+    }
+    return socketHealth;
+  },
+}));
+
 const originalFetch = globalThis.fetch;
 let fetchCalls: Array<{ url: string; init?: RequestInit }>;
 let fetchHandler: (
@@ -42,6 +58,7 @@ beforeEach(() => {
   setConfig("slack", {});
   fetchCalls = [];
   fetchHandler = () => ({ ok: true, body: { ok: true } });
+  socketHealth = { channel: "slack", status: "connected" };
   globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
     const url = typeof input === "string" ? input : input.toString();
     fetchCalls.push({ url, init });
@@ -295,3 +312,127 @@ describe("slack scope-grant check", () => {
     expect(scopeCheck.passed).toBe(true);
   });
 });
+
+describe("slack inbound delivery", () => {
+  /**
+   * Credential health and delivery health are different claims. Valid tokens,
+   * a reachable `auth.test` and a matching workspace all hold while a socket
+   * sits open and delivers nothing, so the delivery verdict must not ride on
+   * any of them.
+   */
+  test("fails on a dead socket even while auth.test passes", async () => {
+    // Both tokens, or the channel is not fully configured and "incomplete" is
+    // the correct answer rather than the one under test.
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    mockSecureKeys[credentialKey("slack_channel", "app_token")] = "xapp-fake";
+    setConfig("slack", { teamId: "T123" });
+    fetchHandler = () => ({
+      ok: true,
+      body: { ok: true, team_id: "T123", team: "acme", user: "apollobot" },
+    });
+    socketHealth = { channel: "slack", status: "disconnected" };
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const authTest = (snapshot.remoteChecks ?? []).find(
+      (c) => c.name === "auth_test",
+    )!;
+    const delivery = snapshot.localChecks.find(
+      (c) => c.name === "inbound_delivery",
+    )!;
+
+    expect(authTest.passed).toBe(true);
+    expect(delivery.passed).toBe(false);
+    expect(delivery.indeterminate).toBeFalsy();
+    expect(delivery.message).toMatch(/not reaching this assistant/i);
+    // The point of declaring it operational: a configured channel whose
+    // socket is dead is down, not half set up.
+    expect(snapshot.setupStatus).toBe("ready");
+    expect(snapshot.health).toBe("failing");
+    expect(snapshot.ready).toBe(false);
+  });
+
+  test("passes on a live socket and reports the last keepalive", async () => {
+    socketHealth = {
+      channel: "slack",
+      status: "connected",
+      lastLivenessAt: Date.parse("2026-08-21T17:00:00.000Z"),
+    };
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const delivery = snapshot.localChecks.find(
+      (c) => c.name === "inbound_delivery",
+    )!;
+
+    expect(delivery.passed).toBe(true);
+    expect(delivery.message).toContain("2026-08-21T17:00:00.000Z");
+  });
+
+  test("a freshly opened socket passes before its first keepalive", async () => {
+    // The first probe is a full interval after open, so requiring a keepalive
+    // would report every healthy reconnect as broken.
+    socketHealth = { channel: "slack", status: "connected" };
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const delivery = snapshot.localChecks.find(
+      (c) => c.name === "inbound_delivery",
+    )!;
+
+    expect(delivery.passed).toBe(true);
+    expect(delivery.message).toMatch(/no keepalive answered yet/i);
+  });
+
+  test("an unconfigured channel is indeterminate, not broken", async () => {
+    socketHealth = { channel: "slack", status: "not_configured" };
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const delivery = snapshot.localChecks.find(
+      (c) => c.name === "inbound_delivery",
+    )!;
+
+    expect(delivery.indeterminate).toBe(true);
+    expect(delivery.passed).toBe(true);
+  });
+
+  test("an unreachable gateway is indeterminate, not an outage", async () => {
+    // A gateway we cannot reach is a fact about the gateway. Rendering it as
+    // "Slack is disconnected" would invent an outage.
+    socketHealth = new Error("gateway socket refused");
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const delivery = snapshot.localChecks.find(
+      (c) => c.name === "inbound_delivery",
+    )!;
+
+    expect(delivery.indeterminate).toBe(true);
+    expect(delivery.passed).toBe(true);
+    expect(delivery.message).toMatch(/could not reach the gateway/i);
+    // Unknown, not failing: an unreachable gateway is a fact about the
+    // gateway, and the channel must be neither vouched for nor condemned.
+    expect(snapshot.health).toBe("unknown");
+    expect(snapshot.ready).toBe(false);
+  });
+
+  test("runs on every request rather than riding the remote-check cache", async () => {
+    // Remote checks are cached for five minutes, which is far longer than a
+    // socket takes to die and recover, so a cached verdict would report a
+    // state the connection has already left. One service instance across both
+    // reads, or the cache under test is never populated in the first place.
+    const { createReadinessService } =
+      await import("../runtime/channel-readiness-service.js");
+    const service = createReadinessService();
+    const delivery = (
+      snapshots: Awaited<ReturnType<typeof service.getReadiness>>,
+    ) => snapshots[0].localChecks.find((c) => c.name === "inbound_delivery")!;
+
+    socketHealth = { channel: "slack", status: "connected" };
+    expect(delivery(await service.getReadiness("slack", true)).passed).toBe(
+      true,
+    );
+
+    // Same service, so the remote checks beside this one are now cached.
+    socketHealth = { channel: "slack", status: "disconnected" };
+    expect(delivery(await service.getReadiness("slack", true)).passed).toBe(
+      false,
+    );
+  });
+});

package/src/__tests__/channel-reply-delivery.test.ts

@@ -266,7 +266,7 @@ describe("channel-reply-delivery", () => {
       payload: {
         chatId: "chat-1",
         text: "Before tool.",
-        useBlocks: true,
+        renderRichly: true,
         attachments: undefined,
         assistantId: "assistant-1",
       },
@@ -276,7 +276,7 @@ describe("channel-reply-delivery", () => {
       payload: {
         chatId: "chat-1",
         text: "After tool.",
-        useBlocks: true,
+        renderRichly: true,
         attachments,
         assistantId: "assistant-1",
       },
@@ -335,14 +335,14 @@ describe("channel-reply-delivery", () => {
     expect(deliveryCalls[0].payload).toEqual({
       chatId: "chat-3",
       text: "Before tool.",
-      useBlocks: true,
+      renderRichly: true,
       attachments: undefined,
       assistantId: "assistant-2",
     });
     expect(deliveryCalls[1].payload).toEqual({
       chatId: "chat-3",
       text: "After tool.",
-      useBlocks: true,
+      renderRichly: true,
       attachments: [
         {
           id: "att-2",

package/src/__tests__/client-os-metadata-persistence.test.ts

@@ -65,7 +65,7 @@ import type {
 import type { MessagingConversationContext } from "../daemon/conversation-messaging.js";
 import { persistQueuedMessageBody } from "../daemon/conversation-messaging.js";
 import type { MessageQueue } from "../daemon/conversation-queue-manager.js";
-import { isMacOriginatedUserMessage } from "../persistence/conversation-types.js";
+import { isDesktopOriginatedUserMessage } from "../persistence/conversation-types.js";
 
 function createWebTurnContext(
   clientOs: string | undefined,
@@ -179,9 +179,9 @@ describe("client OS surface metadata persistence", () => {
  * `Conversation.clientOs` is a live field that only a transport-carrying
  * message refreshes, so a transport-less turn stamps whatever an earlier send
  * left there. `clientOsFromRequest` separates the two, and
- * {@link isMacOriginatedUserMessage} (the row-origin read behind the
+ * {@link isDesktopOriginatedUserMessage} (the row-origin read behind the
  * `chat.assistant_reply` presence gate) requires it before letting an attended
- * Mac suppress a push.
+ * desktop suppress a push.
  */
 describe("client OS per-row evidence marker", () => {
   beforeEach(() => {
@@ -198,7 +198,20 @@ describe("client OS per-row evidence marker", () => {
 
     expect(lastUserMetadata().client).toEqual({ os: "macos" });
     expect(lastUserMetadata().clientOsFromRequest).toBe(true);
-    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(true);
+    expect(isDesktopOriginatedUserMessage(lastUserMetadata())).toBe(true);
+  });
+
+  test("recognizes a Windows app turn as desktop-originated", async () => {
+    const ctx = createWebTurnContext("windows");
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-transport-os-windows",
+      requestClientOs: "windows",
+    });
+
+    expect(lastUserMetadata().client).toEqual({ os: "windows" });
+    expect(lastUserMetadata().clientOsFromRequest).toBe(true);
+    expect(isDesktopOriginatedUserMessage(lastUserMetadata())).toBe(true);
   });
 
   // Mirrors the Mac-originated case above: a plain browser tab reports
@@ -214,7 +227,7 @@ describe("client OS per-row evidence marker", () => {
 
     expect(lastUserMetadata().client).toEqual({ os: "web" });
     expect(lastUserMetadata().clientOsFromRequest).toBe(true);
-    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+    expect(isDesktopOriginatedUserMessage(lastUserMetadata())).toBe(false);
   });
 
   test("marks an OS this row's own request headers reported", async () => {
@@ -226,14 +239,14 @@ describe("client OS per-row evidence marker", () => {
     });
 
     expect(lastUserMetadata().clientOsFromRequest).toBe(true);
-    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(true);
+    expect(isDesktopOriginatedUserMessage(lastUserMetadata())).toBe(true);
   });
 
   // The bug shape: a button tapped on the phone reaches a conversation whose
   // last desktop send left `clientOs: "macos"` behind. The row still carries
   // the inherited OS for telemetry, but nothing says this turn came from the
   // Mac, so the reply push must survive.
-  test("leaves an inherited OS unmarked and not Mac-originated", async () => {
+  test("leaves an inherited OS unmarked and not desktop-originated", async () => {
     const ctx = createWebTurnContext("macos");
     await persistQueuedMessageBody(ctx, {
       content: "[User action on card surface: submit]",
@@ -242,7 +255,7 @@ describe("client OS per-row evidence marker", () => {
 
     expect(lastUserMetadata().client).toEqual({ os: "macos" });
     expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
-    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+    expect(isDesktopOriginatedUserMessage(lastUserMetadata())).toBe(false);
   });
 
   // The marker vouches for the `client.os` that actually landed, not for
@@ -258,7 +271,7 @@ describe("client OS per-row evidence marker", () => {
 
     expect(lastUserMetadata().client).toEqual({ os: "macos" });
     expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
-    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+    expect(isDesktopOriginatedUserMessage(lastUserMetadata())).toBe(false);
   });
 
   // The marker is derived from what this persist can see, so a bag value
@@ -273,7 +286,7 @@ describe("client OS per-row evidence marker", () => {
     });
 
     expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
-    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+    expect(isDesktopOriginatedUserMessage(lastUserMetadata())).toBe(false);
   });
 
   test("leaves the marker off for a reported OS outside the vocabulary", async () => {

package/src/__tests__/conversation-delete-watch-timeline.test.ts

@@ -0,0 +1,231 @@
+/**
+ * A watch session's timeline is the most sensitive thing a conversation owns:
+ * what the user narrated, and frames of their screen while they narrated it.
+ * Both live in the timeline row, so every path that removes a conversation has
+ * to take those rows with it.
+ *
+ * `clearAll` is the sharpest case. Its bulk deletes run in a sqlite3
+ * subprocess, so the daemon's event loop is free between them and an append
+ * can land mid-wipe. The timeline purge is the wipe's last statement, after
+ * `conversations` is emptied: an append that beat it is a row it deletes, and
+ * one that follows it has no conversation to key itself to.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+// Keep the rest of the module real; only the Qdrant collection drop is
+// replaced, so `clearAll` does not reach for a lexical index that is not
+// running here.
+const actualLexical =
+  await import("../persistence/job-handlers/message-lexical.js");
+mock.module("../persistence/job-handlers/message-lexical.js", () => ({
+  ...actualLexical,
+  clearMessagesLexicalIndex: async () => {},
+}));
+
+/**
+ * An append to run from inside the wipe, on the statement it is keyed to.
+ *
+ * Which interleaving a race test runs is otherwise up to whichever subprocess
+ * happens to be slow, and the interleaving that matters is a narrow one: the
+ * append has to write its row while `conversations` is still populated, so its
+ * own existence check has nothing to catch and only the wipe's ordering keeps
+ * the row from outliving the wipe.
+ */
+let appendDuringWipe: { onStatement: string; run: () => void } | null = null;
+
+// Every bulk delete in `clearAll` goes through `runAsyncSqlite`, which spawns
+// a sqlite3 subprocess and yields the event loop. The wrapper runs the real
+// statement and stands in for whatever else the daemon would have done while
+// it was in flight.
+const actualAsyncQuery = await import("../persistence/db-async-query.js");
+const realRunAsyncSqlite = actualAsyncQuery.runAsyncSqlite;
+mock.module("../persistence/db-async-query.js", () => ({
+  ...actualAsyncQuery,
+  runAsyncSqlite: async (
+    sql: string,
+    label: string,
+    options?: Parameters<typeof actualAsyncQuery.runAsyncSqlite>[2],
+  ) => {
+    const result = await realRunAsyncSqlite(sql, label, options);
+    if (appendDuringWipe && appendDuringWipe.onStatement === sql) {
+      const pending = appendDuringWipe;
+      appendDuringWipe = null;
+      pending.run();
+    }
+    return result;
+  },
+}));
+
+import {
+  clearAll,
+  createConversation,
+  deleteConversation,
+  deleteConversationGently,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { attachments } from "../persistence/schema/conversations.js";
+import type { WatchAppendResult } from "../watch/watch-timeline.js";
+import {
+  appendNarration,
+  appendObservation,
+  readWatchScreenshot,
+  renderWatchTimeline,
+} from "../watch/watch-timeline.js";
+
+await initializeDb();
+
+/** A 1x1 JPEG, the shape the host hands over on every observe. */
+const SCREENSHOT_BASE64 =
+  "/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iiigD//2Q==";
+
+interface WatchedConversation {
+  readonly conversationId: string;
+  readonly sessionId: string;
+  readonly entryId: string;
+}
+
+/** A conversation with one narration and one screenshot-carrying observation. */
+function seedWatchedConversation(title: string): WatchedConversation {
+  const conversation = createConversation(title);
+  const sessionId = `watch-${conversation.id}`;
+
+  appendObservation(sessionId, {
+    conversationId: conversation.id,
+    atMs: 1_000,
+    observation: { axTree: "window Mail", screenshot: SCREENSHOT_BASE64 },
+    attachScreenshot: true,
+  });
+  appendNarration(sessionId, {
+    conversationId: conversation.id,
+    atMs: 2_000,
+    text: "this is how I file it",
+  });
+
+  const rendered = renderWatchTimeline(sessionId);
+  expect(rendered.totalEntries).toBe(2);
+  const entryId = rendered.screenshotEntryIds[0];
+  expect(entryId).toBeDefined();
+  expect(readWatchScreenshot(entryId as string)).not.toBeNull();
+
+  return { conversationId: conversation.id, sessionId, entryId: entryId ?? "" };
+}
+
+function expectPurged(watched: WatchedConversation): void {
+  expect(renderWatchTimeline(watched.sessionId).totalEntries).toBe(0);
+  expect(readWatchScreenshot(watched.entryId)).toBeNull();
+}
+
+/** Every attachment row in the store. */
+function attachmentCount(): number {
+  return getDb().select({ id: attachments.id }).from(attachments).all().length;
+}
+
+describe("deleteConversation purges the watch timeline", () => {
+  test("takes the entries and the frames they carry", () => {
+    const watched = seedWatchedConversation("watched-sync");
+    const other = seedWatchedConversation("watched-sync-other");
+
+    // A timeline keeps its screenshots in its own rows, so watching a session
+    // stages nothing in the attachment store for a delete to chase.
+    expect(attachmentCount()).toBe(0);
+
+    deleteConversation(watched.conversationId);
+
+    expectPurged(watched);
+    // Scoped to the conversation being deleted, not the whole store.
+    expect(renderWatchTimeline(other.sessionId).totalEntries).toBe(2);
+    expect(readWatchScreenshot(other.entryId)).not.toBeNull();
+  });
+});
+
+describe("deleteConversationGently purges the watch timeline", () => {
+  test("the off-loop path clears the same state as the synchronous one", async () => {
+    const watched = seedWatchedConversation("watched-gentle");
+
+    await deleteConversationGently(watched.conversationId);
+
+    expectPurged(watched);
+  });
+});
+
+describe("an append that lands after the delete", () => {
+  test("is refused and leaves no row", () => {
+    const watched = seedWatchedConversation("watched-late-append");
+
+    deleteConversation(watched.conversationId);
+    const result = appendObservation(watched.sessionId, {
+      conversationId: watched.conversationId,
+      atMs: 3_000,
+      observation: { axTree: "window Mail", screenshot: SCREENSHOT_BASE64 },
+      attachScreenshot: true,
+    });
+
+    expect(result).toEqual({ ok: false, reason: "conversation_missing" });
+    expect(renderWatchTimeline(watched.sessionId).totalEntries).toBe(0);
+  });
+});
+
+describe("clearAll purges every watch timeline", () => {
+  test("wipes the entries and the frames they carry", async () => {
+    const first = seedWatchedConversation("watched-clear-all-a");
+    const second = seedWatchedConversation("watched-clear-all-b");
+
+    await clearAll();
+
+    expectPurged(first);
+    expectPurged(second);
+  });
+});
+
+describe("an append that lands inside a clear-all", () => {
+  test("does not outlive the wipe that overtook it", async () => {
+    const watched = seedWatchedConversation("watched-clear-all-race");
+
+    // The append runs where the wipe is most exposed: mid-sequence, with
+    // `conversations` still populated so its existence check has nothing to
+    // catch. Only the timeline purge coming after `conversations` keeps the
+    // row from surviving.
+    let landed: WatchAppendResult | null = null;
+    appendDuringWipe = {
+      onStatement: "DELETE FROM messages",
+      run: () => {
+        landed = appendObservation(watched.sessionId, {
+          conversationId: watched.conversationId,
+          atMs: 3_000,
+          observation: {
+            axTree: "window Mail",
+            screenshot: SCREENSHOT_BASE64,
+          },
+          attachScreenshot: true,
+        });
+      },
+    };
+
+    await clearAll();
+
+    // The row really did land, so the wipe had something to sweep.
+    const result = landed as WatchAppendResult | null;
+    expect(result?.ok).toBe(true);
+    expect(renderWatchTimeline(watched.sessionId).totalEntries).toBe(0);
+    expect(
+      readWatchScreenshot(result?.ok === true ? result.entryId : ""),
+    ).toBeNull();
+  });
+});
+
+describe("an append that arrives once the clear-all is done", () => {
+  test("is refused, because there is no conversation left to key it to", async () => {
+    const watched = seedWatchedConversation("watched-clear-all-after");
+
+    await clearAll();
+    const result = appendNarration(watched.sessionId, {
+      conversationId: watched.conversationId,
+      atMs: 3_000,
+      text: "too late",
+    });
+
+    expect(result).toEqual({ ok: false, reason: "conversation_missing" });
+    expect(renderWatchTimeline(watched.sessionId).totalEntries).toBe(0);
+  });
+});

package/src/__tests__/conversation-error.test.ts

@@ -582,6 +582,23 @@ describe("classifyConversationError", () => {
       expect(result.retryable).toBe(true);
       expect(result.errorCategory).toBe("tool_ordering");
     });
+
+    it("classifies user-terminal history rejections separately", () => {
+      /** User-terminal provider rejections receive a dedicated category. */
+
+      // GIVEN a provider error whose history ends with a model turn
+      const error = new Error(
+        "Requests ending with a model turn are not supported.",
+      );
+
+      // WHEN the conversation error is classified
+      const result = classifyConversationError(error, baseCtx);
+
+      // THEN it is a retryable ordering error in the user-terminal category
+      expect(result.code).toBe("PROVIDER_ORDERING");
+      expect(result.retryable).toBe(true);
+      expect(result.errorCategory).toBe("history_user_terminal");
+    });
   });
 
   describe("web search ordering errors", () => {

package/src/__tests__/conversation-seed-composer.test.ts

@@ -71,6 +71,14 @@ describe("resolveVerbosity", () => {
     ).toBe("rich");
   });
 
+  test("explicit interfaceHint=windows overrides to rich", () => {
+    expect(
+      resolveVerbosity("telegram" as NotificationChannel, {
+        interfaceHint: "windows",
+      }),
+    ).toBe("rich");
+  });
+
   test("explicit interfaceHint=telegram overrides to compact", () => {
     expect(
       resolveVerbosity("vellum" as NotificationChannel, {

package/src/__tests__/conversation-slash-commands.test.ts

@@ -49,6 +49,14 @@ describe("resolveSlash /commands interface-aware help", () => {
     ]);
   });
 
+  test("renders desktop command help for Windows", async () => {
+    const lines = await resolveCommandsLines(
+      makeSlashContext({ userMessageInterface: "windows" }),
+    );
+    expect(lines.some((line) => line.startsWith("/btw "))).toBe(true);
+    expect(lines.some((line) => line.startsWith("/fork "))).toBe(true);
+  });
+
   test("renders iOS command help with /fork", async () => {
     const lines = await resolveCommandsLines(
       makeSlashContext({ userMessageInterface: "ios" }),

package/src/__tests__/disk-pressure-policy.test.ts

@@ -90,6 +90,12 @@ describe("classifyDiskPressureTurnPolicy", () => {
       metadata: localOwnerTurn,
       expected: { action: "allow-cleanup-mode", reason: "local-owner" },
     },
+    {
+      name: "locked Windows local owner without trust enters cleanup mode",
+      status: status({ acknowledged: true }),
+      metadata: { ...localOwnerTurn, sourceInterface: "windows" },
+      expected: { action: "allow-cleanup-mode", reason: "local-owner" },
+    },
     {
       name: "locked guardian enters cleanup mode",
       status: status(),