@vellumai/assistant 0.7.1 → 0.7.3

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

@@ -206,6 +206,7 @@ function makeConversation(overrides: Record<string, unknown> = {}) {
     updateClient: () => {},
     setHostBrowserProxy: () => {},
     setHostCuProxy: () => {},
+    setHostAppControlProxy: () => {},
     addPreactivatedSkillId: () => {},
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
@@ -251,12 +252,24 @@ async function sendMessage(
   content: string,
   conversationObj: import("../daemon/conversation.js").Conversation,
   extra: Record<string, unknown> = {},
+  options: {
+    onGetOrCreateConversation?: (
+      conversationId: string,
+      opts?: Record<string, unknown>,
+    ) => void;
+  } = {},
 ) {
   return callHandler(
     (args) =>
       handleSendMessage(args, {
         sendMessageDeps: {
-          getOrCreateConversation: async () => conversationObj,
+          getOrCreateConversation: async (conversationId, opts) => {
+            options.onGetOrCreateConversation?.(
+              conversationId,
+              opts as Record<string, unknown> | undefined,
+            );
+            return conversationObj;
+          },
           assistantEventHub: { publish: async () => {} } as any,
           resolveAttachments: () => [],
         },
@@ -325,3 +338,97 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
     expect(runAgentLoop).toHaveBeenCalledTimes(1);
   });
 });
+
+// ============================================================================
+// CLIENT TIMEZONE — optional HTTP metadata
+// ============================================================================
+describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
+  beforeEach(() => {
+    routeGuardianReplyMock.mockClear();
+    listPendingByDestinationMock.mockClear();
+    listCanonicalMock.mockClear();
+    addMessageMock.mockClear();
+  });
+
+  test("passes canonical clientTimezone through host-proxy transport", async () => {
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+    let capturedOptions: Record<string, unknown> | undefined;
+
+    const res = await sendMessage(
+      "hello",
+      conversation,
+      { clientTimezone: "america/new_york" },
+      {
+        onGetOrCreateConversation: (_conversationId, opts) => {
+          capturedOptions = opts;
+        },
+      },
+    );
+
+    expect(res.status).toBe(202);
+    expect(capturedOptions).toEqual({
+      transport: {
+        channelId: "vellum",
+        interfaceId: "macos",
+        clientTimezone: "America/New_York",
+      },
+    });
+  });
+
+  test("passes canonical clientTimezone through non-host-proxy transport", async () => {
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+    let capturedOptions: Record<string, unknown> | undefined;
+
+    const res = await sendMessage(
+      "hello",
+      conversation,
+      { interface: "ios", clientTimezone: "europe/london" },
+      {
+        onGetOrCreateConversation: (_conversationId, opts) => {
+          capturedOptions = opts;
+        },
+      },
+    );
+
+    expect(res.status).toBe(202);
+    expect(capturedOptions).toEqual({
+      transport: {
+        channelId: "vellum",
+        interfaceId: "ios",
+        clientTimezone: "Europe/London",
+      },
+    });
+  });
+
+  test("drops invalid clientTimezone without rejecting the message", async () => {
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+    let capturedOptions: Record<string, unknown> | undefined;
+
+    const res = await sendMessage(
+      "hello",
+      conversation,
+      { clientTimezone: "not-a-timezone" },
+      {
+        onGetOrCreateConversation: (_conversationId, opts) => {
+          capturedOptions = opts;
+        },
+      },
+    );
+
+    expect(res.status).toBe(202);
+    expect(capturedOptions).toEqual({
+      transport: {
+        channelId: "vellum",
+        interfaceId: "macos",
+      },
+    });
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -60,6 +60,7 @@ mock.module("../prompts/persona-resolver.js", () => ({
 import {
   computeIdentityContentHash,
   getCachedIntro,
+  readWorkspaceIdentityIntro,
   setCachedIntro,
 } from "../runtime/routes/identity-intro-cache.js";
 
@@ -80,6 +81,34 @@ afterEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("identity intro cache", () => {
+  test("reads explicit intro from IDENTITY.md before SOUL.md", () => {
+    workspaceFiles["IDENTITY.md"] = [
+      "# Identity",
+      "",
+      "## Identity Intro",
+      "Nova here.",
+    ].join("\n");
+    workspaceFiles["SOUL.md"] = [
+      "# Soul",
+      "",
+      "## Identity Intro",
+      "Soul fallback.",
+    ].join("\n");
+
+    expect(readWorkspaceIdentityIntro()).toBe("Nova here.");
+  });
+
+  test("falls back to SOUL.md identity intro for legacy workspaces", () => {
+    workspaceFiles["SOUL.md"] = [
+      "# Soul",
+      "",
+      "## Identity Intro",
+      "Soul fallback.",
+    ].join("\n");
+
+    expect(readWorkspaceIdentityIntro()).toBe("Soul fallback.");
+  });
+
   test("returns null when cache is empty", () => {
     expect(getCachedIntro()).toBeNull();
   });

package/src/__tests__/identity-routes.test.ts

@@ -22,8 +22,16 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { handleDetailedHealth } from "../runtime/routes/identity-routes.js";
+import {
+  handleDetailedHealth,
+  ROUTES,
+} from "../runtime/routes/identity-routes.js";
 import { getWorkspaceDir } from "../util/platform.js";
+import {
+  getHatchedSidecarPath,
+  resolveHatchedAtReadOnly,
+  selectHatchedAtFromStats,
+} from "../workspace/hatched-date.js";
 
 // ── Env helpers ─────────────────────────────────────────────────────────
 
@@ -118,6 +126,9 @@ beforeEach(() => {
   if (existsSync(profilerRunsDir)) {
     rmSync(profilerRunsDir, { recursive: true, force: true });
   }
+
+  rmSync(getHatchedSidecarPath(), { force: true });
+  rmSync(join(getWorkspaceDir(), "IDENTITY.md"), { force: true });
 });
 
 afterEach(() => {
@@ -326,3 +337,94 @@ describe("identity routes — health endpoint", () => {
     });
   });
 });
+
+describe("identity routes — createdAt selection", () => {
+  test("falls back to mtime when birthtime is the Unix epoch", () => {
+    const mtime = new Date("2026-05-01T14:49:47.519Z");
+
+    expect(
+      selectHatchedAtFromStats({
+        birthtime: new Date(0),
+        mtime,
+      })?.toISOString(),
+    ).toBe(mtime.toISOString());
+  });
+
+  test("prefers birthtime when it is valid", () => {
+    const birthtime = new Date("2026-04-30T12:00:00.000Z");
+    const mtime = new Date("2026-05-01T14:49:47.519Z");
+
+    expect(
+      selectHatchedAtFromStats({
+        birthtime,
+        mtime,
+      })?.toISOString(),
+    ).toBe(birthtime.toISOString());
+  });
+
+  test("returns undefined when both birthtime and mtime are the Unix epoch", () => {
+    expect(
+      selectHatchedAtFromStats({
+        birthtime: new Date(0),
+        mtime: new Date(0),
+      }),
+    ).toBeUndefined();
+  });
+
+  test("read-only resolver falls back to current time without writing sidecar", () => {
+    const now = new Date("2026-05-04T12:00:00.000Z");
+
+    expect(
+      resolveHatchedAtReadOnly(
+        join(getWorkspaceDir(), "missing-identity.md"),
+        now,
+      ),
+    ).toBe(now.toISOString());
+    expect(existsSync(getHatchedSidecarPath())).toBe(false);
+  });
+
+  test("/identity uses persisted hatched sidecar instead of live file metadata", () => {
+    const workspaceDir = getWorkspaceDir();
+    const dataDir = join(workspaceDir, "data");
+    const identityPath = join(workspaceDir, "IDENTITY.md");
+    const persistedHatchedAt = "2026-05-01T14:49:47.519Z";
+
+    mkdirSync(dataDir, { recursive: true });
+    writeFileSync(
+      identityPath,
+      "# Identity\n\n- **Name:** Example Assistant\n",
+      "utf-8",
+    );
+    writeFileSync(
+      getHatchedSidecarPath(),
+      JSON.stringify({ hatchedAt: persistedHatchedAt }),
+      "utf-8",
+    );
+
+    const route = ROUTES.find(
+      (candidate) => candidate.operationId === "identity",
+    );
+    expect(route).toBeDefined();
+
+    const body = route!.handler({}) as { createdAt?: string };
+    expect(body.createdAt).toBe(persistedHatchedAt);
+  });
+
+  test("/identity does not write hatched sidecar on read", () => {
+    const identityPath = join(getWorkspaceDir(), "IDENTITY.md");
+    writeFileSync(
+      identityPath,
+      "# Identity\n\n- **Name:** Example Assistant\n",
+      "utf-8",
+    );
+
+    const route = ROUTES.find(
+      (candidate) => candidate.operationId === "identity",
+    );
+    expect(route).toBeDefined();
+
+    const body = route!.handler({}) as { createdAt?: string };
+    expect(Date.parse(body.createdAt ?? "")).toBeGreaterThan(0);
+    expect(existsSync(getHatchedSidecarPath())).toBe(false);
+  });
+});

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -41,8 +41,11 @@ describe("initFeatureFlagOverrides", () => {
   it("falls back gracefully when gateway socket is unavailable", async () => {
     mockGatewayIpc(null, { error: true });
 
-    // Should not throw
-    await initFeatureFlagOverrides();
+    // Disable retries — production retries the IPC fetch on failure to
+    // dodge the daemon-vs-gateway startup race, but here we're explicitly
+    // testing the no-gateway fallback and don't want the test to wait
+    // through the backoff schedule.
+    await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
     // Without gateway data or file, undeclared flags default to true
     const config = {} as any;
@@ -64,7 +67,10 @@ describe("initFeatureFlagOverrides", () => {
   it("does not cache empty gateway response", async () => {
     mockGatewayIpc({});
 
-    await initFeatureFlagOverrides();
+    // Disable retries — this test explicitly simulates a sustained empty
+    // response (gateway up but reporting zero flags) and should not wait
+    // through the production backoff schedule.
+    await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
     // Undeclared flags without overrides default to true (not false from
     // a cached empty map)
@@ -72,6 +78,23 @@ describe("initFeatureFlagOverrides", () => {
     expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
   });
 
+  it("retries empty gateway responses and picks up flags once they become available", async () => {
+    // Simulate the daemon-vs-gateway startup race: the first IPC call
+    // returns empty (gateway not yet ready), but a later attempt sees
+    // the populated flag map. The retry loop in init should bridge this
+    // gap without losing the flag.
+    mockGatewayIpc({});
+    setTimeout(() => {
+      resetMockGatewayIpc();
+      mockGatewayIpc({ "retry-test-flag": true });
+    }, 50);
+
+    await initFeatureFlagOverrides({ retryBackoffsMs: [200] });
+
+    const config = {} as any;
+    expect(isAssistantFeatureFlagEnabled("retry-test-flag", config)).toBe(true);
+  });
+
   it("does not re-fetch when cache is already populated", async () => {
     mockGatewayIpc({ "first-call": true });
 

package/src/__tests__/injector-chain.test.ts

@@ -4,10 +4,11 @@
  *
  * Covers:
  *
- * 1. The nine default injectors registered by `defaultInjectorsPlugin` come
- *    back from `getInjectors()` in the documented order (workspace-context →
- *    unified-turn-context → pkb-context → pkb-reminder → memory-v2-static →
- *    now-md → subagent-status → slack-messages → thread-focus).
+ * 1. The ten default injectors registered by `defaultInjectorsPlugin` come
+ *    back from `getInjectors()` in the documented order
+ *    (disk-pressure-warning → workspace-context → unified-turn-context →
+ *    pkb-context → pkb-reminder → memory-v2-static → now-md →
+ *    subagent-status → slack-messages → thread-focus).
  * 2. A third-party-registered injector at `order: 25` slots between
  *    `unified-turn-context` (order 20) and `pkb` (order 30), proving the
  *    extensibility contract.
@@ -25,6 +26,7 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import {
   applyRuntimeInjections,
   composeInjectorChain,
@@ -33,6 +35,11 @@ import {
   DEFAULT_INJECTOR_ORDER,
   defaultInjectorsPlugin,
 } from "../plugins/defaults/injectors.js";
+
+// This test exercises v1 PKB injection. The `memory-v2-enabled` flag
+// (registry default `true`) makes the PKB injector go silent — disable it
+// here so the v1 injection chain assertions stay meaningful.
+_setOverridesForTesting({ "memory-v2-enabled": false });
 import {
   getInjectors,
   registerPlugin,
@@ -76,11 +83,12 @@ describe("injector chain", () => {
     resetPluginRegistryForTests();
   });
 
-  test("defaultInjectorsPlugin registers the nine defaults in the documented order", () => {
+  test("defaultInjectorsPlugin registers the ten defaults in the documented order", () => {
     registerPlugin(defaultInjectorsPlugin);
 
     const names = getInjectors().map((i) => i.name);
     expect(names).toEqual([
+      "disk-pressure-warning",
       "workspace-context",
       "unified-turn-context",
       "pkb-context",
@@ -97,6 +105,9 @@ describe("injector chain", () => {
     registerPlugin(defaultInjectorsPlugin);
 
     const byName = new Map(getInjectors().map((i) => [i.name, i.order]));
+    expect(byName.get("disk-pressure-warning")).toBe(
+      DEFAULT_INJECTOR_ORDER.diskPressureWarning,
+    );
     expect(byName.get("workspace-context")).toBe(
       DEFAULT_INJECTOR_ORDER.workspaceContext,
     );
@@ -132,6 +143,7 @@ describe("injector chain", () => {
 
     const names = getInjectors().map((i) => i.name);
     expect(names).toEqual([
+      "disk-pressure-warning", // 5
       "workspace-context", // 10
       "unified-turn-context", // 20
       "plugin-25", // 25 — slots in
@@ -146,7 +158,7 @@ describe("injector chain", () => {
   });
 
   test("composeInjectorChain returns empty string when every injector opts out", async () => {
-    // The default chain is the golden-path: all nine defaults return `null`
+    // The default chain is the golden-path: all ten defaults return `null`
     // on an empty turn context, so the composed block is an empty string.
     registerPlugin(defaultInjectorsPlugin);
 

package/src/__tests__/injector-disk-pressure.test.ts

@@ -0,0 +1,224 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+import {
+  applyRuntimeInjections,
+  stripInjectionsForCompaction,
+} from "../daemon/conversation-runtime-assembly.js";
+import {
+  DEFAULT_INJECTOR_ORDER,
+  defaultInjectorsPlugin,
+  DISK_PRESSURE_WARNING_PROMPT,
+} from "../plugins/defaults/injectors.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type { Injector, TurnContext } from "../plugins/types.js";
+import type { Message } from "../providers/types.js";
+
+function findInjector(name: string): Injector {
+  const injector = defaultInjectorsPlugin.injectors?.find(
+    (candidate) => candidate.name === name,
+  );
+  if (!injector) {
+    throw new Error(`injector '${name}' not registered`);
+  }
+  return injector;
+}
+
+function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
+  return {
+    requestId: "req-test",
+    conversationId: "conv-test",
+    turnIndex: 0,
+    trust: { sourceChannel: "vellum", trustClass: "guardian" },
+    ...overrides,
+  };
+}
+
+function tailTexts(messages: Message[]): string[] {
+  const tail = messages[messages.length - 1];
+  if (!tail || tail.role !== "user") return [];
+  return tail.content
+    .filter((block): block is { type: "text"; text: string } => {
+      return block.type === "text";
+    })
+    .map((block) => block.text);
+}
+
+const diskPressureInjector = findInjector("disk-pressure-warning");
+const cleanupContext = { cleanupModeActive: true };
+
+describe("disk-pressure-warning injector", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultInjectorsPlugin);
+    _setOverridesForTesting({ "safe-storage-limits": true });
+  });
+
+  test("emits the exact cleanup prompt while safe storage limits are enabled", async () => {
+    const block = await diskPressureInjector.produce(
+      makeContext({
+        injectionInputs: { diskPressureContext: cleanupContext },
+      }),
+    );
+
+    expect(block).toEqual({
+      id: "disk-pressure-warning",
+      text: DISK_PRESSURE_WARNING_PROMPT,
+      placement: "prepend-user-tail",
+    });
+    expect(diskPressureInjector.order).toBe(
+      DEFAULT_INJECTOR_ORDER.diskPressureWarning,
+    );
+    expect(DISK_PRESSURE_WARNING_PROMPT).toBe(`<disk_pressure_warning>
+Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is at least 95% full.
+
+In your first paragraph, warn the user that storage is critically low and that normal work is suspended until space is freed.
+
+Then help the user clean up storage. Prefer safe inspection steps first, such as checking available space and finding large directories. Ask before deleting files or caches unless the user has already clearly approved the specific cleanup action.
+
+Do not work on unrelated tasks until disk usage drops below the critical threshold or the user explicitly overrides the lock. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
+</disk_pressure_warning>`);
+  });
+
+  test("omits the prompt when cleanup context is null or inactive", async () => {
+    await expect(
+      diskPressureInjector.produce(
+        makeContext({ injectionInputs: { diskPressureContext: null } }),
+      ),
+    ).resolves.toBeNull();
+
+    await expect(
+      diskPressureInjector.produce(
+        makeContext({
+          injectionInputs: {
+            diskPressureContext: { cleanupModeActive: false },
+          },
+        }),
+      ),
+    ).resolves.toBeNull();
+  });
+
+  test("omits the prompt when safe storage limits are disabled", async () => {
+    _setOverridesForTesting({ "safe-storage-limits": false });
+
+    await expect(
+      diskPressureInjector.produce(
+        makeContext({
+          injectionInputs: { diskPressureContext: cleanupContext },
+        }),
+      ),
+    ).resolves.toBeNull();
+  });
+
+  test("prepends ahead of workspace and unified turn context in full mode", async () => {
+    const runMessages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "clean up space" }] },
+    ];
+    const workspace = "<workspace>\nRoot: /workspace\n</workspace>";
+    const turnContext = "<turn_context>\ninterface: macos\n</turn_context>";
+
+    const result = await applyRuntimeInjections(runMessages, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+      workspaceTopLevelContext: workspace,
+      unifiedTurnContext: turnContext,
+    });
+
+    expect(tailTexts(result.messages).slice(0, 4)).toEqual([
+      DISK_PRESSURE_WARNING_PROMPT,
+      workspace,
+      turnContext,
+      "clean up space",
+    ]);
+    expect(
+      result.blocks.injectorChainBlock?.startsWith(
+        DISK_PRESSURE_WARNING_PROMPT,
+      ),
+    ).toBe(true);
+  });
+
+  test("survives minimal mode as safety-critical context", async () => {
+    const result = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "status" }] }],
+      {
+        turnContext: makeContext(),
+        mode: "minimal",
+        diskPressureContext: cleanupContext,
+        workspaceTopLevelContext: "<workspace>...</workspace>",
+        unifiedTurnContext: "<turn_context>...</turn_context>",
+      },
+    );
+
+    expect(tailTexts(result.messages)).toEqual([
+      DISK_PRESSURE_WARNING_PROMPT,
+      "<turn_context>...</turn_context>",
+      "status",
+    ]);
+  });
+
+  test("applies after Slack chronological transcript replacement", async () => {
+    const originalRun: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "latest raw user text" }],
+      },
+    ];
+    const slackTranscript: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "[12:00 user]: earlier" }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "[12:01 @assistant]: cleanup?" }],
+      },
+    ];
+
+    const result = await applyRuntimeInjections(originalRun, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+      channelCapabilities: {
+        channel: "slack",
+        dashboardCapable: false,
+        supportsDynamicUi: false,
+        supportsVoiceInput: false,
+        chatType: "channel",
+      },
+      slackChronologicalMessages: slackTranscript,
+    });
+
+    expect(result.messages).toHaveLength(2);
+    const texts = tailTexts(result.messages);
+    expect(texts[0]).toBe(DISK_PRESSURE_WARNING_PROMPT);
+    expect(
+      texts.some((text) => text.startsWith("<channel_capabilities>")),
+    ).toBe(true);
+    expect(texts[texts.length - 1]).toBe("[12:01 @assistant]: cleanup?");
+  });
+
+  test("compaction strip plus re-apply does not duplicate the warning", async () => {
+    const runMessages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "find large files" }] },
+    ];
+
+    const first = await applyRuntimeInjections(runMessages, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+    });
+    const stripped = stripInjectionsForCompaction(first.messages);
+    expect(tailTexts(stripped)).toEqual(["find large files"]);
+
+    const second = await applyRuntimeInjections(stripped, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+    });
+    expect(
+      tailTexts(second.messages).filter(
+        (text) => text === DISK_PRESSURE_WARNING_PROMPT,
+      ),
+    ).toHaveLength(1);
+  });
+});

package/src/__tests__/inline-command-runner.test.ts

@@ -27,7 +27,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,