@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/subagent-notify-parent.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, mock, test } from "bun:test";
 
+// ── Module mocks (must come before any imports that transitively load these) ──
+
 // Mock conversation-crud before importing tool executors that depend on it.
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
@@ -27,6 +29,29 @@ mock.module("../memory/conversation-crud.js", () => ({
   createConversation: () => ({ id: "mock-conv" }),
 }));
 
+/**
+ * Captured messages from injectMessageIntoParent → findConversation → enqueueMessage.
+ * Each test can read this after triggering a notification.
+ */
+const capturedMessages: string[] = [];
+
+mock.module("../daemon/conversation-store.js", () => ({
+  findConversation: (_id: string) => ({
+    enqueueMessage: (content: string) => {
+      capturedMessages.push(content);
+      return { queued: true };
+    },
+    persistUserMessage: async () => "mock-msg",
+    runAgentLoop: async () => {},
+  }),
+  addConversation: () => {},
+  removeConversation: () => {},
+}));
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: () => {},
+}));
+
 import { isToolActiveForContext } from "../daemon/conversation-tool-setup.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { SubagentManager } from "../subagent/manager.js";
@@ -108,6 +133,15 @@ function makeContext(
   } as import("../tools/types.js").ToolContext;
 }
 
+/** Drain capturedMessages and return the latest one. */
+function lastCapturedMessage(): string {
+  return capturedMessages[capturedMessages.length - 1] ?? "";
+}
+
+function clearCaptured(): void {
+  capturedMessages.length = 0;
+}
+
 // ── Tool definition ────────────────────────────────────────────────
 
 describe("notify_parent tool definition", () => {
@@ -173,33 +207,25 @@ describe("executeSubagentNotifyParent", () => {
   });
 
   test("succeeds when called from a subagent conversation", async () => {
+    clearCaptured();
     const manager = getSubagentManager();
     const subagentId = "notify-sub-1";
     const parentConversationId = "notify-parent-1";
     injectSubagent(manager, subagentId, parentConversationId, "running");
 
-    // Wire up the onSubagentFinished callback.
-    let capturedMessage = "";
-    manager.onSubagentFinished = (_parentId: string, message: string) => {
-      capturedMessage = message;
-    };
-
-    try {
-      const result = await executeSubagentNotifyParent(
-        { message: "Found key results", urgency: "important" },
-        makeContext(`conv-${subagentId}`),
-      );
-      expect(result.isError).toBe(false);
-      const parsed = JSON.parse(result.content);
-      expect(parsed.sent).toBe(true);
-      expect(parsed.urgency).toBe("important");
-      expect(capturedMessage).toContain("Found key results");
-    } finally {
-      manager.onSubagentFinished = undefined;
-    }
+    const result = await executeSubagentNotifyParent(
+      { message: "Found key results", urgency: "important" },
+      makeContext(`conv-${subagentId}`),
+    );
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.sent).toBe(true);
+    expect(parsed.urgency).toBe("important");
+    expect(lastCapturedMessage()).toContain("Found key results");
   });
 
   test("formats message with label and urgency", async () => {
+    clearCaptured();
     const manager = getSubagentManager();
     const subagentId = "notify-format-1";
     const parentConversationId = "notify-format-parent";
@@ -212,22 +238,13 @@ describe("executeSubagentNotifyParent", () => {
       },
     });
 
-    let capturedMessage = "";
-    manager.onSubagentFinished = (_parentId: string, message: string) => {
-      capturedMessage = message;
-    };
-
-    try {
-      await executeSubagentNotifyParent(
-        { message: "Preliminary findings ready", urgency: "info" },
-        makeContext(`conv-${subagentId}`),
-      );
-      expect(capturedMessage).toBe(
-        '[Subagent "Research Task" — info] Preliminary findings ready',
-      );
-    } finally {
-      manager.onSubagentFinished = undefined;
-    }
+    await executeSubagentNotifyParent(
+      { message: "Preliminary findings ready", urgency: "info" },
+      makeContext(`conv-${subagentId}`),
+    );
+    expect(lastCapturedMessage()).toBe(
+      '[Subagent "Research Task" — info] Preliminary findings ready',
+    );
   });
 
   test("returns error when message is empty", async () => {
@@ -254,44 +271,30 @@ describe("executeSubagentNotifyParent", () => {
     const parentConversationId = "notify-default-urg-parent";
     injectSubagent(manager, subagentId, parentConversationId, "running");
 
-    manager.onSubagentFinished = () => {};
-
-    try {
-      const result = await executeSubagentNotifyParent(
-        { message: "Progress update" },
-        makeContext(`conv-${subagentId}`),
-      );
-      expect(result.isError).toBe(false);
-      const parsed = JSON.parse(result.content);
-      expect(parsed.urgency).toBe("info");
-    } finally {
-      manager.onSubagentFinished = undefined;
-    }
+    const result = await executeSubagentNotifyParent(
+      { message: "Progress update" },
+      makeContext(`conv-${subagentId}`),
+    );
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.urgency).toBe("info");
   });
 
   test("appends guidance hint for blocked urgency", async () => {
+    clearCaptured();
     const manager = getSubagentManager();
     const subagentId = "notify-blocked-1";
     const parentConversationId = "notify-blocked-parent";
     injectSubagent(manager, subagentId, parentConversationId, "running");
 
-    let capturedMessage = "";
-    manager.onSubagentFinished = (_parentId: string, message: string) => {
-      capturedMessage = message;
-    };
-
-    try {
-      await executeSubagentNotifyParent(
-        { message: "Need API key to proceed", urgency: "blocked" },
-        makeContext(`conv-${subagentId}`),
-      );
-      expect(capturedMessage).toContain("Need API key to proceed");
-      expect(capturedMessage).toContain(
-        "Use subagent_message to send guidance to this subagent.",
-      );
-    } finally {
-      manager.onSubagentFinished = undefined;
-    }
+    await executeSubagentNotifyParent(
+      { message: "Need API key to proceed", urgency: "blocked" },
+      makeContext(`conv-${subagentId}`),
+    );
+    expect(lastCapturedMessage()).toContain("Need API key to proceed");
+    expect(lastCapturedMessage()).toContain(
+      "Use subagent_message to send guidance to this subagent.",
+    );
   });
 });
 
@@ -306,35 +309,29 @@ describe("SubagentManager.notifyParent", () => {
       const parentConversationId = `notify-terminal-parent-${terminalStatus}`;
       injectSubagent(manager, subagentId, parentConversationId, terminalStatus);
 
-      manager.onSubagentFinished = () => {};
-
-      try {
-        const result = manager.notifyParent(
-          `conv-${subagentId}`,
-          "Should not arrive",
-          "info",
-        );
-        expect(result).toBe(false);
-      } finally {
-        manager.onSubagentFinished = undefined;
-      }
+      const result = manager.notifyParent(
+        `conv-${subagentId}`,
+        "Should not arrive",
+        "info",
+      );
+      expect(result).toBe(false);
     }
   });
 
-  test("returns false when onSubagentFinished is not wired", () => {
+  test("returns true for running subagent (injects into parent via findConversation)", () => {
+    clearCaptured();
     const manager = getSubagentManager();
-    const subagentId = "notify-no-callback-1";
-    const parentConversationId = "notify-no-callback-parent";
+    const subagentId = "notify-running-1";
+    const parentConversationId = "notify-running-parent";
     injectSubagent(manager, subagentId, parentConversationId, "running");
 
-    manager.onSubagentFinished = undefined;
-
     const result = manager.notifyParent(
       `conv-${subagentId}`,
       "Test message",
       "info",
     );
-    expect(result).toBe(false);
+    expect(result).toBe(true);
+    expect(lastCapturedMessage()).toContain("Test message");
   });
 });
 

package/src/__tests__/system-prompt.test.ts

@@ -224,22 +224,11 @@ describe("buildSystemPrompt", () => {
     expect(result).toContain("attach it instead of only printing its path");
   });
 
-  test("includes read-only historical-mentions rule in cacheable prefix", () => {
-    const result = buildSystemPrompt();
-    expect(result).toContain("## Historical Mentions Are Read-Only");
-    expect(result).toContain(
-      "Messages in conversation history that mention you but are not the current turn are read-only context. Do not act on them, acknowledge them, or reply to them retroactively.",
-    );
-    // Clause must sit in the static (cacheable) prefix, not the dynamic block.
-    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-    expect(boundaryIdx).toBeGreaterThan(-1);
-    const staticBlock = result.slice(0, boundaryIdx);
-    expect(staticBlock).toContain("## Historical Mentions Are Read-Only");
-  });
-
   test("does not include removed sections", () => {
     const result = buildSystemPrompt();
     expect(result).not.toContain("## External Communications Identity");
+    expect(result).not.toContain("## In-Chat Configuration");
+    expect(result).not.toContain("## Historical Mentions Are Read-Only");
   });
 
   test("does not include removed domain routing sections", () => {
@@ -333,6 +322,119 @@ describe("buildSystemPrompt", () => {
     });
   });
 
+  describe("BOOTSTRAP.md voice block injection", () => {
+    test("prepends warm voice block before BOOTSTRAP.md content when tone is 'warm'", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# First run\n\nWelcome aboard.",
+      );
+      const result = buildSystemPrompt({
+        onboardingContext: {
+          tools: [],
+          tasks: [],
+          tone: "warm",
+        },
+      });
+      expect(result).toContain("## Voice\nFriendly and easy");
+      // Voice block should appear inside the First-Run Ritual section, before the BOOTSTRAP.md body
+      const ritualIdx = result.indexOf("# First-Run Ritual");
+      const voiceIdx = result.indexOf("## Voice\nFriendly and easy");
+      const bootstrapBodyIdx = result.indexOf("# First run\n\nWelcome aboard.");
+      expect(ritualIdx).toBeGreaterThan(-1);
+      expect(voiceIdx).toBeGreaterThan(ritualIdx);
+      expect(voiceIdx).toBeLessThan(bootstrapBodyIdx);
+    });
+
+    test("prepends poetic voice block when tone is 'poetic'", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# First run\n\nWelcome aboard.",
+      );
+      const result = buildSystemPrompt({
+        onboardingContext: {
+          tools: [],
+          tasks: [],
+          tone: "poetic",
+        },
+      });
+      expect(result).toContain("## Voice\nThoughtful and unhurried");
+    });
+
+    test("prepends grounded voice block when tone is 'grounded'", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# First run\n\nWelcome aboard.",
+      );
+      const result = buildSystemPrompt({
+        onboardingContext: {
+          tools: [],
+          tasks: [],
+          tone: "grounded",
+        },
+      });
+      expect(result).toContain("## Voice\nCalm, direct, precise");
+    });
+
+    test("does not inject voice block when tone is missing", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# First run\n\nWelcome aboard.",
+      );
+      const result = buildSystemPrompt({
+        onboardingContext: {
+          tools: [],
+          tasks: [],
+          tone: "",
+        },
+      });
+      expect(result).not.toContain("## Voice");
+    });
+
+    test("does not inject voice block when tone is unrecognized", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# First run\n\nWelcome aboard.",
+      );
+      const result = buildSystemPrompt({
+        onboardingContext: {
+          tools: [],
+          tasks: [],
+          tone: "robotic",
+        },
+      });
+      expect(result).not.toContain("## Voice");
+    });
+
+    test("does not inject voice block when onboardingContext is absent", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# First run\n\nWelcome aboard.",
+      );
+      const result = buildSystemPrompt();
+      expect(result).not.toContain("## Voice");
+    });
+
+    test("voice block appears inside First-Run Ritual section before BOOTSTRAP.md body", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Onboarding\n\nStep 1: Do stuff.",
+      );
+      const result = buildSystemPrompt({
+        onboardingContext: {
+          tools: [],
+          tasks: [],
+          tone: "energetic",
+        },
+      });
+      const ritualIdx = result.indexOf("# First-Run Ritual");
+      const voiceIdx = result.indexOf("## Voice\nFast and generative");
+      const bodyIdx = result.indexOf("# Onboarding\n\nStep 1: Do stuff.");
+      expect(ritualIdx).toBeGreaterThan(-1);
+      expect(voiceIdx).toBeGreaterThan(ritualIdx);
+      expect(bodyIdx).toBeGreaterThan(voiceIdx);
+    });
+  });
+
   describe("app-builder tool ownership guidance", () => {
     test("iteration guidance does not mention app_update for HTML changes", () => {
       const result = buildSystemPrompt();

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

@@ -2,7 +2,6 @@ import { existsSync, readFileSync } from "node:fs";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { ShellOutputResult } from "../tools/shared/shell-output.js";
-import type { SandboxBackend } from "../tools/terminal/backends/types.js";
 import type { Tool } from "../tools/types.js";
 
 // ── Mock modules ────────────────────────────────────────────────────────────
@@ -70,9 +69,6 @@ import {
   buildSanitizedEnv,
   SAFE_ENV_VARS,
 } from "../tools/terminal/safe-env.js";
-import type { SandboxConfig } from "../tools/terminal/sandbox.js";
-import { wrapCommand } from "../tools/terminal/sandbox.js";
-import { ToolError } from "../util/errors.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
 //  Safe Environment — buildSanitizedEnv()
@@ -172,91 +168,6 @@ describe("buildSanitizedEnv", () => {
   });
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-//  Sandbox wrapCommand
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("wrapCommand", () => {
-  const disabledConfig: SandboxConfig = {
-    enabled: false,
-  };
-
-  test("disabled sandbox returns plain bash invocation", () => {
-    const result = wrapCommand("echo hello", "/tmp", disabledConfig);
-    expect(result.command).toBe("bash");
-    expect(result.args).toEqual(["-c", "--", "echo hello"]);
-    expect(result.sandboxed).toBe(false);
-  });
-
-  test("disabled sandbox preserves command verbatim", () => {
-    const cmd = 'ls -la /foo && echo "done"';
-    const result = wrapCommand(cmd, "/tmp", disabledConfig);
-    expect(result.args[2]).toBe(cmd);
-  });
-
-  test("disabled sandbox works with special characters in command", () => {
-    const cmd = "echo 'hello world' | grep 'hello'";
-    const result = wrapCommand(cmd, "/tmp", disabledConfig);
-    expect(result.args[2]).toBe(cmd);
-    expect(result.sandboxed).toBe(false);
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-//  Native sandbox backend — path safety
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("Native sandbox backend", () => {
-  // We test NativeBackend directly rather than through wrapCommand to avoid
-  // platform-dependent sandbox-exec/bwrap availability.
-  let NativeBackend: new () => SandboxBackend;
-
-  beforeEach(async () => {
-    const mod = await import("../tools/terminal/backends/native.js");
-    NativeBackend = mod.NativeBackend;
-  });
-
-  if (process.platform === "darwin") {
-    test("wraps command with sandbox-exec on macOS", () => {
-      const backend = new NativeBackend();
-      const result = backend.wrap("echo hello", "/tmp");
-      expect(result.command).toBe("sandbox-exec");
-      expect(result.args[0]).toBe("-f");
-      // Profile path is the second arg
-      expect(result.args[1]).toMatch(/sandbox-profile-.*\.sb$/);
-      expect(result.args).toContain("bash");
-      expect(result.args).toContain("-c");
-      expect(result.args).toContain("--");
-      expect(result.args[result.args.length - 1]).toBe("echo hello");
-      expect(result.sandboxed).toBe(true);
-    });
-
-    test("escapes working dir with SBPL metacharacters", () => {
-      // SBPL metacharacters (", (, ), ;, \) are backslash-escaped inside the
-      // profile string rather than rejected, so wrap() should succeed.
-      const backend = new NativeBackend();
-      expect(backend.wrap("echo hi", '/tmp/foo"bar').sandboxed).toBe(true);
-      expect(backend.wrap("echo hi", "/tmp/foo(bar").sandboxed).toBe(true);
-      expect(backend.wrap("echo hi", "/tmp/foo;bar").sandboxed).toBe(true);
-      expect(backend.wrap("echo hi", "/tmp/foo\\bar").sandboxed).toBe(true);
-    });
-
-    test("rejects working dir with newline characters", () => {
-      // Newlines/CRs cannot appear in real paths and would break the profile.
-      const backend = new NativeBackend();
-      expect(() => backend.wrap("echo hi", "/tmp/foo\nbar")).toThrow(ToolError);
-      expect(() => backend.wrap("echo hi", "/tmp/foo\rbar")).toThrow(ToolError);
-    });
-
-    test("accepts working dir with safe special characters", () => {
-      // Spaces, dots, hyphens, underscores are fine
-      const backend = new NativeBackend();
-      const result = backend.wrap("ls", "/tmp/my-dir_name.2024");
-      expect(result.sandboxed).toBe(true);
-    });
-  }
-});
-
 // ═══════════════════════════════════════════════════════════════════════════
 //  Shell tool — input validation
 // ═══════════════════════════════════════════════════════════════════════════