@vellumai/assistant 0.4.43 → 0.4.45

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

@@ -10,7 +10,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
@@ -34,10 +33,6 @@ import {
 } from "../schedule/schedule-store.js";
 import { startScheduler } from "../schedule/scheduler.js";
 import { createTask } from "../tasks/task-store.js";
-import {
-  getReminder,
-  insertReminder,
-} from "../tools/reminder/reminder-store.js";
 
 initializeDb();
 
@@ -97,7 +92,6 @@ describe("scheduler RRULE execution", () => {
     const db = getDb();
     db.run("DELETE FROM cron_runs");
     db.run("DELETE FROM cron_jobs");
-    db.run("DELETE FROM reminders");
     db.run("DELETE FROM task_runs");
     db.run("DELETE FROM tasks");
     db.run("DELETE FROM messages");
@@ -545,31 +539,71 @@ describe("scheduler RRULE execution", () => {
     expect(after!.lastRunAt).not.toBeNull();
   });
 
-  test("notify reminder passes routing metadata to notifyReminder callback", async () => {
-    const reminder = insertReminder({
-      label: "Route this reminder",
-      message: "Reminder body",
-      fireAt: Date.now() - 1000,
+  // ── One-shot schedule tests ───────────────────────────────────────
+
+  test("one-shot execute mode fires and marks schedule as fired", async () => {
+    const schedule = createSchedule({
+      name: "One-shot execute",
+      message: "Execute this once",
+      mode: "execute",
+      nextRunAt: Date.now() - 1000,
+      // No expression = one-shot
+    });
+
+    expect(getSchedule(schedule.id)!.status).toBe("active");
+
+    const processedMessages: { conversationId: string; message: string }[] = [];
+    const processMessage = async (conversationId: string, message: string) => {
+      processedMessages.push({ conversationId, message });
+    };
+
+    const scheduler = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    expect(
+      processedMessages.some((m) => m.message === "Execute this once"),
+    ).toBe(true);
+
+    const after = getSchedule(schedule.id);
+    expect(after).not.toBeNull();
+    expect(after!.status).toBe("fired");
+    expect(after!.enabled).toBe(false);
+
+    // A cron_runs entry should have been created
+    const runs = getScheduleRuns(schedule.id);
+    expect(runs.length).toBeGreaterThanOrEqual(1);
+    expect(runs[0].status).toBe("ok");
+  });
+
+  test("one-shot notify mode emits notification and marks schedule as fired", async () => {
+    const schedule = createSchedule({
+      name: "One-shot notify",
+      message: "Notify about this",
       mode: "notify",
+      nextRunAt: Date.now() - 1000,
       routingIntent: "multi_channel",
-      routingHints: {
-        requestedByUser: true,
-        channelMentions: ["telegram", "slack"],
-      },
+      routingHints: { channel: "slack" },
     });
 
+    expect(getSchedule(schedule.id)!.status).toBe("active");
+
     const notifyCalls: Array<{
       id: string;
       label: string;
       message: string;
-      routingIntent: "single_channel" | "multi_channel" | "all_channels";
+      routingIntent: string;
       routingHints: Record<string, unknown>;
     }> = [];
-    const notifyReminder = (payload: {
+    const notifyScheduleOneShot = (payload: {
       id: string;
       label: string;
       message: string;
-      routingIntent: "single_channel" | "multi_channel" | "all_channels";
+      routingIntent: string;
       routingHints: Record<string, unknown>;
     }) => {
       notifyCalls.push(payload);
@@ -577,7 +611,7 @@ describe("scheduler RRULE execution", () => {
 
     const scheduler = startScheduler(
       async () => {},
-      notifyReminder,
+      notifyScheduleOneShot,
       () => {},
     );
     await new Promise((resolve) => setTimeout(resolve, 500));
@@ -585,15 +619,154 @@ describe("scheduler RRULE execution", () => {
 
     expect(notifyCalls).toHaveLength(1);
     expect(notifyCalls[0]).toEqual({
-      id: reminder.id,
-      label: reminder.label,
-      message: reminder.message,
+      id: schedule.id,
+      label: "One-shot notify",
+      message: "Notify about this",
       routingIntent: "multi_channel",
+      routingHints: { channel: "slack" },
+    });
+
+    const after = getSchedule(schedule.id);
+    expect(after).not.toBeNull();
+    expect(after!.status).toBe("fired");
+    expect(after!.enabled).toBe(false);
+  });
+
+  test("one-shot failure reverts to active for retry", async () => {
+    const schedule = createSchedule({
+      name: "One-shot fail",
+      message: "This will fail",
+      mode: "execute",
+      nextRunAt: Date.now() - 1000,
+    });
+
+    expect(getSchedule(schedule.id)!.status).toBe("active");
+
+    const processMessage = async () => {
+      throw new Error("Simulated failure");
+    };
+
+    const scheduler = startScheduler(
+      processMessage,
+      () => {},
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    const after = getSchedule(schedule.id);
+    expect(after).not.toBeNull();
+    expect(after!.status).toBe("active");
+    expect(after!.enabled).toBe(true);
+  });
+
+  test("recurring + notify mode emits notification and continues recurring", async () => {
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "Recurring notify",
+      cronExpression: rruleExpr,
+      message: "Recurring notification",
+      syntax: "rrule",
+      expression: rruleExpr,
+      mode: "notify",
+      routingIntent: "single_channel",
+      routingHints: { preferred: "email" },
+    });
+
+    forceScheduleDue(schedule.id);
+
+    const notifyCalls: Array<{
+      id: string;
+      label: string;
+      message: string;
+      routingIntent: string;
+      routingHints: Record<string, unknown>;
+    }> = [];
+    const notifyScheduleOneShot = (payload: {
+      id: string;
+      label: string;
+      message: string;
+      routingIntent: string;
+      routingHints: Record<string, unknown>;
+    }) => {
+      notifyCalls.push(payload);
+    };
+
+    const scheduler = startScheduler(
+      async () => {},
+      notifyScheduleOneShot,
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    expect(notifyCalls).toHaveLength(1);
+    expect(notifyCalls[0]).toEqual({
+      id: schedule.id,
+      label: "Recurring notify",
+      message: "Recurring notification",
+      routingIntent: "single_channel",
+      routingHints: { preferred: "email" },
+    });
+
+    // Schedule should remain enabled and have a future nextRunAt (not fired/disabled)
+    const after = getSchedule(schedule.id);
+    expect(after).not.toBeNull();
+    expect(after!.enabled).toBe(true);
+    expect(after!.nextRunAt).toBeGreaterThan(Date.now() - 5000);
+    // Status should still be "active" (not "fired")
+    expect(after!.status).toBe("active");
+  });
+
+  test("one-shot notify mode passes routing intent and hints to notifier", async () => {
+    const schedule = createSchedule({
+      name: "Routing test",
+      message: "Check routing",
+      mode: "notify",
+      nextRunAt: Date.now() - 1000,
+      routingIntent: "all_channels",
       routingHints: {
         requestedByUser: true,
         channelMentions: ["telegram", "slack"],
+        priority: "high",
       },
     });
-    expect(getReminder(reminder.id)?.status).toBe("fired");
+
+    const notifyCalls: Array<{
+      id: string;
+      label: string;
+      message: string;
+      routingIntent: string;
+      routingHints: Record<string, unknown>;
+    }> = [];
+    const notifyScheduleOneShot = (payload: {
+      id: string;
+      label: string;
+      message: string;
+      routingIntent: string;
+      routingHints: Record<string, unknown>;
+    }) => {
+      notifyCalls.push(payload);
+    };
+
+    const scheduler = startScheduler(
+      async () => {},
+      notifyScheduleOneShot,
+      () => {},
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    expect(notifyCalls).toHaveLength(1);
+    expect(notifyCalls[0].routingIntent).toBe("all_channels");
+    expect(notifyCalls[0].routingHints).toEqual({
+      requestedByUser: true,
+      channelMentions: ["telegram", "slack"],
+      priority: "high",
+    });
+
+    // Should be marked as fired
+    const after = getSchedule(schedule.id);
+    expect(after!.status).toBe("fired");
   });
 });

package/src/__tests__/scoped-approval-grants.test.ts

@@ -10,7 +10,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/scoped-grant-security-matrix.test.ts

@@ -35,7 +35,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

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

@@ -1,6 +1,9 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { SecretRequest, ServerMessage } from "../daemon/message-protocol.js";
+import type {
+  SecretRequest,
+  ServerMessage,
+} from "../daemon/message-protocol.js";
 
 // Capture all logger calls so we can verify secret values never appear
 const logCalls: Array<{ level: string; args: unknown[] }> = [];
@@ -100,10 +103,10 @@ describe("secret prompt log hygiene", () => {
     }
   });
 
-  test("sent IPC message contains value=undefined (value flows through IPC, not logs)", async () => {
+  test("sent message contains value=undefined (value flows through event, not logs)", async () => {
     const promise = prompter.prompt("svc", "tok", "Token");
     const msg = sentMessages[0] as SecretRequest & { value?: unknown };
-    // The IPC message should NOT contain a value field
+    // The message should NOT contain a value field
     expect(msg.value).toBeUndefined();
     prompter.resolveSecret(msg.requestId, undefined);
     await promise;

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

@@ -1,6 +1,9 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import type { SecretRequest, ServerMessage } from "../daemon/message-protocol.js";
+import type {
+  SecretRequest,
+  ServerMessage,
+} from "../daemon/message-protocol.js";
 import type { SecretPromptResult } from "../permissions/secret-prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 

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

@@ -29,7 +29,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
@@ -53,6 +52,7 @@ mock.module("../config/loader.js", () => ({
     memory: { enabled: false },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     secretDetection: { enabled: false },
+    contextWindow: { maxInputTokens: 200000 },
   }),
 }));
 
@@ -65,7 +65,7 @@ mock.module("../runtime/guardian-vellum-migration.js", () => ({
 // Mock local-actor-identity to return a stable guardian context that uses
 // the same principal as the canonical requests created in tests.
 mock.module("../runtime/local-actor-identity.js", () => ({
-  resolveLocalIpcTrustContext: () => ({
+  resolveLocalTrustContext: () => ({
     sourceChannel: "vellum",
     trustClass: "guardian",
     guardianPrincipalId: "test-principal-id",
@@ -112,8 +112,11 @@ function makeCompletingSession(): Session {
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
-    setStateSignalListener: () => {},
+    ensureActorScopedHistory: async () => {},
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
+    setHostBashProxy: () => {},
+    setHostFileProxy: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
@@ -165,8 +168,11 @@ function makeHangingSession(): Session {
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
-    setStateSignalListener: () => {},
+    ensureActorScopedHistory: async () => {},
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
+    setHostBashProxy: () => {},
+    setHostFileProxy: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
@@ -246,8 +252,11 @@ function makePendingApprovalSession(
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
-    setStateSignalListener: () => {},
+    ensureActorScopedHistory: async () => {},
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
+    setHostBashProxy: () => {},
+    setHostFileProxy: () => {},
     hasAnyPendingConfirmation: () => pending.size > 0,
     hasPendingConfirmation: (candidateRequestId: string) =>
       pending.has(candidateRequestId),

package/src/__tests__/send-notification-tool.test.ts

@@ -7,9 +7,6 @@ mock.module("../notifications/emit-signal.js", () => ({
     emitNotificationSignalMock(params),
 }));
 
-// Import from the new canonical location (notifications skill)
-// Backward-compat: the messaging re-export should resolve to the same function
-import { run as messagingRun } from "../config/bundled-skills/messaging/tools/send-notification.js";
 import { run } from "../config/bundled-skills/notifications/tools/send-notification.js";
 
 describe("send-notification tool", () => {
@@ -85,8 +82,4 @@ describe("send-notification tool", () => {
     expect(result.content).toContain("database unavailable");
     expect(emitNotificationSignalMock).toHaveBeenCalledTimes(1);
   });
-
-  test("messaging re-export resolves to the same run function", () => {
-    expect(messagingRun).toBe(run);
-  });
 });

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

@@ -11,7 +11,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/server-history-render.test.ts

@@ -12,7 +12,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
@@ -240,7 +239,7 @@ describe("renderHistoryContent", () => {
       {
         type: "tool_use",
         id: "tu_1",
-        name: "memory_save",
+        name: "memory_manage",
         input: { key: "task" },
       },
       { type: "tool_result", tool_use_id: "tu_1", content: "saved" },

package/src/__tests__/session-abort-tool-results.test.ts

@@ -13,7 +13,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 

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

@@ -16,7 +16,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 
@@ -229,12 +228,13 @@ mock.module("../daemon/session-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
 
+const resolveAssistantAttachmentsMock = mock(async () => ({
+  assistantAttachments: [],
+  emittedAttachments: [],
+  directiveWarnings: [],
+}));
 mock.module("../daemon/session-attachments.js", () => ({
-  resolveAssistantAttachments: async () => ({
-    assistantAttachments: [],
-    emittedAttachments: [],
-    directiveWarnings: [],
-  }),
+  resolveAssistantAttachments: resolveAssistantAttachmentsMock,
   approveHostAttachmentRead: async () => true,
   formatAttachmentWarnings: () => "",
 }));
@@ -1506,6 +1506,46 @@ describe("session-agent-loop", () => {
       const sessionError = events.find((e) => e.type === "session_error");
       expect(sessionError).toBeUndefined();
     });
+
+    test("skips resolveAssistantAttachments when cancelled", async () => {
+      const events: ServerMessage[] = [];
+      const abortController = new AbortController();
+      resolveAssistantAttachmentsMock.mockClear();
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "partial" }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 100,
+          outputTokens: 50,
+          model: "test-model",
+          providerDurationMs: 100,
+        });
+        // Simulate abort after processing
+        abortController.abort();
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: "partial" }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({ agentLoopRun, abortController });
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      const cancelled = events.find((e) => e.type === "generation_cancelled");
+      expect(cancelled).toBeDefined();
+      // resolveAssistantAttachments should NOT have been called
+      expect(resolveAssistantAttachmentsMock).not.toHaveBeenCalled();
+    });
   });
 
   describe("finally block cleanup", () => {

package/src/__tests__/session-confirmation-signals.test.ts

@@ -6,7 +6,7 @@
  * - handleConfirmationResponse emits both confirmation_state_changed and
  *   assistant_activity_state events centrally
  * - emitActivityState produces monotonically increasing activityVersion
- * - setStateSignalListener routes signals to an external callback (HTTP/SSE)
+ * - sendToClient receives state signals (confirmation_state_changed, assistant_activity_state)
  * - "deny" decisions produce 'denied' state, "allow" produces 'approved'
  */
 import { mkdtempSync, rmSync } from "node:fs";
@@ -52,7 +52,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => join(testDir, "test.sock"),
   getDataDir: () => testDir,
 }));
 
@@ -521,40 +520,21 @@ describe("activity version ordering", () => {
   });
 });
 
-describe("state signal listener", () => {
-  test("setStateSignalListener routes emitActivityState to external callback", () => {
+describe("sendToClient receives state signals", () => {
+  test("emitActivityState delivers to sendToClient", () => {
     const clientMsgs: ServerMessage[] = [];
-    const signalMsgs: ServerMessage[] = [];
-
     const session = makeSession((msg) => clientMsgs.push(msg));
-    session.setStateSignalListener((msg) => signalMsgs.push(msg));
 
     session.emitActivityState("thinking", "message_dequeued", "assistant_turn");
 
-    // Both sendToClient and signal listener should receive the message
     expect(
       clientMsgs.filter((m) => m.type === "assistant_activity_state"),
     ).toHaveLength(1);
-    expect(
-      signalMsgs.filter((m) => m.type === "assistant_activity_state"),
-    ).toHaveLength(1);
-
-    // Messages should be identical
-    const clientMsg = clientMsgs.find(
-      (m) => m.type === "assistant_activity_state",
-    );
-    const signalMsg = signalMsgs.find(
-      (m) => m.type === "assistant_activity_state",
-    );
-    expect(clientMsg).toEqual(signalMsg);
   });
 
-  test("setStateSignalListener routes emitConfirmationStateChanged to external callback", () => {
+  test("emitConfirmationStateChanged delivers to sendToClient", () => {
     const clientMsgs: ServerMessage[] = [];
-    const signalMsgs: ServerMessage[] = [];
-
     const session = makeSession((msg) => clientMsgs.push(msg));
-    session.setStateSignalListener((msg) => signalMsgs.push(msg));
 
     session.emitConfirmationStateChanged({
       sessionId: "conv-signals-test",
@@ -566,41 +546,22 @@ describe("state signal listener", () => {
     expect(
       clientMsgs.filter((m) => m.type === "confirmation_state_changed"),
     ).toHaveLength(1);
-    expect(
-      signalMsgs.filter((m) => m.type === "confirmation_state_changed"),
-    ).toHaveLength(1);
   });
 
-  test("without state signal listener, only sendToClient receives messages", () => {
+  test("handleConfirmationResponse delivers state signals to sendToClient", () => {
     const clientMsgs: ServerMessage[] = [];
-
     const session = makeSession((msg) => clientMsgs.push(msg));
-    // No setStateSignalListener call
-
-    session.emitActivityState("idle", "message_complete", "global");
-
-    expect(
-      clientMsgs.filter((m) => m.type === "assistant_activity_state"),
-    ).toHaveLength(1);
-  });
-
-  test("state signal listener receives handleConfirmationResponse emissions", () => {
-    const signalMsgs: ServerMessage[] = [];
-
-    // Use no-op sendToClient (simulates HTTP session with no socket)
-    const session = makeSession(() => {});
-    session.setStateSignalListener((msg) => signalMsgs.push(msg));
 
     seedPendingConfirmation(session, "req-signal-confirm");
     session.handleConfirmationResponse("req-signal-confirm", "allow");
 
-    const confirmSignal = signalMsgs.find(
+    const confirmSignal = clientMsgs.find(
       (m) =>
         m.type === "confirmation_state_changed" &&
         "requestId" in m &&
         (m as { requestId: string }).requestId === "req-signal-confirm",
     );
-    const activitySignal = signalMsgs.find(
+    const activitySignal = clientMsgs.find(
       (m) =>
         m.type === "assistant_activity_state" &&
         "reason" in m &&

package/src/__tests__/session-conflict-gate.test.ts

@@ -67,7 +67,6 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test.sock",
   getDataDir: () => "/tmp",
 }));
 
@@ -102,11 +101,8 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 100000,
-      targetInputTokens: 80000,
-      compactThreshold: 0.8,
-      preserveRecentUserTurns: 8,
-      summaryMaxTokens: 512,
-      chunkTokens: 12000,
+      targetBudgetRatio: 0.30,
+      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
       overflowRecovery: {
         enabled: true,
         safetyMarginRatio: 0.05,