@vellumai/assistant 0.10.6-staging.1 → 0.10.6

package/src/daemon/conversation-messaging.ts

@@ -31,16 +31,19 @@ import {
   attachInlineAttachmentToMessage,
   attachmentExists,
   AttachmentUploadError,
+  getFilePathForAttachment,
   linkAttachmentToMessage,
   validateAttachmentUpload,
 } from "../persistence/attachments-store.js";
 import {
   addMessage,
+  extractAttachmentStoredPaths,
   extractImageSourcePaths,
   getConversation,
   provenanceFromTrustContext,
   setConversationOriginChannelIfUnset,
   setConversationOriginInterfaceIfUnset,
+  updateMessageMetadata,
 } from "../persistence/conversation-crud.js";
 import {
   syncMessageToDisk,
@@ -484,30 +487,18 @@ export async function persistQueuedMessageBody(
     displayContent,
     clientMessageId,
   } = options;
-  const attachmentInputs = attachments.map((attachment) => ({
-    id: attachment.id,
-    filename: attachment.filename,
-    mimeType: attachment.mimeType,
-    data: attachment.data,
-    extractedText: attachment.extractedText,
-    filePath: attachment.filePath,
-  }));
-  const cleanMessage = createUserMessage(content, attachmentInputs);
-  const llmMessage = enrichMessageWithSourcePaths(
-    cleanMessage,
-    attachmentInputs,
-  );
-  log.info(
-    {
-      requestId,
-      contentBlockTypes: Array.isArray(llmMessage.content)
-        ? llmMessage.content.map((b) => b.type)
-        : typeof llmMessage.content,
-      attachmentCount: attachments.length,
-    },
-    "persistUserMessage: content blocks being sent to model",
+  const attachmentInputs: MessageAttachmentInput[] = attachments.map(
+    (attachment) => ({
+      id: attachment.id,
+      filename: attachment.filename,
+      mimeType: attachment.mimeType,
+      data: attachment.data,
+      extractedText: attachment.extractedText,
+      filePath: attachment.filePath,
+    }),
   );
-  ctx.messages.push(llmMessage);
+  const cleanMessage = createUserMessage(content, attachmentInputs);
+  let pushedToHistory = false;
 
   try {
     const turnCtx =
@@ -579,7 +570,6 @@ export async function persistQueuedMessageBody(
     );
 
     if (persistedUserMessage.deduplicated) {
-      ctx.messages.pop();
       return { id: persistedUserMessage.id, deduplicated: true };
     }
 
@@ -608,7 +598,11 @@ export async function persistQueuedMessageBody(
       throw new Error("Failed to persist user message");
     }
 
-    // Index user attachments in the attachments table for later retrieval.
+    // Index user attachments in the attachments table for later retrieval,
+    // capturing the resolved stored path of each linked attachment. Name
+    // collisions in the conversation's attachments/ dir get a -2/-3 suffix,
+    // so the stored path — not the original filename — is the only reliable
+    // on-disk handle for the file.
     for (let i = 0; i < attachments.length; i++) {
       const a = attachments[i];
       try {
@@ -617,7 +611,13 @@ export async function persistQueuedMessageBody(
         // re-uploading. This handles the case where data is empty because
         // the attachment content lives on disk.
         if (a.id && attachmentExists(a.id)) {
-          linkAttachmentToMessage(persistedUserMessage.id, a.id, i);
+          const scopedAttachmentId = linkAttachmentToMessage(
+            persistedUserMessage.id,
+            a.id,
+            i,
+          );
+          attachmentInputs[i].storedPath =
+            getFilePathForAttachment(scopedAttachmentId) ?? undefined;
           continue;
         }
 
@@ -631,7 +631,7 @@ export async function persistQueuedMessageBody(
           );
           continue;
         }
-        attachInlineAttachmentToMessage(
+        const stored = attachInlineAttachmentToMessage(
           persistedUserMessage.id,
           i,
           a.filename,
@@ -639,6 +639,7 @@ export async function persistQueuedMessageBody(
           a.data,
           { sourcePath: a.filePath, normalizeImage: true },
         );
+        attachmentInputs[i].storedPath = stored.filePath;
       } catch (err) {
         if (err instanceof AttachmentUploadError) {
           log.warn(
@@ -654,6 +655,31 @@ export async function persistQueuedMessageBody(
       }
     }
 
+    // Persist the resolved paths so history reloads can rebuild the same
+    // annotation block the in-memory message carries below.
+    const attachmentStoredPaths =
+      extractAttachmentStoredPaths(attachmentInputs);
+    if (attachmentStoredPaths) {
+      updateMessageMetadata(persistedUserMessage.id, { attachmentStoredPaths });
+    }
+
+    const llmMessage = enrichMessageWithSourcePaths(
+      cleanMessage,
+      attachmentInputs,
+    );
+    log.info(
+      {
+        requestId,
+        contentBlockTypes: Array.isArray(llmMessage.content)
+          ? llmMessage.content.map((b) => b.type)
+          : typeof llmMessage.content,
+        attachmentCount: attachments.length,
+      },
+      "persistUserMessage: content blocks being sent to model",
+    );
+    ctx.messages.push(llmMessage);
+    pushedToHistory = true;
+
     // Sync the persisted user message (with attachments) to the disk view
     const conv = getConversation(ctx.conversationId);
     if (conv) {
@@ -666,7 +692,9 @@ export async function persistQueuedMessageBody(
 
     return { id: persistedUserMessage.id, deduplicated: false };
   } catch (err) {
-    ctx.messages.pop();
+    if (pushedToHistory) {
+      ctx.messages.pop();
+    }
     throw err;
   }
 }

package/src/daemon/conversation.ts

@@ -117,7 +117,7 @@ import { isToolResultBlock, undo as undoImpl } from "./conversation-history.js";
 import {
   abortConversation,
   disposeConversation,
-  reinjectImageSourcePaths,
+  reinjectAttachmentPathAnnotations,
 } from "./conversation-lifecycle.js";
 import type {
   EnqueueMessageOptions,
@@ -1044,7 +1044,7 @@ export class Conversation {
         content = [{ type: "text", text: m.content }];
       }
 
-      content = reinjectImageSourcePaths(content, role, m.metadata);
+      content = reinjectAttachmentPathAnnotations(content, role, m.metadata);
 
       // Re-inject persisted injection blocks from metadata so it survives
       // conversation reloads (eviction, restart, fork).

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -29,8 +29,14 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
 // Stub workspace prompt reads so the heartbeat service doesn't try to
 // read real workspace files. Use a fallback for early module-load calls
 // (e.g. AuthSessionCache constructor) before beforeEach sets workspaceDir.
+// The mock spreads the real module so exports it doesn't override (imported
+// by transitive dependencies of the service under test) keep their real,
+// preload-temp-dir-scoped implementations instead of vanishing — a missing
+// export is an import-time SyntaxError for the whole test file.
+const realPlatform = await import("../../util/platform.js");
 const fallbackDir = join(tmpdir(), "vellum-hb-svc-fallback");
 mock.module("../../util/platform.js", () => ({
+  ...realPlatform,
   getWorkspaceDir: () => workspaceDir ?? fallbackDir,
   getWorkspacePromptPath: (name: string) =>
     join(workspaceDir ?? fallbackDir, name),

package/src/hooks/__tests__/hook-live-reload.test.ts

@@ -1,36 +1,36 @@
 /**
- * End-to-end coverage for hook live-reload through the hook loader: an
- * edited hook file takes effect on the next dispatch, without a daemon
- * restart.
+ * Pins the eviction primitives hook live-reload is built on, driven through
+ * the production import machinery (`preImportHooksDir` →
+ * `collectUserHookEntries`), one layer below the sentinel-driven reconcile
+ * that orchestrates them in production (see `../../plugins/mtime-cache.ts`
+ * and its end-to-end suite).
  *
- * The loader keys each hook on its source file's mtime; when the mtime
- * moves it evicts the module from the runtime registry (`evictModule` in
- * `../../plugins/surface-import.ts`) and re-imports, so the fresh content is
- * what dispatches. These tests drive the public collection API against real
- * hook files on disk, which also makes them the regression guard for the
- * Bun behavior the eviction is built on — `require.cache` deletion
- * invalidating dynamic `import()` is intended per
- * github.com/oven-sh/bun/discussions/10162 but not spec-guaranteed, and a
- * Bun upgrade that breaks it must fail here rather than silently degrade
- * hook edits back to restart-required.
+ * Two invariants live here:
+ *
+ * 1. **The Bun primitive.** Deleting a file's `require.cache` entry makes
+ *    the next dynamic `import()` re-evaluate it from disk. This is
+ *    Node-compat surface, intended per
+ *    github.com/oven-sh/bun/discussions/10162 but not spec-guaranteed — a
+ *    Bun upgrade that breaks it must fail here rather than silently degrade
+ *    hook edits back to restart-required.
+ *
+ * 2. **Whole-owner eviction.** Evicting only a hook's own module re-binds
+ *    the re-imported hook to its stale cached helpers. The reconcile sweeps
+ *    every path in the plugin for exactly this reason, and this suite pins
+ *    the failure mode that rule prevents.
  */
 
-import {
-  mkdirSync,
-  mkdtempSync,
-  rmSync,
-  unlinkSync,
-  utimesSync,
-  writeFileSync,
-} from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
+import { evictModule } from "../../plugins/surface-import.js";
 import type { HookEntry } from "../../plugins/types.js";
-import { getWorkspaceHooksDir } from "../../util/platform.js";
 import {
   collectUserHookEntries,
+  evictHooksForOwner,
+  preImportHooksDir,
   resetHookCacheForTests,
 } from "../hook-loader.js";
 
@@ -46,108 +46,122 @@ beforeEach(() => {
   resetHookCacheForTests();
 });
 
-/**
- * Each write gets an explicitly bumped, strictly increasing mtime: two
- * writes can land inside the same filesystem-timestamp granule, which the
- * loader's mtime check would read as "unchanged". Real edits arrive seconds
- * apart; the tests must not race that granularity.
- */
-let mtimeSeq = 1_750_000_000;
-function writeHookFile(hooksDir: string, marker: string): string {
-  const path = join(hooksDir, `${HOOK_NAME}.ts`);
-  writeFileSync(path, `export default () => ${JSON.stringify(marker)};\n`);
-  const stamp = new Date(++mtimeSeq * 1000);
-  utimesSync(path, stamp, stamp);
-  return path;
-}
-
 /** Fresh plugin fixture: `<root>/<name>/hooks/`, unique name per call. */
 let pluginSeq = 0;
 function makePlugin(): { dir: string; hooksDir: string; name: string } {
   const name = `reload-plugin-${++pluginSeq}`;
   const dir = join(root, name);
   const hooksDir = join(dir, "hooks");
+  mkdirSync(join(dir, "lib"), { recursive: true });
   mkdirSync(hooksDir, { recursive: true });
   return { dir, hooksDir, name };
 }
 
-/** Collect the hook chain for a plugin, exactly as dispatch does. */
-async function collect(
-  pluginDir: string,
-  pluginName: string,
-): Promise<HookEntry[]> {
-  return collectUserHookEntries(HOOK_NAME, [[pluginDir, pluginName]]);
+/**
+ * Redeploy an owner's hooks the way the reconcile does: drop its cache
+ * entries, sweep the given module paths, and re-import from disk.
+ */
+async function redeploy(
+  plugin: { hooksDir: string; name: string },
+  modulePaths: string[],
+): Promise<void> {
+  evictHooksForOwner(plugin.name);
+  for (const path of modulePaths) {
+    evictModule(path);
+  }
+  await preImportHooksDir(plugin.hooksDir, plugin.name);
 }
 
-/** Run the single expected hook in the chain and return its result. */
-async function dispatchOne(
-  pluginDir: string,
-  pluginName: string,
-): Promise<unknown> {
-  const entries = await collect(pluginDir, pluginName);
+/** Collect and run the single expected hook, returning its result. */
+async function dispatchOne(plugin: {
+  dir: string;
+  name: string;
+}): Promise<unknown> {
+  const entries: HookEntry[] = await collectUserHookEntries(HOOK_NAME, [
+    [plugin.dir, plugin.name],
+  ]);
   expect(entries).toHaveLength(1);
   return (entries[0]!.fn as () => unknown)();
 }
 
-describe("hook live-reload", () => {
-  test("an edited hook file takes effect on the next dispatch, repeatably", async () => {
+describe("hook reload primitives", () => {
+  test("evict + re-import serves fresh hook code, repeatably", async () => {
     const plugin = makePlugin();
-    writeHookFile(plugin.hooksDir, "v1");
-    expect(await dispatchOne(plugin.dir, plugin.name)).toBe("v1");
+    const hookPath = join(plugin.hooksDir, `${HOOK_NAME}.ts`);
+    writeFileSync(hookPath, `export default () => "v1";\n`);
+    await preImportHooksDir(plugin.hooksDir, plugin.name);
+    expect(await dispatchOne(plugin)).toBe("v1");
 
-    // Two edit → dispatch cycles: the first proves reload works at all, the
-    // second proves a reloaded hook is itself reloadable (edits keep landing
-    // turn after turn, not just once).
+    // Two edit → redeploy cycles: the first proves the primitive, the
+    // second proves a re-imported module is itself evictable again.
     for (const marker of ["v2", "v3"]) {
-      writeHookFile(plugin.hooksDir, marker);
-      expect(await dispatchOne(plugin.dir, plugin.name)).toBe(marker);
+      writeFileSync(
+        hookPath,
+        `export default () => ${JSON.stringify(marker)};\n`,
+      );
+      await redeploy(plugin, [hookPath]);
+      expect(await dispatchOne(plugin)).toBe(marker);
     }
   });
 
-  test("an unchanged hook file is served from the cache, not re-imported", async () => {
+  test("dispatch serves the same cached function until an eviction", async () => {
     const plugin = makePlugin();
-    writeHookFile(plugin.hooksDir, "stable");
-
-    const first = await collect(plugin.dir, plugin.name);
-    const second = await collect(plugin.dir, plugin.name);
-
-    // Same function instance means the cache hit — dispatch after dispatch
-    // costs a stat, not an import.
+    writeFileSync(
+      join(plugin.hooksDir, `${HOOK_NAME}.ts`),
+      `export default () => "stable";\n`,
+    );
+    await preImportHooksDir(plugin.hooksDir, plugin.name);
+
+    const first = await collectUserHookEntries(HOOK_NAME, [
+      [plugin.dir, plugin.name],
+    ]);
+    const second = await collectUserHookEntries(HOOK_NAME, [
+      [plugin.dir, plugin.name],
+    ]);
+
+    // Same function instance: dispatch is a map lookup, not an import.
     expect(second[0]!.fn).toBe(first[0]!.fn);
   });
 
-  test("a deleted hook stops dispatching; recreating it serves the new content", async () => {
+  test("evicting only the hook re-binds it to a stale helper; the full sweep does not", async () => {
     const plugin = makePlugin();
-    const path = writeHookFile(plugin.hooksDir, "original");
-    expect(await dispatchOne(plugin.dir, plugin.name)).toBe("original");
-
-    unlinkSync(path);
-    expect(await collect(plugin.dir, plugin.name)).toHaveLength(0);
-
-    // The recreated file must dispatch its own content, not the module the
-    // registry cached for the deleted original.
-    writeHookFile(plugin.hooksDir, "recreated");
-    expect(await dispatchOne(plugin.dir, plugin.name)).toBe("recreated");
+    const helperPath = join(plugin.dir, "lib", "helper.ts");
+    const hookPath = join(plugin.hooksDir, `${HOOK_NAME}.ts`);
+    writeFileSync(helperPath, `export const value = "h1";\n`);
+    writeFileSync(
+      hookPath,
+      `import { value } from "../lib/helper.ts";\nexport default () => value;\n`,
+    );
+    await preImportHooksDir(plugin.hooksDir, plugin.name);
+    expect(await dispatchOne(plugin)).toBe("h1");
+
+    writeFileSync(helperPath, `export const value = "h2";\n`);
+
+    // Partial eviction — the hook file only. The re-evaluated hook binds to
+    // the helper module still cached at h1: the version-skew failure mode
+    // whole-plugin sweeping exists to prevent.
+    await redeploy(plugin, [hookPath]);
+    expect(await dispatchOne(plugin)).toBe("h1");
+
+    // The full sweep (hook + helper, as the reconcile's eviction list would
+    // carry) brings the edit through.
+    await redeploy(plugin, [hookPath, helperPath]);
+    expect(await dispatchOne(plugin)).toBe("h2");
   });
 
-  test("standalone workspace hooks reload the same way", async () => {
-    const wsHooksDir = getWorkspaceHooksDir();
-    mkdirSync(wsHooksDir, { recursive: true });
-    const path = writeHookFile(wsHooksDir, "ws-v1");
-
-    try {
-      const before = await collectUserHookEntries(HOOK_NAME, []);
-      expect(before).toHaveLength(1);
-      expect(before[0]!.owner.kind).toBe("workspace");
-      expect((before[0]!.fn as () => unknown)()).toBe("ws-v1");
-
-      writeHookFile(wsHooksDir, "ws-v2");
-      const after = await collectUserHookEntries(HOOK_NAME, []);
-      expect((after[0]!.fn as () => unknown)()).toBe("ws-v2");
-    } finally {
-      // The workspace hooks dir is shared per-process test state — leave it
-      // the way this test found it.
-      unlinkSync(path);
-    }
+  test("re-import after owner eviction drops hooks whose files are gone", async () => {
+    const plugin = makePlugin();
+    const hookPath = join(plugin.hooksDir, `${HOOK_NAME}.ts`);
+    writeFileSync(hookPath, `export default () => "here";\n`);
+    await preImportHooksDir(plugin.hooksDir, plugin.name);
+    expect(await dispatchOne(plugin)).toBe("here");
+
+    rmSync(hookPath);
+    await redeploy(plugin, [hookPath]);
+
+    const entries = await collectUserHookEntries(HOOK_NAME, [
+      [plugin.dir, plugin.name],
+    ]);
+    expect(entries).toHaveLength(0);
   });
 });