@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.9.1-staging.1",
+  "version": "0.10.0-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/access-request-card-view.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  buildAccessRequestCardView,
+  parseAccessRequestPayload,
+} from "../notifications/access-request-copy.js";
+
+function view(raw: Record<string, unknown>) {
+  return buildAccessRequestCardView(parseAccessRequestPayload(raw));
+}
+
+const TAB = String.fromCharCode(9);
+
+describe("buildAccessRequestCardView", () => {
+  test("prefers actorDisplayName, falls back to senderIdentifier then 'Someone'", () => {
+    expect(
+      view({ actorDisplayName: "Alice", senderIdentifier: "U999" }).displayName,
+    ).toBe("Alice");
+    expect(view({ senderIdentifier: "U999" }).displayName).toBe("U999");
+    expect(view({}).displayName).toBe("Someone");
+  });
+
+  test("sanitizes identity fields (strips control characters)", () => {
+    const v = view({
+      actorDisplayName: `Al${TAB}ice`,
+      actorUsername: `a${TAB}lice`,
+      actorExternalId: `U9${TAB}99`,
+    });
+    expect(v.displayName).toBe("Al ice");
+    expect(v.username).toBe("a lice");
+    expect(v.externalId).toBe("U9 99");
+  });
+
+  test("username and externalId are undefined when absent", () => {
+    const v = view({ actorDisplayName: "Alice" });
+    expect(v.username).toBeUndefined();
+    expect(v.externalId).toBeUndefined();
+  });
+
+  test("detects Slack DM conversations", () => {
+    expect(
+      view({ sourceChannel: "slack", conversationExternalId: "D01XYZ" })
+        .isSlackDm,
+    ).toBe(true);
+    expect(
+      view({ sourceChannel: "slack", conversationExternalId: "C01ABC" })
+        .isSlackDm,
+    ).toBe(false);
+    expect(
+      view({ sourceChannel: "telegram", conversationExternalId: "D01XYZ" })
+        .isSlackDm,
+    ).toBe(false);
+  });
+
+  test("builds a Slack permalink only with slack source + conversation + ts", () => {
+    expect(
+      view({
+        sourceChannel: "slack",
+        conversationExternalId: "C01ABC",
+        messageTs: "1700000000.000100",
+      }).messagePermalink,
+    ).toBe("https://slack.com/archives/C01ABC/p1700000000000100");
+    expect(
+      view({ sourceChannel: "slack", conversationExternalId: "C01ABC" })
+        .messagePermalink,
+    ).toBeUndefined();
+    expect(
+      view({
+        sourceChannel: "telegram",
+        conversationExternalId: "C01ABC",
+        messageTs: "1.2",
+      }).messagePermalink,
+    ).toBeUndefined();
+  });
+
+  test("sanitizes message preview and yields undefined when blank after sanitizing", () => {
+    expect(view({ messagePreview: "  hello  " }).messagePreview).toBe("hello");
+    // Blank / control-character-only previews sanitize to empty → undefined
+    // (no empty quote block is rendered downstream).
+    expect(view({ messagePreview: "" }).messagePreview).toBeUndefined();
+    expect(view({ messagePreview: "   " }).messagePreview).toBeUndefined();
+    expect(view({}).messagePreview).toBeUndefined();
+  });
+
+  test("collects trust/security warnings", () => {
+    const v = view({
+      isStranger: true,
+      isRestricted: true,
+      previousMemberStatus: "revoked",
+    });
+    expect(v.warnings).toEqual([
+      "This user was previously revoked.",
+      "External Slack user (not in this workspace).",
+      "Guest / restricted account.",
+    ]);
+    expect(view({}).warnings).toEqual([]);
+  });
+});

package/src/__tests__/access-request-seed-content-blocks.test.ts

@@ -1,9 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
-import {
-  buildAccessRequestSeedContentBlocks,
-  parseAccessRequestPayload,
-} from "../notifications/access-request-copy.js";
+import { parseAccessRequestPayload } from "../notifications/access-request-copy.js";
+import { buildAccessRequestSeedContentBlocks } from "../notifications/approval-card-data.js";
 
 describe("buildAccessRequestSeedContentBlocks", () => {
   const basePayload: Record<string, unknown> = {

package/src/__tests__/actor-trust-resolver-address-fallback.test.ts

@@ -43,7 +43,6 @@ const PHONE = "+15559871234";
 function makeContact(
   role: "guardian" | "contact" = "contact",
   status: "unverified" | "active" = "unverified",
-  externalUserId: string | null = null,
 ): ContactWithChannels {
   const channelId = "ch-test";
   return {
@@ -64,7 +63,6 @@ function makeContact(
         contactId: "contact-test",
         type: "phone",
         address: PHONE,
-        externalUserId,
         externalChatId: null,
         isPrimary: true,
         status,
@@ -94,7 +92,7 @@ describe("resolveActorTrust — address fallback", () => {
 
   test("finds unverified channel via address when externalUserId is null", () => {
     // Simulate a contact registered by name-capture: address set, externalUserId null.
-    _byAddress = makeContact("contact", "unverified", null);
+    _byAddress = makeContact("contact", "unverified");
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -106,12 +104,13 @@ describe("resolveActorTrust — address fallback", () => {
     expect(result.memberRecord).not.toBeNull();
     expect(result.memberRecord?.contact.displayName).toBe("Patrick Test");
     expect(result.memberRecord?.channel.status).toBe("unverified");
-    // trustClass is 'unknown' for an unverified member (correct — not yet active)
-    expect(result.trustClass).toBe("unknown");
+    // trustClass is 'unverified_contact' for a member whose channel is
+    // pending or unverified — known to the guardian but not yet verified.
+    expect(result.trustClass).toBe("unverified_contact");
   });
 
   test("address lookup is the sole member resolution path", () => {
-    _byAddress = makeContact("contact", "active", null);
+    _byAddress = makeContact("contact", "active");
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -141,7 +140,7 @@ describe("resolveActorTrust — address fallback", () => {
   test("address-found active channel elevates trust to trusted_contact", () => {
     // An active channel found via address (e.g. after manual verify without externalUserId set)
     // should still yield trusted_contact trust class.
-    _byAddress = makeContact("contact", "active", null);
+    _byAddress = makeContact("contact", "active");
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -154,4 +153,57 @@ describe("resolveActorTrust — address fallback", () => {
     expect(result.memberRecord?.channel.status).toBe("active");
     expect(result.trustClass).toBe("trusted_contact");
   });
+
+  test("pending-status member is classified as unverified_contact", () => {
+    // Mirrors the unverified branch but for `pending` status (e.g. a phone
+    // contact registered by name-capture awaiting the DTMF challenge).
+    const contact = makeContact("contact", "unverified");
+    // Override status to "pending" — makeContact only accepts unverified/active
+    contact.channels[0]!.status = "pending";
+    _byAddress = contact;
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord?.channel.status).toBe("pending");
+    expect(result.trustClass).toBe("unverified_contact");
+  });
+
+  test("blocked-status member is classified as unknown (not unverified_contact)", () => {
+    // Hard-deny statuses (blocked, revoked) stay `unknown` — admission-layer
+    // re-checks channel.status and emits the hard-deny reasons.
+    const contact = makeContact("contact", "unverified");
+    contact.channels[0]!.status = "blocked";
+    _byAddress = contact;
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord?.channel.status).toBe("blocked");
+    expect(result.trustClass).toBe("unknown");
+  });
+
+  test("revoked-status member is classified as unknown", () => {
+    const contact = makeContact("contact", "unverified");
+    contact.channels[0]!.status = "revoked";
+    _byAddress = contact;
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord?.channel.status).toBe("revoked");
+    expect(result.trustClass).toBe("unknown");
+  });
 });

package/src/__tests__/agent-loop-compaction-strip.test.ts

@@ -1,12 +1,13 @@
 /**
- * The compaction summarizer's input routing.
+ * The compaction summarizer's input.
  *
- * Budget-gate compaction summarizes the *injected* history so the summary
- * call's prompt prefix matches the agent's warm prefix cache (a cache read
- * rather than a fresh cache write). Overflow recovery summarizes the
- * injection-*stripped* history because its emergency split keeps an
- * un-stripped verbatim prefix that the post-compaction re-injection would
- * otherwise double-stack.
+ * Both the budget gate and overflow recovery summarize the *injected* history
+ * (the genuine conversation as the agent saw it) so the summary call's prompt
+ * prefix matches the agent's warm prefix cache — a cache read rather than a
+ * fresh cache write. The agent loop hands the full injected history to
+ * compaction unconditionally; the post-compaction re-injection hook owns
+ * injection idempotency by stripping the tail's per-turn blocks before
+ * re-applying them.
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
@@ -46,17 +47,17 @@ const testPostCompactPlugin = {
 const CONVERSATION_ID = "compaction-strip-conversation";
 
 /**
- * A runtime `<workspace>` injection block. `stripInjectionsForCompaction`
- * matches its full `{ prefix: "<workspace>\n", suffix: "\n</workspace>" }`
- * wrapper and drops it from user-message content.
+ * A runtime `<workspace>` injection block. Its presence in the summarizer's
+ * input proves compaction received the injected history rather than a stripped
+ * copy.
  */
 const WORKSPACE_INJECTION =
   "<workspace>\nActive workspace: project-x\n</workspace>";
 const TURN_BODY = "Hello there, this is the turn body.";
 
 /**
- * A user turn carrying a real text block plus a runtime injection block.
- * Stripping drops the injection block and keeps the real one.
+ * A user turn carrying a real text block plus a runtime injection block, both
+ * of which ride into compaction's input as-is.
  */
 const injectedUserMessage: Message = {
   role: "user",
@@ -184,7 +185,7 @@ describe("AgentLoop compaction summarizer input", () => {
     expect(events.some((e) => e.type === "history_stripped")).toBe(true);
   });
 
-  test("overflow-driven compaction summarizes the injection-stripped history", async () => {
+  test("overflow-driven compaction summarizes the injected history", async () => {
     // GIVEN a history whose user turn carries a runtime-injection block
     const capture: CompactionInputCapture = { budget: null, overflow: null };
 
@@ -229,10 +230,10 @@ describe("AgentLoop compaction summarizer input", () => {
       ...installCapturingManager(capture),
     });
 
-    // THEN overflow recovery received the history with the injection removed
+    // THEN overflow recovery received the injected history, injection intact
     expect(capture.overflow).not.toBeNull();
-    expect(serialize(capture.overflow)).not.toContain("<workspace>");
-    // AND the real turn body survives the strip
+    expect(serialize(capture.overflow)).toContain("<workspace>");
+    // AND the real turn body is present alongside the injection
     expect(serialize(capture.overflow)).toContain(TURN_BODY);
     // AND the budget summarizer was not invoked
     expect(capture.budget).toBeNull();

package/src/__tests__/agent-loop-mutable-latest-user-message.test.ts

@@ -1,14 +1,14 @@
 /**
- * Verifies that the `memory-v3-live` cache-anchor signal surfaces on every
- * `SendMessageOptions.config` the loop emits. When the flag is on, the latest
+ * Verifies that the memory-v3-live cache-anchor signal surfaces on every
+ * `SendMessageOptions.config` the loop emits. When v3-live is on, the latest
  * user message carries a volatile `<memory>` block, so the loop sets
  * `providerConfig.mutableLatestUserMessage` to tell the provider to anchor its
  * long-TTL cache breakpoint on the most recent STABLE message instead.
  *
- * The loop reads the flag directly where it assembles `providerConfig`, so the
- * signal is sourced from the flag rather than a run option. When the flag is
- * off the field is omitted (not `false`/`undefined`) so the wire stays
- * byte-identical to today.
+ * The loop reads `config.memory.v3.live` directly where it assembles
+ * `providerConfig`, so the signal is sourced from config rather than a run
+ * option. When v3-live is off the field is omitted (not `false`/`undefined`) so
+ * the wire stays byte-identical to today.
  */
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -19,11 +19,14 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
 
+// AgentLoop reads the v3-live gate (`config.memory.v3.live`) via
+// `isMemoryV3Live` to decide the cache-anchor signal; drive it per-test.
+let memoryV3LiveSlot = false;
+mock.module("../config/memory-v3-gate.js", () => ({
+  isMemoryV3Live: () => memoryV3LiveSlot,
+}));
+
 import { AgentLoop } from "../agent/loop.js";
-import {
-  clearCachedOverrides,
-  setCachedOverrides,
-} from "../config/feature-flag-cache.js";
 import type {
   Message,
   Provider,
@@ -82,12 +85,12 @@ function makeRecordingProvider(responses: ProviderResponse[]): {
 
 describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () => {
   afterEach(() => {
-    clearCachedOverrides();
+    memoryV3LiveSlot = false;
   });
 
   test("sets mutableLatestUserMessage on every LLM call when memory-v3-live is on (multi-turn)", async () => {
     // GIVEN memory-v3-live is enabled
-    setCachedOverrides({ "memory-v3-live": true }, { fromGateway: true });
+    memoryV3LiveSlot = true;
 
     // AND a provider that records the config of each LLM call across a tool round-trip
     const { provider, configs } = makeRecordingProvider([
@@ -131,7 +134,7 @@ describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () =>
 
   test("omits mutableLatestUserMessage when memory-v3-live is off (flag-off byte-identity)", async () => {
     // GIVEN memory-v3-live is off (no override; registry default is false)
-    clearCachedOverrides();
+    memoryV3LiveSlot = false;
 
     // AND a provider that records the config of each LLM call
     const { provider, configs } = makeRecordingProvider([textResponse("hi")]);

package/src/__tests__/app-compiler.test.ts

@@ -2,9 +2,17 @@ import { existsSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+  afterAll,
+  beforeAll,
+  describe,
+  expect,
+  setDefaultTimeout,
+  test,
+} from "bun:test";
 
 import { compileApp } from "../bundler/app-compiler.js";
+import { ensureCompilerTools } from "../bundler/compiler-tools.js";
 import {
   ALLOWED_PACKAGES,
   getCacheDir,
@@ -19,8 +27,14 @@ import {
 
 let tempDir: string;
 
+// Compiler-tool download (esbuild + preact from npm) can take 10s+ on a cold
+// CI cache. Raise the file-level default so beforeAll isn't killed mid-install.
+// Each test file runs in its own process, so this doesn't leak.
+setDefaultTimeout(30_000);
+
 beforeAll(async () => {
   tempDir = await mkdtemp(join(tmpdir(), "app-compiler-test-"));
+  await ensureCompilerTools();
 });
 
 afterAll(async () => {

package/src/__tests__/auth-fallback-events-store.test.ts

@@ -7,18 +7,10 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-let collectUsageData = true;
+let shareAnalytics = true;
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-    collectUsageData,
-  }),
+mock.module("../platform/consent-cache.js", () => ({
+  getCachedShareAnalytics: () => shareAnalytics,
 }));
 
 import {
@@ -53,7 +45,7 @@ const SAMPLE: AuthFallbackCount[] = [
 
 describe("auth-fallback-events-store", () => {
   beforeEach(() => {
-    collectUsageData = true;
+    shareAnalytics = true;
     resetTable();
   });
 
@@ -78,8 +70,8 @@ describe("auth-fallback-events-store", () => {
     });
   });
 
-  test("honors the collectUsageData opt-out (records nothing)", () => {
-    collectUsageData = false;
+  test("honors the share_analytics opt-out (records nothing)", () => {
+    shareAnalytics = false;
     const recorded = recordAuthFallbackCounts(1000, 2000, SAMPLE);
     expect(recorded).toBe(0);
     expect(queryUnreportedAuthFallbackEvents(0, undefined, 100).length).toBe(0);

package/src/__tests__/call-pointer-messages.test.ts

@@ -343,6 +343,34 @@ describe("addPointerMessage", () => {
     expect(processorCalled).toBe(true);
   });
 
+  test("unverified_contact provenance round-trips through the metadata schema and is treated as trusted audience", async () => {
+    // Persisted unverified_contact metadata must survive the schema parse so
+    // downstream consumers (e.g. memory write gate, pointer audience trust)
+    // see the durable trust snapshot rather than a silently-dropped undefined.
+    const convId = "conv-ptr-uvc-provenance";
+    ensureConversation(convId);
+    await addMessage(convId, "user", "hello", {
+      metadata: { provenanceTrustClass: "unverified_contact" },
+    });
+
+    // Confirm the durable snapshot round-trips through the schema parser.
+    const { getConversationRecentProvenanceTrustClass } = await import(
+      "../memory/conversation-crud.js"
+    );
+    expect(getConversationRecentProvenanceTrustClass(convId)).toBe(
+      "unverified_contact",
+    );
+
+    // And that pointer-audience trust treats it identically to trusted_contact.
+    let processorCalled = false;
+    setPointerMessageProcessor(async () => {
+      processorCalled = true;
+    });
+
+    await addPointerMessage(convId, "completed", "+15559876543");
+    expect(processorCalled).toBe(true);
+  });
+
   test("unknown provenance trust class does not grant trusted audience", () => {
     const convId = "conv-ptr-unknown-provenance";
     ensureConversation(convId);

package/src/__tests__/cancel-clears-processing.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Cancel contract: a user cancel raises the conversation's AbortController and
+ * defers clearing the `processing` flag to the in-flight turn's `finally`.
+ *
+ * `cancelGeneration` no longer force-clears `processing` itself. Abort now
+ * propagates into the provider call and tool execution — and is backed by the
+ * agent loop's abort watchdog — so a cancelled turn always reaches its
+ * `finally` within a bounded time and tears down its own state there. The
+ * watchdog-driven path (turn reaches `finally`, processing clears) is covered
+ * by `conversation-agent-loop.test.ts`; this file pins the handler-side
+ * contract: cancel signals abort and leaves the flag to the turn.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { cancelGeneration } from "../daemon/handlers/conversations.js";
+
+interface CancelledConversation {
+  isProcessing: () => boolean;
+  setProcessingCalls: () => boolean[];
+  abortCount: () => number;
+}
+
+/**
+ * Register a conversation whose in-flight turn is processing. The fake records
+ * abort calls and any `setProcessing` writes so the test can assert that
+ * `cancelGeneration` signals abort without flipping the flag itself.
+ */
+function registerProcessingTurn(id: string): CancelledConversation {
+  let processing = true;
+  let abortCount = 0;
+  const setProcessingCalls: boolean[] = [];
+  const fake = {
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      setProcessingCalls.push(value);
+      processing = value;
+    },
+    abort: () => {
+      abortCount += 1;
+    },
+  };
+  setConversation(id, fake as unknown as Conversation);
+  return {
+    isProcessing: () => processing,
+    setProcessingCalls: () => setProcessingCalls,
+    abortCount: () => abortCount,
+  };
+}
+
+describe("cancelGeneration", () => {
+  const conversationId = "cancel-clears-processing-test-conversation";
+
+  afterEach(() => {
+    deleteConversation(conversationId);
+  });
+
+  test("raises abort and defers clearing processing to the turn's finally", () => {
+    // GIVEN a registered conversation that is processing
+    const fake = registerProcessingTurn(conversationId);
+    expect(fake.isProcessing()).toBe(true);
+
+    // WHEN the user cancels generation
+    const cancelled = cancelGeneration(conversationId);
+
+    // THEN the cancel is acknowledged
+    expect(cancelled).toBe(true);
+    // AND the abort signal is raised on the conversation
+    expect(fake.abortCount()).toBe(1);
+    // AND cancelGeneration does NOT force-clear the flag itself — the in-flight
+    // turn's `finally` owns that teardown once abort drives it there.
+    expect(fake.setProcessingCalls()).not.toContain(false);
+    expect(fake.isProcessing()).toBe(true);
+  });
+
+  test("returns false for a conversation that is not registered", () => {
+    // GIVEN no conversation registered under the id
+
+    // WHEN the user cancels generation for the unknown id
+    const cancelled = cancelGeneration("cancel-clears-processing-unknown-id");
+
+    // THEN the cancel reports that nothing was found
+    expect(cancelled).toBe(false);
+  });
+});

package/src/__tests__/channel-approval-routes.test.ts

@@ -224,14 +224,12 @@ function ensureTestContact(): void {
       {
         type: "telegram",
         address: "telegram-user-default",
-        externalUserId: "telegram-user-default",
         status: "active",
         policy: "allow",
       },
       {
         type: "slack",
         address: "slack-user-default",
-        externalUserId: "slack-user-default",
         status: "active",
         policy: "allow",
       },
@@ -2054,7 +2052,6 @@ describe("requester cancel of guardian-gated pending request", () => {
         {
           type: "telegram",
           address: "requester-cancel-user",
-          externalUserId: "requester-cancel-user",
           status: "active",
           policy: "allow",
         },
@@ -2981,7 +2978,6 @@ describe("trusted-contact self-approval blocked before guardian approval row exi
         {
           type: "telegram",
           address: "tc-selfapproval-user",
-          externalUserId: "tc-selfapproval-user",
           status: "active",
           policy: "allow",
         },

package/src/__tests__/channel-inbound-disk-pressure.test.ts

@@ -97,7 +97,6 @@ function seedTrustedContact(policy: "allow" | "escalate" = "allow"): void {
       {
         type: "telegram",
         address: "telegram-user-1",
-        externalUserId: "telegram-user-1",
         status: "active",
         policy,
       },
@@ -237,14 +236,13 @@ describe("channel inbound disk pressure gate", () => {
     expect(db.select().from(messages).all()).toHaveLength(0);
   });
 
-  test("blocks non-guardian Slack reactions before persistence while locked", async () => {
+  test("blocks non-guardian Slack reactions silently (no reply) before persistence while locked", async () => {
     upsertContact({
       displayName: "Example Slack User",
       channels: [
         {
           type: "slack",
           address: "slack-user-1",
-          externalUserId: "slack-user-1",
           status: "active",
           policy: "allow",
         },
@@ -276,18 +274,10 @@ describe("channel inbound disk pressure gate", () => {
       reason: "trusted-contact",
     });
     expect(processMessage).not.toHaveBeenCalled();
-    expect(deliverChannelReplyMock.mock.calls).toEqual([
-      [
-        "https://gateway.test/deliver/slack",
-        {
-          chatId: "slack-channel-1",
-          text: expectedRemoteBlockReply,
-          assistantId: "self",
-          ephemeral: true,
-          user: "slack-user-1",
-        },
-      ],
-    ]);
+    // Reactions are blocked silently during disk pressure: a passive signal
+    // has nothing to "try again", so no block reply is delivered (unlike the
+    // message path, which does reply).
+    expect(deliverChannelReplyMock).not.toHaveBeenCalled();
 
     const db = getDb();
     const event = db

package/src/__tests__/cli-memory-v2-reembed-skills.test.ts

@@ -52,7 +52,7 @@ mock.module("../memory/v2/skill-store.js", () => ({
 // ---------------------------------------------------------------------------
 
 const { registerMemoryV2Command } =
-  await import("../cli/commands/memory-v2.js");
+  await import("../cli/commands/memory/memory-v2.js");
 const { ROUTES: memoryV2Routes, MEMORY_V2_DISABLED_CODE } =
   await import("../runtime/routes/memory-v2-routes.js");
 const { RouteError } = await import("../runtime/routes/errors.js");
@@ -68,9 +68,8 @@ function buildProgram(): Command {
     writeErr: () => {},
     writeOut: () => {},
   });
-  // The registrar creates the `memory` parent itself, so callers don't
-  // need to stub one.
-  registerMemoryV2Command(program);
+  const memory = program.command("memory");
+  registerMemoryV2Command(memory);
   return program;
 }