@vellumai/assistant 0.7.1 → 0.7.3

package/src/__tests__/conversation-agent-loop.test.ts

@@ -20,6 +20,7 @@ const conversationDiskViewRealSnapshot = {
     "../memory/conversation-disk-view.js",
   ) as Record<string, unknown>),
 };
+let mockUiConfig: { userTimezone?: string; detectedTimezone?: string } = {};
 
 // ── Module mocks (must precede imports of the module under test) ─────
 
@@ -60,7 +61,7 @@ mock.module("../config/loader.js", () => ({
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
-    ui: {},
+    ui: mockUiConfig,
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
@@ -125,6 +126,34 @@ mock.module("../daemon/context-overflow-policy.js", () => ({
   resolveOverflowAction: () => mockOverflowAction,
 }));
 
+const mockDiskPressureStatus = {
+  enabled: true,
+  state: "critical",
+  locked: true,
+  acknowledged: true,
+  overrideActive: false,
+  effectivelyLocked: true,
+  lockId: "disk-pressure-test",
+  usagePercent: 98,
+  thresholdPercent: 95,
+  path: "/workspace",
+  lastCheckedAt: "2026-05-05T00:00:00.000Z",
+  blockedCapabilities: ["agent-turns", "background-work", "remote-ingress"],
+  error: null,
+};
+let mockDiskPressureDecision: Record<string, unknown> = {
+  action: "allow-normal",
+};
+const classifyDiskPressureTurnPolicyMock = mock(
+  (_status: unknown, _metadata: unknown) => mockDiskPressureDecision,
+);
+mock.module("../daemon/disk-pressure-guard.js", () => ({
+  getDiskPressureStatus: () => mockDiskPressureStatus,
+}));
+mock.module("../daemon/disk-pressure-policy.js", () => ({
+  classifyDiskPressureTurnPolicy: classifyDiskPressureTurnPolicyMock,
+}));
+
 const updateMessageMetadataMock = mock(
   (_id: string, _updates: Record<string, unknown>) => {},
 );
@@ -144,6 +173,7 @@ let mockConversationRow: Record<string, unknown> = {
   totalEstimatedCost: 0,
   title: null,
 };
+let mockMessageById: Record<string, unknown> | null = null;
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationUsage: () => {},
@@ -164,7 +194,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     updateConversationSlackContextWatermarkMock,
   updateConversationTitle: () => {},
   getConversationOriginChannel: () => null,
-  getMessageById: () => null,
+  getMessageById: () => mockMessageById,
   getLastUserTimestampBefore: () => 0,
 }));
 
@@ -237,6 +267,10 @@ let mockInjectionBlocks: {
   pkbSystemReminder?: string;
   unifiedTurnContext?: string;
 } = {};
+const buildUnifiedTurnContextBlockMock = mock(
+  (options: Record<string, unknown>) =>
+    `<turn_context>\ncurrent_time: ${String(options.timestamp)}\n</turn_context>`,
+);
 const applyRuntimeInjectionsMock = mock(
   async (msgs: Message[], _options?: unknown) => ({
     messages: msgs,
@@ -278,6 +312,7 @@ const getSlackCompactionWatermarkForPrefixMock = mock(
 );
 mock.module("../daemon/conversation-runtime-assembly.js", () => ({
   applyRuntimeInjections: applyRuntimeInjectionsMock,
+  buildUnifiedTurnContextBlock: buildUnifiedTurnContextBlockMock,
   stripInjectionsForCompaction: (msgs: Message[]) => msgs,
   findLastInjectedNowContent: () => null,
   readNowScratchpad: () => null,
@@ -298,8 +333,40 @@ mock.module("../daemon/conversation-runtime-assembly.js", () => ({
   assembleSlackActiveThreadFocusBlock: () => null,
 }));
 
+const resolveTurnTimezoneContextMock = mock(
+  (options: {
+    configuredUserTimeZone?: string | null;
+    clientTimezone?: string | null;
+    detectedTimezone?: string | null;
+    hostTimeZone?: string | null;
+  }) => ({
+    configuredUserTimezone: options.configuredUserTimeZone ?? null,
+    clientTimezone: options.clientTimezone ?? null,
+    detectedTimezone: options.detectedTimezone ?? null,
+    hostTimezone: options.hostTimeZone ?? "UTC",
+    effectiveTimezone:
+      options.configuredUserTimeZone ??
+      options.clientTimezone ??
+      options.detectedTimezone ??
+      options.hostTimeZone ??
+      "UTC",
+    source: options.configuredUserTimeZone
+      ? "configuredUserTimezone"
+      : options.clientTimezone
+        ? "clientTimezone"
+        : options.detectedTimezone
+          ? "detectedTimezone"
+          : options.hostTimeZone
+            ? "hostTimezone"
+            : "utcFallback",
+  }),
+);
+const formatTurnTimestampMock = mock(
+  (_options?: unknown) => "2026-01-01 (Thursday) 00:00:00 +00:00 (UTC)",
+);
 mock.module("../daemon/date-context.js", () => ({
-  formatTurnTimestamp: () => "2026-01-01 (Thursday) 00:00:00 +00:00 (UTC)",
+  formatTurnTimestamp: formatTurnTimestampMock,
+  resolveTurnTimezoneContext: resolveTurnTimezoneContextMock,
 }));
 
 mock.module("../daemon/history-repair.js", () => ({
@@ -416,6 +483,17 @@ mock.module("../memory/llm-request-log-store.js", () => ({
   backfillMessageIdOnLogs: () => {},
 }));
 
+let mockHasProactiveArtifactCompleted = true;
+let mockTryClaimProactiveArtifactTrigger = false;
+const runProactiveArtifactJobMock = mock(
+  async (_params: Record<string, unknown>) => {},
+);
+mock.module("../proactive-artifact/index.js", () => ({
+  hasProactiveArtifactCompleted: () => mockHasProactiveArtifactCompleted,
+  tryClaimProactiveArtifactTrigger: () => mockTryClaimProactiveArtifactTrigger,
+  runProactiveArtifactJob: runProactiveArtifactJobMock,
+}));
+
 // ── Imports (after mocks) ────────────────────────────────────────────
 
 import {
@@ -428,7 +506,7 @@ import {
 
 type AgentLoopRun = (
   messages: Message[],
-  onEvent: (event: AgentEvent) => void,
+  onEvent: (event: AgentEvent) => void | Promise<void>,
   signal?: AbortSignal,
   requestId?: string,
   onCheckpoint?: (
@@ -569,9 +647,12 @@ function makeCtx(
 // ── Tests ────────────────────────────────────────────────────────────
 
 beforeEach(() => {
+  mockUiConfig = {};
   mockEstimateTokens = 1000;
   mockReducerStepFn = null;
   mockOverflowAction = "fail_gracefully";
+  mockDiskPressureDecision = { action: "allow-normal" };
+  classifyDiskPressureTurnPolicyMock.mockClear();
   mockInjectionBlocks = {};
   recordUsageMock.mockClear();
   recordRequestLogMock.mockClear();
@@ -591,11 +672,18 @@ beforeEach(() => {
     totalEstimatedCost: 0,
     title: null,
   };
+  mockMessageById = null;
+  mockHasProactiveArtifactCompleted = true;
+  mockTryClaimProactiveArtifactTrigger = false;
+  runProactiveArtifactJobMock.mockClear();
   clearStrippedInjectionMetadataForConversationMock.mockClear();
   clearStrippedInjectionMetadataForConversationMock.mockImplementation(
     () => {},
   );
   applyRuntimeInjectionsMock.mockClear();
+  buildUnifiedTurnContextBlockMock.mockClear();
+  resolveTurnTimezoneContextMock.mockClear();
+  formatTurnTimestampMock.mockClear();
   mockSlackChronologicalContext = null;
   loadSlackChronologicalContextMock.mockClear();
   getSlackCompactionWatermarkForPrefixMock.mockClear();
@@ -608,6 +696,56 @@ beforeEach(() => {
 });
 
 describe("session-agent-loop", () => {
+  describe("timezone turn context", () => {
+    test("passes ctx.clientTimezone and ui.detectedTimezone into timezone resolution", async () => {
+      mockUiConfig = {
+        userTimezone: "America/New_York",
+        detectedTimezone: "America/Chicago",
+      };
+      const ctx = makeCtx({ clientTimezone: "America/Los_Angeles" });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(resolveTurnTimezoneContextMock).toHaveBeenCalled();
+      const timezoneOptions = resolveTurnTimezoneContextMock.mock.calls[0]?.[0];
+      expect(timezoneOptions).toMatchObject({
+        configuredUserTimeZone: "America/New_York",
+        clientTimezone: "America/Los_Angeles",
+        detectedTimezone: "America/Chicago",
+      });
+    });
+
+    test("passes resolved canonical timezones into unified turn context", async () => {
+      mockUiConfig = {
+        userTimezone: "US/Eastern",
+        detectedTimezone: "US/Central",
+      };
+      resolveTurnTimezoneContextMock.mockImplementationOnce(() => ({
+        configuredUserTimezone: "America/New_York",
+        clientTimezone: "America/Los_Angeles",
+        detectedTimezone: "America/Chicago",
+        hostTimezone: "America/Denver",
+        effectiveTimezone: "America/New_York",
+        source: "configuredUserTimezone",
+      }));
+      const ctx = makeCtx({ clientTimezone: "US/Pacific" });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(formatTurnTimestampMock).toHaveBeenCalledWith({
+        timeZone: "America/New_York",
+      });
+      expect(buildUnifiedTurnContextBlockMock).toHaveBeenCalled();
+      const turnContextOptions =
+        buildUnifiedTurnContextBlockMock.mock.calls[0]?.[0];
+      expect(turnContextOptions).toMatchObject({
+        configuredUserTimezone: "America/New_York",
+        clientTimezone: "America/Los_Angeles",
+        detectedTimezone: "America/Chicago",
+      });
+    });
+  });
+
   describe("pre-flight checks", () => {
     test("throws if called without an abortController", async () => {
       const ctx = makeCtx();
@@ -618,6 +756,304 @@ describe("session-agent-loop", () => {
     });
   });
 
+  describe("proactive artifact trigger", () => {
+    test("suppresses proactive app build when the foreground turn used app tools", async () => {
+      mockConversationRow = {
+        ...mockConversationRow,
+        id: "test-conv",
+        conversationType: "standard",
+      };
+      mockMessageById = {
+        id: "user-msg-1",
+        conversationId: "test-conv",
+        createdAt: 1000,
+      };
+      mockHasProactiveArtifactCompleted = false;
+      mockTryClaimProactiveArtifactTrigger = true;
+
+      const agentLoopRun: AgentLoopRun = async (
+        messages,
+        onEvent,
+        _signal,
+        _requestId,
+        onCheckpoint,
+      ) => {
+        await onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "I'll build that app." }],
+          },
+        });
+        await onEvent({
+          type: "tool_use",
+          id: "tool-1",
+          name: "app_create",
+          input: { name: "Flow" },
+        });
+        await onEvent({
+          type: "tool_result",
+          toolUseId: "tool-1",
+          content: "{}",
+          isError: false,
+        });
+        await onCheckpoint?.({
+          turnIndex: 0,
+          toolCount: 1,
+          hasToolUse: true,
+          history: messages,
+        });
+        await onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "Done." }],
+          },
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text" as const, text: "Done." }],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({
+        conversationId: "test-conv",
+        agentLoopRun,
+      });
+      await runAgentLoopImpl(
+        ctx,
+        "build a kanban app",
+        "user-msg-1",
+        () => {},
+        {
+          isUserMessage: true,
+        },
+      );
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(runProactiveArtifactJobMock).toHaveBeenCalledTimes(1);
+      expect(runProactiveArtifactJobMock.mock.calls[0]?.[0]).toMatchObject({
+        conversationId: "test-conv",
+        suppressAppBuild: true,
+      });
+    });
+  });
+
+  describe("disk pressure injection context", () => {
+    test("passes cleanup context into runtime injections for cleanup-mode turns", async () => {
+      mockDiskPressureDecision = {
+        action: "allow-cleanup-mode",
+        reason: "guardian",
+      };
+      mockConversationRow = {
+        ...mockConversationRow,
+        conversationType: "standard",
+        source: "user",
+      };
+      const ctx = makeCtx({
+        channelCapabilities: {
+          channel: "telegram",
+          dashboardCapable: false,
+          supportsDynamicUi: false,
+          supportsVoiceInput: false,
+          chatType: "private",
+        },
+        trustContext: {
+          sourceChannel: "telegram",
+          trustClass: "guardian",
+        } as AgentLoopConversationContext["trustContext"],
+      });
+
+      await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {});
+
+      expect(classifyDiskPressureTurnPolicyMock).toHaveBeenCalledWith(
+        mockDiskPressureStatus,
+        expect.objectContaining({
+          callSite: "mainAgent",
+          conversationSource: "user",
+          conversationType: "standard",
+          isInteractive: true,
+          sourceChannel: "telegram",
+          sourceInterface: "web",
+          trustContext: {
+            sourceChannel: "telegram",
+            trustClass: "guardian",
+          },
+        }),
+      );
+      const firstInjectionOptions = applyRuntimeInjectionsMock.mock
+        .calls[0]![1] as {
+        diskPressureContext?: { cleanupModeActive: boolean } | null;
+      };
+      expect(firstInjectionOptions.diskPressureContext).toEqual({
+        cleanupModeActive: true,
+      });
+    });
+
+    test("passes cleanup context into runtime injections for local-owner turns", async () => {
+      mockDiskPressureDecision = {
+        action: "allow-cleanup-mode",
+        reason: "local-owner",
+      };
+      const ctx = makeCtx();
+
+      await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {});
+
+      expect(classifyDiskPressureTurnPolicyMock).toHaveBeenCalledWith(
+        mockDiskPressureStatus,
+        expect.objectContaining({
+          sourceChannel: "vellum",
+          sourceInterface: "web",
+          trustContext: null,
+        }),
+      );
+      const firstInjectionOptions = applyRuntimeInjectionsMock.mock
+        .calls[0]![1] as {
+        diskPressureContext?: { cleanupModeActive: boolean } | null;
+      };
+      expect(firstInjectionOptions.diskPressureContext).toEqual({
+        cleanupModeActive: true,
+      });
+    });
+
+    test("keeps cleanup context on overflow recovery reinjection", async () => {
+      mockDiskPressureDecision = {
+        action: "allow-cleanup-mode",
+        reason: "guardian",
+      };
+      mockEstimateTokens = 96000;
+      mockReducerStepFn = (msgs: Message[]) => ({
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: ["forced_compaction"],
+          injectionMode: "full",
+          exhausted: true,
+        },
+        estimatedTokens: 50000,
+      });
+      const ctx = makeCtx({
+        trustContext: {
+          sourceChannel: "telegram",
+          trustClass: "guardian",
+        } as AgentLoopConversationContext["trustContext"],
+      });
+
+      await runAgentLoopImpl(ctx, "free up space", "msg-1", () => {});
+
+      expect(applyRuntimeInjectionsMock.mock.calls.length).toBeGreaterThan(1);
+      for (const call of applyRuntimeInjectionsMock.mock.calls) {
+        const options = call[1] as {
+          diskPressureContext?: { cleanupModeActive: boolean } | null;
+        };
+        expect(options.diskPressureContext).toEqual({
+          cleanupModeActive: true,
+        });
+      }
+    });
+
+    test("blocks policy-denied turns before runtime injection or model execution", async () => {
+      mockDiskPressureDecision = {
+        action: "block",
+        reason: "trusted-contact",
+      };
+      const events: ServerMessage[] = [];
+      const agentLoopRun = mock(async (_messages: Message[]) => {
+        throw new Error("agent loop should not run");
+      });
+      const activityStates: unknown[][] = [];
+      const traceEvents: unknown[][] = [];
+      const ctx = makeCtx({
+        emitActivityState: (...args: unknown[]) => {
+          activityStates.push(args);
+        },
+        traceEmitter: {
+          emit: (...args: unknown[]) => {
+            traceEvents.push(args);
+          },
+        } as unknown as AgentLoopConversationContext["traceEmitter"],
+      });
+      ctx.agentLoop.run = agentLoopRun as AgentLoopRun;
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      expect(agentLoopRun).not.toHaveBeenCalled();
+      expect(applyRuntimeInjectionsMock).not.toHaveBeenCalled();
+      expect(activityStates).toContainEqual([
+        "idle",
+        "error_terminal",
+        "global",
+        "test-req",
+      ]);
+      expect(traceEvents[0]).toEqual([
+        "request_error",
+        expect.stringContaining("Storage is critically low"),
+        expect.objectContaining({
+          requestId: "test-req",
+          status: "error",
+          attributes: expect.objectContaining({
+            errorCategory: "disk_pressure",
+            errorCode: "DISK_SPACE_CRITICAL",
+            diskPressureReason: "trusted-contact",
+          }),
+        }),
+      ]);
+      expect(events.find((event) => event.type === "error")).toMatchObject({
+        type: "error",
+        conversationId: "test-conv",
+        requestId: "test-req",
+        code: "DISK_SPACE_CRITICAL",
+        category: "disk_pressure",
+        message: expect.stringContaining("remote messages are ignored"),
+      });
+      expect(
+        events.find((event) => event.type === "conversation_error"),
+      ).toMatchObject({
+        type: "conversation_error",
+        conversationId: "test-conv",
+        code: "DISK_SPACE_CRITICAL",
+        retryable: true,
+        errorCategory: "disk_pressure",
+        userMessage: expect.stringContaining("remote messages are ignored"),
+      });
+    });
+
+    test("blocked background turns clear processing state and drain the queue", async () => {
+      mockDiskPressureDecision = {
+        action: "block",
+        reason: "background",
+      };
+      const drainQueue = mock(async (_reason: unknown) => {});
+      const activityStates: unknown[][] = [];
+      const ctx = makeCtx({
+        drainQueue,
+        emitActivityState: (...args: unknown[]) => {
+          activityStates.push(args);
+        },
+      });
+
+      await runAgentLoopImpl(ctx, "background task", "msg-1", () => {}, {
+        callSite: "memoryConsolidation",
+        isInteractive: false,
+      });
+
+      expect(applyRuntimeInjectionsMock).not.toHaveBeenCalled();
+      expect(ctx.processing).toBe(false);
+      expect(ctx.abortController).toBeNull();
+      expect(ctx.currentRequestId).toBeUndefined();
+      expect(drainQueue).toHaveBeenCalledWith("loop_complete");
+      expect(activityStates).toContainEqual([
+        "idle",
+        "error_terminal",
+        "global",
+        "test-req",
+      ]);
+    });
+  });
+
   describe("tool execution errors via agent loop", () => {
     test("error events from agent loop are classified and emitted", async () => {
       const events: ServerMessage[] = [];
@@ -2095,16 +2531,29 @@ describe("session-agent-loop", () => {
     });
 
     test("clears state even when agent loop throws", async () => {
+      const events: ServerMessage[] = [];
       const ctx = makeCtx({
         agentLoopRun: async () => {
           throw new Error("unexpected crash");
         },
       });
 
-      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+      await runAgentLoopImpl(ctx, "hi", "msg-1", (msg) => events.push(msg));
 
       expect(ctx.processing).toBe(false);
       expect(ctx.abortController).toBeNull();
+      expect(events.find((event) => event.type === "error")).toMatchObject({
+        type: "error",
+        code: "CONVERSATION_PROCESSING_FAILED",
+        errorCategory: "processing_failed",
+      });
+      expect(
+        events.find((event) => event.type === "conversation_error"),
+      ).toMatchObject({
+        type: "conversation_error",
+        code: "CONVERSATION_PROCESSING_FAILED",
+        errorCategory: "processing_failed",
+      });
     });
 
     test("drains queue after completion", async () => {