@vellumai/assistant 0.8.3 → 0.8.5

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,16 +96,61 @@ 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;
@@ -117,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;
   },
@@ -200,6 +289,12 @@ describe("memoryRetrospectiveJob", () => {
     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 () => {
@@ -220,6 +315,13 @@ describe("memoryRetrospectiveJob", () => {
     expect(bootstrapCalls[0]!.forkParentConversationId).toBe("src-conv-1");
   });
 
+  test("legacy path: wake opts include suppressWakeSurface so the full retrospective prompt isn't rendered as a 'Conversation Woke' card body to clients", async () => {
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(wakeCalls).toHaveLength(1);
+    expect(wakeCalls[0]!.opts.suppressWakeSurface).toBe(true);
+  });
+
   test("no-new-messages early return: neither field changes, no wake, no bootstrap", async () => {
     newMessages = [];
     const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
@@ -408,4 +510,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");
+  });
 });

package/src/memory/auto-analysis-enqueue.ts

@@ -6,7 +6,7 @@ import {
 } from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
 import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
-import { upsertAutoAnalysisJob } from "./jobs-store.js";
+import { isMemoryEnabled, upsertAutoAnalysisJob } from "./jobs-store.js";
 
 const log = getLogger("auto-analysis-enqueue");
 
@@ -46,6 +46,10 @@ export function enqueueAutoAnalysisIfEnabled(args: {
 }): void {
   const { conversationId, trigger } = args;
 
+  if (!isMemoryEnabled()) {
+    return;
+  }
+
   let config;
   try {
     config = getConfig();