@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/memory/schema/acp.ts

@@ -20,6 +20,10 @@ export const acpSessionHistory = sqliteTable(
     stopReason: text("stop_reason"),
     error: text("error"),
     eventLogJson: text("event_log_json").notNull().default("[]"),
+    // Working directory the agent process was spawned with. Required to
+    // resume a persisted session; null for rows written before migration
+    // 272 (those sessions are not resumable).
+    cwd: text("cwd"),
   },
   (table) => [
     index("idx_acp_session_history_started_at").on(table.startedAt),

package/src/memory/schema/infrastructure.ts

@@ -277,6 +277,11 @@ export const onboardingEvents = sqliteTable("onboarding_events", {
   googleScopesJson: text("google_scopes_json"),
   priorAssistantsJson: text("prior_assistants_json"),
   abVariant: text("ab_variant"),
+  sessionId: text("session_id"),
+  stepName: text("step_name"),
+  stepIndex: integer("step_index"),
+  completedAt: text("completed_at"),
+  funnelVersion: text("funnel_version"),
 });
 
 // Aggregated legacy-loopback auth-fallback counts forwarded by the gateway.
@@ -294,6 +299,14 @@ export const authFallbackEvents = sqliteTable("auth_fallback_events", {
   windowEnd: integer("window_end").notNull(),
 });
 
+// One row per conversation started on the activation-rail bootstrap template.
+// Lets the activation funnel telemetry scope its events to activation
+// conversations without inspecting the bootstrap template at emit time.
+export const activationSessions = sqliteTable("activation_sessions", {
+  conversationId: text("conversation_id").primaryKey(),
+  createdAt: integer("created_at").notNull(),
+});
+
 export const traceEvents = sqliteTable(
   "trace_events",
   {

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

@@ -105,43 +105,15 @@ mock.module("../../jobs-store.js", () => ({
   isMemoryEnabled: () => true,
 }));
 
-// ── v3 health-injection mocks ───────────────────────────────────────
+// ── v3 follow-up flag mock ──────────────────────────────────────────
 //
-// The consolidation handler optionally prepends a v3 health block to the
-// prompt when a v3 flag is on AND the rendered report is non-empty. These
-// mocks let each test (a) toggle the flag, (b) decide what health block the
-// renderer produces, and (c) force the health computation to throw — without
-// materializing a real v3 data dir. The tree/core/page-index loaders are
-// stubbed to inert values; `computeV3Health` is a pass-through whose result is
-// fed to the toggleable `renderV3Health`.
+// A v3 flag being on appends `memory_v3_maintain` to the post-consolidation
+// follow-up fan-out. This mock lets each test toggle the flag.
 let v3FlagOn = false;
 mock.module("../../../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: () => v3FlagOn,
 }));
 
-let renderedHealth = "";
-let computeThrows = false;
-mock.module("../../v3/health.js", () => ({
-  computeV3Health: () => {
-    if (computeThrows) throw new Error("simulated health compute failure");
-    return {};
-  },
-  renderV3Health: () => renderedHealth,
-}));
-
-mock.module("../../v3/tree.js", () => ({
-  loadLeafTree: async () => ({ leaves: new Map(), byPage: new Map() }),
-  resolveDataDir: () => "/tmp/v3-data-stub",
-}));
-
-mock.module("../../v3/core.js", () => ({
-  loadCore: async () => new Set<string>(),
-}));
-
-mock.module("../../v2/page-index.js", () => ({
-  getPageIndex: async () => ({ entries: [] }),
-}));
-
 // ── Workspace pin ───────────────────────────────────────────────────
 let tmpWorkspace: string;
 let previousWorkspaceEnv: string | undefined;
@@ -211,10 +183,8 @@ beforeEach(() => {
   enqueuedJobs.length = 0;
   nextJobIdCounter = 0;
 
-  // v3 health injection defaults: flag off, no rendered block, no throw.
+  // v3 follow-up flag default: off.
   v3FlagOn = false;
-  renderedHealth = "";
-  computeThrows = false;
 });
 
 // ---------------------------------------------------------------------------
@@ -409,69 +379,6 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
   });
 });
 
-describe("memoryV2ConsolidateJob — v3 health injection", () => {
-  beforeEach(() => {
-    writeFileSync(
-      bufferPath(),
-      "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n",
-    );
-  });
-
-  test("prepends the health block when a v3 flag is on and the report is actionable", async () => {
-    v3FlagOn = true;
-    renderedHealth = "memory-v3 health:\n- 2 unassigned slug(s): a, b";
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    const prompt = runnerLastArgs?.prompt as string;
-    // The health block is PREPENDED, separated by a blank line, with the
-    // base consolidation prompt still present underneath it.
-    expect(prompt.startsWith(`${renderedHealth}\n\n`)).toBe(true);
-    expect(prompt).toContain("memory consolidation");
-    expect(prompt).not.toContain(CUTOFF_PLACEHOLDER);
-  });
-
-  test("leaves the prompt unchanged when the report is all-green (empty render)", async () => {
-    v3FlagOn = true;
-    renderedHealth = "";
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    const prompt = runnerLastArgs?.prompt as string;
-    expect(prompt).not.toContain("memory-v3 health:");
-    // Prompt is exactly the resolved consolidation body.
-    expect(prompt).toContain("memory consolidation");
-  });
-
-  test("leaves the prompt unchanged when v3 flags are off even if a block would render", async () => {
-    v3FlagOn = false;
-    renderedHealth = "memory-v3 health:\n- 1 unassigned slug(s): a";
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    const prompt = runnerLastArgs?.prompt as string;
-    expect(prompt).not.toContain("memory-v3 health:");
-    expect(prompt).toContain("memory consolidation");
-  });
-
-  test("falls back to the base prompt when health computation throws", async () => {
-    v3FlagOn = true;
-    computeThrows = true;
-    renderedHealth = "memory-v3 health:\n- should not appear";
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    // A health-compute failure must NEVER break consolidation.
-    expect(result.kind).toBe("invoked");
-    const prompt = runnerLastArgs?.prompt as string;
-    expect(prompt).not.toContain("memory-v3 health:");
-    expect(prompt).toContain("memory consolidation");
-  });
-});
-
 describe("memoryV2ConsolidateJob — concurrent invocations", () => {
   beforeEach(() => {
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");

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

@@ -186,6 +186,28 @@ describe("writePage + readPage round-trip", () => {
     expect(read!.body).toBe(page.body);
   });
 
+  test("round-trips authored links: frontmatter (memory-v3 edge lane)", async () => {
+    const page = makePage({
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        ref_urls: [],
+        links: ["bob-handoff — the partner this hands off to"],
+      },
+    });
+    await writePage(workspaceDir, page);
+
+    // A page using the optional `links:` frontmatter must NOT be rejected by the
+    // strict schema (it would otherwise be dropped from memory-v3 entirely), and
+    // the curated links must survive the render → read round-trip so the edge
+    // graph can parse them back from the rendered frontmatter.
+    const read = await readPage(workspaceDir, page.slug);
+    expect(read).not.toBeNull();
+    expect(read!.frontmatter.links).toEqual([
+      "bob-handoff — the partner this hands off to",
+    ]);
+  });
+
   test("renders frontmatter at the top with --- delimiters", async () => {
     const page = makePage();
     await writePage(workspaceDir, page);

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

@@ -73,11 +73,6 @@ import {
   type MemoryJob,
   type MemoryJobType,
 } from "../jobs-store.js";
-import { getPageIndex } from "../v2/page-index.js";
-import { loadCore } from "../v3/core.js";
-import { computeV3Health, renderV3Health } from "../v3/health.js";
-import { loadLeafTree, resolveDataDir } from "../v3/tree.js";
-import type { LeafPath, Slug } from "../v3/types.js";
 import { MEMORY_V2_CONSOLIDATION_SOURCE } from "./constants.js";
 import { resolveConsolidationPrompt } from "./prompts/consolidation.js";
 
@@ -87,8 +82,7 @@ const log = getLogger("memory-v2-consolidate");
 const JOB_NAME = "memory.consolidate";
 
 /**
- * v3 plugin flags. Either being on (a) prepends a v3 health block to the
- * consolidation prompt and (b) enqueues `memory_v3_maintain` as a
+ * v3 plugin flags. Either being on enqueues `memory_v3_maintain` as a
  * post-consolidation follow-up. These gate the v3 plugin itself.
  */
 const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
@@ -182,15 +176,10 @@ export async function memoryV2ConsolidateJob(
     // it to a regular file under 1 MiB before substitution so a stray path
     // (or a `/dev/zero`-style pseudo-file) cannot exfiltrate megabytes of
     // bytes through the wake hint.
-    //
-    // That resolved prompt is the base; `maybePrependV3Health` prepends a
-    // freshly computed v3 health block when a v3 flag is on and the tree has
-    // actionable drift, leaving it untouched otherwise.
-    const basePrompt = resolveConsolidationPrompt(
+    const prompt = resolveConsolidationPrompt(
       config.memory.v2.consolidation_prompt_path,
       cutoff,
     );
-    const prompt = await maybePrependV3Health(basePrompt, config);
 
     const runResult = await runBackgroundJob({
       jobName: JOB_NAME,
@@ -261,56 +250,6 @@ export async function memoryV2ConsolidateJob(
   }
 }
 
-/**
- * When a v3 flag is enabled and the v3 tree has actionable structural drift,
- * prepend a rendered health block to `basePrompt` so the consolidation run can
- * fold tree maintenance into its pass. Returns `basePrompt` UNCHANGED when:
- *   - neither `memory-v3-shadow` nor `memory-v3-live` is enabled,
- *   - the health report is all-green (`renderV3Health` returns ""), or
- *   - computing the report throws for any reason.
- *
- * The block is computed here (not baked into the prompt template) so an
- * operator's custom consolidation prompt stays untouched and the block reflects
- * the tree state at run time. Health computation is wrapped so a load/compute
- * failure can never break consolidation — the run proceeds on the base prompt.
- */
-async function maybePrependV3Health(
-  basePrompt: string,
-  config: AssistantConfig,
-): Promise<string> {
-  const v3Enabled =
-    isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config) ||
-    isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config);
-  if (!v3Enabled) return basePrompt;
-
-  try {
-    const pageIndex = await getPageIndex(getWorkspaceDir());
-    const pageLeaves = new Map<Slug, LeafPath[]>();
-    const allSlugs: Slug[] = [];
-    for (const entry of pageIndex.entries) {
-      pageLeaves.set(entry.slug, entry.leaves);
-      allSlugs.push(entry.slug);
-    }
-
-    const dataDir = resolveDataDir();
-    const [tree, core] = await Promise.all([
-      loadLeafTree(dataDir, pageLeaves),
-      loadCore(dataDir),
-    ]);
-
-    const report = computeV3Health({ tree, allSlugs, core });
-    const healthBlock = renderV3Health(report);
-    if (healthBlock.length === 0) return basePrompt;
-    return `${healthBlock}\n\n${basePrompt}`;
-  } catch (err) {
-    log.warn(
-      { err: err instanceof Error ? err.message : String(err) },
-      "consolidation: v3 health computation failed; using base prompt",
-    );
-    return basePrompt;
-  }
-}
-
 /**
  * Read `memory/buffer.md`. Missing file → empty string so the skip-on-empty
  * branch doesn't have to distinguish "no file" from "blank file".

package/src/memory/v2/types.ts

@@ -41,6 +41,11 @@ export const ConceptPageFrontmatterSchema = z
     ref_urls: z.array(z.string().url()).default([]),
     summary: z.string().optional(),
     leaves: z.array(z.string()).optional(),
+    // Optional authored `"<target-slug> — <why>"` cross-links. Curated, first-class
+    // edges for the memory-v3 edge lane. Declared here so `.strict()` does not
+    // reject a page that uses `links:`, and so `renderPageContent` round-trips the
+    // field (the edge graph reads it back from the rendered frontmatter).
+    links: z.array(z.string()).optional(),
   })
   .strict();
 

package/src/messaging/providers/telegram-bot/api.ts

@@ -8,7 +8,8 @@
  */
 
 import { credentialKey } from "../../../security/credential-key.js";
-import { getSecureKeyAsync } from "../../../security/secure-keys.js";
+import { getSecureKeyResultAsync } from "../../../security/secure-keys.js";
+import { BackendUnavailableError, ConfigError } from "../../../util/errors.js";
 import { getLogger } from "../../../util/logger.js";
 
 const log = getLogger("telegram-api");
@@ -197,13 +198,21 @@ async function retryableFetch<T>(
 // ---------------------------------------------------------------------------
 
 async function resolveBotToken(): Promise<string> {
-  const botToken = await getSecureKeyAsync(
+  const result = await getSecureKeyResultAsync(
     credentialKey("telegram", "bot_token"),
   );
-  if (!botToken) {
-    throw new Error("Telegram bot token not configured");
+  if (result.value) {
+    return result.value;
   }
-  return botToken;
+  // Distinguish a transient credential-store outage from a token that was
+  // genuinely never set. Both surface as an absent value, but only the
+  // latter is an operator misconfiguration; the former is retryable
+  // infrastructure unavailability that callers should not treat as
+  // "not configured".
+  if (result.unreachable) {
+    throw new BackendUnavailableError("Telegram credential store unreachable");
+  }
+  throw new ConfigError("Telegram bot token not configured");
 }
 
 // ---------------------------------------------------------------------------

package/src/notifications/__tests__/copy-composer.test.ts

@@ -0,0 +1,244 @@
+/**
+ * Tests for the notification copy-composer — specifically the fallback
+ * path that composeFallbackCopy uses when the LLM is unavailable, and
+ * the shared deriveTitle utility.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { composeFallbackCopy, deriveTitle } from "../copy-composer.js";
+import type { NotificationSignal } from "../signal.js";
+import type { NotificationChannel } from "../types.js";
+
+// ── Helpers ───────────────────────────────────────────────────────────
+
+function makeSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: "sig-copy-test-1",
+    createdAt: Date.now(),
+    sourceChannel: "scheduler",
+    sourceContextId: "ctx-1",
+    sourceEventName: "user.send_notification",
+    contextPayload: {},
+    attentionHints: {
+      requiresAction: false,
+      urgency: "low",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+const CHANNELS: NotificationChannel[] = ["vellum" as NotificationChannel];
+
+// ── composeFallbackCopy with requestedMessage ─────────────────────────
+
+describe("composeFallbackCopy honors requestedMessage / requestedTitle", () => {
+  test("uses requestedMessage as body and requestedTitle as title", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "Take out the trash",
+        requestedTitle: "Household Reminder",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("Take out the trash");
+    expect(copy.vellum?.title).toBe("Household Reminder");
+    expect(copy.vellum?.conversationSeedMessage).toBe("Take out the trash");
+  });
+
+  test("derives title from body when requestedTitle is absent", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "First sentence. Second sentence follows.",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("First sentence. Second sentence follows.");
+    expect(copy.vellum?.title).toBe("First sentence.");
+  });
+
+  test("derives title from body when requestedTitle is empty string", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "Some message body here",
+        requestedTitle: "",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("Some message body here");
+    expect(copy.vellum?.title).toBe("Some message body here");
+  });
+
+  test("derives title from body when requestedTitle is whitespace", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "Whitespace title test",
+        requestedTitle: "   ",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("Whitespace title test");
+    expect(copy.vellum?.title).toBe("Whitespace title test");
+  });
+
+  test("trims whitespace from requestedMessage", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "  padded message  ",
+        requestedTitle: "  padded title  ",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("padded message");
+    expect(copy.vellum?.title).toBe("padded title");
+  });
+
+  test("populates copy for all requested channels", () => {
+    const channels = [
+      "vellum" as NotificationChannel,
+      "telegram" as NotificationChannel,
+    ];
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "Multi-channel test",
+        requestedTitle: "Multi Title",
+      },
+    });
+    const copy = composeFallbackCopy(signal, channels);
+
+    expect(copy.vellum?.body).toBe("Multi-channel test");
+    expect(copy.vellum?.title).toBe("Multi Title");
+    expect(copy.telegram?.body).toBe("Multi-channel test");
+    expect(copy.telegram?.title).toBe("Multi Title");
+  });
+
+  test("falls through to template when requestedMessage is absent", () => {
+    const signal = makeSignal({
+      sourceEventName: "schedule.notify",
+      contextPayload: {
+        message: "Standup time",
+        label: "Daily Standup",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.title).toBe("Daily Standup");
+    expect(copy.vellum?.body).toBe("Standup time");
+  });
+
+  test("falls through to template when requestedMessage is empty string", () => {
+    const signal = makeSignal({
+      sourceEventName: "schedule.notify",
+      contextPayload: {
+        requestedMessage: "",
+        message: "Standup time",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.title).toBe("Reminder");
+    expect(copy.vellum?.body).toBe("Standup time");
+  });
+
+  test("falls through to template when requestedMessage is whitespace", () => {
+    const signal = makeSignal({
+      sourceEventName: "schedule.notify",
+      contextPayload: {
+        requestedMessage: "   ",
+        message: "Standup time",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.title).toBe("Reminder");
+    expect(copy.vellum?.body).toBe("Standup time");
+  });
+
+  test("falls through to generic copy when no requestedMessage and no template match", () => {
+    const signal = makeSignal({
+      sourceEventName: "unknown.event",
+      contextPayload: {},
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.title).toBe("Notification");
+    expect(copy.vellum?.body).toBe("");
+  });
+
+  test("requestedMessage takes priority over event-name template", () => {
+    const signal = makeSignal({
+      sourceEventName: "schedule.notify",
+      contextPayload: {
+        requestedMessage: "User-supplied content",
+        requestedTitle: "User Title",
+        message: "Template message field",
+        label: "Template label field",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("User-supplied content");
+    expect(copy.vellum?.title).toBe("User Title");
+  });
+
+  test("works with non-assistant_tool source channels", () => {
+    for (const sourceChannel of ["scheduler", "watcher", "slack"] as const) {
+      const signal = makeSignal({
+        sourceChannel,
+        contextPayload: {
+          requestedMessage: `Message from ${sourceChannel}`,
+        },
+      });
+      const copy = composeFallbackCopy(signal, CHANNELS);
+
+      expect(copy.vellum?.body).toBe(`Message from ${sourceChannel}`);
+    }
+  });
+});
+
+// ── deriveTitle ───────────────────────────────────────────────────────
+
+describe("deriveTitle", () => {
+  test("extracts first sentence when period is present", () => {
+    expect(deriveTitle("First sentence. Second sentence.")).toBe(
+      "First sentence.",
+    );
+  });
+
+  test("extracts first sentence on exclamation mark", () => {
+    expect(deriveTitle("Alert! More details follow.")).toBe("Alert!");
+  });
+
+  test("extracts first sentence on question mark", () => {
+    expect(deriveTitle("Ready? Let me know.")).toBe("Ready?");
+  });
+
+  test("uses full body when no sentence terminator", () => {
+    expect(deriveTitle("No terminator here")).toBe("No terminator here");
+  });
+
+  test("truncates to 60 characters with ellipsis", () => {
+    const long = "A".repeat(80);
+    const result = deriveTitle(long);
+    expect(result.length).toBeLessThanOrEqual(61); // 60 + ellipsis char
+    expect(result.endsWith("\u2026")).toBe(true);
+  });
+
+  test("does not truncate at exactly 60 characters", () => {
+    const exact = "A".repeat(60);
+    expect(deriveTitle(exact)).toBe(exact);
+  });
+
+  test("trims whitespace", () => {
+    expect(deriveTitle("  trimmed  ")).toBe("trimmed");
+  });
+});