@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/__tests__/task-progress-nudge-hook.test.ts

@@ -0,0 +1,372 @@
+/**
+ * Tests for the default `task-progress-nudge` plugin's `post-tool-use` hook.
+ *
+ * Covers:
+ * - Stays silent below the round threshold; nudges once a multi-step turn
+ *   reaches it with no task_progress card shown.
+ * - Never nudges when a task_progress card was already shown this turn.
+ * - Fires at most once per turn (dedupes parallel results / further rounds).
+ * - Resets across turns so a later multi-step turn can nudge again.
+ * - Gating: fires only for weak models (Kimi/DeepSeek/MiniMax) and skips
+ *   capable models, non-mainAgent call sites, surface-incapable clients, and
+ *   subagent conversations.
+ * - Appends to (not overwrites) `additionalContext` set by an earlier hook.
+ * - The nudge leaves the tool result's `content` untouched.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import * as realConversationRegistry from "../daemon/conversation-registry.js";
+
+// The hook lazily imports the conversation registry and subagent manager on
+// the would-nudge path; mock both before importing the hook. The registry mock
+// spreads the real module so other consumers in the shared test process keep
+// their exports — only `findConversation` is overridden.
+interface MockConversation {
+  currentCallSite?: string;
+  currentTurnChannelCapabilities?: {
+    channel: string;
+    supportsDynamicUi: boolean;
+  };
+  channelCapabilities?: { channel: string; supportsDynamicUi: boolean };
+}
+let mockConversation: (
+  conversationId: string,
+) => MockConversation | undefined = () => ({
+  currentCallSite: "mainAgent",
+  currentTurnChannelCapabilities: { channel: "web", supportsDynamicUi: true },
+});
+mock.module("../daemon/conversation-registry.js", () => ({
+  ...realConversationRegistry,
+  findConversation: (conversationId: string) =>
+    mockConversation(conversationId),
+}));
+
+let mockParentInfo: (conversationId: string) => unknown = () => undefined;
+mock.module("../subagent/index.js", () => ({
+  getSubagentManager: () => ({
+    getParentInfo: (conversationId: string) => mockParentInfo(conversationId),
+  }),
+}));
+
+import type { PluginLogger, PostToolUseContext } from "../plugin-api/types.js";
+import postToolUse, {
+  resetTaskProgressNudgeStateForTests,
+  TASK_PROGRESS_NUDGE_ROUND_THRESHOLD,
+  TASK_PROGRESS_NUDGE_TEXT,
+} from "../plugins/defaults/task-progress-nudge/hooks/post-tool-use.js";
+import type { Message, ToolResultContent } from "../providers/types.js";
+
+const noopLogger: PluginLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+};
+
+let conversationCounter = 0;
+function freshConversationId(): string {
+  conversationCounter++;
+  return `conv-nudge-test-${conversationCounter}`;
+}
+
+function toolUseTurn(
+  id: string,
+  name: string,
+  input: Record<string, unknown> = {},
+): Message {
+  return {
+    role: "assistant",
+    content: [{ type: "tool_use", id, name, input }],
+  };
+}
+
+function toolResultTurn(toolUseId: string): Message {
+  return {
+    role: "user",
+    content: [
+      {
+        type: "tool_result",
+        tool_use_id: toolUseId,
+        content: "ok",
+        is_error: false,
+      },
+    ],
+  };
+}
+
+function currentResponse(toolUseId: string): ToolResultContent {
+  return {
+    type: "tool_result",
+    tool_use_id: toolUseId,
+    content: "result body",
+    is_error: false,
+  };
+}
+
+/** A weak-model id that matches WEAK_MODEL_PATTERN (the gated population). */
+const WEAK_MODEL = "minimax/minimax-m3";
+
+function makeCtx(
+  conversationId: string,
+  toolResponse: ToolResultContent,
+  messages: Message[],
+  model: string = WEAK_MODEL,
+): PostToolUseContext {
+  return {
+    conversationId,
+    toolResponse,
+    messages,
+    additionalContext: null,
+    model,
+    maxInputTokens: 10_000,
+    logger: noopLogger,
+  };
+}
+
+/**
+ * Build a turn of `rounds` tool-use rounds. The last round's tool_use has no
+ * result in history (it arrives via `ctx.toolResponse`). When `showCardAtRound`
+ * is set, that round issues a `ui_show` task_progress card instead of a plain
+ * tool.
+ */
+function turnWithRounds(
+  rounds: number,
+  opts: { showCardAtRound?: number } = {},
+): { messages: Message[]; currentToolUseId: string } {
+  const messages: Message[] = [
+    { role: "user", content: [{ type: "text", text: "build the thing" }] },
+  ];
+  for (let r = 1; r <= rounds; r++) {
+    const id = `tool-${r}`;
+    if (opts.showCardAtRound === r) {
+      messages.push(
+        toolUseTurn(id, "ui_show", {
+          surface_type: "card",
+          template: "task_progress",
+          templateData: { status: "in_progress", steps: [] },
+        }),
+      );
+    } else {
+      messages.push(toolUseTurn(id, "bash", { command: `cmd-${r}` }));
+    }
+    if (r < rounds) messages.push(toolResultTurn(id));
+  }
+  return { messages, currentToolUseId: `tool-${rounds}` };
+}
+
+describe("task-progress-nudge post-tool-use hook", () => {
+  beforeEach(() => {
+    resetTaskProgressNudgeStateForTests();
+    mockConversation = () => ({
+      currentCallSite: "mainAgent",
+      currentTurnChannelCapabilities: {
+        channel: "web",
+        supportsDynamicUi: true,
+      },
+    });
+    mockParentInfo = () => undefined;
+  });
+
+  test("stays silent below the round threshold", async () => {
+    const { messages, currentToolUseId } = turnWithRounds(
+      TASK_PROGRESS_NUDGE_ROUND_THRESHOLD - 1,
+    );
+    const ctx = makeCtx(
+      freshConversationId(),
+      currentResponse(currentToolUseId),
+      messages,
+    );
+    await postToolUse(ctx);
+    expect(ctx.additionalContext).toBeNull();
+  });
+
+  test("nudges once the turn reaches the threshold with no card shown", async () => {
+    const { messages, currentToolUseId } = turnWithRounds(
+      TASK_PROGRESS_NUDGE_ROUND_THRESHOLD,
+    );
+    const ctx = makeCtx(
+      freshConversationId(),
+      currentResponse(currentToolUseId),
+      messages,
+    );
+    await postToolUse(ctx);
+    expect(ctx.additionalContext).toBe(TASK_PROGRESS_NUDGE_TEXT);
+    // tool result content is untouched
+    expect(ctx.toolResponse.content).toBe("result body");
+  });
+
+  test("never nudges when a task_progress card was already shown this turn", async () => {
+    const { messages, currentToolUseId } = turnWithRounds(
+      TASK_PROGRESS_NUDGE_ROUND_THRESHOLD + 2,
+      { showCardAtRound: 1 },
+    );
+    const ctx = makeCtx(
+      freshConversationId(),
+      currentResponse(currentToolUseId),
+      messages,
+    );
+    await postToolUse(ctx);
+    expect(ctx.additionalContext).toBeNull();
+  });
+
+  test("fires at most once per turn", async () => {
+    const conversationId = freshConversationId();
+    const first = turnWithRounds(TASK_PROGRESS_NUDGE_ROUND_THRESHOLD);
+    const ctx1 = makeCtx(
+      conversationId,
+      currentResponse(first.currentToolUseId),
+      first.messages,
+    );
+    await postToolUse(ctx1);
+    expect(ctx1.additionalContext).toBe(TASK_PROGRESS_NUDGE_TEXT);
+
+    // One more round, still no card — must not nudge again this turn.
+    const second = turnWithRounds(TASK_PROGRESS_NUDGE_ROUND_THRESHOLD + 1);
+    const ctx2 = makeCtx(
+      conversationId,
+      currentResponse(second.currentToolUseId),
+      second.messages,
+    );
+    await postToolUse(ctx2);
+    expect(ctx2.additionalContext).toBeNull();
+  });
+
+  test("resets across turns so a later multi-step turn nudges again", async () => {
+    const conversationId = freshConversationId();
+    const first = turnWithRounds(TASK_PROGRESS_NUDGE_ROUND_THRESHOLD);
+    const ctx1 = makeCtx(
+      conversationId,
+      currentResponse(first.currentToolUseId),
+      first.messages,
+    );
+    await postToolUse(ctx1);
+    expect(ctx1.additionalContext).toBe(TASK_PROGRESS_NUDGE_TEXT);
+
+    // A brand-new turn (counting restarts low) below threshold — resets state.
+    const lull = turnWithRounds(1);
+    const ctxLull = makeCtx(
+      conversationId,
+      currentResponse(lull.currentToolUseId),
+      lull.messages,
+    );
+    await postToolUse(ctxLull);
+    expect(ctxLull.additionalContext).toBeNull();
+
+    // Another multi-step turn — should nudge again.
+    const third = turnWithRounds(TASK_PROGRESS_NUDGE_ROUND_THRESHOLD);
+    const ctx3 = makeCtx(
+      conversationId,
+      currentResponse(third.currentToolUseId),
+      third.messages,
+    );
+    await postToolUse(ctx3);
+    expect(ctx3.additionalContext).toBe(TASK_PROGRESS_NUDGE_TEXT);
+  });
+
+  test("fires for weak models (Kimi, DeepSeek, MiniMax)", async () => {
+    for (const model of [
+      "moonshotai/kimi-k2.6",
+      "deepseek/deepseek-chat",
+      "accounts/fireworks/models/minimax-m3",
+    ]) {
+      const { messages, currentToolUseId } = turnWithRounds(
+        TASK_PROGRESS_NUDGE_ROUND_THRESHOLD,
+      );
+      const ctx = makeCtx(
+        freshConversationId(),
+        currentResponse(currentToolUseId),
+        messages,
+        model,
+      );
+      await postToolUse(ctx);
+      expect(ctx.additionalContext).toBe(TASK_PROGRESS_NUDGE_TEXT);
+    }
+  });
+
+  test("skips capable models (not in the weak-model set)", async () => {
+    for (const model of ["claude-opus-4-8", "gpt-5.5"]) {
+      const { messages, currentToolUseId } = turnWithRounds(
+        TASK_PROGRESS_NUDGE_ROUND_THRESHOLD + 2,
+      );
+      const ctx = makeCtx(
+        freshConversationId(),
+        currentResponse(currentToolUseId),
+        messages,
+        model,
+      );
+      await postToolUse(ctx);
+      expect(ctx.additionalContext).toBeNull();
+    }
+  });
+
+  test("skips non-mainAgent call sites", async () => {
+    mockConversation = () => ({
+      currentCallSite: "wake",
+      currentTurnChannelCapabilities: {
+        channel: "web",
+        supportsDynamicUi: true,
+      },
+    });
+    const { messages, currentToolUseId } = turnWithRounds(
+      TASK_PROGRESS_NUDGE_ROUND_THRESHOLD,
+    );
+    const ctx = makeCtx(
+      freshConversationId(),
+      currentResponse(currentToolUseId),
+      messages,
+    );
+    await postToolUse(ctx);
+    expect(ctx.additionalContext).toBeNull();
+  });
+
+  test("skips clients without dynamic UI support", async () => {
+    mockConversation = () => ({
+      currentCallSite: "mainAgent",
+      currentTurnChannelCapabilities: {
+        channel: "telegram",
+        supportsDynamicUi: false,
+      },
+    });
+    const { messages, currentToolUseId } = turnWithRounds(
+      TASK_PROGRESS_NUDGE_ROUND_THRESHOLD,
+    );
+    const ctx = makeCtx(
+      freshConversationId(),
+      currentResponse(currentToolUseId),
+      messages,
+    );
+    await postToolUse(ctx);
+    expect(ctx.additionalContext).toBeNull();
+  });
+
+  test("skips subagent conversations", async () => {
+    mockParentInfo = () => ({ parentConversationId: "parent-1" });
+    const { messages, currentToolUseId } = turnWithRounds(
+      TASK_PROGRESS_NUDGE_ROUND_THRESHOLD,
+    );
+    const ctx = makeCtx(
+      freshConversationId(),
+      currentResponse(currentToolUseId),
+      messages,
+    );
+    await postToolUse(ctx);
+    expect(ctx.additionalContext).toBeNull();
+  });
+
+  test("appends to existing additionalContext rather than overwriting", async () => {
+    const { messages, currentToolUseId } = turnWithRounds(
+      TASK_PROGRESS_NUDGE_ROUND_THRESHOLD,
+    );
+    const ctx = makeCtx(
+      freshConversationId(),
+      currentResponse(currentToolUseId),
+      messages,
+    );
+    ctx.additionalContext = "<system_notice>prior coaching</system_notice>";
+    await postToolUse(ctx);
+    expect(ctx.additionalContext).toBe(
+      `<system_notice>prior coaching</system_notice>\n${TASK_PROGRESS_NUDGE_TEXT}`,
+    );
+  });
+});

package/src/__tests__/task-scheduler.test.ts

@@ -44,6 +44,22 @@ mock.module("../runtime/background-job-runner.js", () => ({
   },
 }));
 
+// Capture workflow-mode dispatch. The scheduler's `workflow` branch calls
+// `getWorkflowRunManager().start(...)`; we stub the singleton so each trigger
+// is observable without spinning up the real engine.
+const workflowStartCalls: Array<Record<string, unknown>> = [];
+let workflowStartImpl: (opts: Record<string, unknown>) => { runId: string } = (
+  opts,
+) => {
+  workflowStartCalls.push(opts);
+  return { runId: "wf-run-1" };
+};
+mock.module("../workflows/run-manager.js", () => ({
+  getWorkflowRunManager: () => ({
+    start: (opts: Record<string, unknown>) => workflowStartImpl(opts),
+  }),
+}));
+
 // Capture `emitNotificationSignal` calls so tests can assert that scheduled
 // task failures surface via the notification pipeline (home feed + native).
 const emitNotificationCalls: Array<Record<string, unknown>> = [];
@@ -60,11 +76,21 @@ mock.module("../notifications/emit-signal.js", () => ({
   },
 }));
 
+// Control the tool-registry readiness gate the scheduler checks before launching
+// workflow schedules. Default ready=true so the existing workflow-mode tests are
+// unaffected; one test flips it to exercise the boot-time deferral path. Only the
+// scheduler consumes registry in this test's graph, so a minimal mock suffices.
+let coreToolsReady = true;
+mock.module("../tools/registry.js", () => ({
+  areCoreToolsInitialized: () => coreToolsReady,
+}));
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { recordUsageEvent } from "../memory/llm-usage-store.js";
 import {
   createSchedule,
+  deferClaimedSchedule,
   getSchedule,
   getScheduleRuns,
 } from "../schedule/schedule-store.js";
@@ -460,3 +486,276 @@ describe("scheduler run_task detection", () => {
     });
   });
 });
+
+// ── Workflow mode dispatch ──────────────────────────────────────────
+
+describe("scheduler workflow mode", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+    workflowStartCalls.length = 0;
+    workflowStartImpl = (opts) => {
+      workflowStartCalls.push(opts);
+      return { runId: "wf-run-1" };
+    };
+    coreToolsReady = true;
+  });
+
+  test("a due workflow-mode job triggers the run manager with name/args", async () => {
+    const schedule = createSchedule({
+      name: "Triage inbox",
+      cronExpression: "0 9 * * *",
+      message: "triage",
+      syntax: "cron",
+      mode: "workflow",
+      workflowName: "triage-inbox",
+      workflowArgs: { folder: "primary" },
+      wakeConversationId: "conv-origin",
+    });
+    forceScheduleDue(schedule.id);
+
+    const result = await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+
+    expect(result.completed).toBe(1);
+    expect(result.failed).toBe(0);
+    expect(workflowStartCalls).toHaveLength(1);
+    expect(workflowStartCalls[0]).toMatchObject({
+      name: "triage-inbox",
+      args: { folder: "primary" },
+      conversationId: "conv-origin",
+      manifest: { tools: [], hostFunctions: [], persona: false },
+    });
+
+    const runs = getScheduleRuns(schedule.id);
+    expect(runs).toHaveLength(1);
+    expect(runs[0].status).toBe("ok");
+  });
+
+  test("fires with the schedule's stored side-effecting manifest", async () => {
+    const schedule = createSchedule({
+      name: "Side-effecting workflow",
+      cronExpression: "0 9 * * *",
+      message: "go",
+      syntax: "cron",
+      mode: "workflow",
+      workflowName: "send-report",
+      capabilities: {
+        tools: ["file_write"],
+        hostFunctions: ["notify"],
+        persona: true,
+      },
+    });
+    forceScheduleDue(schedule.id);
+
+    await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+
+    expect(workflowStartCalls).toHaveLength(1);
+    expect(workflowStartCalls[0]).toMatchObject({
+      manifest: {
+        tools: ["file_write"],
+        hostFunctions: ["notify"],
+        persona: true,
+      },
+    });
+  });
+
+  test("a legacy schedule (null capabilities) fires with the read-only baseline", async () => {
+    const schedule = createSchedule({
+      name: "Legacy workflow",
+      cronExpression: "0 9 * * *",
+      message: "go",
+      syntax: "cron",
+      mode: "workflow",
+      workflowName: "digest",
+      capabilities: null,
+    });
+    forceScheduleDue(schedule.id);
+
+    await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+
+    expect(workflowStartCalls).toHaveLength(1);
+    expect(workflowStartCalls[0]).toMatchObject({
+      manifest: { tools: [], hostFunctions: [], persona: false },
+    });
+  });
+
+  test("falls back to createdFromConversationId for the completion wake", async () => {
+    // Workflow schedules created via schedule_create store the originating
+    // conversation as createdFromConversationId and leave wakeConversationId
+    // unset; without the fallback the completion summary lands nowhere.
+    const schedule = createSchedule({
+      name: "Morning digest",
+      cronExpression: "0 9 * * *",
+      message: "",
+      syntax: "cron",
+      mode: "workflow",
+      workflowName: "digest",
+      createdFromConversationId: "conv-creator",
+    });
+    forceScheduleDue(schedule.id);
+
+    await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+
+    expect(workflowStartCalls).toHaveLength(1);
+    expect(workflowStartCalls[0]).toMatchObject({
+      conversationId: "conv-creator",
+    });
+  });
+
+  test("prefers an explicit wakeConversationId over createdFromConversationId", async () => {
+    const schedule = createSchedule({
+      name: "Both set",
+      cronExpression: "0 9 * * *",
+      message: "",
+      syntax: "cron",
+      mode: "workflow",
+      workflowName: "digest",
+      wakeConversationId: "conv-wake",
+      createdFromConversationId: "conv-creator",
+    });
+    forceScheduleDue(schedule.id);
+
+    await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+
+    expect(workflowStartCalls[0]).toMatchObject({
+      conversationId: "conv-wake",
+    });
+  });
+
+  test("defaults workflowArgs to {} when unset", async () => {
+    const schedule = createSchedule({
+      name: "No-args workflow",
+      cronExpression: "0 9 * * *",
+      message: "go",
+      syntax: "cron",
+      mode: "workflow",
+      workflowName: "nightly",
+    });
+    forceScheduleDue(schedule.id);
+
+    await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+
+    expect(workflowStartCalls).toHaveLength(1);
+    expect(workflowStartCalls[0].args).toEqual({});
+  });
+
+  test("records an error and skips when start() throws", async () => {
+    workflowStartImpl = () => {
+      throw new Error("workflows disabled");
+    };
+    const schedule = createSchedule({
+      name: "Failing workflow",
+      cronExpression: "0 9 * * *",
+      message: "go",
+      syntax: "cron",
+      mode: "workflow",
+      workflowName: "broken",
+    });
+    forceScheduleDue(schedule.id);
+
+    const result = await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+
+    expect(result.failed).toBe(1);
+    const runs = getScheduleRuns(schedule.id);
+    expect(runs[0].status).toBe("error");
+    expect(runs[0].error).toContain("workflows disabled");
+  });
+
+  test("skips a workflow-mode job with no workflowName", async () => {
+    const schedule = createSchedule({
+      name: "Nameless workflow",
+      cronExpression: "0 9 * * *",
+      message: "go",
+      syntax: "cron",
+      mode: "workflow",
+    });
+    forceScheduleDue(schedule.id);
+
+    const result = await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+
+    expect(result.skipped).toBe(1);
+    expect(workflowStartCalls).toHaveLength(0);
+  });
+
+  test("defers a due workflow job until tools are registered, then fires it", async () => {
+    coreToolsReady = false;
+    const schedule = createSchedule({
+      name: "Boot workflow",
+      cronExpression: "0 9 * * *",
+      message: "go",
+      syntax: "cron",
+      mode: "workflow",
+      workflowName: "triage-inbox",
+    });
+    forceScheduleDue(schedule.id);
+
+    // Tools not yet registered: the run must be deferred, not launched with an
+    // empty baseline. No run-manager start, no run record, marked skipped.
+    const result = await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+    expect(workflowStartCalls).toHaveLength(0);
+    expect(result.skipped).toBe(1);
+    expect(getScheduleRuns(schedule.id)).toHaveLength(0);
+
+    // Re-armed to due (not consumed): once tools are ready, a later tick fires
+    // it with the full baseline.
+    coreToolsReady = true;
+    await runScheduleDueWorkOnce(
+      async () => {},
+      () => {},
+    );
+    expect(workflowStartCalls).toHaveLength(1);
+    expect(workflowStartCalls[0]).toMatchObject({ name: "triage-inbox" });
+  });
+
+  test("deferring a final/disabled occurrence re-enables it so it isn't lost", async () => {
+    // claimDueSchedules disables a row whose claimed occurrence was its last
+    // (one-shot / exhausted finite RRULE). The due-claim query requires
+    // enabled=true, so a deferred final occurrence must be re-enabled or it is
+    // never re-claimed. Simulate that disabled-on-claim state, then defer.
+    const schedule = createSchedule({
+      name: "Final workflow occurrence",
+      cronExpression: "0 9 * * *",
+      message: "",
+      syntax: "cron",
+      mode: "workflow",
+      workflowName: "digest",
+      enabled: false, // as claimDueSchedules leaves a last occurrence
+    });
+    expect(getSchedule(schedule.id)?.enabled).toBe(false);
+
+    deferClaimedSchedule(schedule.id);
+
+    const after = getSchedule(schedule.id);
+    expect(after?.enabled).toBe(true);
+    expect(after?.status).toBe("active");
+    expect(after?.nextRunAt).toBeLessThanOrEqual(Date.now());
+  });
+});