@vellumai/assistant 0.8.1 → 0.8.2

package/src/memory/v2/__tests__/injection.test.ts

@@ -879,17 +879,17 @@ describe("injectMemoryV2Block", () => {
   // Unified pool — skills as `skills/<id>` slugs
   // ---------------------------------------------------------------------------
 
-  test("renders a skill-only block via the skills/ slug prefix", async () => {
+  test("renders a retrieved skills/<id> slug under Skills You Can Use", async () => {
     // No concept-page candidates this turn — the only ANN hit is a skill
     // slug. The render path branches on `skills/` prefix: it pulls the
     // entry from the skill-store cache (mocked) and emits the bullet under
     // the `### Skills You Can Use` subsection.
-    stageTurn([{ slug: "skills/example-skill-a", denseScore: 0.9 }]);
+    stageTurn([{ slug: "skills/retrieved-skill", denseScore: 0.9 }]);
     stageSkills([
       {
-        id: "example-skill-a",
+        id: "retrieved-skill",
         content:
-          'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
+          'The "Retrieved Skill" skill (retrieved-skill) is available. Helps with retrieved skills.',
       },
     ]);
 
@@ -904,16 +904,18 @@ describe("injectMemoryV2Block", () => {
       config: makeConfig(),
     });
 
-    expect(result.toInject).toEqual(["skills/example-skill-a"]);
+    expect(result.toInject).toEqual(["skills/retrieved-skill"]);
     expect(result.block).not.toBeNull();
     expect(result.block).not.toContain("<memory>");
     expect(result.block).not.toContain("</memory>");
     expect(result.block).not.toContain("## What I Remember Right Now");
     expect(result.block).not.toContain("# memory/concepts/alice-vscode.md");
-    expect(result.block).toContain("### Skills You Can Use");
-    expect(result.block).toContain(
-      '- The "Example Skill A" skill (example-skill-a) is available. Helps with examples. → use skill_load to activate',
+    const headerIdx = result.block!.indexOf("### Skills You Can Use");
+    const skillIdx = result.block!.indexOf(
+      '- The "Retrieved Skill" skill (retrieved-skill) is available. Helps with retrieved skills. → use skill_load to activate',
     );
+    expect(headerIdx).toBeGreaterThan(-1);
+    expect(skillIdx).toBeGreaterThan(headerIdx);
   });
 
   test("renders concept-page sections before the skills subsection in mixed blocks", async () => {
@@ -1679,6 +1681,56 @@ describe("injectMemoryV2Block", () => {
       expect(row.concepts).toEqual([]);
     });
 
+    test("flag-on: router-failure path swallows a save() error and returns block:null instead of throwing", async () => {
+      // PR 30176 refactored router-failure handling to delegate to
+      // `finalizeInjection`. That regressed the prior inline log-and-continue
+      // semantics on the router-failure path: a transient SQLite write
+      // throwing during the stub-state save now aborted the whole turn
+      // because `finalizeInjection`'s try/catch re-threw caughtErr at the end.
+      //
+      // This test stages exactly that scenario — router returns
+      // `failureReason: api_error` AND `save()` throws — and asserts the
+      // turn completes with `{ block: null, toInject: [] }` rather than
+      // propagating the SQLite error to `prepareMemory`.
+      routerState.nextResult = {
+        selectedSlugs: [],
+        failureReason: "api_error",
+      };
+      activationStoreState.saveShouldThrow = true;
+
+      let threw: unknown = undefined;
+      let result: Awaited<ReturnType<typeof injectMemoryV2Block>> | undefined;
+      try {
+        result = await injectMemoryV2Block({
+          database: db,
+          conversationId: "conv-router-fail-save-throws",
+          currentTurn: 5,
+          userMessage: "anything",
+          assistantMessage: "ok",
+          nowText: "Now",
+          messageId: "msg-fail-save",
+          config: makeConfig({ router: { enabled: true } }),
+        });
+      } catch (err) {
+        threw = err;
+      }
+
+      expect(threw).toBeUndefined();
+      expect(result).toBeDefined();
+      expect(result!.block).toBeNull();
+      expect(result!.toInject).toEqual([]);
+
+      // Telemetry still flushes with `mode: "errored"` so the failure stays
+      // observable — the same row the inline pre-refactor path emitted.
+      expect(telemetryState.recordCalls.length).toBe(1);
+      const row = telemetryState.recordCalls[0] as {
+        mode: string;
+        concepts: unknown[];
+      };
+      expect(row.mode).toBe("errored");
+      expect(row.concepts).toEqual([]);
+    });
+
     test("flag-on: router abstention (empty selectedSlugs, no failure) writes mode:`router` row with no injected pages", async () => {
       routerState.nextResult = {
         selectedSlugs: [],
@@ -1904,5 +1956,43 @@ describe("injectMemoryV2Block", () => {
       const row = telemetryState.recordCalls[0] as { mode: string };
       expect(row.mode).toBe("per-turn");
     });
+
+    test("flag-on + mode='context-load': router runs (everInjected was cleared by onCompacted so dedupe is a no-op; abstention is accepted as the trade-off)", async () => {
+      // Context-load is the full top-K bootstrap fired after compaction or
+      // a fresh conversation reload. The earlier worry about the router's
+      // `everInjected` dedupe filtering out post-compaction restorations
+      // doesn't apply: `ConversationGraphMemory.onCompacted` calls
+      // `evictCompactedTurnsV2` which empties the list before this code
+      // runs. Router abstention here means no v2 pages this turn — that's
+      // preferable to letting the activation graph pick something arbitrary.
+      routerState.nextResult = {
+        selectedSlugs: ["alice-vscode"],
+        failureReason: null,
+      };
+
+      const result = await injectMemoryV2Block({
+        database: db,
+        conversationId: "conv-context-load-router-on",
+        currentTurn: 1,
+        userMessage: "Tell me about Alice",
+        assistantMessage: "",
+        nowText: "Now",
+        messageId: "msg-1",
+        mode: "context-load",
+        config: makeConfig({ router: { enabled: true } }),
+      });
+
+      // Router was called on context-load too.
+      expect(routerState.callCount).toBe(1);
+
+      // Router's picks were rendered.
+      expect(result.toInject).toEqual(["alice-vscode"]);
+      expect(result.block).toContain("# memory/concepts/alice-vscode.md");
+
+      // Telemetry row reflects the router mode, not the activation mode.
+      expect(telemetryState.recordCalls.length).toBe(1);
+      const row = telemetryState.recordCalls[0] as { mode: string };
+      expect(row.mode).toBe("router");
+    });
   });
 });

package/src/memory/v2/__tests__/migration.test.ts

@@ -754,6 +754,93 @@ describe("runMemoryV2Migration", () => {
     expect(body).toContain("second body");
   });
 
+  test("force=true cleanly strips the prior migration block from essentials.md", async () => {
+    insertNode(database, {
+      content: "Alice prefers VS Code.",
+      significance: 0.95,
+    });
+    await runMemoryV2Migration({
+      workspaceDir,
+      database,
+      provider: buildStubProvider("body"),
+    });
+
+    const essentialsPath = join(workspaceDir, "memory", "essentials.md");
+    const afterFirst = readFileSync(essentialsPath, "utf-8");
+    expect(afterFirst).toContain("<!-- migration:v1-to-v2 -->");
+    expect(afterFirst).toContain("<!-- /migration:v1-to-v2 -->");
+
+    await runMemoryV2Migration({
+      workspaceDir,
+      database,
+      provider: buildStubProvider("body"),
+      force: true,
+    });
+
+    const afterRerun = readFileSync(essentialsPath, "utf-8");
+    // Exactly one migration block — no leftover/duplicated markers.
+    expect(afterRerun.match(/<!-- migration:v1-to-v2 -->/g)?.length ?? 0).toBe(
+      1,
+    );
+    expect(
+      afterRerun.match(/<!-- \/migration:v1-to-v2 -->/g)?.length ?? 0,
+    ).toBe(1);
+  });
+
+  test("force=true preserves user-appended content after the migration block", async () => {
+    insertNode(database, {
+      content: "Alice prefers VS Code.",
+      significance: 0.95,
+    });
+    await runMemoryV2Migration({
+      workspaceDir,
+      database,
+      provider: buildStubProvider("body"),
+    });
+
+    const essentialsPath = join(workspaceDir, "memory", "essentials.md");
+    const beforeAppend = readFileSync(essentialsPath, "utf-8");
+    const userAppended = "\nUser added this after the migration ran.\n";
+    writeFileSync(essentialsPath, beforeAppend + userAppended, "utf-8");
+
+    await runMemoryV2Migration({
+      workspaceDir,
+      database,
+      provider: buildStubProvider("body"),
+      force: true,
+    });
+
+    const after = readFileSync(essentialsPath, "utf-8");
+    expect(after).toContain("User added this after the migration ran.");
+    // And exactly one migration envelope remains.
+    expect(after.match(/<!-- migration:v1-to-v2 -->/g)?.length ?? 0).toBe(1);
+    expect(after.match(/<!-- \/migration:v1-to-v2 -->/g)?.length ?? 0).toBe(1);
+  });
+
+  test("force=true on legacy (close-marker-less) file strips only up to the next blank line", async () => {
+    // Simulate a file written by the prior migration format: opening marker
+    // with no closing sentinel, with user-appended content separated by a
+    // blank line. The strip should preserve the user content.
+    insertNode(database, { content: "Alice prefers VS Code." });
+    const essentialsPath = join(workspaceDir, "memory", "essentials.md");
+    writeFileSync(
+      essentialsPath,
+      "<!-- migration:v1-to-v2 -->\nlegacy migrated line\n\nUser-appended legacy note.\n",
+      "utf-8",
+    );
+
+    await runMemoryV2Migration({
+      workspaceDir,
+      database,
+      provider: buildStubProvider("body"),
+      force: true,
+    });
+
+    const after = readFileSync(essentialsPath, "utf-8");
+    expect(after).toContain("User-appended legacy note.");
+    expect(after).not.toContain("legacy migrated line");
+  });
+
   test("clearing the sentinel allows a non-force re-run", async () => {
     insertNode(database, { content: "fact" });
     const provider = buildStubProvider("body");

package/src/memory/v2/__tests__/page-index.test.ts

@@ -245,6 +245,89 @@ describe("getPageIndex", () => {
     const idx = await getPageIndex(workspaceDir);
     expect(idx.bySlug.get("alice")?.summary.length).toBe(200);
   });
+
+  test("collapses embedded newlines in frontmatter.summary to single spaces", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("alice", { summary: "First line.\nSecond line.\nThird line." }),
+    );
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("alice")?.summary).toBe(
+      "First line. Second line. Third line.",
+    );
+  });
+
+  test("collapses embedded newlines and runs of whitespace in body fallback", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("alice", {
+        body: "  Body  with\n\nmultiple\tlines\n  and   spaces.  ",
+      }),
+    );
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("alice")?.summary).toBe(
+      "Body with multiple lines and spaces.",
+    );
+  });
+
+  test("normalizes skill-entry content with embedded newlines", async () => {
+    skillState.entries = [
+      { id: "browser", content: "Drive a browser.\nSupports multiple tabs." },
+    ];
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("skills/browser")?.summary).toBe(
+      "Drive a browser. Supports multiple tabs.",
+    );
+  });
+
+  test("renders a single line per entry even when summaries contain newlines", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("alice", { summary: "line one\nline two" }),
+    );
+    const idx = await getPageIndex(workspaceDir);
+    // Exactly one trailing newline — the entry itself must not split.
+    expect(idx.rendered.split("\n").filter(Boolean).length).toBe(1);
+  });
+
+  test("drops a user concept page whose slug collides with a seeded skill entry", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("skills/browser", {
+        summary: "User-authored page that shadows the skill.",
+      }),
+    );
+    skillState.entries = [{ id: "browser", content: "Seeded skill content." }];
+
+    const idx = await getPageIndex(workspaceDir);
+    // Only the skill entry survives under skills/browser.
+    expect(idx.entries.filter((e) => e.slug === "skills/browser").length).toBe(
+      1,
+    );
+    expect(idx.bySlug.get("skills/browser")?.summary).toBe(
+      "Seeded skill content.",
+    );
+  });
+
+  test("collision dedupe leaves non-colliding pages and skills intact", async () => {
+    await writePage(workspaceDir, makePage("alice", { summary: "Alice" }));
+    await writePage(
+      workspaceDir,
+      makePage("skills/browser", { summary: "Shadow page." }),
+    );
+    skillState.entries = [
+      { id: "browser", content: "Seeded browser." },
+      { id: "calendar", content: "Seeded calendar." },
+    ];
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.entries.map((e) => e.slug)).toEqual([
+      "alice",
+      "skills/browser",
+      "skills/calendar",
+    ]);
+    expect(idx.bySlug.get("skills/browser")?.summary).toBe("Seeded browser.");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/memory/v2/__tests__/prompts-router.test.ts

@@ -123,6 +123,39 @@ describe("renderRouterPrompt — page index handling", () => {
   });
 });
 
+describe("renderRouterPrompt — replacement-pattern specials", () => {
+  // String.prototype.replaceAll interprets `$&`, `$'`, `` $` ``, `$$`, and
+  // `$n` in the replacement string as backreferences. LLM-generated page
+  // index content can contain literal `$` runs, so the substituter must
+  // pass values through unchanged.
+  const SPECIALS = "$& and $' and $` and $$ and $1";
+
+  test.each([
+    [
+      "pageIndexBlock",
+      { assistantName: "Aria", userName: "Alice", pageIndexBlock: SPECIALS },
+    ],
+    [
+      "assistantName",
+      {
+        assistantName: SPECIALS,
+        userName: "Alice",
+        pageIndexBlock: SAMPLE_INDEX,
+      },
+    ],
+    [
+      "userName",
+      {
+        assistantName: "Aria",
+        userName: SPECIALS,
+        pageIndexBlock: SAMPLE_INDEX,
+      },
+    ],
+  ])("renders %s with $ specials verbatim", (_, opts) => {
+    expect(renderRouterPrompt(opts)).toContain(SPECIALS);
+  });
+});
+
 describe("renderRouterPrompt — determinism & snapshot stability", () => {
   test("returns the same string for the same inputs", () => {
     const opts = {
@@ -196,7 +229,7 @@ describe("resolveRouterPrompt — override path", () => {
   };
 
   test("null overridePath returns the bundled prompt verbatim", () => {
-    expect(resolveRouterPrompt(null, STD_OPTS)).toEqual(
+    expect(resolveRouterPrompt(null, tmpDir, STD_OPTS)).toEqual(
       renderRouterPrompt(STD_OPTS),
     );
   });
@@ -209,16 +242,35 @@ describe("resolveRouterPrompt — override path", () => {
       "utf-8",
     );
 
-    const out = resolveRouterPrompt(overridePath, STD_OPTS);
+    const out = resolveRouterPrompt(overridePath, tmpDir, STD_OPTS);
     expect(out).toContain("Hi Aria, you are routing for Alice.");
     expect(out).toContain(SAMPLE_INDEX);
     expect(out).not.toContain("{{ASSISTANT_NAME}}");
     expect(out).not.toContain("{{PAGE_INDEX}}");
   });
 
+  test("relative override path is resolved under the passed workspaceDir, not the default workspace", () => {
+    // Write the override into the per-test temp dir, which acts as a
+    // non-default workspace. The configured path is purely relative so the
+    // loader must resolve it against the supplied workspaceDir — if it
+    // resolved against the process-wide default workspace instead, the file
+    // wouldn't be found and the bundled prompt would be returned.
+    const relativeName = "router-override.md";
+    writeFileSync(
+      join(tmpDir, relativeName),
+      "Routed via {{ASSISTANT_NAME}} for {{USER_NAME}} :: {{PAGE_INDEX}}",
+      "utf-8",
+    );
+
+    const out = resolveRouterPrompt(relativeName, tmpDir, STD_OPTS);
+    expect(out).toContain("Routed via Aria for Alice");
+    expect(out).toContain(SAMPLE_INDEX);
+    expect(out).not.toEqual(renderRouterPrompt(STD_OPTS));
+  });
+
   test("missing override file falls back to bundled prompt", () => {
     const overridePath = join(tmpDir, "does-not-exist.md");
-    expect(resolveRouterPrompt(overridePath, STD_OPTS)).toEqual(
+    expect(resolveRouterPrompt(overridePath, tmpDir, STD_OPTS)).toEqual(
       renderRouterPrompt(STD_OPTS),
     );
   });
@@ -226,7 +278,7 @@ describe("resolveRouterPrompt — override path", () => {
   test("empty override file falls back to bundled prompt", () => {
     const overridePath = join(tmpDir, "empty.md");
     writeFileSync(overridePath, "   \n\t\n", "utf-8");
-    expect(resolveRouterPrompt(overridePath, STD_OPTS)).toEqual(
+    expect(resolveRouterPrompt(overridePath, tmpDir, STD_OPTS)).toEqual(
       renderRouterPrompt(STD_OPTS),
     );
   });
@@ -234,7 +286,7 @@ describe("resolveRouterPrompt — override path", () => {
   test("override that is a directory falls back to bundled prompt", () => {
     // Pass the temp directory itself as the override path — lstat sees a
     // directory, not a regular file, so the loader bails to bundled.
-    expect(resolveRouterPrompt(tmpDir, STD_OPTS)).toEqual(
+    expect(resolveRouterPrompt(tmpDir, tmpDir, STD_OPTS)).toEqual(
       renderRouterPrompt(STD_OPTS),
     );
   });
@@ -247,7 +299,7 @@ describe("resolveRouterPrompt — override path", () => {
       "utf-8",
     );
 
-    const out = resolveRouterPrompt(overridePath, {
+    const out = resolveRouterPrompt(overridePath, tmpDir, {
       assistantName: null,
       userName: null,
       pageIndexBlock: "",

package/src/memory/v2/__tests__/qdrant.test.ts

@@ -121,6 +121,9 @@ const state = {
   // Throw queue for upsert: first call shifts and throws if non-null;
   // subsequent calls succeed once the queue is exhausted.
   upsertThrowQueue: [] as Array<Error | null>,
+  // Throw queue for createPayloadIndex: each entry maps to the next call,
+  // so tests can simulate index-creation failures (strict-mode, network).
+  createIndexThrowQueue: [] as Array<Error | null>,
 };
 
 class MockQdrantClient {
@@ -157,6 +160,10 @@ class MockQdrantClient {
     params: { field_name: string; field_schema: string },
   ) {
     state.createIndexCalls.push(params);
+    if (state.createIndexThrowQueue.length > 0) {
+      const next = state.createIndexThrowQueue.shift();
+      if (next) throw next;
+    }
     return {};
   }
   async upsert(_name: string, params: { wait: boolean; points: MockPoint[] }) {
@@ -228,6 +235,7 @@ function resetState(): void {
   state.countThrows = null;
   state.countCalls = 0;
   state.upsertThrowQueue.length = 0;
+  state.createIndexThrowQueue.length = 0;
   _resetMemoryV2QdrantForTests();
   // Drop any sentinel a prior test left behind so the no-drift default path
   // doesn't accidentally report `migrated: true`.
@@ -278,9 +286,10 @@ describe("memory v2 qdrant — collection lifecycle", () => {
     });
     expect(params.on_disk_payload).toBe(true);
 
-    // Slug payload index is created up front.
+    // Slug + kind payload indexes are created up front.
     expect(state.createIndexCalls).toEqual([
       { field_name: "slug", field_schema: "keyword" },
+      { field_name: "kind", field_schema: "keyword" },
     ]);
   });
 
@@ -295,9 +304,14 @@ describe("memory v2 qdrant — collection lifecycle", () => {
     await ensureConceptPageCollection();
 
     // Existence check fired exactly once thanks to the in-memory readiness
-    // cache; createCollection / createPayloadIndex never ran.
+    // cache; createCollection never ran. Payload indexes are (idempotently)
+    // ensured on the existing-collection path to backfill long-lived installs
+    // that predate the `kind` index.
     expect(state.createCollectionCalls).toBe(0);
-    expect(state.createIndexCalls).toEqual([]);
+    expect(state.createIndexCalls).toEqual([
+      { field_name: "slug", field_schema: "keyword" },
+      { field_name: "kind", field_schema: "keyword" },
+    ]);
     expect(state.collectionExistsCalls).toBe(1);
   });
 
@@ -314,6 +328,7 @@ describe("memory v2 qdrant — collection lifecycle", () => {
     expect(state.createCollectionCalls).toBe(1);
     expect(state.createIndexCalls).toEqual([
       { field_name: "slug", field_schema: "keyword" },
+      { field_name: "kind", field_schema: "keyword" },
     ]);
   });
 
@@ -433,6 +448,54 @@ describe("memory v2 qdrant — collection lifecycle", () => {
     expect(existsSync(REEMBED_SENTINEL_PATH)).toBe(false);
   });
 
+  test("swallows 'already exists' on createPayloadIndex but propagates other failures without latching readiness", async () => {
+    // Existing collection that already has the full schema — the ensure
+    // path goes through `ensurePayloadIndexes` to backfill long-lived
+    // installs. The first index call hits an "already exists" race
+    // (benign; swallow); the second hits a strict-mode rejection (must
+    // propagate so readiness is not latched).
+    state.collectionExistsBeforeCreate = true;
+    state.createIndexThrowQueue.push(
+      Object.assign(
+        new Error("Wrong input: Payload field 'slug' already exists"),
+        { status: 400 },
+      ),
+      Object.assign(
+        new Error(
+          "Strict mode prohibits creating payload indexes on this deployment",
+        ),
+        { status: 400 },
+      ),
+    );
+
+    let caught: unknown = null;
+    try {
+      await ensureConceptPageCollection();
+    } catch (err) {
+      caught = err;
+    }
+    expect((caught as Error | null)?.message).toMatch(/strict mode/i);
+
+    // Both attempts ran; the strict-mode failure was not swallowed.
+    expect(state.createIndexCalls).toEqual([
+      { field_name: "slug", field_schema: "keyword" },
+      { field_name: "kind", field_schema: "keyword" },
+    ]);
+
+    // Readiness must NOT be latched after a non-benign failure — otherwise
+    // later slug/kind-filtered queries (e.g. skill backfill) would keep
+    // failing until a daemon restart. A follow-up ensure must retry.
+    const result = await ensureConceptPageCollection();
+    expect(result).toEqual({ migrated: false });
+    // Indexes attempted again on the retry (no throws queued this time).
+    expect(state.createIndexCalls).toEqual([
+      { field_name: "slug", field_schema: "keyword" },
+      { field_name: "kind", field_schema: "keyword" },
+      { field_name: "slug", field_schema: "keyword" },
+      { field_name: "kind", field_schema: "keyword" },
+    ]);
+  });
+
   test("concurrent ensure during a schema rebuild only deletes/creates once", async () => {
     state.collectionExistsBeforeCreate = true;
     state.getCollectionInfo = {

package/src/memory/v2/__tests__/router.test.ts

@@ -460,6 +460,21 @@ describe("runRouter — failure modes", () => {
     expect(warnSeen).toBe(true);
   });
 
+  test("duplicate-heavy IDs are deduped before the cap is applied", async () => {
+    // [1, 1, 2] with max=2 must yield two distinct slugs, not collapse to one
+    // after a pre-dedupe slice trims away the only other unique ID.
+    providerStub = makeProvider(toolUseResponse([1, 1, 2]));
+
+    const result = await runRouter({
+      workspaceDir,
+      ...COMMON_PARAMS,
+      config: makeConfig({ maxPageIds: 2 }),
+    });
+
+    expect(result.failureReason).toBeNull();
+    expect(result.selectedSlugs).toEqual(["alpha", "bravo"]);
+  });
+
   test("more than max_page_ids → truncated with warn", async () => {
     providerStub = makeProvider(toolUseResponse([1, 2, 3]));