@vellumai/assistant 0.8.3 → 0.8.4

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

@@ -1,10 +1,7 @@
 import { writeFileSync } from "node:fs";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import {
-  invalidateConfigCache,
-  loadRawConfig,
-} from "../config/loader.js";
+import { invalidateConfigCache, loadRawConfig } from "../config/loader.js";
 import {
   classifySlash,
   resolveSlash,
@@ -42,6 +39,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -58,6 +56,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -74,6 +73,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -87,6 +87,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/context — Show conversation context usage",
       "/model — List or switch inference profile",
       "/models — List all available models",
@@ -99,6 +100,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/clean — Strip injected runtime context and reset memory injection state (no summarization)",
       "/model — List or switch inference profile",
       "/models — List all available models",
     ]);
@@ -187,13 +189,38 @@ describe("resolveSlash /compact target override", () => {
   });
 });
 
+describe("resolveSlash /clean", () => {
+  test("plain /clean resolves to kind=clean", async () => {
+    const result = await resolveSlash("/clean");
+    expect(result).toEqual({ kind: "clean" });
+  });
+
+  test("/clean tolerates surrounding whitespace", async () => {
+    const result = await resolveSlash("  /clean  ");
+    expect(result).toEqual({ kind: "clean" });
+  });
+
+  test("/clean is case-insensitive", async () => {
+    const result = await resolveSlash("/CLEAN");
+    expect(result).toEqual({ kind: "clean" });
+  });
+
+  test("/clean rejects arguments with usage hint", async () => {
+    const result = await resolveSlash("/clean now");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown");
+    expect(result.message).toContain("/clean");
+    expect(result.message).toContain("does not take arguments");
+  });
+});
+
 describe("classifySlash is a pure classifier matching resolveSlash kinds", () => {
   // Lookahead in `buildPassthroughBatch` must not run `resolveSlash`'s side
   // 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";
+    kind: "passthrough" | "compact" | "clean" | "unknown";
   }> = [
     { input: "/models", kind: "unknown" },
     { input: "/context", kind: "unknown" },
@@ -204,6 +231,9 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/compact 30k", kind: "compact" },
     { input: "/compact 1.5M", kind: "compact" },
     { input: "/compact bogus", kind: "unknown" },
+    { input: "/clean", kind: "clean" },
+    { input: "  /clean  ", kind: "clean" },
+    { input: "/clean foo", kind: "unknown" },
     { input: "/model", kind: "unknown" },
     { input: "/model foo", kind: "unknown" },
     { input: "/opus", kind: "unknown" },
@@ -318,9 +348,7 @@ describe("resolveSlash /model — inference profile switcher", () => {
     const result = await resolveSlash("/model balanced");
     expect(result.kind).toBe("unknown");
     if (result.kind !== "unknown") throw new Error("expected unknown kind");
-    expect(result.message).toBe(
-      "Already using profile `balanced` (Balanced).",
-    );
+    expect(result.message).toBe("Already using profile `balanced` (Balanced).");
   });
 
   test("`/model` with no profiles defined points at Settings", async () => {

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

@@ -28,7 +28,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

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

@@ -24,7 +24,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

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

@@ -48,7 +48,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 // Controllable config mock — speed and feature flag behavior are test-specific.

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -84,6 +84,95 @@ describe("task_progress surface compatibility", () => {
     expect(sent).toHaveLength(0);
   });
 
+  test("allows Slack ui_show for task_progress card when dynamic UI is otherwise disabled", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Working",
+      template: "task_progress",
+      templateData: {
+        status: "in_progress",
+        steps: [{ label: "Start", status: "in_progress" }],
+      },
+    });
+
+    expect(result.isError).toBe(false);
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    );
+    expect(showMessage).toBeDefined();
+    if (!showMessage || showMessage.surfaceType !== "card") return;
+    expect((showMessage.data as CardSurfaceData).template).toBe(
+      "task_progress",
+    );
+  });
+
+  test("blocks Slack ui_show for non-task_progress card when dynamic UI is disabled", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Blocked",
+      data: { title: "Blocked", body: "not progress" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_show is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
+  test("blocks Slack ui_show when normalized card data is not task_progress", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Blocked",
+      template: "task_progress",
+      data: { title: "Blocked", body: "not progress", template: "plain" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_show is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
+  test("blocks Slack ui_show for non-card task_progress input when dynamic UI is disabled", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "dynamic_page",
+      title: "Blocked",
+      data: { template: "task_progress", html: "<p>Blocked</p>" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_show is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
   test("ui_show maps legacy top-level task_progress fields into card data", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);
@@ -249,6 +338,137 @@ describe("task_progress surface compatibility", () => {
     expect(Array.isArray(templateData.steps)).toBe(true);
   });
 
+  test("allows Slack ui_update for stored task_progress card when dynamic UI is disabled", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+    ctx.surfaceState.set("surface-1", {
+      surfaceType: "card",
+      data: {
+        title: "Working",
+        body: "",
+        template: "task_progress",
+        templateData: { status: "in_progress", steps: [] },
+      } satisfies CardSurfaceData,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "surface-1",
+      data: { status: "completed" },
+    });
+
+    expect(result.isError).toBe(false);
+    const updateMessage = sent.find(
+      (msg): msg is UiSurfaceUpdate => msg.type === "ui_surface_update",
+    );
+    expect(updateMessage).toBeDefined();
+    if (!updateMessage) return;
+    const templateData = (updateMessage.data as CardSurfaceData)
+      .templateData as Record<string, unknown>;
+    expect(templateData.status).toBe("completed");
+  });
+
+  test("blocks Slack ui_update when stored surface is not a task_progress card", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+    ctx.surfaceState.set("surface-1", {
+      surfaceType: "card",
+      data: { title: "Plain", body: "No progress" } satisfies CardSurfaceData,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "surface-1",
+      data: { body: "still blocked" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_update is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
+  test("blocks Slack ui_update that would convert a plain card to task_progress", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+    ctx.surfaceState.set("surface-1", {
+      surfaceType: "card",
+      data: { title: "Plain", body: "No progress" } satisfies CardSurfaceData,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "surface-1",
+      data: {
+        template: "task_progress",
+        templateData: { status: "in_progress", steps: [] },
+      },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_update is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
+  test("blocks Slack ui_update that would change task_progress card template", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+    ctx.surfaceState.set("surface-1", {
+      surfaceType: "card",
+      data: {
+        title: "Working",
+        body: "",
+        template: "task_progress",
+        templateData: { status: "in_progress", steps: [] },
+      } satisfies CardSurfaceData,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "surface-1",
+      data: { template: "plain", body: "now a plain card" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_update is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+    expect(
+      (ctx.surfaceState.get("surface-1")?.data as CardSurfaceData).template,
+    ).toBe("task_progress");
+  });
+
+  test("blocks Slack ui_update when the surface is not already stored", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent, {
+      channel: "slack",
+      supportsDynamicUi: false,
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: "missing-surface",
+      data: { status: "completed" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'ui_update is unavailable on channel "slack"',
+    );
+    expect(sent).toHaveLength(0);
+  });
+
   test("ui_show rejects new interactive surface when a non-dynamic_page pending surface exists", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -18,7 +18,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -27,7 +27,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -141,6 +141,10 @@ mock.module("../memory/conversation-crud.js", () => ({
   deleteLastExchange: () => 0,
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  setLastNotifiedInferenceProfile: () => {},
+  getConversationOverrideProfileFromRow: () => undefined,
+  updateMessageMetadata: () => {},
+  clearStrippedInjectionMetadataForConversation: () => {},
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -25,7 +25,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -138,6 +138,10 @@ mock.module("../memory/conversation-crud.js", () => ({
   deleteLastExchange: () => 0,
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  setLastNotifiedInferenceProfile: () => {},
+  getConversationOverrideProfileFromRow: () => undefined,
+  updateMessageMetadata: () => {},
+  clearStrippedInjectionMetadataForConversation: () => {},
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/credential-security-invariants.test.ts

@@ -209,6 +209,9 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "config/bundled-skills/media-processing/tools/analyze-keyframes.ts", // keyframe analysis tool API key lookup
       "providers/registry.ts", // provider registry API key lookup for initialization
       "providers/inference/resolve-auth.ts", // provider_connection auth resolver (api_key path reads vault, mirrors registry.ts)
+      "providers/inference/codex-token-refresh.ts", // Codex OAuth token refresh (reads/writes access_token, refresh_token, expires_at)
+      "cli/commands/inference-providers.ts", // ChatGPT subscription OAuth token storage
+      "runtime/routes/chatgpt-subscription-auth-routes.ts", // ChatGPT subscription daemon OAuth flow (stores tokens in CES)
       "providers/provider-availability.ts", // provider availability API key check
       "media/image-credentials.ts", // shared image-gen credential resolver (provider API key lookup)
       "memory/embedding-backend.ts", // embedding backend API key lookup
@@ -223,6 +226,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/daemon-skill-host.ts", // SkillHost secureKeys facet adapter (delegates to getProviderKeyAsync)
       "runtime/routes/credential-prompt-routes.ts", // Route for secure credential prompt (stores secret via setSecureKeyAsync)
       "runtime/routes/credential-routes.ts", // CLI credential management routes (CLI-migrated to IPC)
+      "runtime/routes/sanity-routes.ts", // Sanity connect/discover routes (reads stored api_token from credential store)
       "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
       "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
@@ -236,6 +240,8 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/routes/avatar-routes.ts", // avatar generate route reads platform_base_url from credential store
       "cli/commands/keys.ts", // CLI provider key management
       "cli/commands/oauth/connect.ts", // CLI OAuth connect stored-secret verification
+      "runtime/routes/chatgpt-subscription-auth-routes.ts", // ChatGPT subscription OAuth token storage
+      "runtime/routes/identity-routes.ts", // health/readyz endpoint checks CES connectivity via getCesClient
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));

package/src/__tests__/cu-unified-flow.test.ts

@@ -26,7 +26,16 @@ let mockCuClients: Array<{
 ];
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  broadcastMessage: (msg: unknown) => {
+    // `interaction_resolved` envelopes are emitted by the
+    // pending-interactions tracker for every resolution. They are
+    // orthogonal to the surface-proxy wire messages these tests assert
+    // on, so swallow them here.
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
+    sentMessages.push(msg);
+  },
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) =>
       cap === "host_cu" && mockHasClient ? { id: "mock-client" } : null,

package/src/__tests__/dm-backfill.test.ts

@@ -40,6 +40,20 @@ mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
 }));
 
+mock.module("../messaging/providers/slack/adapter.js", () => ({
+  withSlackBotToken: async (
+    _account: string | undefined,
+    fn: (token: string) => Promise<unknown>,
+  ) => fn("test-slack-token"),
+  resolveSlackBotUserId: async (
+    _account: string | undefined,
+    botId: string,
+  ) => {
+    if (botId === "B_ASSISTANT") return "U_BOT";
+    return null;
+  },
+}));
+
 import type { Message } from "../messaging/provider-types.js";
 
 // `backfillDm` is the only piece of the slack provider surface this test
@@ -59,6 +73,11 @@ mock.module("../messaging/providers/slack/backfill.js", () => ({
   backfillThread: () => backfillThreadMock(),
 }));
 
+import {
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../config/loader.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
@@ -88,6 +107,13 @@ function resetState(): void {
   db.run("DELETE FROM contact_channels");
   db.run("DELETE FROM contacts");
   db.run("DELETE FROM external_conversation_bindings");
+  setConfiguredSlackBotUserId("U_BOT");
+}
+
+function setConfiguredSlackBotUserId(botUserId: string): void {
+  const raw = loadRawConfig();
+  setNestedValue(raw, "slack.botUserId", botUserId);
+  saveRawConfig(raw);
 }
 
 function seedActiveMember(): void {
@@ -494,6 +520,44 @@ describe("PR 23 — Slack DM cold-start backfill", () => {
     expect(botRow?.provenanceRequesterIdentifier).toBe("B_BOT");
   });
 
+  test("skips Slack assistant new-thread placeholder during DM backfill", async () => {
+    backfillDmMock.mockImplementation(async () => [
+      makeBackfilledMessage({
+        id: "1700000000.000001",
+        text: "New Assistant Thread",
+        sender: { id: "B_ASSISTANT", name: "Ada" },
+        metadata: { isBot: true, slackBotId: "B_ASSISTANT" },
+      }),
+      makeBackfilledMessage({
+        id: "1700000000.000002",
+        text: "real bot context",
+        sender: { id: "B_ASSISTANT", name: "Ada" },
+        metadata: { isBot: true, slackBotId: "B_ASSISTANT" },
+      }),
+      makeBackfilledMessage({
+        id: "1700000000.000003",
+        text: "New Assistant Thread",
+        sender: { id: "B_OTHER", name: "Build Bot" },
+        metadata: { isBot: true, slackBotId: "B_OTHER" },
+      }),
+    ]);
+
+    await handleChannelInbound(
+      buildDmRequest("live new DM"),
+      noopProcessMessage,
+      TEST_BEARER_TOKEN,
+    );
+
+    const rows = readPersistedSlackRows();
+    expect(rows.map((row) => row.rawContent).sort()).toEqual([
+      "New Assistant Thread",
+      "real bot context",
+    ]);
+    expect(
+      rows.some((row) => row.slackMeta?.actorExternalUserId === "B_OTHER"),
+    ).toBe(true);
+  });
+
   test("backfill skips channelTs values already stored", async () => {
     // First DM: backfill returns three rows.
     backfillDmMock.mockImplementation(async () => [

package/src/__tests__/dm-persistence.test.ts

@@ -179,6 +179,39 @@ describe("PR 16 — Slack DM persistence parity", () => {
     expect(slackMeta!.displayName).toBeUndefined();
   });
 
+  test("DM inbound persists Slack actor timezone metadata", async () => {
+    const ctx = createSlackTurnContext();
+    await persistQueuedMessageBody(
+      ctx,
+      "hello across timezones",
+      [],
+      "req-dm-timezone",
+      {
+        slackInbound: {
+          channelId: "D0123DM",
+          channelTs: "1700000000.777777",
+          displayName: "Alice",
+          actorTimezone: "America/New_York",
+          actorTimezoneLabel: "ET",
+          actorTimezoneOffsetSeconds: -18000,
+          timestampTimezone: "America/New_York",
+          timestampTimezoneLabel: "ET",
+          speakerTimezoneLabel: "ET",
+        },
+      },
+      undefined,
+    );
+
+    const slackMeta = lastPersistedSlackMeta();
+    expect(slackMeta).not.toBeNull();
+    expect(slackMeta!.actorTimezone).toBe("America/New_York");
+    expect(slackMeta!.actorTimezoneLabel).toBe("ET");
+    expect(slackMeta!.actorTimezoneOffsetSeconds).toBe(-18000);
+    expect(slackMeta!.timestampTimezone).toBe("America/New_York");
+    expect(slackMeta!.timestampTimezoneLabel).toBe("ET");
+    expect(slackMeta!.speakerTimezoneLabel).toBe("ET");
+  });
+
   test("DM and channel-message envelopes differ only by threadTs", async () => {
     // Capture the channel-thread case first.
     const ctx = createSlackTurnContext();