@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/__tests__/workspace-migrations-runner.test.ts

@@ -123,6 +123,61 @@ describe("runWorkspaceMigrations", () => {
     expect(m2.run).toHaveBeenCalledTimes(1);
   });
 
+  test("logs a start line and returns applied/skipped/failed counts", async () => {
+    // One already applied, one new — exercises both applied and skipped counts.
+    mockCheckpointContents = JSON.stringify({
+      applied: {
+        "001": { appliedAt: "2025-01-01T00:00:00.000Z", status: "completed" },
+      },
+    });
+
+    const m1 = makeMigration("001");
+    const m2 = makeMigration("002");
+
+    const summary = await runWorkspaceMigrations(WORKSPACE_DIR, [m1, m2]);
+
+    // One info log before all migrations, naming how many are registered.
+    expect(logInfoFn).toHaveBeenCalledWith(
+      "Running workspace migrations (2 registered)",
+    );
+
+    // One info log for the new migration that actually ran.
+    expect(logInfoFn).toHaveBeenCalledWith(
+      expect.stringContaining("Running workspace migration: 002"),
+    );
+
+    // Counts are returned for the caller to fold into its own startup log —
+    // the runner no longer emits a standalone summary line.
+    expect(summary).toEqual({ applied: 1, skipped: 1, failed: 0 });
+  });
+
+  test("counts a migration that throws as failed, not applied", async () => {
+    const m1 = makeMigration("001");
+    const m2 = makeMigration("002");
+    (m2.run as ReturnType<typeof mock>).mockImplementation(() => {
+      throw new Error("boom");
+    });
+
+    const summary = await runWorkspaceMigrations(WORKSPACE_DIR, [m1, m2]);
+
+    expect(summary).toEqual({ applied: 1, skipped: 0, failed: 1 });
+  });
+
+  test("counts a pre-existing failed checkpoint as failed, not skipped", async () => {
+    mockCheckpointContents = JSON.stringify({
+      applied: {
+        "001": { appliedAt: "2025-01-01T00:00:00.000Z", status: "failed" },
+      },
+    });
+
+    const m1 = makeMigration("001");
+    const summary = await runWorkspaceMigrations(WORKSPACE_DIR, [m1]);
+
+    // Non-retryable failed checkpoint: not re-run, surfaced as failed.
+    expect(m1.run).not.toHaveBeenCalled();
+    expect(summary).toEqual({ applied: 0, skipped: 0, failed: 1 });
+  });
+
   test("writes checkpoint after each migration", async () => {
     const m1 = makeMigration("001");
     const m2 = makeMigration("002");

package/src/__tests__/workspace-tool-loader.test.ts

@@ -94,6 +94,9 @@ function makeFakeCoreTool(name: string): Tool {
     category: "test",
     defaultRiskLevel: RiskLevel.Low,
     executionTarget: "sandbox",
+    // Match the finalized shape the registry stores (defaults filled), so
+    // `getCoreToolOverride(name)` toEqual comparisons hold after registration.
+    exclusive: false,
     input_schema: { type: "object", properties: {}, required: [] },
     async execute(
       _input: Record<string, unknown>,

package/src/a2a/__tests__/e2e-a2a-channel.test.ts

@@ -68,7 +68,7 @@ import {
   updateState,
 } from "../task-store.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Global fetch intercept

package/src/a2a/__tests__/task-store.test.ts

@@ -21,7 +21,7 @@ import {
   updateState,
 } from "../task-store.js";
 
-initializeDb();
+await initializeDb();
 
 function makeRequestMessage(overrides?: Partial<A2AMessage>): A2AMessage {
   return {

package/src/acp/__tests__/session-manager-persistence.test.ts

@@ -28,7 +28,7 @@ import {
   insertHistoryRow,
   readHistoryRow,
 } from "./helpers/acp-history-db.js";
-initializeDb();
+await initializeDb();
 
 /**
  * Builds a manager with a fake session pre-injected and returns the handles

package/src/acp/__tests__/session-manager-resume.test.ts

@@ -177,8 +177,11 @@ mock.module("../resolve-agent.js", () => ({
 import { installExecFileStub } from "./helpers/exec-file-stub.js";
 import { installWhichStub } from "./helpers/which-stub.js";
 
-const { execScripts, execFileMock, reset: resetExecStub } =
-  installExecFileStub();
+const {
+  execScripts,
+  execFileMock,
+  reset: resetExecStub,
+} = installExecFileStub();
 const which = installWhichStub();
 /** Fixed resolved `bun` path so install script keys are predictable. */
 const BUN_BIN = "/usr/local/bin/bun";
@@ -200,9 +203,10 @@ const { AcpResumeError, AcpSessionManager, AcpSessionNotFoundError } =
   await import("../session-manager.js");
 // Imported dynamically (after the exec/which stubs above) so auto-install.js
 // binds to the mocked node:child_process, exactly like session-manager.js.
-const { _resetAdapterInstallCacheForTests } = await import("../auto-install.js");
+const { _resetAdapterInstallCacheForTests } =
+  await import("../auto-install.js");
 
-initializeDb();
+await initializeDb();
 
 function countHistoryRows(): number {
   const row = getSqlite()
@@ -400,9 +404,9 @@ describe("AcpSessionManager.resumeFromHistory", () => {
       { sessionId: "proto-old", cwd: "/tmp/proj" },
     ]);
     // The SessionEntry command is the basename (resume hints gate on it).
-    expect(
-      internals(manager).sessions.get("installed-resume-1")!.command,
-    ).toBe("claude-agent-acp");
+    expect(internals(manager).sessions.get("installed-resume-1")!.command).toBe(
+      "claude-agent-acp",
+    );
   });
 
   test("missing adapter on resume: installs via sandboxed bun, then resumes against the real binary", async () => {
@@ -481,7 +485,9 @@ describe("AcpSessionManager.resumeFromHistory", () => {
 
     // prepareAgentEnv ran AFTER resolution, on the resolved real binary, and
     // injected the token at spawn time — the sole point the token is in scope.
-    expect(prepareAgentEnvCommands).toEqual(["/usr/local/bin/claude-agent-acp"]);
+    expect(prepareAgentEnvCommands).toEqual([
+      "/usr/local/bin/claude-agent-acp",
+    ]);
     expect(fake.config.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("should-not-leak");
   });
 
@@ -498,7 +504,10 @@ describe("AcpSessionManager.resumeFromHistory", () => {
     execScripts.set(BUN_ADD_KEY, { error: new Error("network is down") });
 
     const manager = new AcpSessionManager(4);
-    const promise = manager.resumeFromHistory("resume-install-fail-1", () => {});
+    const promise = manager.resumeFromHistory(
+      "resume-install-fail-1",
+      () => {},
+    );
     await expect(promise).rejects.toThrow(/claude-agent-acp is not on PATH/);
     await expect(promise).rejects.toThrow(
       /auto-install failed: .*network is down/,
@@ -819,8 +828,10 @@ describe("AcpSessionManager.steerOrResume", () => {
 
     const manager = new AcpSessionManager(4);
     const sent: ServerMessage[] = [];
-    const first = manager.steerOrResume("sor-init-1", "first instruction", (msg) =>
-      sent.push(msg),
+    const first = manager.steerOrResume(
+      "sor-init-1",
+      "first instruction",
+      (msg) => sent.push(msg),
     );
 
     // Advance microtasks until the first call's resume has registered its

package/src/acp/__tests__/session-manager-startup.test.ts

@@ -17,7 +17,7 @@ mock.module("../../util/logger.js", () => ({
 import { AcpSessionManager } from "../../acp/session-manager.js";
 import { getSqlite } from "../../memory/db-connection.js";
 import { initializeDb } from "../../memory/db-init.js";
-initializeDb();
+await initializeDb();
 
 function clearHistory() {
   getSqlite().run("DELETE FROM acp_session_history");

package/src/acp/__tests__/session-manager.test.ts

@@ -8,6 +8,10 @@ import { describe, expect, mock, test } from "bun:test";
 
 import type { AcpSessionState } from "../types.js";
 
+// Records every `cancel(protocolSessionId)` the manager dispatches to a fake
+// process, so tests can assert which sessions were cancelled.
+const cancelCalls: string[] = [];
+
 // Stub the agent-process module so spawn() does not actually launch a child
 // process. Each fake instance records the cwd it was spawned in and resolves
 // every protocol method synchronously. The mock is process-global (Bun's
@@ -30,7 +34,9 @@ mock.module("../agent-process.js", () => ({
       // the duration of the test so cleanup logic doesn't tear it down.
       return new Promise(() => {});
     }
-    async cancel(): Promise<void> {}
+    async cancel(sessionId: string): Promise<void> {
+      cancelCalls.push(sessionId);
+    }
     kill(): void {}
   },
 }));
@@ -81,3 +87,68 @@ describe("AcpSessionManager — parentConversationId population", () => {
     expect(parents).toEqual(["conv-parent-1", "conv-parent-2"]);
   });
 });
+
+describe("AcpSessionManager — cancelForParent", () => {
+  const noopSend = () => {};
+
+  test("cancels only the sessions spawned by the given parent", async () => {
+    cancelCalls.length = 0;
+    const manager = new AcpSessionManager(5);
+
+    const a1 = await manager.spawn(
+      "agent-a1",
+      { command: "echo", args: ["hi"] },
+      "task",
+      "/tmp",
+      "parent-A",
+      noopSend,
+    );
+    const a2 = await manager.spawn(
+      "agent-a2",
+      { command: "echo", args: ["hi"] },
+      "task",
+      "/tmp",
+      "parent-A",
+      noopSend,
+    );
+    const b1 = await manager.spawn(
+      "agent-b1",
+      { command: "echo", args: ["hi"] },
+      "task",
+      "/tmp",
+      "parent-B",
+      noopSend,
+    );
+
+    // WHEN parent-A is cancelled
+    const count = manager.cancelForParent("parent-A");
+
+    // THEN it reports the two parent-A sessions and leaves parent-B alone
+    expect(count).toBe(2);
+
+    // Let the detached per-session cancels settle (each awaits a protocol
+    // notification before flipping status).
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect((manager.getStatus(a1.acpSessionId) as AcpSessionState).status).toBe(
+      "cancelled",
+    );
+    expect((manager.getStatus(a2.acpSessionId) as AcpSessionState).status).toBe(
+      "cancelled",
+    );
+    expect((manager.getStatus(b1.acpSessionId) as AcpSessionState).status).toBe(
+      "running",
+    );
+
+    // AND the cancel reached each parent-A agent process exactly once.
+    expect(cancelCalls.sort()).toEqual(["proto-agent-a1", "proto-agent-a2"]);
+  });
+
+  test("returns 0 and dispatches nothing when the parent has no sessions", () => {
+    cancelCalls.length = 0;
+    const manager = new AcpSessionManager(5);
+
+    expect(manager.cancelForParent("parent-with-nothing")).toBe(0);
+    expect(cancelCalls).toEqual([]);
+  });
+});

package/src/acp/index.ts

@@ -18,6 +18,16 @@ export function getAcpSessionManager(): AcpSessionManager {
   return manager;
 }
 
+/**
+ * Returns the existing AcpSessionManager singleton, or null when none has been
+ * created yet. Use this on cleanup hot paths (e.g. cancelling a conversation)
+ * that must not spin up a manager just to discover there are no sessions to
+ * act on.
+ */
+export function peekAcpSessionManager(): AcpSessionManager | null {
+  return manager;
+}
+
 /**
  * Disposes the singleton AcpSessionManager and nulls the reference.
  */

package/src/acp/session-manager.ts

@@ -691,6 +691,41 @@ export class AcpSessionManager {
     }
   }
 
+  /**
+   * Cancels every in-flight session spawned by `parentConversationId`.
+   *
+   * Mirrors the subagent manager's `abortAllForParent`: when the user cancels
+   * a turn, the ACP agents it launched should stop rather than keep running in
+   * the background — holding a child process — and then, on completion, enqueue
+   * a follow-up message into the conversation the user just stopped. Cancelling
+   * settles each in-flight prompt down its `"cancelled"` path, which sends a
+   * client event but does NOT notify the parent, so no model activity follows
+   * the stop.
+   *
+   * Each session's `cancel()` runs detached (it awaits a protocol notification
+   * to the child) so callers on the cancel hot path never block on an
+   * unresponsive agent; failures are logged. Session ids are snapshotted before
+   * dispatch so concurrent teardown can't disturb the iteration. Returns the
+   * number of sessions a cancel was kicked off for.
+   */
+  cancelForParent(parentConversationId: string): number {
+    const ids: string[] = [];
+    for (const [acpSessionId, entry] of this.sessions) {
+      if (entry.parentConversationId === parentConversationId) {
+        ids.push(acpSessionId);
+      }
+    }
+    for (const acpSessionId of ids) {
+      void this.cancel(acpSessionId).catch((err) => {
+        log.warn(
+          { acpSessionId, parentConversationId, err },
+          "Failed to cancel ACP session on parent cancel",
+        );
+      });
+    }
+    return ids.length;
+  }
+
   /**
    * Kills the agent process and removes the session from tracking.
    *

package/src/agent/loop-exclusive-tool.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Verifies the agent loop's exclusive-tool dispatch: when a tool the loop is
+ * told is exclusive (e.g. the advisor) appears in a multi-call turn, only that
+ * tool runs and the siblings are deferred un-run with a benign result — so the
+ * model incorporates the exclusive tool's output before acting on anything
+ * else. Drives the REAL loop, mocking only the provider boundary.
+ */
+import { describe, expect, test } from "bun:test";
+
+import { createMockProvider } from "../__tests__/helpers/mock-provider.js";
+import type { ContentBlock, ProviderResponse } from "../providers/types.js";
+import { AgentLoop } from "./loop.js";
+
+const endTurn = (text: string): ProviderResponse => ({
+  content: [{ type: "text", text }],
+  model: "mock-model",
+  usage: { inputTokens: 1, outputTokens: 1 },
+  stopReason: "end_turn",
+});
+
+const toolUseTurn = (
+  blocks: Array<{ id: string; name: string }>,
+): ProviderResponse => ({
+  content: [
+    { type: "text", text: "working" },
+    ...blocks.map((b) => ({
+      type: "tool_use" as const,
+      id: b.id,
+      name: b.name,
+      input: {},
+    })),
+  ],
+  model: "mock-model",
+  usage: { inputTokens: 1, outputTokens: 1 },
+  stopReason: "tool_use",
+});
+
+function toolResults(history: { content: ContentBlock[] }[]) {
+  return history
+    .flatMap((m) => m.content)
+    .filter(
+      (b): b is Extract<ContentBlock, { type: "tool_result" }> =>
+        b.type === "tool_result",
+    );
+}
+
+const baseRun = {
+  requestId: "req-excl",
+  onEvent: () => {},
+  callSite: "mainAgent" as const,
+  trust: { sourceChannel: "vellum" as const, trustClass: "unknown" as const },
+};
+
+describe("AgentLoop — exclusive tool deferral", () => {
+  test("runs the exclusive tool alone and defers sibling calls un-run", async () => {
+    const { provider } = createMockProvider([
+      toolUseTurn([
+        { id: "call-advisor", name: "advisor" },
+        { id: "call-edit", name: "write_file" },
+      ]),
+      endTurn("done"),
+    ]);
+
+    const executed: string[] = [];
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "sys",
+      conversationId: "excl-1",
+      tools: [
+        { name: "advisor", description: "", input_schema: { type: "object" } },
+        {
+          name: "write_file",
+          description: "",
+          input_schema: { type: "object" },
+        },
+      ],
+      toolExecutor: async (name) => {
+        executed.push(name);
+        return { content: `ran ${name}`, isError: false };
+      },
+      isExclusiveTool: (name) => name === "advisor",
+    });
+
+    const { history } = await loop.run({
+      ...baseRun,
+      messages: [{ role: "user", content: [{ type: "text", text: "do it" }] }],
+    });
+
+    // Only the exclusive tool actually executed.
+    expect(executed).toEqual(["advisor"]);
+
+    const results = toolResults(history);
+    const advisorResult = results.find(
+      (b) => b.tool_use_id === "call-advisor",
+    )!;
+    const editResult = results.find((b) => b.tool_use_id === "call-edit")!;
+
+    // The advisor ran; the sibling came back un-run (not an error) so the model
+    // can re-issue it after reading the guidance.
+    expect(advisorResult.content).toBe("ran advisor");
+    expect(editResult.content).toContain("not run");
+    expect(editResult.content).toContain("advisor");
+    expect(editResult.is_error).toBe(false);
+  });
+
+  test("runs sibling tools normally when no exclusive tool is present", async () => {
+    const { provider } = createMockProvider([
+      toolUseTurn([
+        { id: "call-read", name: "read_file" },
+        { id: "call-write", name: "write_file" },
+      ]),
+      endTurn("done"),
+    ]);
+
+    const executed: string[] = [];
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "sys",
+      conversationId: "excl-2",
+      tools: [
+        {
+          name: "read_file",
+          description: "",
+          input_schema: { type: "object" },
+        },
+        {
+          name: "write_file",
+          description: "",
+          input_schema: { type: "object" },
+        },
+      ],
+      toolExecutor: async (name) => {
+        executed.push(name);
+        return { content: `ran ${name}`, isError: false };
+      },
+      isExclusiveTool: (name) => name === "advisor",
+    });
+
+    const { history } = await loop.run({
+      ...baseRun,
+      messages: [{ role: "user", content: [{ type: "text", text: "do it" }] }],
+    });
+
+    // Both non-exclusive tools ran; nothing was deferred.
+    expect(executed.sort()).toEqual(["read_file", "write_file"]);
+    for (const result of toolResults(history)) {
+      expect(result.content).not.toContain("not run");
+    }
+  });
+});