@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/helpers/mock-logger.ts

@@ -34,3 +34,29 @@ export function makeMockLogger(): unknown {
     get: (_target, prop) => (prop === "child" ? makeMockLogger : () => {}),
   });
 }
+
+/**
+ * Returns a complete mock module object for `util/logger.js`. Use this when
+ * the consumer of `mock.module("../util/logger.js", ...)` needs full export
+ * coverage — i.e. when the transitive import graph reaches `getCliLogger`,
+ * `initLogger`, or other helpers in addition to `getLogger`.
+ *
+ *   mock.module("../util/logger.js", () => createMockLoggerModule());
+ *
+ * Pass `overrides` to swap any specific export for a custom stub (e.g. an
+ * observable spy). Anything not overridden falls back to the recursive
+ * proxy logger / no-op defaults.
+ */
+export function createMockLoggerModule(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    getLogger: () => makeMockLogger(),
+    getCliLogger: () => makeMockLogger(),
+    initLogger: () => {},
+    truncateForLog: (value: string) => value,
+    pruneOldLogFiles: () => 0,
+    LOG_FILE_PATTERN: /^assistant-(\d{4}-\d{2}-\d{2})\.log$/,
+    ...overrides,
+  };
+}

package/src/__tests__/host-bash-routes.test.ts

@@ -76,6 +76,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     getActorPrincipalIdForClient: (clientId: string) =>
       clientActorPrincipals.get(clientId),
   },
+  broadcastMessage: async () => {},
 }));
 
 // ── Real imports (after mocks) ───────────────────────────────────────

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -88,6 +88,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     getActorPrincipalIdForClient: (clientId: string) =>
       actorPrincipalByClient.get(clientId),
   },
+  broadcastMessage: async () => {},
 }));
 
 // ── Real imports (after mocks) ──────────────────────────────────────────────

package/src/__tests__/host-file-routes-targeted.test.ts

@@ -73,6 +73,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     getActorPrincipalIdForClient: (clientId: string) =>
       clientActors.get(clientId),
   },
+  broadcastMessage: async () => {},
 }));
 
 // ── Real imports (after mocks) ──────────────────────────────────────────────

package/src/__tests__/host-shell-tool.test.ts

@@ -863,9 +863,10 @@ describe("host_bash — proxy delegation", () => {
 
   test("propagates VELLUM_UNTRUSTED_SHELL env to proxy under CES lockdown", async () => {
     // Enable CES shell lockdown via the override cache
-    const { _setOverridesForTesting } =
-      await import("../config/assistant-feature-flags.js");
-    _setOverridesForTesting({
+    const { setOverridesForTesting } = await import(
+  "./feature-flag-test-helpers.js"
+);
+    setOverridesForTesting({
       "ces-shell-lockdown": true,
     });
 
@@ -899,7 +900,7 @@ describe("host_bash — proxy delegation", () => {
         __CONVERSATION_ID: "test-conversation",
       });
     } finally {
-      _setOverridesForTesting({});
+      setOverridesForTesting({});
       restoreEnv(envSnapshot);
     }
   });

package/src/__tests__/host-transfer-routes-targeted.test.ts

@@ -85,6 +85,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     getActorPrincipalIdForClient: (clientId: string) =>
       clientActors.get(clientId),
   },
+  broadcastMessage: async () => {},
 }));
 
 // ── Real imports (after mocks) ──────────────────────────────────────────────

package/src/__tests__/http-conversation-lineage.test.ts

@@ -35,10 +35,11 @@ import {
   createConversation,
   updateConversationTitle,
 } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { rawRun } from "../memory/raw-query.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -65,7 +66,7 @@ describe("conversation lineage in HTTP reads", () => {
 
   afterAll(async () => {
     await server?.stop();
-    resetDb();
+    resetDbForTesting();
   });
 
   test("GET /v1/conversations returns forkParent for surviving parents", async () => {

package/src/__tests__/http-user-message-parity.test.ts

@@ -100,6 +100,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     content: string,
     metadata?: Record<string, unknown>,
   ) => addMessageMock(conversationId, role, content, metadata),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({
@@ -218,7 +219,10 @@ function makeConversation(overrides: Record<string, unknown> = {}) {
     hasAnyPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
     enqueueMessage: () => ({ queued: true, requestId: "queued-id" }),
-    persistUserMessage: mock(async () => "persisted-user-id"),
+    persistUserMessage: mock(async () => ({
+      id: "persisted-user-id",
+      deduplicated: false,
+    })),
     runAgentLoop: mock(async () => undefined),
     getMessages: () => [] as unknown[],
     assistantId: "self",
@@ -296,7 +300,10 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
     // Dedicated /v1/recording/* endpoints handle recording lifecycle.
     // Text-based recording intent interception was retired with the
     // legacy handleUserMessage entry point.
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
@@ -313,7 +320,10 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
     // content, conversationKey, attachmentIds, sourceChannel, and interface.
     // This ensures a future regression that starts parsing commandIntent would
     // be caught.
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
@@ -327,7 +337,10 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
   });
 
   test("stop recording commands pass through to the agent loop", async () => {
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
 
@@ -351,7 +364,10 @@ describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
   });
 
   test("passes canonical clientTimezone through host-proxy transport", async () => {
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
     let capturedOptions: Record<string, unknown> | undefined;
@@ -378,7 +394,10 @@ describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
   });
 
   test("passes canonical clientTimezone through non-host-proxy transport", async () => {
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
     let capturedOptions: Record<string, unknown> | undefined;
@@ -405,7 +424,10 @@ describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
   });
 
   test("drops invalid clientTimezone without rejecting the message", async () => {
-    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const persistUserMessage = mock(async () => ({
+      id: "persisted-msg-id",
+      deduplicated: false,
+    }));
     const runAgentLoop = mock(async () => undefined);
     const conversation = makeConversation({ persistUserMessage, runAgentLoop });
     let capturedOptions: Record<string, unknown> | undefined;

package/src/__tests__/identity-intro-cache.test.ts

@@ -60,6 +60,8 @@ mock.module("../prompts/persona-resolver.js", () => ({
 import {
   computeIdentityContentHash,
   getCachedIntro,
+  parseGreetingsSection,
+  readWorkspaceGreetings,
   readWorkspaceIdentityIntro,
   setCachedIntro,
 } from "../runtime/routes/identity-intro-cache.js";
@@ -113,21 +115,21 @@ describe("identity intro cache", () => {
     expect(getCachedIntro()).toBeNull();
   });
 
-  test("round-trip: set then get returns cached text", () => {
+  test("round-trip: set then get returns cached greetings array", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
     workspaceFiles["SOUL.md"] = "Be playful.";
     guardianPersonaContent = "The user likes coffee.";
 
-    setCachedIntro("Hey, I'm Atlas.");
+    setCachedIntro(["Hey, I'm Atlas.", "What's up?"]);
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
-    expect(cached!.text).toBe("Hey, I'm Atlas.");
+    expect(cached!.greetings).toEqual(["Hey, I'm Atlas.", "What's up?"]);
   });
 
   test("returns null when cache is expired (TTL exceeded)", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
 
-    setCachedIntro("Hello!");
+    setCachedIntro(["Hello!"]);
 
     // Manually set the timestamp to 5 hours ago
     const fiveHoursAgo = String(Date.now() - 5 * 60 * 60 * 1000);
@@ -136,10 +138,10 @@ describe("identity intro cache", () => {
     expect(getCachedIntro()).toBeNull();
   });
 
-  test("returns cached text when within TTL (3 hours ago)", () => {
+  test("returns cached greetings when within TTL (3 hours ago)", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
 
-    setCachedIntro("Hello!");
+    setCachedIntro(["Hello!"]);
 
     // Set timestamp to 3 hours ago (within 4-hour TTL)
     const threeHoursAgo = String(Date.now() - 3 * 60 * 60 * 1000);
@@ -147,12 +149,12 @@ describe("identity intro cache", () => {
 
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
-    expect(cached!.text).toBe("Hello!");
+    expect(cached!.greetings).toEqual(["Hello!"]);
   });
 
   test("busts cache when IDENTITY.md changes", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
-    setCachedIntro("I'm Atlas!");
+    setCachedIntro(["I'm Atlas!"]);
 
     // Change IDENTITY.md
     workspaceFiles["IDENTITY.md"] = "- **Name:** Nova";
@@ -162,7 +164,7 @@ describe("identity intro cache", () => {
 
   test("busts cache when SOUL.md changes", () => {
     workspaceFiles["SOUL.md"] = "Be playful.";
-    setCachedIntro("Hey there!");
+    setCachedIntro(["Hey there!"]);
 
     // Change SOUL.md
     workspaceFiles["SOUL.md"] = "Be serious and formal.";
@@ -172,7 +174,7 @@ describe("identity intro cache", () => {
 
   test("busts cache when guardian persona content changes", () => {
     guardianPersonaContent = "Likes coffee.";
-    setCachedIntro("Good morning!");
+    setCachedIntro(["Good morning!"]);
 
     // Change guardian persona (e.g. user edited users/<slug>.md)
     guardianPersonaContent = "Likes tea.";
@@ -185,11 +187,10 @@ describe("identity intro cache", () => {
     workspaceFiles["SOUL.md"] = "Be chill.";
     guardianPersonaContent = "Likes sunsets.";
 
-    setCachedIntro("Atlas here.");
+    setCachedIntro(["Atlas here.", "Hey friend."]);
 
-    // Read twice with the same guardian persona — both should return the cached value
-    expect(getCachedIntro()?.text).toBe("Atlas here.");
-    expect(getCachedIntro()?.text).toBe("Atlas here.");
+    expect(getCachedIntro()?.greetings).toEqual(["Atlas here.", "Hey friend."]);
+    expect(getCachedIntro()?.greetings).toEqual(["Atlas here.", "Hey friend."]);
   });
 
   test("computeIdentityContentHash is deterministic", () => {
@@ -235,30 +236,140 @@ describe("identity intro cache", () => {
 
   test("handles missing workspace files gracefully", () => {
     // No files exist — should still work (empty content hashed)
-    setCachedIntro("Hello!");
+    setCachedIntro(["Hello!"]);
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
-    expect(cached!.text).toBe("Hello!");
+    expect(cached!.greetings).toEqual(["Hello!"]);
   });
 
-  test("returns null when text checkpoint is missing", () => {
+  test("handles legacy single-string cache value", () => {
+    // Simulate a cache entry written by an older daemon version
+    const hash = computeIdentityContentHash();
+    checkpointStore.set("identity:intro:greetings", "Legacy greeting");
+    checkpointStore.set("identity:intro:content_hash", hash);
+    checkpointStore.set("identity:intro:cached_at", String(Date.now()));
+
+    const cached = getCachedIntro();
+    expect(cached).not.toBeNull();
+    expect(cached!.greetings).toEqual(["Legacy greeting"]);
+  });
+
+  test("returns null when greetings checkpoint is missing", () => {
     checkpointStore.set("identity:intro:content_hash", "abc");
     checkpointStore.set("identity:intro:cached_at", String(Date.now()));
-    // Missing text — should return null
     expect(getCachedIntro()).toBeNull();
   });
 
   test("returns null when hash checkpoint is missing", () => {
-    checkpointStore.set("identity:intro:text", "Hello");
+    checkpointStore.set("identity:intro:greetings", '["Hello"]');
     checkpointStore.set("identity:intro:cached_at", String(Date.now()));
-    // Missing hash — should return null
     expect(getCachedIntro()).toBeNull();
   });
 
   test("returns null when timestamp checkpoint is missing", () => {
-    checkpointStore.set("identity:intro:text", "Hello");
+    checkpointStore.set("identity:intro:greetings", '["Hello"]');
     checkpointStore.set("identity:intro:content_hash", "abc");
-    // Missing timestamp — should return null
     expect(getCachedIntro()).toBeNull();
   });
 });
+
+describe("parseGreetingsSection", () => {
+  test("parses bullet list from ## Greetings section", () => {
+    const content = [
+      "# Soul",
+      "",
+      "## Greetings",
+      "- Hey there, friend!",
+      "- What's on your mind?",
+      "- Ready to roll!",
+      "",
+      "## Other Section",
+      "Some other content.",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Hey there, friend!",
+      "What's on your mind?",
+      "Ready to roll!",
+    ]);
+  });
+
+  test("handles asterisk bullets", () => {
+    const content = [
+      "## Greetings",
+      "* Hello!",
+      "* Hi there.",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual(["Hello!", "Hi there."]);
+  });
+
+  test("returns null when section is missing", () => {
+    const content = [
+      "# Soul",
+      "## Personality",
+      "Be friendly.",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toBeNull();
+  });
+
+  test("returns null when section is empty", () => {
+    const content = [
+      "## Greetings",
+      "",
+      "## Next Section",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toBeNull();
+  });
+
+  test("ignores non-bullet lines in section", () => {
+    const content = [
+      "## Greetings",
+      "Some intro text that's not a bullet",
+      "- Actual greeting",
+      "Another non-bullet line",
+      "- Second greeting",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Actual greeting",
+      "Second greeting",
+    ]);
+  });
+
+  test("stops at next heading", () => {
+    const content = [
+      "## Greetings",
+      "- First",
+      "- Second",
+      "### Sub-heading",
+      "- Should not appear",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual(["First", "Second"]);
+  });
+});
+
+describe("readWorkspaceGreetings", () => {
+  test("reads greetings from SOUL.md", () => {
+    workspaceFiles["SOUL.md"] = [
+      "# Soul",
+      "## Greetings",
+      "- Hey!",
+      "- What's up?",
+    ].join("\n");
+
+    expect(readWorkspaceGreetings()).toEqual(["Hey!", "What's up?"]);
+  });
+
+  test("returns null when SOUL.md has no greetings section", () => {
+    workspaceFiles["SOUL.md"] = "# Soul\nBe friendly.";
+    expect(readWorkspaceGreetings()).toBeNull();
+  });
+
+  test("returns null when SOUL.md does not exist", () => {
+    expect(readWorkspaceGreetings()).toBeNull();
+  });
+});

package/src/__tests__/inbound-slack-persistence.test.ts

@@ -48,6 +48,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => ({}),
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({
@@ -140,12 +141,10 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Reply inside a thread",
-      [],
-      "req-thread",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Reply inside a thread",
+      requestId: "req-thread",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelName: "engineering",
@@ -155,8 +154,7 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
           actorExternalUserId: "U_ALICE",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = readPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -176,20 +174,17 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Top-level channel post",
-      [],
-      "req-top",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Top-level channel post",
+      requestId: "req-top",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000010.222222",
           displayName: "Bob",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = readPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -205,20 +200,17 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "@leo can you check this?",
-      [],
-      "req-normalized-content",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "@leo can you check this?",
+      requestId: "req-normalized-content",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000015.123456",
           displayName: "Alice",
         },
       },
-      undefined,
-    );
+    });
 
     expect(JSON.parse(addMessageCalls.at(-1)!.content)).toEqual([
       { type: "text", text: "@leo can you check this?" },
@@ -236,19 +228,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Anonymous channel post",
-      [],
-      "req-anon",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Anonymous channel post",
+      requestId: "req-anon",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000020.333333",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = readPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -261,14 +250,10 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "telegram",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Telegram message",
-      [],
-      "req-tg",
-      undefined,
-      undefined,
-    );
+    await persistQueuedMessageBody(ctx, {
+      content: "Telegram message",
+      requestId: "req-tg",
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -284,19 +269,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "telegram",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Telegram message with stray slackInbound",
-      [],
-      "req-tg-stray",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Telegram message with stray slackInbound",
+      requestId: "req-tg-stray",
+      metadata: {
         slackInbound: {
           channelId: "C0_DOES_NOT_APPLY",
           channelTs: "1700000030.444444",
         },
       },
-      undefined,
-    );
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -312,14 +294,10 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Slack wake without inbound metadata",
-      [],
-      "req-no-slack-inbound",
-      undefined,
-      undefined,
-    );
+    await persistQueuedMessageBody(ctx, {
+      content: "Slack wake without inbound metadata",
+      requestId: "req-no-slack-inbound",
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -331,19 +309,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Malformed inbound payload",
-      [],
-      "req-malformed",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Malformed inbound payload",
+      requestId: "req-malformed",
+      metadata: {
         slackInbound: {
           // channelTs intentionally missing — simulates a bug upstream.
           channelId: "C0123CHANNEL",
         } as unknown as Record<string, unknown>,
       },
-      undefined,
-    );
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackMeta" in metadata).toBe(false);
@@ -355,19 +330,16 @@ describe("PR 11 — inbound Slack message metadata persistence", () => {
       assistantMessageChannel: "slack",
     });
 
-    await persistQueuedMessageBody(
-      ctx,
-      "Verify carrier is stripped",
-      [],
-      "req-strip",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "Verify carrier is stripped",
+      requestId: "req-strip",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHANNEL",
           channelTs: "1700000040.555555",
         },
       },
-      undefined,
-    );
+    });
 
     const metadata = lastPersistedMetadata();
     expect("slackInbound" in metadata).toBe(false);