@vellumai/assistant 0.8.2 → 0.8.4

package/src/memory/__tests__/memory-retrospective-job.test.ts

@@ -33,11 +33,52 @@ let priorRetroMessages: Array<{ role: string; content: string }> = [];
 
 let mockWakeResult: { invoked: boolean; reason?: string } = { invoked: true };
 let mockWakeThrows: Error | null = null;
-let wakeCalls: Array<{ conversationId: string; hint: string }> = [];
+let wakeCalls: Array<{
+  conversationId: string;
+  hint: string;
+  opts: Record<string, unknown>;
+}> = [];
 let bootstrappedConversationId = "bg-conv-new";
 let bootstrapCalls: Array<{ forkParentConversationId?: string }> = [];
 let deletedConversationIds: string[] = [];
 
+// Fork-path mocks. Flag off by default so legacy-path tests stay untouched.
+let forkFlagEnabled = false;
+let forkedConversationId = "fork-conv-1";
+let forkCalls: Array<{
+  conversationId: string;
+  throughMessageId?: string;
+  source: string;
+  title: string;
+  conversationType?: string;
+  groupId?: string;
+}> = [];
+let addMessageCalls: Array<{
+  conversationId: string;
+  role: string;
+  content: string;
+  metadata: unknown;
+}> = [];
+
+// Per-conversation overrides for getConversation. Lets fork-path tests stage
+// a fork-kind prior retrospective row alongside the default legacy stub.
+type ConversationStub = {
+  source: string;
+  forkParentMessageId: string | null;
+  title?: string;
+};
+let conversationOverrides: Record<string, ConversationStub> = {};
+
+// Per-conversation overrides for getMessages so fork-path tests can return
+// fork-shaped message rows (with metadata stamps + createdAt boundaries).
+type StubMessage = {
+  role: string;
+  content: string;
+  createdAt: number;
+  metadata: string | null;
+};
+let messagesByConversationId: Record<string, StubMessage[]> = {};
+
 mock.module("../memory-retrospective-state.js", () => ({
   getRetrospectiveState: (_id: string) => mockState,
   upsertRetrospectiveState: (args: {
@@ -55,20 +96,97 @@ mock.module("../memory-retrospective-state.js", () => ({
 mock.module("../conversation-crud.js", () => ({
   getMessagesAfter: (_id: string, _afterId: string | null) => newMessages,
   getMessages: (id: string) => {
+    if (messagesByConversationId[id]) return messagesByConversationId[id];
     if (id === priorRetroId) return priorRetroMessages;
     return [];
   },
   findMostRecentRetrospectiveFor: (_id: string) =>
     priorRetroId ? { id: priorRetroId } : null,
+  // The fork path calls `getConversation(sourceConversationId)` to read the
+  // source's title for the fork title. `collectPriorRetrospectiveRemembers`
+  // also calls it with the prior retro id to discriminate legacy vs fork
+  // sources — for that id return a legacy-shaped row by default so existing
+  // tests exercise the unchanged extract-everything code path.
+  // `conversationOverrides` lets per-test setup stage fork-kind priors.
+  getConversation: (id: string) => {
+    if (conversationOverrides[id]) return conversationOverrides[id];
+    if (id === priorRetroId) {
+      return {
+        source: "memory-retrospective",
+        forkParentMessageId: null,
+      };
+    }
+    return {
+      source: "user",
+      forkParentMessageId: null,
+      title: "Source conversation",
+    };
+  },
+  forkConversation: (params: {
+    conversationId: string;
+    throughMessageId?: string;
+    source: string;
+    title: string;
+    conversationType?: string;
+    groupId?: string;
+  }) => {
+    forkCalls.push(params);
+    return { id: forkedConversationId };
+  },
+  addMessage: async (
+    conversationId: string,
+    role: string,
+    content: string,
+    metadata: unknown,
+  ) => {
+    addMessageCalls.push({ conversationId, role, content, metadata });
+  },
   deleteConversation: (id: string) => {
     deletedConversationIds.push(id);
   },
 }));
 
+mock.module("../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (flag: string) =>
+    flag === "memory-retrospective-fork" && forkFlagEnabled,
+}));
+
+let transcriptFormatterCalls: Array<{
+  messageIds: string[];
+  timeZone?: string;
+  assistantName?: string | null;
+  userName?: string | null;
+}> = [];
+
 mock.module("../../export/transcript-formatter.js", () => ({
   formatMessageSliceForTranscript: (
     messages: Array<{ id: string; createdAt: number }>,
-  ) => messages.map((m) => `[msg ${m.id}]`).join("\n"),
+    options: {
+      timeZone?: string;
+      assistantName?: string | null;
+      userName?: string | null;
+    } = {},
+  ) => {
+    transcriptFormatterCalls.push({
+      messageIds: messages.map((m) => m.id),
+      timeZone: options.timeZone,
+      assistantName: options.assistantName,
+      userName: options.userName,
+    });
+    return messages.map((m) => `[msg ${m.id}]`).join("\n");
+  },
+}));
+
+let mockAssistantName: string | null = "Bob";
+let mockUserName: string | null = "Alice";
+
+mock.module("../../daemon/identity-helpers.js", () => ({
+  getAssistantName: () => mockAssistantName,
+  resolveUserName: (_workspaceDir: string) => mockUserName,
+}));
+
+mock.module("../../util/platform.js", () => ({
+  getWorkspaceDir: () => "/tmp/test-workspace",
 }));
 
 mock.module("../conversation-bootstrap.js", () => ({
@@ -85,11 +203,14 @@ mock.module("../../daemon/trust-context.js", () => ({
 }));
 
 mock.module("../../runtime/agent-wake.js", () => ({
-  wakeAgentForOpportunity: async (opts: {
-    conversationId: string;
-    hint: string;
-  }) => {
-    wakeCalls.push({ conversationId: opts.conversationId, hint: opts.hint });
+  wakeAgentForOpportunity: async (
+    opts: { conversationId: string; hint: string } & Record<string, unknown>,
+  ) => {
+    wakeCalls.push({
+      conversationId: opts.conversationId,
+      hint: opts.hint,
+      opts,
+    });
     if (mockWakeThrows) throw mockWakeThrows;
     return mockWakeResult;
   },
@@ -102,9 +223,19 @@ mock.module("../jobs-store.js", () => ({
 import type { MemoryJob } from "../jobs-store.js";
 import { memoryRetrospectiveJob } from "../memory-retrospective-job.js";
 
-const stubConfig = {
-  memory: { v2: { enabled: true } },
-} as unknown as Parameters<typeof memoryRetrospectiveJob>[1];
+function makeConfig(
+  overrides: { userTimezone?: string; detectedTimezone?: string } = {},
+): Parameters<typeof memoryRetrospectiveJob>[1] {
+  return {
+    memory: { v2: { enabled: true } },
+    ui: {
+      userTimezone: overrides.userTimezone,
+      detectedTimezone: overrides.detectedTimezone,
+    },
+  } as unknown as Parameters<typeof memoryRetrospectiveJob>[1];
+}
+
+const stubConfig = makeConfig();
 
 function makeJob(conversationId = "src-conv-1"): MemoryJob<{
   conversationId?: string;
@@ -155,6 +286,15 @@ describe("memoryRetrospectiveJob", () => {
     bootstrappedConversationId = "bg-conv-new";
     bootstrapCalls = [];
     deletedConversationIds = [];
+    transcriptFormatterCalls = [];
+    mockAssistantName = "Bob";
+    mockUserName = "Alice";
+    forkFlagEnabled = false;
+    forkedConversationId = "fork-conv-1";
+    forkCalls = [];
+    addMessageCalls = [];
+    conversationOverrides = {};
+    messagesByConversationId = {};
   });
 
   test("first-run happy path: no state row, no prior retrospective, both pointer fields set on success", async () => {
@@ -274,6 +414,44 @@ describe("memoryRetrospectiveJob", () => {
     expect(hint).toContain("- a real save");
   });
 
+  test("transcript is formatted in the configured user timezone and the prompt discloses it", async () => {
+    const config = makeConfig({ userTimezone: "America/Los_Angeles" });
+    await memoryRetrospectiveJob(makeJob(), config);
+
+    expect(transcriptFormatterCalls).toHaveLength(1);
+    expect(transcriptFormatterCalls[0]!.timeZone).toBe("America/Los_Angeles");
+
+    const hint = wakeCalls[0]!.hint;
+    expect(hint).toContain("Timestamps are in America/Los_Angeles.");
+  });
+
+  test("detected timezone is used when no manual override is set", async () => {
+    const config = makeConfig({ detectedTimezone: "Europe/Berlin" });
+    await memoryRetrospectiveJob(makeJob(), config);
+
+    expect(transcriptFormatterCalls[0]!.timeZone).toBe("Europe/Berlin");
+
+    const hint = wakeCalls[0]!.hint;
+    expect(hint).toContain("Timestamps are in Europe/Berlin.");
+  });
+
+  test("resolved assistant and user display names are passed to the transcript formatter", async () => {
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(transcriptFormatterCalls).toHaveLength(1);
+    expect(transcriptFormatterCalls[0]!.assistantName).toBe("Bob");
+    expect(transcriptFormatterCalls[0]!.userName).toBe("Alice");
+  });
+
+  test("formatter receives null names when identity files are missing — formatter handles fallback", async () => {
+    mockAssistantName = null;
+    mockUserName = null;
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(transcriptFormatterCalls[0]!.assistantName).toBeNull();
+    expect(transcriptFormatterCalls[0]!.userName).toBeNull();
+  });
+
   test("non-remember tool_use blocks in the prior retro are ignored", async () => {
     priorRetroId = "prior-retro-conv-1";
     priorRetroMessages = [
@@ -325,4 +503,223 @@ describe("memoryRetrospectiveJob", () => {
     const hint = wakeCalls[0]!.hint;
     expect(hint).toContain("<\u200B/already_remembered>");
   });
+
+  test("fork path: persisted instruction is stamped with hidden: true so the UI list serializer drops it", async () => {
+    forkFlagEnabled = true;
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(addMessageCalls).toHaveLength(1);
+    expect(addMessageCalls[0]!.conversationId).toBe("fork-conv-1");
+    expect(addMessageCalls[0]!.role).toBe("user");
+    expect(addMessageCalls[0]!.metadata).toEqual({
+      kind: "memory_retrospective_instruction",
+      hidden: true,
+    });
+  });
+
+  test("fork path: forked retrospective is bucketed as background under the retrospective group", async () => {
+    forkFlagEnabled = true;
+    const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(outcome.kind).toBe("invoked");
+    expect(forkCalls).toHaveLength(1);
+    expect(forkCalls[0]!.conversationType).toBe("background");
+    expect(forkCalls[0]!.groupId).toBe("system:background");
+  });
+
+  test("fork path: wake opts include suppressWakeSurface so clients don't render an empty wake card on top of the '(Retrospective)' fork", async () => {
+    forkFlagEnabled = true;
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(forkCalls).toHaveLength(1);
+    expect(wakeCalls).toHaveLength(1);
+    expect(wakeCalls[0]!.conversationId).toBe("fork-conv-1");
+    const opts = wakeCalls[0]!.opts;
+    expect(opts.suppressWakeSurface).toBe(true);
+    // Sanity: the other fork-specific opts the handler relies on are still set.
+    expect(opts.skipHintInjection).toBe(true);
+    expect(opts.suppressAutoCompaction).toBe(true);
+    expect(opts.hintRole).toBe("user");
+  });
+
+  test("fork path: fork is pinned to the computed cutoffMessageId so late-arriving messages don't sneak into this run", async () => {
+    // Without `throughMessageId`, the fork snapshots the latest source
+    // message at fork time. If a new user/assistant turn lands between the
+    // slice read and the fork, this run would process the late turn while
+    // state advances only to `cutoffMessageId`, causing the next
+    // retrospective to reprocess it.
+    forkFlagEnabled = true;
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(forkCalls).toHaveLength(1);
+    expect(forkCalls[0]!.throughMessageId).toBe("m3");
+  });
+
+  test("fork path: prior fork-kind retrospective with nested-fork ancestry still surfaces its post-fork remembers in <already_remembered>", async () => {
+    // The source conversation was itself a fork. Its assistant messages
+    // therefore carry `forkSourceMessageId` values pointing at the
+    // ANCESTOR's message ids — not at the new fork's `forkParentMessageId`.
+    // The boundary detector must locate the boundary by scanning for the
+    // last metadata stamp regardless of value, not by equality against
+    // `forkParentMessageId` (which would miss every copied row and lose
+    // dedup context).
+    forkFlagEnabled = true;
+    priorRetroId = "prior-fork-retro-1";
+
+    // The fork's `forkParentMessageId` is the source conv's tip ("m-src-2"),
+    // but the cloned messages preserve ancestor stamps ("m-ancestor-*").
+    conversationOverrides[priorRetroId] = {
+      source: "memory-retrospective-fork",
+      forkParentMessageId: "m-src-2",
+    };
+    messagesByConversationId[priorRetroId] = [
+      // Copied prefix — note metadata stamps point at the ANCESTOR, not
+      // `forkParentMessageId`. The old detector would return null here.
+      {
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "hi" }]),
+        createdAt: 1000,
+        metadata: JSON.stringify({ forkSourceMessageId: "m-ancestor-1" }),
+      },
+      {
+        role: "assistant",
+        // An inline `remember` from the source conv (should NOT leak into
+        // dedup baseline — it's part of the copied prefix, not the post-fork
+        // retrospective tail).
+        content: JSON.stringify([
+          {
+            type: "tool_use",
+            name: "remember",
+            input: { content: "source-inline save — must be excluded" },
+          },
+        ]),
+        createdAt: 2000,
+        metadata: JSON.stringify({ forkSourceMessageId: "m-ancestor-2" }),
+      },
+      // Post-fork instruction (no forkSourceMessageId) + the wake's tail
+      // assistant turn with the retrospective's own remember call.
+      {
+        role: "user",
+        content: JSON.stringify([
+          { type: "text", text: "Retrospective instruction" },
+        ]),
+        createdAt: 3000,
+        metadata: JSON.stringify({
+          kind: "memory_retrospective_instruction",
+          hidden: true,
+        }),
+      },
+      {
+        role: "assistant",
+        content: JSON.stringify([
+          {
+            type: "tool_use",
+            name: "remember",
+            input: { content: "retrospective save — must be included" },
+          },
+        ]),
+        createdAt: 4000,
+        metadata: null,
+      },
+    ];
+
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    // The fork path persists the prompt as a user-role message, not via the
+    // wake's hint. Pull the rendered text block out of the persisted JSON.
+    expect(addMessageCalls).toHaveLength(1);
+    const blocks = JSON.parse(addMessageCalls[0]!.content) as Array<{
+      type: string;
+      text: string;
+    }>;
+    const instructionText = blocks[0]!.text;
+    expect(instructionText).toContain(
+      "- retrospective save — must be included",
+    );
+    expect(instructionText).not.toContain("source-inline save");
+    // Sanity: the "first retrospective" sentinel should not appear — we
+    // located dedup context.
+    expect(instructionText).not.toContain(
+      "(none — this is your first retrospective over this conversation)",
+    );
+  });
+
+  test("fork path: prior fork-kind retrospective with no copied messages degrades to empty dedup", async () => {
+    // Corrupted/empty fork-kind prior: no message carries
+    // `forkSourceMessageId`. The detector should return null and the
+    // handler should treat dedup as empty rather than dumping everything
+    // (which would leak any pre-fork content into the baseline).
+    forkFlagEnabled = true;
+    priorRetroId = "prior-fork-retro-2";
+
+    conversationOverrides[priorRetroId] = {
+      source: "memory-retrospective-fork",
+      forkParentMessageId: "m-src-2",
+    };
+    messagesByConversationId[priorRetroId] = [
+      {
+        role: "assistant",
+        content: JSON.stringify([
+          {
+            type: "tool_use",
+            name: "remember",
+            input: { content: "would-be-leaked save" },
+          },
+        ]),
+        createdAt: 1000,
+        metadata: null,
+      },
+    ];
+
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(addMessageCalls).toHaveLength(1);
+    const blocks = JSON.parse(addMessageCalls[0]!.content) as Array<{
+      type: string;
+      text: string;
+    }>;
+    const instructionText = blocks[0]!.text;
+    expect(instructionText).not.toContain("- would-be-leaked save");
+    expect(instructionText).toContain(
+      "(none — this is your first retrospective over this conversation)",
+    );
+  });
+
+  test("fork path: prompt anchors review window at first turn_context current_time and disambiguates first-pass vs incremental", async () => {
+    forkFlagEnabled = true;
+    // Stage a user turn whose content carries a turn_context current_time
+    // block — the handler should anchor the prompt at that timestamp.
+    newMessages = [
+      {
+        id: "m1",
+        createdAt: Date.parse("2026-05-11T10:00:00Z"),
+        role: "user",
+        content: JSON.stringify([
+          {
+            type: "text",
+            text: "<turn_context>\ncurrent_time: 2026-05-11T10:00:00-07:00\n</turn_context>\n\nhi",
+          },
+        ]),
+      },
+      // Wake's response — no turn_context, not used as anchor.
+      {
+        id: "m2",
+        createdAt: Date.parse("2026-05-11T10:05:00Z"),
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "hello" }]),
+      },
+    ] as Array<{ id: string; createdAt: number } & Record<string, unknown>>;
+
+    // Incremental run — `lastProcessedMessageId` already set.
+    mockState = {
+      conversationId: "src-conv-1",
+      lastProcessedMessageId: "prev-msg",
+      lastRunAt: Date.now() - 60 * 60 * 1000,
+    };
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(addMessageCalls).toHaveLength(1);
+    expect(forkCalls).toHaveLength(1);
+    expect(forkCalls[0]!.throughMessageId).toBe("m2");
+  });
 });