@vellumai/assistant 0.6.6 → 0.7.1

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -16,7 +16,6 @@ mock.module("../memory/pkb/pkb-search.js", () => ({
   },
 }));
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type {
   ChannelCapabilities,
   SlackTranscriptInputRow,
@@ -29,11 +28,13 @@ import {
   buildSubagentStatusBlock,
   buildUnifiedTurnContextBlock,
   findLastInjectedNowContent,
+  getSlackCompactionWatermarkForPrefix,
   injectChannelCapabilityContext,
   injectChannelCommandContext,
   isGroupChatType,
   isSlackChannelConversation,
   loadSlackActiveThreadFocusBlock,
+  loadSlackChronologicalContext,
   loadSlackChronologicalMessages,
   resolveChannelCapabilities,
   stripChannelCapabilityContext,
@@ -1125,90 +1126,46 @@ describe("buildUnifiedTurnContextBlock", () => {
     expect(text).not.toContain("trust_class:");
   });
 
-  test("non-guardian trusted_contact: all actor fields + behavioral guidance", () => {
-    _setOverridesForTesting({ "permission-controls-v2": false });
-    try {
-      const options: UnifiedTurnContextOptions = {
-        timestamp: "2026-04-02T12:00:00Z",
-        interfaceName: "telegram",
-        channelName: "telegram",
-        actorContext: {
-          sourceChannel: "telegram",
-          canonicalActorIdentity: "trusted-user-1",
-          actorIdentifier: "@jeff_handle",
-          actorDisplayName: "Jeff",
-          actorSenderDisplayName: "Jeffrey",
-          actorMemberDisplayName: "Jeff",
-          trustClass: "trusted_contact",
-          guardianIdentity: "guardian-user-1",
-          memberStatus: "active",
-          memberPolicy: "allow",
-        },
-      };
-
-      const text = buildUnifiedTurnContextBlock(options);
-      expect(text).toContain("<turn_context>");
-      expect(text).toContain("current_time: 2026-04-02T12:00:00Z");
-      expect(text).toContain("interface: telegram");
-      expect(text).toContain("source_channel: telegram");
-      expect(text).toContain("canonical_actor_identity: trusted-user-1");
-      expect(text).toContain("actor_identifier: @jeff_handle");
-      expect(text).toContain("actor_display_name: Jeff");
-      expect(text).toContain("actor_sender_display_name: Jeffrey");
-      expect(text).toContain("actor_member_display_name: Jeff");
-      expect(text).toContain("trust_class: trusted_contact");
-      expect(text).toContain("guardian_identity: guardian-user-1");
-      expect(text).toContain("member_status: active");
-      expect(text).toContain("member_policy: allow");
-      // Behavioral guidance
-      expect(text).toContain("trusted contact (non-guardian)");
-      expect(text).toContain("attempt to fulfill it normally");
-      expect(text).toContain(
-        "tool execution layer will automatically deny it and escalate",
-      );
-      expect(text).toContain('their name is "Jeff"');
-      expect(text).toContain("</turn_context>");
-    } finally {
-      _setOverridesForTesting({});
-    }
-  });
-
-  test("non-guardian trusted_contact under v2: guidance shifts to conversational guardian confirmation", () => {
-    _setOverridesForTesting({ "permission-controls-v2": true });
-
-    try {
-      const options: UnifiedTurnContextOptions = {
-        timestamp: "2026-04-02T12:00:00Z",
-        interfaceName: "telegram",
-        channelName: "telegram",
-        actorContext: {
-          sourceChannel: "telegram",
-          canonicalActorIdentity: "trusted-user-1",
-          actorIdentifier: "@jeff_handle",
-          actorDisplayName: "Jeff",
-          actorSenderDisplayName: "Jeffrey",
-          actorMemberDisplayName: "Jeff",
-          trustClass: "trusted_contact",
-          guardianIdentity: "guardian-user-1",
-          memberStatus: "active",
-          memberPolicy: "allow",
-        },
-      };
+  test("non-guardian trusted_contact: all actor fields + conversational guidance", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "telegram",
+      channelName: "telegram",
+      actorContext: {
+        sourceChannel: "telegram",
+        canonicalActorIdentity: "trusted-user-1",
+        actorIdentifier: "@jeff_handle",
+        actorDisplayName: "Jeff",
+        actorSenderDisplayName: "Jeffrey",
+        actorMemberDisplayName: "Jeff",
+        trustClass: "trusted_contact",
+        guardianIdentity: "guardian-user-1",
+        memberStatus: "active",
+        memberPolicy: "allow",
+      },
+    };
 
-      const text = buildUnifiedTurnContextBlock(options);
-      expect(text).toContain("trusted contact (non-guardian)");
-      expect(text).toContain(
-        "confirming the guardian's intent conversationally",
-      );
-      expect(text).toContain(
-        "ask the guardian to enable computer access for this conversation",
-      );
-      expect(text).not.toContain(
-        "tool execution layer will automatically deny it and escalate",
-      );
-    } finally {
-      _setOverridesForTesting({});
-    }
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).toContain("<turn_context>");
+    expect(text).toContain("current_time: 2026-04-02T12:00:00Z");
+    expect(text).toContain("interface: telegram");
+    expect(text).toContain("source_channel: telegram");
+    expect(text).toContain("canonical_actor_identity: trusted-user-1");
+    expect(text).toContain("actor_identifier: @jeff_handle");
+    expect(text).toContain("actor_display_name: Jeff");
+    expect(text).toContain("actor_sender_display_name: Jeffrey");
+    expect(text).toContain("actor_member_display_name: Jeff");
+    expect(text).toContain("trust_class: trusted_contact");
+    expect(text).toContain("guardian_identity: guardian-user-1");
+    expect(text).toContain("member_status: active");
+    expect(text).toContain("member_policy: allow");
+    // Behavioral guidance: conversational confirmation (one-time decision pattern)
+    expect(text).toContain("trusted contact (non-guardian)");
+    expect(text).toContain("confirming the guardian's intent conversationally");
+    expect(text).not.toContain(
+      "tool execution layer will automatically deny it and escalate",
+    );
+    expect(text).toContain("</turn_context>");
   });
 
   test("non-guardian unknown: all actor fields + unknown guidance", () => {
@@ -2341,6 +2298,24 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     });
   }
 
+  test("normalized Slack mention labels stay in assembled model context", async () => {
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m-normalized-mention",
+        createdAt: 1700000000_000,
+        text: "@leo can you check this?",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+    ];
+
+    const result = await runSlackChannelAssembly(rows);
+    const renderedContext = texts(result).join("\n");
+
+    expect(renderedContext).toContain("@leo can you check this?");
+    expect(renderedContext).not.toContain("<@U_LEO>");
+    expect(renderedContext).not.toContain("U_LEO");
+  });
+
   // ── Scenario 1: reply in mid-thread ──────────────────────────────────
   // Alice posts to thread A, Bob replies in thread B (cross-thread). Then
   // Alice posts a follow-up reply in thread A. Cross-thread visibility:
@@ -2868,6 +2843,37 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     expect(allText).not.toContain("dm context");
   });
 
+  test("slack late-join notice is model-facing and non-persisted", async () => {
+    const slackChannelCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const notice =
+      "Slack context note: this turn joined an existing thread. 3 earlier thread messages were backfilled before the current message.";
+
+    const { messages: result, blocks } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "current turn" }] }],
+      {
+        channelCapabilities: slackChannelCaps,
+        slackRuntimeContextNotice: notice,
+        transportHints: [notice],
+      },
+    );
+
+    const allText = result
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).toContain("<slack_context_notice>");
+    expect(allText).toContain(notice);
+    expect(allText).not.toContain("<transport_hints>");
+    expect(JSON.stringify(blocks)).not.toContain(notice);
+  });
+
   // ── transport_hints kept for non-slack channels ───────────────────────
   test("non-slack conversations still receive <transport_hints>", async () => {
     const { messages: result } = await applyRuntimeInjections(
@@ -2937,6 +2943,211 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     expect(allText).toContain("from untrusted actor");
   });
 
+  test("loadSlackChronologicalContext preserves summary and filters by Slack watermark", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const rows: MessageRow[] = [
+      userRow({
+        id: "newer-inserted-first",
+        createdAt: 1700000030_000,
+        text: "after watermark",
+        slackMeta: buildSlackMeta({
+          channelTs: T2,
+          displayName: "carol",
+        }),
+      }),
+      userRow({
+        id: "older-backfilled-later",
+        createdAt: 1700000040_000,
+        text: "before watermark even though inserted later",
+        slackMeta: buildSlackMeta({
+          channelTs: T0,
+          displayName: "alice",
+        }),
+      }),
+      userRow({
+        id: "legacy-before-watermark",
+        createdAt: 1700000008_000,
+        text: "legacy row before watermark",
+      }),
+      userRow({
+        id: "at-watermark",
+        createdAt: 1700000045_000,
+        text: "at watermark",
+        slackMeta: buildSlackMeta({
+          channelTs: T1,
+          displayName: "bob",
+        }),
+      }),
+    ];
+
+    const result = loadSlackChronologicalContext("conv-1", caps, {
+      loader: () => rows,
+      trustClass: "guardian",
+      contextSummary: "## Summary\n- compacted Slack history",
+      contextCompactedMessageCount: 99,
+      slackContextCompactionWatermarkTs: T1,
+    });
+
+    expect(result).not.toBeNull();
+    const renderedText = result!.messages
+      .flatMap((message) => message.content)
+      .filter((block): block is { type: "text"; text: string } => {
+        return block.type === "text";
+      })
+      .map((block) => block.text)
+      .join("\n");
+    expect(renderedText).toContain("<context_summary>");
+    expect(renderedText).toContain("compacted Slack history");
+    expect(renderedText).toContain("after watermark");
+    expect(renderedText).not.toContain("before watermark");
+    expect(renderedText).not.toContain("legacy row before watermark");
+    expect(renderedText).not.toContain("at watermark");
+    expect(result!.renderedMessages.map((entry) => entry.message)).toEqual(
+      result!.messages,
+    );
+    expect(
+      result!.renderedMessages.map((entry) => entry.sourceChannelTs),
+    ).toEqual([null, T2]);
+    expect(getSlackCompactionWatermarkForPrefix(result, 1)).toBe(T2);
+  });
+
+  test("active-thread focus filters pre-watermark and legacy compacted rows", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const rows: MessageRow[] = [
+      userRow({
+        id: "thread-root",
+        createdAt: 1700000000_000,
+        text: "compacted root",
+        slackMeta: buildSlackMeta({
+          channelTs: T0,
+          threadTs: T0,
+          displayName: "alice",
+        }),
+      }),
+      userRow({
+        id: "legacy-old",
+        createdAt: 1700000005_000,
+        text: "legacy compacted row",
+      }),
+      userRow({
+        id: "reply-before",
+        createdAt: 1700000008_000,
+        text: "compacted reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY1,
+          threadTs: T0,
+          displayName: "bob",
+        }),
+      }),
+      userRow({
+        id: "reply-after",
+        createdAt: 1700000025_000,
+        text: "live reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY2,
+          threadTs: T0,
+          displayName: "carol",
+        }),
+      }),
+    ];
+
+    const result = loadSlackActiveThreadFocusBlock("conv-1", caps, {
+      loader: () => rows,
+      trustClass: "guardian",
+      contextCompactedMessageCount: 3,
+      slackContextCompactionWatermarkTs: T1,
+    });
+
+    expect(result).not.toBeNull();
+    expect(result!).toContain("live reply");
+    expect(result!).not.toContain("compacted root");
+    expect(result!).not.toContain("compacted reply");
+    expect(result!).not.toContain("legacy compacted row");
+  });
+
+  test("long Slack thread stays compacted after a later reply", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const ts = (n: number) => `1700000${String(n).padStart(3, "0")}.000000`;
+    const watermark = ts(80);
+    const rows: MessageRow[] = [
+      ...Array.from({ length: 121 }, (_, index) =>
+        userRow({
+          id: `thread-${index}`,
+          createdAt: 1700000000_000 + index,
+          text: index === 0 ? "original root" : `pre-compaction ${index}`,
+          slackMeta: buildSlackMeta({
+            channelTs: ts(index),
+            threadTs: index === 0 ? undefined : ts(0),
+            displayName: index % 2 === 0 ? "alice" : "bob",
+          }),
+        }),
+      ),
+      userRow({
+        id: "subsequent-reply",
+        createdAt: 1700000000_500,
+        text: "reply after compaction",
+        slackMeta: buildSlackMeta({
+          channelTs: ts(121),
+          threadTs: ts(0),
+          displayName: "carol",
+        }),
+      }),
+    ];
+
+    const result = loadSlackChronologicalContext("conv-1", caps, {
+      loader: () => rows,
+      trustClass: "guardian",
+      contextSummary: "## Summary\n- compacted long Slack thread",
+      contextCompactedMessageCount: 81,
+      slackContextCompactionWatermarkTs: watermark,
+    });
+
+    expect(result).not.toBeNull();
+    const renderedText = result!.messages
+      .flatMap((message) => message.content)
+      .filter((block): block is { type: "text"; text: string } => {
+        return block.type === "text";
+      })
+      .map((block) => block.text)
+      .join("\n");
+
+    expect(renderedText).toContain("compacted long Slack thread");
+    expect(renderedText).toContain("reply after compaction");
+    expect(renderedText).not.toContain("original root");
+    expect(renderedText).not.toContain("pre-compaction 80");
+    const sourceChannelTs = result!.renderedMessages.map(
+      (entry) => entry.sourceChannelTs,
+    );
+    expect(sourceChannelTs[0]).toBeNull();
+    expect(
+      sourceChannelTs
+        .slice(1)
+        .every(
+          (channelTs) =>
+            channelTs !== null &&
+            Number.parseFloat(channelTs) > Number.parseFloat(watermark),
+        ),
+    ).toBe(true);
+  });
+
   // ── loadSlackChronologicalMessages returns null for non-slack channels ─
   test("loadSlackChronologicalMessages returns null for non-slack channels", () => {
     const result = loadSlackChronologicalMessages(

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

@@ -36,22 +36,23 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/context — Show conversation context usage",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
       "/fork — Fork the current conversation into a new branch",
-      "/pair — Generate pairing info for connecting a mobile device",
     ]);
     expect(lines).not.toContain("/model — Switch the active model");
   });
 
-  test("renders iOS command help with /fork but without /pair", async () => {
+  test("renders iOS command help with /fork", async () => {
     const lines = await resolveCommandsLines(
       makeSlashContext({ userMessageInterface: "ios" }),
     );
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/context — Show conversation context usage",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -59,26 +60,27 @@ describe("resolveSlash /commands interface-aware help", () => {
     ]);
   });
 
-  test("renders explicit cli command help without /pair", async () => {
+  test("renders explicit cli command help", async () => {
     const lines = await resolveCommandsLines(
       makeSlashContext({ userMessageInterface: "cli" }),
     );
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/context — Show conversation context usage",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
     ]);
   });
 
-  test("keeps legacy fallback help when no interface is provided", async () => {
+  test("orders fallback help consistently when no interface is provided", async () => {
     const lines = await resolveCommandsLines(makeSlashContext());
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/context — Show conversation context usage",
       "/models — List all available models",
-      "/pair — Generate pairing info for connecting a mobile device",
       "/status — Show conversation status and context usage",
     ]);
   });
@@ -89,18 +91,32 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/models — List all available models",
-      "/pair — Generate pairing info for connecting a mobile device",
     ]);
   });
 });
 
 describe("resolveSlash command contract", () => {
+  test("/context reports the resolved context budget", async () => {
+    const result = await resolveSlash(
+      "/context",
+      makeSlashContext({ inputTokens: 75_000, maxInputTokens: 150_000 }),
+    );
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") {
+      throw new Error("Expected /context to resolve to kind=unknown");
+    }
+    expect(result.message).toContain("50%");
+    expect(result.message).toContain("75,000 / 150,000 tokens");
+  });
+
   test("keeps unsupported slash forms as passthrough", async () => {
     const slashForms = [
       "/commands foo",
+      "/context foo",
       "/models foo",
       "/status foo",
       "/pair foo",
+      "/pair",
       "/btw",
     ];
 
@@ -112,52 +128,19 @@ describe("resolveSlash command contract", () => {
       expect(result).toEqual({ kind: "passthrough", content: input });
     }
   });
-
-  test("rejects /pair on iOS interfaces", async () => {
-    const result = await resolveSlash(
-      "/pair",
-      makeSlashContext({ userMessageInterface: "ios" }),
-    );
-    expect(result.kind).toBe("unknown");
-    if (result.kind !== "unknown") {
-      throw new Error("Expected /pair on iOS to resolve to kind=unknown");
-    }
-    expect(result.message).toContain("only available in the macOS desktop app");
-  });
-
-  test("keeps /pair rejected for explicit non-macOS interfaces", async () => {
-    const result = await resolveSlash(
-      "/pair",
-      makeSlashContext({ userMessageInterface: "cli" }),
-    );
-    expect(result.kind).toBe("unknown");
-    if (result.kind !== "unknown") {
-      throw new Error("Expected /pair on cli to resolve to kind=unknown");
-    }
-    expect(result.message).toContain("only available in the macOS desktop app");
-  });
-
-  test("keeps /pair handling enabled on macOS interfaces", async () => {
-    const result = await resolveSlash(
-      "/pair",
-      makeSlashContext({ userMessageInterface: "macos" }),
-    );
-    expect(result.kind).toBe("unknown");
-    if (result.kind !== "unknown") {
-      throw new Error("Expected /pair on macOS to resolve to kind=unknown");
-    }
-    expect(result.message).toContain("Pairing is not available");
-  });
 });
 
 describe("classifySlash is a pure classifier matching resolveSlash kinds", () => {
   // Lookahead in `buildPassthroughBatch` must not run `resolveSlash`'s side
-  // effects (/pair registers a pairing request and writes a QR PNG). The
-  // pure classifier is synchronous, takes no side-effecting dependencies,
-  // and must agree with resolveSlash's `kind`.
-  const cases: Array<{ input: string; kind: "passthrough" | "compact" | "unknown" }> = [
-    { input: "/pair", kind: "unknown" },
+  // effects. The pure classifier is synchronous, takes no side-effecting
+  // dependencies, and must agree with resolveSlash's `kind`.
+  const cases: Array<{
+    input: string;
+    kind: "passthrough" | "compact" | "unknown";
+  }> = [
+    { input: "/pair", kind: "passthrough" },
     { input: "/models", kind: "unknown" },
+    { input: "/context", kind: "unknown" },
     { input: "/status", kind: "unknown" },
     { input: "/commands", kind: "unknown" },
     { input: "/compact", kind: "compact" },

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

@@ -60,6 +60,8 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
+    conversations: { skipAutoRetitling: false },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,
@@ -99,7 +101,6 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
   updateConversationContextWindow: () => {},

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

@@ -105,7 +105,6 @@ const addMessageCalls: Array<{
 }> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},

package/src/__tests__/conversation-speed-override.test.ts

@@ -128,7 +128,6 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
@@ -295,7 +294,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // broadcastToAllClients
       undefined, // memoryPolicy
       undefined, // sharedCesClient
       "standard", // speedOverride
@@ -317,7 +315,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // broadcastToAllClients
       undefined, // memoryPolicy
       undefined, // sharedCesClient
       // no speedOverride — should fall back to global config "fast"
@@ -338,7 +335,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // broadcastToAllClients
       undefined, // memoryPolicy
       undefined, // sharedCesClient
       "fast", // speedOverride