@vellumai/assistant 0.8.7 → 0.8.8

package/src/memory/pkb/context.ts

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+import { getWorkspaceDir } from "../../util/platform.js";
+import { stripCommentLines } from "../../util/strip-comment-lines.js";
+import { getPkbAutoInjectList } from "./autoinject.js";
+
+/** Max buffer.md lines injected into prompts — keeps context bounded even when filing is off. */
+const MAX_BUFFER_LINES = 50;
+
+/**
+ * Read the always-loaded PKB files and append a nudge encouraging the
+ * assistant to proactively read topic files and use `remember` aggressively.
+ *
+ * Which files are loaded is determined by `pkb/_autoinject.md` (one filename
+ * per line). Falls back to the built-in defaults when that file is absent.
+ *
+ * Returns the concatenated content ready for injection, or `null` if all
+ * files are missing or empty.
+ */
+export function readPkbContext(): string | null {
+  const pkbDir = join(getWorkspaceDir(), "pkb");
+  if (!existsSync(pkbDir)) return null;
+
+  const filesToInject = getPkbAutoInjectList(pkbDir);
+
+  const parts: string[] = [];
+  for (const file of filesToInject) {
+    // Path traversal guard: reject entries that escape the pkb directory
+    const filePath = resolve(pkbDir, file);
+    if (!filePath.startsWith(pkbDir + "/")) continue;
+
+    if (!existsSync(filePath)) continue;
+    try {
+      let content = stripCommentLines(readFileSync(filePath, "utf-8")).trim();
+      if (file === "buffer.md" && content.length > 0) {
+        // Cap buffer entries to prevent unbounded growth when filing is disabled
+        const lines = content.split("\n");
+        if (lines.length > MAX_BUFFER_LINES) {
+          content = lines.slice(-MAX_BUFFER_LINES).join("\n");
+        }
+      }
+      if (content.length > 0) parts.push(content);
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  return parts.length > 0 ? parts.join("\n\n") : null;
+}

package/src/memory/pkb/types.ts

@@ -5,8 +5,22 @@
  * index writer) land in later PRs.
  */
 
+import { join } from "node:path";
+
+import { getWorkspaceDir } from "../../util/platform.js";
+
 export const PKB_TARGET_TYPE = "pkb_file" as const;
 
+/**
+ * Absolute path to the workspace's PKB directory (`<workspace>/pkb`). PKB is
+ * a workspace-shared resource with a single on-disk location, so this is the
+ * canonical way to resolve its root rather than re-joining the workspace dir
+ * at each call site.
+ */
+export function getPkbRoot(): string {
+  return join(getWorkspaceDir(), "pkb");
+}
+
 /**
  * Sentinel `memory_scope_id` under which ALL PKB points are indexed and
  * searched. PKB files are a workspace-shared resource: one copy on disk is

package/src/memory/schedule-attribution-sql.ts

@@ -0,0 +1,104 @@
+export interface ScheduleAttributionFilter {
+  scheduleId?: string;
+}
+
+export type ScheduleAttributionSqlParam = string | number;
+
+export interface ScheduleAttributionSqlFragment {
+  sql: string;
+  params: ScheduleAttributionSqlParam[];
+}
+
+export function normalizeScheduleAttributionFilter(
+  filter?: ScheduleAttributionFilter,
+): ScheduleAttributionFilter {
+  const scheduleId = filter?.scheduleId?.trim();
+  return scheduleId ? { scheduleId } : {};
+}
+
+function usageColumn(column: string, eventAlias: string): string {
+  return `${eventAlias}.${column}`;
+}
+
+function buildScheduleRunWindowPredicate({
+  eventAlias,
+  runAlias,
+  filter,
+}: {
+  eventAlias: string;
+  runAlias: string;
+  filter?: ScheduleAttributionFilter;
+}): string {
+  const normalized = normalizeScheduleAttributionFilter(filter);
+  const scheduleClause = normalized.scheduleId
+    ? `${runAlias}.job_id = ? AND `
+    : "";
+  return `${scheduleClause}${runAlias}.conversation_id = ${usageColumn(
+    "conversation_id",
+    eventAlias,
+  )}
+    AND ${usageColumn("created_at", eventAlias)} >= ${runAlias}.started_at
+    AND ${usageColumn("created_at", eventAlias)} <= COALESCE(${runAlias}.finished_at, ?)`;
+}
+
+function buildScheduleRunWindowParams(
+  filter: ScheduleAttributionFilter | undefined,
+  now: number,
+): ScheduleAttributionSqlParam[] {
+  const normalized = normalizeScheduleAttributionFilter(filter);
+  return normalized.scheduleId ? [normalized.scheduleId, now] : [now];
+}
+
+export function buildScheduleRunWindowExists({
+  eventAlias,
+  filter,
+  now,
+  runAlias = "schedule_filter_runs",
+}: {
+  eventAlias: string;
+  filter?: ScheduleAttributionFilter;
+  now: number;
+  runAlias?: string;
+}): ScheduleAttributionSqlFragment {
+  return {
+    sql: `EXISTS (
+      SELECT 1
+      FROM cron_runs ${runAlias}
+      WHERE ${buildScheduleRunWindowPredicate({
+        eventAlias,
+        runAlias,
+        filter,
+      })}
+    )`,
+    params: buildScheduleRunWindowParams(filter, now),
+  };
+}
+
+export function buildScheduleAttributionSubquery({
+  eventAlias,
+  filter,
+  now,
+  selectExpression,
+  runAlias = "schedule_attr_runs",
+}: {
+  eventAlias: string;
+  filter?: ScheduleAttributionFilter;
+  now: number;
+  selectExpression: string;
+  runAlias?: string;
+}): ScheduleAttributionSqlFragment {
+  return {
+    sql: `(
+    SELECT ${selectExpression}
+    FROM cron_runs ${runAlias}
+    WHERE ${buildScheduleRunWindowPredicate({
+      eventAlias,
+      runAlias,
+      filter,
+    })}
+    ORDER BY ${runAlias}.started_at DESC, ${runAlias}.id DESC
+    LIMIT 1
+  )`,
+    params: buildScheduleRunWindowParams(filter, now),
+  };
+}

package/src/memory/schema/infrastructure.ts

@@ -22,6 +22,7 @@ export const cronJobs = sqliteTable("cron_jobs", {
   maxRetries: integer("max_retries").notNull().default(3),
   retryBackoffMs: integer("retry_backoff_ms").notNull().default(60000),
   timeoutMs: integer("timeout_ms"), // script-mode execution timeout override (ms); null = use default
+  createdFromConversationId: text("created_from_conversation_id"),
   createdBy: text("created_by").notNull(), // 'agent' | 'user'
   mode: text("mode").notNull().default("execute"), // 'notify' | 'execute'
   routingIntent: text("routing_intent").notNull().default("all_channels"), // 'single_channel' | 'multi_channel' | 'all_channels'
@@ -278,6 +279,21 @@ export const onboardingEvents = sqliteTable("onboarding_events", {
   abVariant: text("ab_variant"),
 });
 
+// Aggregated legacy-loopback auth-fallback counts forwarded by the gateway.
+// One row per (guard, path, failure_kind) per flush window; `count` is how many
+// requests fell back to the loopback exemption in that window. Flushed to the
+// platform telemetry endpoint by the usage telemetry reporter.
+export const authFallbackEvents = sqliteTable("auth_fallback_events", {
+  id: text("id").primaryKey(),
+  createdAt: integer("created_at").notNull(),
+  guard: text("guard").notNull(), // 'edge' | 'edge-scoped' | 'edge-guardian'
+  path: text("path").notNull(),
+  failureKind: text("failure_kind").notNull(),
+  count: integer("count").notNull(),
+  windowStart: integer("window_start").notNull(),
+  windowEnd: integer("window_end").notNull(),
+});
+
 export const traceEvents = sqliteTable(
   "trace_events",
   {

package/src/memory/usage-grouped-buckets.ts

@@ -27,6 +27,7 @@ export interface UsageGroupedSeriesBucket extends UsageDayBucket {
 
 export interface UsageGroupedBucketRow extends UsageEventBucketRow {
   group_key: string | null;
+  group_label?: string | null;
 }
 
 const VALUE_GROUP_PREFIX = "value:";
@@ -42,6 +43,9 @@ export function displayUsageGroup(
   if (groupBy === "inference_profile") {
     return groupKey === null ? "Default / Unset" : groupKey;
   }
+  if (groupBy === "schedule") {
+    return groupKey ?? "Other";
+  }
   return groupKey ?? "Other";
 }
 
@@ -102,7 +106,8 @@ export function bucketGroupedUsageEvents(
     let group = groupedBucket.groups[seriesKey];
     if (!group) {
       group = {
-        group: displayUsageGroup(options.groupBy, row.group_key),
+        group:
+          row.group_label ?? displayUsageGroup(options.groupBy, row.group_key),
         groupKey: row.group_key,
         totalInputTokens: 0,
         totalOutputTokens: 0,

package/src/memory/v2/__tests__/consolidation-job.test.ts

@@ -279,7 +279,7 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
     expect(runnerLastArgs).not.toBeNull();
     expect(runnerLastArgs?.jobName).toBe("memory.consolidate");
     expect(runnerLastArgs?.source).toBe("memory_v2_consolidation");
-    expect(runnerLastArgs?.callSite).toBe("mainAgent");
+    expect(runnerLastArgs?.callSite).toBe("memoryV2Consolidation");
     expect(runnerLastArgs?.origin).toBe("memory_consolidation");
     // The whole point of this PR: opt out of activity.failed notifications
     // because consolidation runs on tight intervals and transient failures

package/src/memory/v2/consolidation-job.ts

@@ -197,7 +197,7 @@ export async function memoryV2ConsolidateJob(
       source: MEMORY_V2_CONSOLIDATION_SOURCE,
       prompt,
       trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
-      callSite: "mainAgent",
+      callSite: "memoryV2Consolidation",
       timeoutMs: CONSOLIDATION_TIMEOUT_MS,
       origin: "memory_consolidation",
       suppressFailureNotifications: true,

package/src/memory/v3/__tests__/health.test.ts

@@ -42,6 +42,22 @@ describe("computeV3Health", () => {
     expect(report.unassigned).toEqual(["page-b", "page-c"]);
   });
 
+  test("excludes synthetic capability slugs from unassigned / novel clusters", () => {
+    const t = tree({ "domain-a/topic-x": ["page-a"] });
+    const report = computeV3Health({
+      tree: t,
+      allSlugs: ["page-a", "page-b", "cli-commands/example", "skills/example"],
+    });
+    // Capability slugs are handled by the always-on capabilities leaf (injected
+    // into the live lane tree, absent here), not the persisted tree — so they must
+    // not be reported as unassigned or grouped into novel clusters. page-b is the
+    // one real unassigned concept page.
+    expect(report.unassigned).toEqual(["page-b"]);
+    expect(report.novelClusters).toEqual([
+      { prefix: "page-b", slugs: ["page-b"], count: 1 },
+    ]);
+  });
+
   test("flags dangling page refs pointing at missing leaves", () => {
     const t = tree({ "domain-a/topic-x": ["page-a"] });
     const report = computeV3Health({

package/src/memory/v3/__tests__/orchestrate.test.ts

@@ -217,6 +217,43 @@ describe("orchestrate — fixture sequence (carry-forward)", () => {
     expect(t2.currentSelections.map((s) => s.slug)).not.toContain("page-a");
     expect(t2.finalInjection).toContain("page-a");
   });
+
+  test("carry-forward survives a turn whose selections fill the cap", async () => {
+    const tree = makeTree();
+    // Cap of 1: under a naive record-then-cap order this turn's own selection
+    // would evict the carried page before injection. Snapshotting the carry
+    // BEFORE recording this turn keeps the earlier page in the injection.
+    const workingSet = new WorkingSet(1);
+    const needle = fakeNeedle([]);
+    const stub = (selectIds: number[]): Provider => ({
+      name: "stub",
+      sendMessage: async (_messages, options) =>
+        options?.tools?.[0]?.name === "open_leaves"
+          ? toolUseResponse("open_leaves", { ids: [1] })
+          : toolUseResponse("select_pages", { ids: selectIds, pinned_ids: [] }),
+    });
+
+    providerStub = stub([1]); // turn 1 → page-a
+    await orchestrate(makeTurn(1, "page a"), {
+      tree,
+      core: new Set(),
+      needle,
+      workingSet,
+      pageSummary: summaryOf,
+    });
+
+    providerStub = stub([2]); // turn 2 → page-b, never re-selects page-a
+    const t2 = await orchestrate(makeTurn(2, "page b"), {
+      tree,
+      core: new Set(),
+      needle,
+      workingSet,
+      pageSummary: summaryOf,
+    });
+
+    expect(t2.currentSelections.map((s) => s.slug)).toEqual(["page-b"]);
+    expect(t2.finalInjection).toContain("page-a"); // carried despite the cap
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -298,14 +335,16 @@ describe("orchestrate — edge cases", () => {
     expect(result.finalInjection).toEqual(["page-a", "page-b"]);
   });
 
-  test("L1 routing fallback (omitted ids → all leaves) still works", async () => {
+  test("omitted L1 ids opens only the deterministic lanes, not the whole tree", async () => {
     const tree = makeTree();
-    // Omitted ids → routeL1 opens ALL leaves; select everything per leaf.
+    // L1 omits ids → routeL1 opens NO routed leaves; only the needle/core lanes
+    // drive the open set, so the whole tree is never fanned out (topic-y, which
+    // nothing routes or needles to, stays closed).
     providerStub = {
       name: "stub",
       sendMessage: async (_messages, options) => {
         if (options?.tools?.[0]?.name === "open_leaves") {
-          return toolUseResponse("open_leaves", {}); // omitted ids
+          return toolUseResponse("open_leaves", {}); // omitted ids → []
         }
         return toolUseResponse("select_pages", {}); // omitted → all members
       },
@@ -313,15 +352,12 @@ describe("orchestrate — edge cases", () => {
     const result = await orchestrate(makeTurn(1, "x"), {
       tree,
       core: new Set(),
-      needle: fakeNeedle([]),
+      needle: fakeNeedle(["page-a"]), // needle opens domain-a/topic-x only
       workingSet: new WorkingSet(),
       pageSummary: summaryOf,
     });
-    expect(result.openedLeaves).toEqual([
-      "domain-a/topic-x",
-      "domain-a/topic-y",
-    ]);
-    expect(result.finalInjection).toEqual(["page-a", "page-b", "page-c"]);
+    expect(result.openedLeaves).toEqual(["domain-a/topic-x"]);
+    expect(result.finalInjection).toEqual(["page-a", "page-b"]);
   });
 
   test("pinned current-turn selections land in the working set", async () => {

package/src/memory/v3/__tests__/provider-blocks.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, test } from "bun:test";
+
+import { cachedTextBlock } from "../provider-blocks.js";
+
+describe("cachedTextBlock", () => {
+  test("stamps an ephemeral cache_control with a 1h TTL", () => {
+    const block = cachedTextBlock("stable leaf block");
+    expect(block).toMatchObject({ type: "text", text: "stable leaf block" });
+    expect(
+      (block as unknown as { cache_control?: unknown }).cache_control,
+    ).toEqual({ type: "ephemeral", ttl: "1h" });
+  });
+});

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

@@ -3,10 +3,13 @@
  *
  * Coverage matrix:
  *   - Returned IDs map to the right leaves by 1-based index, in model order.
- *   - Omitted `ids` → ALL leaves (recall-safe).
+ *   - Omitted `ids` → no leaves (the router must name leaves explicitly,
+ *     never open the whole tree).
  *   - Explicit `ids: []` → no leaves (deliberate abstention).
  *   - Out-of-range / duplicate IDs ignored, no throw.
- *   - No provider / missing tool_use / schema mismatch / throw → ALL leaves.
+ *   - No provider / missing tool_use / schema mismatch / throw → no leaves
+ *     (degrade to the deterministic lanes), the last three after a re-prompt
+ *     retry; a malformed response that recovers on retry returns its IDs.
  *   - The rendered leaf block is byte-identical across two calls with
  *     different queries (the cache invariant).
  *   - The system prompt mentions "register" (locks the routing commitment).
@@ -76,6 +79,45 @@ function toolUseResponse(input: Record<string, unknown>): ProviderResponse {
   };
 }
 
+/** A 200 response that carries no tool_use — the malformed-but-successful case
+ * the re-prompt retry exists to recover from. */
+function noToolResponse(): ProviderResponse {
+  return {
+    model: "stub-model",
+    stopReason: "end_turn",
+    usage: { inputTokens: 0, outputTokens: 0 },
+    content: [{ type: "text", text: "no tool call" }],
+  };
+}
+
+/** Provider returning a different response per call (the i-th call returns
+ * responses[i], or the last entry once exhausted), recording each call so a
+ * test can assert how many attempts were made. */
+function makeSequenceProvider(responses: ProviderResponse[]): Provider {
+  let i = 0;
+  return {
+    name: "sequence",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      const response = responses[Math.min(i, responses.length - 1)];
+      i += 1;
+      return response;
+    },
+  };
+}
+
+/** Provider that records each call and then throws — for the throw-after-retries
+ * path (the provider's own RetryProvider has already exhausted its backoff). */
+function makeThrowingProvider(): Provider {
+  return {
+    name: "throwing",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      throw new Error("boom");
+    },
+  };
+}
+
 function makeLeaf(path: LeafPath, description: string): LeafNode {
   return {
     path,
@@ -101,8 +143,6 @@ function makeTree(): LeafTree {
   };
 }
 
-const SORTED_PATHS = ["people/alice", "people/bob", "projects/atlas"];
-
 function makeTurn(currentMessage: string): TurnContext {
   return {
     conversationId: "conv-xyz",
@@ -128,10 +168,10 @@ describe("routeL1 — id mapping", () => {
     expect(result).toEqual(["projects/atlas", "people/alice"]);
   });
 
-  test("omitted ids opens ALL leaves (recall-safe)", async () => {
+  test("omitted ids opens no leaves (must name leaves explicitly)", async () => {
     providerStub = makeProvider(toolUseResponse({}));
     const result = await routeL1(makeTurn("anything"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
   });
 
   test("explicit empty ids opens no leaves (abstention)", async () => {
@@ -157,39 +197,43 @@ describe("routeL1 — id mapping", () => {
   });
 });
 
-describe("routeL1 — recall-safe fallbacks", () => {
-  test("no provider → ALL leaves", async () => {
+describe("routeL1 — degradation on failure", () => {
+  test("no provider → no leaves, without calling the provider", async () => {
     providerStub = null;
     const result = await routeL1(makeTurn("x"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(0);
   });
 
-  test("missing tool_use → ALL leaves", async () => {
-    providerStub = makeProvider({
-      model: "stub-model",
-      stopReason: "end_turn",
-      usage: { inputTokens: 0, outputTokens: 0 },
-      content: [{ type: "text", text: "no tool call" }],
-    });
+  test("missing tool_use → no leaves after retrying", async () => {
+    providerStub = makeProvider(noToolResponse());
     const result = await routeL1(makeTurn("x"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
   });
 
-  test("schema mismatch → ALL leaves", async () => {
+  test("schema mismatch → no leaves after retrying", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: "not-an-array" }));
     const result = await routeL1(makeTurn("x"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
   });
 
-  test("provider throw → ALL leaves", async () => {
-    providerStub = {
-      name: "throwing",
-      sendMessage: async () => {
-        throw new Error("boom");
-      },
-    };
+  test("provider throw → no leaves after retrying", async () => {
+    providerStub = makeThrowingProvider();
     const result = await routeL1(makeTurn("x"), makeTree());
-    expect(result).toEqual(SORTED_PATHS);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
+  });
+
+  test("a malformed response that recovers on retry returns its IDs", async () => {
+    providerStub = makeSequenceProvider([
+      noToolResponse(),
+      toolUseResponse({ ids: [2] }),
+    ]);
+    const result = await routeL1(makeTurn("bob?"), makeTree());
+    expect(result).toEqual(["people/bob"]);
+    expect(providerCalls).toHaveLength(2);
   });
 });
 
@@ -213,11 +257,11 @@ describe("routeL1 — request shape", () => {
     const [blockA, blockB] = providerCalls[0].messages[0].content as Array<{
       type: string;
       text: string;
-      cache_control?: { type: string };
+      cache_control?: { type: string; ttl?: string };
     }>;
     expect(blockA.type).toBe("text");
     expect(blockA.text).toContain("<leaves>");
-    expect(blockA.cache_control).toEqual({ type: "ephemeral" });
+    expect(blockA.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
 
     expect(blockB.type).toBe("text");
     expect(blockB.text).toContain("<current_message>alice?</current_message>");
@@ -225,6 +269,34 @@ describe("routeL1 — request shape", () => {
     expect(blockB.cache_control).toBeUndefined();
   });
 
+  test("situational context renders in the per-turn block when present", async () => {
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+    await routeL1(
+      {
+        ...makeTurn("x"),
+        situationalContext: "Today is Saturday. Alice's anniversary is today.",
+      },
+      makeTree(),
+    );
+    const blockB = providerCalls[0].messages[0].content[1] as { text: string };
+    expect(blockB.text).toContain(
+      "<situation>Today is Saturday. Alice's anniversary is today.</situation>",
+    );
+  });
+
+  test("situational context is omitted when the turn has none", async () => {
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+    await routeL1(makeTurn("x"), makeTree());
+    const blockB = providerCalls[0].messages[0].content[1] as { text: string };
+    expect(blockB.text).not.toContain("<situation>");
+  });
+
+  test("system prompt mentions situation (locks the routing commitment)", async () => {
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+    await routeL1(makeTurn("x"), makeTree());
+    expect(providerCalls[0].options?.systemPrompt).toMatch(/[Ss]ituation/);
+  });
+
   test("system prompt mentions register (locks the routing commitment)", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: [1] }));
     await routeL1(makeTurn("x"), makeTree());