@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/schedule-store.test.ts

@@ -12,10 +12,10 @@ mock.module("../background-wake/publisher.js", () => ({
   refreshBackgroundWakeIntent: () => {},
 }));
 
+import type { AssistantEventEnvelope } from "../api/index.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
-import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
   cancelSchedule,
@@ -56,7 +56,7 @@ async function waitFor(predicate: () => boolean): Promise<void> {
 }
 
 async function expectScheduleSyncEvent(
-  received: AssistantEvent[],
+  received: AssistantEventEnvelope[],
 ): Promise<void> {
   await waitFor(() =>
     received.some(
@@ -85,7 +85,7 @@ describe("schedule sync invalidation", () => {
   });
 
   test("store-level schedule mutations emit schedule sync invalidation", async () => {
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
       callback: (event) => {

package/src/__tests__/schedule-tools.test.ts

@@ -1881,3 +1881,179 @@ describe("schedule_delete tool", () => {
     expect(result.content).toContain("Schedule not found");
   });
 });
+
+// ── model-input schema validation (LUM-2853) ────────────────────────
+
+describe("schedule tools — model-input schema validation", () => {
+  beforeEach(() => {
+    getRawDb().run("DELETE FROM cron_runs");
+    getRawDb().run("DELETE FROM cron_jobs");
+  });
+
+  test("schedule_create rejects a mistyped field instead of persisting it", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Bad timezone",
+        expression: "0 9 * * *",
+        message: "hi",
+        timezone: 42,
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Invalid input for tool "schedule_create"',
+    );
+    expect(result.content).toContain("timezone");
+    const count = getRawDb()
+      .query("SELECT COUNT(*) as n FROM cron_jobs")
+      .get() as { n: number };
+    expect(count.n).toBe(0);
+  });
+
+  test("schedule_create rejects a non-integer retry policy", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Bad retries",
+        expression: "0 9 * * *",
+        message: "hi",
+        max_retries: "five",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("max_retries");
+  });
+
+  test("schedule_create rejects an unknown syntax value instead of persisting it", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Bad syntax",
+        expression: "0 9 * * *",
+        syntax: "daily",
+        message: "hi",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("syntax");
+  });
+
+  test("schedule_create treats explicit null as an omitted optional", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Null tolerance",
+        expression: "0 9 * * *",
+        message: "hi",
+        timezone: null,
+        enabled: null,
+        quiet: null,
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBeFalsy();
+    expect(result.content).toContain("Enabled: true");
+  });
+
+  test("schedule_create keeps the bespoke error for a non-string mode", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Bad mode",
+        expression: "0 9 * * *",
+        message: "hi",
+        mode: 42,
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("mode must be one of");
+  });
+
+  test("schedule_create passes unknown keys through (loose schema)", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Loose keys",
+        expression: "0 9 * * *",
+        message: "hi",
+        activity: "creating a schedule",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBeFalsy();
+  });
+
+  test("schedule_update rejects a mistyped field", async () => {
+    const create = await executeScheduleCreate(
+      { name: "To update", expression: "0 9 * * *", message: "hi" },
+      ctx,
+    );
+    expect(create.isError).toBeFalsy();
+    const jobId = (
+      getRawDb().query("SELECT id FROM cron_jobs").get() as { id: string }
+    ).id;
+
+    const result = await executeScheduleUpdate(
+      { job_id: jobId, max_retries: 2.5 },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Invalid input for tool "schedule_update"',
+    );
+    expect(result.content).toContain("max_retries");
+  });
+
+  test("schedule_update still clears timezone with an explicit null", async () => {
+    const create = await executeScheduleCreate(
+      {
+        name: "Tz clear",
+        expression: "0 9 * * *",
+        message: "hi",
+        timezone: "America/Los_Angeles",
+      },
+      ctx,
+    );
+    expect(create.isError).toBeFalsy();
+    const jobId = (
+      getRawDb().query("SELECT id FROM cron_jobs").get() as { id: string }
+    ).id;
+
+    const result = await executeScheduleUpdate(
+      { job_id: jobId, timezone: null },
+      ctx,
+    );
+
+    expect(result.isError).toBeFalsy();
+    const row = getRawDb()
+      .query("SELECT timezone FROM cron_jobs WHERE id = ?")
+      .get(jobId) as { timezone: string | null };
+    expect(row.timezone).toBeNull();
+  });
+
+  test("schedule_list rejects a mistyped enabled_only and tolerates null", async () => {
+    const bad = await executeScheduleList({ enabled_only: "yes" }, ctx);
+    expect(bad.isError).toBe(true);
+    expect(bad.content).toContain('Invalid input for tool "schedule_list"');
+
+    const ok = await executeScheduleList(
+      { enabled_only: null, job_id: null },
+      ctx,
+    );
+    expect(ok.isError).toBeFalsy();
+  });
+
+  test("schedule_delete rejects a mistyped job_id", async () => {
+    const result = await executeScheduleDelete({ job_id: 42 }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Invalid input for tool "schedule_delete"',
+    );
+  });
+});

package/src/__tests__/secret-prompt-log-hygiene.test.ts

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { SecretRequestEvent } from "../api/events/secret-request.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // Capture all logger calls so we can verify secret values never appear
@@ -30,9 +30,9 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // Capture broadcastMessage calls
-const broadcastedMessages: ServerMessage[] = [];
+const broadcastedMessages: AssistantEvent[] = [];
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: ServerMessage) => {
+  broadcastMessage: (msg: AssistantEvent) => {
     broadcastedMessages.push(msg);
   },
 }));

package/src/__tests__/secret-prompter-channel-fallback.test.ts

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { SecretRequestEvent } from "../api/events/secret-request.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // Use a tiny timeout so the setTimeout branch fires quickly in tests
@@ -25,9 +25,9 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
-let broadcastMessages: ServerMessage[] = [];
+let broadcastMessages: AssistantEvent[] = [];
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: ServerMessage) => broadcastMessages.push(msg),
+  broadcastMessage: (msg: AssistantEvent) => broadcastMessages.push(msg),
 }));
 
 // Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.

package/src/__tests__/secret-response-routing.test.ts

@@ -1,12 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { SecretRequestEvent } from "../api/events/secret-request.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import type { SecretPromptResult } from "../permissions/secret-prompt-types.js";
 
-let broadcastedMessages: ServerMessage[] = [];
+let broadcastedMessages: AssistantEvent[] = [];
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: ServerMessage) => broadcastedMessages.push(msg),
+  broadcastMessage: (msg: AssistantEvent) => broadcastedMessages.push(msg),
 }));
 
 // Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -90,13 +90,10 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
 
 // `handleAddSecret` fires this detached when a managed-proxy credential lands —
 // a v2-memory side effect outside this suite's provider-registry scope. Stub it
-// to a no-op; its behavior is covered by memory-v2-startup.test.ts.
-mock.module(
-  "../plugins/defaults/memory/v3/substrate/memory-v2-startup.js",
-  () => ({
-    maybeReseedCapabilitiesAfterManagedCredential: async () => {},
-  }),
-);
+// to a no-op; its behavior is covered by boot-maintenance.test.ts.
+mock.module("../plugins/defaults/memory/substrate/boot-maintenance.js", () => ({
+  maybeReseedCapabilitiesAfterManagedCredential: async () => {},
+}));
 
 // secret-routes evicts conversations after a credential change so the next turn
 // rebuilds against the new providers; count the calls to assert that happens.

package/src/__tests__/secret-scanner.test.ts

@@ -8,6 +8,7 @@ import {
 import {
   _isPlaceholder,
   redactSecrets,
+  redactSecretsWith,
   scanText,
   type SecretMatch,
 } from "../security/secret-scanner.js";
@@ -433,6 +434,41 @@ describe("redaction", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// PEM private-key body redaction — the scanner replaces the matched span in
+// place, so the match must cover header→body→footer or the base64 body and
+// END footer survive redaction (the header-only-matcher leak this fixes).
+// Synthetic fake PEM material only — never a real key.
+// ---------------------------------------------------------------------------
+describe("private-key block redaction", () => {
+  const FAKE_PEM_BODY =
+    "MIIFAKEfakefakefakefakefakefakefakefakefake\n" +
+    "FAKEfakefakefakefakefakefakefakefakefake==";
+  const FULL_PEM_BLOCK = `-----BEGIN RSA PRIVATE KEY-----\n${FAKE_PEM_BODY}\n-----END RSA PRIVATE KEY-----`;
+
+  test("redactSecrets removes the whole block — body and footer, not just the header", () => {
+    const input = `here is the key:\n${FULL_PEM_BLOCK}\nuse it well`;
+    const result = redactSecrets(input);
+    expect(result).toContain('<redacted type="Private Key" />');
+    // The base64 body must not survive.
+    expect(result).not.toContain("MIIFAKE");
+    expect(result).not.toContain("FAKEfake");
+    // Header and footer must not survive either.
+    expect(result).not.toContain("-----BEGIN");
+    expect(result).not.toContain("-----END");
+    // Surrounding text is preserved.
+    expect(result).toContain("here is the key:");
+    expect(result).toContain("use it well");
+  });
+
+  test("redactSecretsWith removes the whole block", () => {
+    const result = redactSecretsWith(FULL_PEM_BLOCK, () => "[KEY]");
+    expect(result).toBe("[KEY]");
+    expect(result).not.toContain("MIIFAKE");
+    expect(result).not.toContain("-----END");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Plugin-declared patterns (runtime registry)
 // ---------------------------------------------------------------------------

package/src/__tests__/send-endpoint-busy.test.ts

@@ -10,8 +10,8 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
+import type { AssistantEvent } from "../api/index.js";
 import type { Conversation } from "../daemon/conversation.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import {
   getConversationByKey,
   getOrCreateConversation,
@@ -97,10 +97,10 @@ mock.module(
   () => gatewayGuardianRequestsStoreBridge,
 );
 
+import type { AssistantEventEnvelope } from "../api/index.js";
 import { __resetGuardianDeliveryCacheForTest } from "../contacts/guardian-delivery-reader.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
-import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import type { ApprovalConversationGenerator } from "../runtime/http-types.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
@@ -143,7 +143,7 @@ function makeCompletingConversation(): Conversation {
     runAgentLoop: async (
       _content: string,
       _messageId: string,
-      options?: { onEvent?: (msg: ServerMessage) => void },
+      options?: { onEvent?: (msg: AssistantEvent) => void },
     ) => {
       const onEvent = options?.onEvent ?? (() => {});
       onEvent({ type: "assistant_text_delta", text: "Hello!" });
@@ -162,7 +162,7 @@ function makeHangingConversation(): Conversation {
   const messages: unknown[] = [];
   const enqueuedMessages: Array<{
     content: string;
-    onEvent?: (msg: ServerMessage) => void;
+    onEvent?: (msg: AssistantEvent) => void;
     requestId?: string;
   }> = [];
   return {
@@ -191,7 +191,7 @@ function makeHangingConversation(): Conversation {
     getQueueDepth: () => enqueuedMessages.length,
     enqueueMessage: (options: {
       content: string;
-      onEvent?: (msg: ServerMessage) => void;
+      onEvent?: (msg: AssistantEvent) => void;
       requestId?: string;
     }) => {
       enqueuedMessages.push({
@@ -375,7 +375,7 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
   });
 
   test("publishes events to assistantEventHub when conversation is idle", async () => {
-    const publishedEvents: AssistantEvent[] = [];
+    const publishedEvents: AssistantEventEnvelope[] = [];
 
     await startServer(() => makeCompletingConversation());
 
@@ -384,7 +384,7 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       await import("../runtime/assistant-event-hub.js");
     routeEventHub.subscribe({
       type: "process",
-      callback: (event: AssistantEvent) => {
+      callback: (event: AssistantEventEnvelope) => {
         publishedEvents.push(event);
       },
     });

package/src/__tests__/slack-required-scopes-mirror.test.ts

@@ -0,0 +1,81 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+/**
+ * The required-scope list in `channel-readiness-service.ts` is a third copy of
+ * data owned by the Slack manifest — the web helper and the skill script hold
+ * the other two. Copies drift silently, and a stale list here would either miss
+ * a real gap or flag a scope the manifest stopped asking for, so pin it to the
+ * canonical source rather than trusting a comment to hold the line.
+ */
+const REPO_ROOT = join(import.meta.dir, "..", "..", "..");
+
+const MANIFEST_SOURCE = readFileSync(
+  join(REPO_ROOT, "skills/slack-app-setup/scripts/build-manifest.ts"),
+  "utf-8",
+);
+const READINESS_SOURCE = readFileSync(
+  join(import.meta.dir, "..", "runtime", "channel-readiness-service.ts"),
+  "utf-8",
+);
+const WEB_HELPER_SOURCE = readFileSync(
+  join(REPO_ROOT, "clients/web/src/utils/slack-manifest.ts"),
+  "utf-8",
+);
+
+/** Pull the quoted strings out of the array introduced by `opener`. */
+function scopeArrayAfter(source: string, opener: string): string[] {
+  const start = source.indexOf(opener);
+  if (start === -1) {
+    throw new Error(`Not found: ${opener}`);
+  }
+  const from = start + opener.length;
+  const end = source.indexOf("]", from);
+  if (end === -1) {
+    throw new Error(`Unterminated array after: ${opener}`);
+  }
+  return [...source.slice(from, end).matchAll(/"([^"]+)"/g)].map((m) => m[1]);
+}
+
+const bot = scopeArrayAfter(MANIFEST_SOURCE, "bot: [");
+const botOptional = scopeArrayAfter(MANIFEST_SOURCE, "bot_optional: [");
+const required = scopeArrayAfter(
+  READINESS_SOURCE,
+  "const SLACK_REQUIRED_BOT_SCOPES = [",
+);
+const webBot = scopeArrayAfter(
+  WEB_HELPER_SOURCE,
+  "export const SLACK_MANIFEST_BOT_SCOPES = [",
+);
+const webBotOptional = scopeArrayAfter(
+  WEB_HELPER_SOURCE,
+  "const SLACK_MANIFEST_BOT_SCOPES_OPTIONAL = [",
+);
+
+describe("required Slack scopes stay in sync with the manifest", () => {
+  test("the manifest source parses into usable scope arrays", () => {
+    expect(bot.length).toBeGreaterThan(0);
+    expect(botOptional.length).toBeGreaterThan(0);
+    // Guards the extraction itself, and the manifest's own subset contract.
+    expect(botOptional.every((scope) => bot.includes(scope))).toBe(true);
+  });
+
+  test("readiness requires exactly the non-declinable bot scopes", () => {
+    const expected = bot.filter((scope) => !botOptional.includes(scope)).sort();
+
+    expect([...required].sort()).toEqual(expected);
+  });
+
+  test("readiness never demands a scope the workspace may decline", () => {
+    expect(required.filter((scope) => botOptional.includes(scope))).toEqual([]);
+  });
+
+  // The web helper is the third copy. Both mirrors are asserted to emit
+  // identical manifest JSON elsewhere, but that check lives in the web package
+  // and cannot see this one, so pin the scope arrays here too.
+  test("the web helper requests the same bot scopes as the skill script", () => {
+    expect([...webBot].sort()).toEqual([...bot].sort());
+    expect([...webBotOptional].sort()).toEqual([...botOptional].sort());
+  });
+});

package/src/__tests__/starter-task-flow.test.ts

@@ -1,10 +1,13 @@
 import { describe, expect, mock, test } from "bun:test";
 
-import type { ServerMessage, SurfaceType } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
+import type { SurfaceType } from "../daemon/message-protocol.js";
 
 mock.module("../apps/app-store.js", () => ({
   getApp: (id: string) => {
-    if (id !== "test-app") return null;
+    if (id !== "test-app") {
+      return null;
+    }
     return {
       id,
       name: "Test App",
@@ -13,6 +16,16 @@ mock.module("../apps/app-store.js", () => ({
     };
   },
   getAppPreview: () => null,
+  isDirectAppConversation: (app: { id: string }) => app.id === "test-app",
+  linkAppToConversationLineage: () => {},
+  listAppsByConversation: () => [
+    {
+      id: "inherited-app",
+      updatedAt: 2,
+      inheritedConversationIds: ["session-1"],
+    },
+    { id: "test-app", updatedAt: 1 },
+  ],
   updateApp: () => {
     throw new Error("updateApp should not be called in this test");
   },
@@ -116,7 +129,7 @@ describe("starter task surface actions", () => {
   });
 
   test("app_open registers dynamic_page surface as action-capable", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext();
     ctx.sendToClient = (msg) => sent.push(msg);
 
@@ -135,4 +148,14 @@ describe("starter task surface actions", () => {
     );
     expect(sent.some((msg) => msg.type === "ui_surface_show")).toBe(true);
   });
+
+  test("app_open without app_id prefers a direct app over a newer inherited app", async () => {
+    const ctx = makeContext();
+
+    const result = await surfaceProxyResolver(ctx, "app_open", {});
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(String(result.content)) as { appId: string };
+    expect(parsed.appId).toBe("test-app");
+  });
 });

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -17,7 +17,7 @@
  */
 import { afterAll, describe, expect, mock, test } from "bun:test";
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { getProvider as getProviderImport } from "../providers/registry.js";
 import { setConfig } from "./helpers/set-config.js";
 
@@ -42,7 +42,7 @@ class FakeConversation {
     provider: unknown,
     _systemPrompt: string,
     _maxTokens: number,
-    _sendToClient: (msg: ServerMessage) => void,
+    _sendToClient: (msg: AssistantEvent) => void,
   ) {
     capturedProvider = provider;
     this.capturedState = {