@vellumai/assistant 0.5.16 → 0.6.1

package/src/config/bundled-skills/outlook-calendar/tools/outlook-calendar-rsvp.ts

@@ -0,0 +1,36 @@
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import * as calendar from "../calendar-client.js";
+import { getCalendarConnection, ok } from "./shared.js";
+
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const account = input.account as string | undefined;
+  const eventId = input.event_id as string;
+  const response = input.response as "accepted" | "declined" | "tentative";
+
+  const connection = await getCalendarConnection(account);
+
+  // Fetch the event to get context for the response message
+  const event = await calendar.getEvent(connection, eventId);
+
+  // If the user is the organizer, no RSVP is needed
+  if (event.responseStatus?.response === "organizer") {
+    return ok("You are the organizer of this event. No RSVP needed.");
+  }
+
+  // Send RSVP via the dedicated Microsoft Graph endpoint, notifying the organizer
+  await calendar.rsvpEvent(connection, eventId, response, true);
+
+  const responseLabel =
+    response === "accepted"
+      ? "Accepted"
+      : response === "declined"
+        ? "Declined"
+        : "Tentatively accepted";
+  return ok(`${responseLabel} the event "${event.subject ?? eventId}".`);
+}

package/src/config/bundled-skills/outlook-calendar/tools/shared.ts

@@ -0,0 +1,17 @@
+import type { OAuthConnection } from "../../../../oauth/connection.js";
+import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
+import type { ToolExecutionResult } from "../../../../tools/types.js";
+
+export function ok(content: string): ToolExecutionResult {
+  return { content, isError: false };
+}
+
+export function err(message: string): ToolExecutionResult {
+  return { content: message, isError: true };
+}
+
+export async function getCalendarConnection(
+  account?: string,
+): Promise<OAuthConnection> {
+  return resolveOAuthConnection("outlook", { account });
+}

package/src/config/bundled-skills/outlook-calendar/types.ts

@@ -0,0 +1,120 @@
+/** Microsoft Graph date+time pair. timeZone may be omitted when dateTime carries an offset. */
+export interface OutlookDateTimeZone {
+  dateTime: string;
+  timeZone?: string;
+}
+
+/** Attendee on a calendar event. */
+export interface OutlookCalendarAttendee {
+  emailAddress: { address: string; name?: string };
+  type: "required" | "optional" | "resource";
+  status?: {
+    response:
+      | "none"
+      | "organizer"
+      | "tentativelyAccepted"
+      | "accepted"
+      | "declined"
+      | "notResponded";
+    time?: string;
+  };
+}
+
+/** Physical or virtual location for a calendar event. */
+export interface OutlookLocation {
+  displayName?: string;
+  locationType?: string;
+  address?: Record<string, unknown>;
+  coordinates?: Record<string, unknown>;
+}
+
+/** Rich-text body of a calendar item. */
+export interface OutlookItemBody {
+  contentType: "text" | "html";
+  content: string;
+}
+
+/** A single calendar event from Microsoft Graph. */
+export interface OutlookCalendarEvent {
+  id: string;
+  subject?: string;
+  bodyPreview?: string;
+  body?: OutlookItemBody;
+  start?: OutlookDateTimeZone;
+  end?: OutlookDateTimeZone;
+  location?: OutlookLocation;
+  locations?: OutlookLocation[];
+  attendees?: OutlookCalendarAttendee[];
+  organizer?: { emailAddress: { address: string; name?: string } };
+  isAllDay?: boolean;
+  isCancelled?: boolean;
+  showAs?:
+    | "free"
+    | "tentative"
+    | "busy"
+    | "oof"
+    | "workingElsewhere"
+    | "unknown";
+  importance?: "low" | "normal" | "high";
+  sensitivity?: "normal" | "personal" | "private" | "confidential";
+  webLink?: string;
+  onlineMeetingUrl?: string;
+  createdDateTime?: string;
+  lastModifiedDateTime?: string;
+  seriesMasterId?: string;
+  type?: "singleInstance" | "occurrence" | "exception" | "seriesMaster";
+  categories?: string[];
+  responseStatus?: { response: string; time?: string };
+}
+
+/** Paginated list of calendar events. */
+export interface OutlookCalendarEventListResponse {
+  value?: OutlookCalendarEvent[];
+  "@odata.nextLink"?: string;
+  "@odata.deltaLink"?: string;
+  "@odata.count"?: number;
+}
+
+/** A single schedule item (free/busy block). */
+export interface OutlookScheduleItem {
+  status:
+    | "free"
+    | "tentative"
+    | "busy"
+    | "oof"
+    | "workingElsewhere"
+    | "unknown";
+  start: OutlookDateTimeZone;
+  end: OutlookDateTimeZone;
+  subject?: string;
+  location?: string;
+}
+
+/** Schedule information for one user. */
+export interface OutlookScheduleInformation {
+  scheduleId: string;
+  availabilityView: string;
+  scheduleItems: OutlookScheduleItem[];
+  error?: Record<string, unknown>;
+}
+
+/** Response from the getSchedule endpoint. */
+export interface OutlookScheduleResponse {
+  value?: OutlookScheduleInformation[];
+}
+
+/** A calendar in the user's mailbox. */
+export interface OutlookCalendar {
+  id: string;
+  name?: string;
+  color?: string;
+  isDefaultCalendar?: boolean;
+  canEdit?: boolean;
+  owner?: { name: string; address: string };
+}
+
+/** Paginated list of calendars. */
+export interface OutlookCalendarListResponse {
+  value?: OutlookCalendar[];
+  "@odata.nextLink"?: string;
+}

package/src/config/bundled-skills/playbooks/tools/playbook-create.ts

@@ -1,10 +1,10 @@
-import { and, eq } from "drizzle-orm";
-import { v4 as uuid } from "uuid";
+import { sql } from "drizzle-orm";
 
 import { getDb } from "../../../../memory/db.js";
-import { computeMemoryFingerprint } from "../../../../memory/fingerprint.js";
+import { createNode, updateNode } from "../../../../memory/graph/store.js";
+import type { NewNode } from "../../../../memory/graph/types.js";
 import { enqueueMemoryJob } from "../../../../memory/jobs-store.js";
-import { memoryItems } from "../../../../memory/schema.js";
+import { memoryGraphNodes } from "../../../../memory/schema.js";
 import type {
   Playbook,
   PlaybookAutonomyLevel,
@@ -13,7 +13,6 @@ import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
-import { truncate } from "../../../../util/truncate.js";
 
 const VALID_AUTONOMY_LEVELS = new Set<string>(["auto", "draft", "notify"]);
 
@@ -56,27 +55,23 @@ export async function executePlaybookCreate(
     priority,
   };
   const statement = JSON.stringify(playbook);
-  const subject = truncate(`Playbook: ${trigger}`, 80, "");
+  const sanitizedTrigger = trigger.replace(/[\r\n]+/g, " ");
+  const subject = `Playbook: ${sanitizedTrigger}`.slice(0, 80);
+  const content = `${subject}\n${statement}`;
   const scopeId = context.memoryScopeId ?? "default";
 
-  const fingerprint = computeMemoryFingerprint(
-    scopeId,
-    "playbook",
-    subject,
-    statement,
-  );
-
   try {
     const db = getDb();
 
+    // Check for duplicate by matching content in playbook-prefixed graph nodes
     const existing = db
-      .select()
-      .from(memoryItems)
+      .select({ id: memoryGraphNodes.id })
+      .from(memoryGraphNodes)
       .where(
-        and(
-          eq(memoryItems.fingerprint, fingerprint),
-          eq(memoryItems.scopeId, scopeId),
-        ),
+        sql`${memoryGraphNodes.sourceConversations} LIKE '%playbook:%'
+            AND ${memoryGraphNodes.content} = ${content}
+            AND ${memoryGraphNodes.scopeId} = ${scopeId}
+            AND ${memoryGraphNodes.fidelity} != 'gone'`,
       )
       .get();
 
@@ -87,29 +82,41 @@ export async function executePlaybookCreate(
       };
     }
 
-    const id = uuid();
     const now = Date.now();
+    const newNode: NewNode = {
+      content,
+      type: "semantic",
+      created: now,
+      lastAccessed: now,
+      lastConsolidated: now,
+      eventDate: null,
+      emotionalCharge: {
+        valence: 0,
+        intensity: 0.1,
+        decayCurve: "linear",
+        decayRate: 0.05,
+        originalIntensity: 0.1,
+      },
+      fidelity: "vivid",
+      confidence: 0.95,
+      significance: 0.8,
+      stability: 14,
+      reinforcementCount: 0,
+      lastReinforced: now,
+      sourceConversations: [],
+      sourceType: "direct",
+      narrativeRole: null,
+      partOfStory: null,
+      imageRefs: null,
+      scopeId,
+    };
 
-    db.insert(memoryItems)
-      .values({
-        id,
-        kind: "playbook",
-        subject,
-        statement,
-        status: "active",
-        confidence: 0.95,
-        importance: 0.8,
-        fingerprint,
-        sourceType: "tool",
-        verificationState: "user_confirmed",
-        scopeId,
-        firstSeenAt: now,
-        lastSeenAt: now,
-        lastUsedAt: null,
-      })
-      .run();
+    const node = createNode(newNode);
+    updateNode(node.id, {
+      sourceConversations: [`playbook:${node.id}`],
+    });
 
-    enqueueMemoryJob("embed_item", { itemId: id });
+    enqueueMemoryJob("embed_graph_node", { nodeId: node.id });
 
     const autonomyLabel =
       autonomyLevel === "auto"
@@ -121,7 +128,7 @@ export async function executePlaybookCreate(
     return {
       content: [
         "Playbook created successfully.",
-        `  ID: ${id}`,
+        `  ID: ${node.id}`,
         `  Trigger: ${trigger}`,
         `  Channel: ${channel}`,
         `  Category: ${category}`,

package/src/config/bundled-skills/playbooks/tools/playbook-delete.ts

@@ -1,7 +1,4 @@
-import { and, eq } from "drizzle-orm";
-
-import { getDb } from "../../../../memory/db.js";
-import { memoryItems } from "../../../../memory/schema.js";
+import { getNode, updateNode } from "../../../../memory/graph/store.js";
 import { parsePlaybookStatement } from "../../../../playbooks/types.js";
 import type {
   ToolContext,
@@ -23,38 +20,28 @@ export async function executePlaybookDelete(
   const scopeId = context.memoryScopeId ?? "default";
 
   try {
-    const db = getDb();
-
-    const existing = db
-      .select()
-      .from(memoryItems)
-      .where(
-        and(
-          eq(memoryItems.id, playbookId),
-          eq(memoryItems.kind, "playbook"),
-          eq(memoryItems.scopeId, scopeId),
-        ),
-      )
-      .get();
-
-    if (!existing) {
+    const existing = getNode(playbookId);
+    if (
+      !existing ||
+      existing.scopeId !== scopeId ||
+      !existing.sourceConversations.some((s) => s.startsWith("playbook:")) ||
+      existing.fidelity === "gone"
+    ) {
       return {
         content: `Error: Playbook with ID "${playbookId}" not found`,
         isError: true,
       };
     }
 
-    const playbook = parsePlaybookStatement(existing.statement);
-    const triggerLabel = playbook?.trigger ?? existing.subject;
+    // Extract trigger label from content
+    const newlineIdx = existing.content.indexOf("\n");
+    const statement =
+      newlineIdx !== -1 ? existing.content.slice(newlineIdx + 1) : "";
+    const playbook = parsePlaybookStatement(statement);
+    const triggerLabel = playbook?.trigger ?? existing.content.split("\n")[0];
 
-    // Soft-delete by marking as superseded rather than hard-deleting,
-    // consistent with how other memory items are retired.
-    // Setting invalidAt so the cleanup job can eventually hard-delete it.
-    const now = Date.now();
-    db.update(memoryItems)
-      .set({ status: "superseded", invalidAt: now })
-      .where(eq(memoryItems.id, existing.id))
-      .run();
+    // Soft-delete by setting fidelity to "gone"
+    updateNode(existing.id, { fidelity: "gone" });
 
     return {
       content: `Playbook deleted (ID: ${existing.id}, trigger: "${triggerLabel}").`,

package/src/config/bundled-skills/playbooks/tools/playbook-list.ts

@@ -1,7 +1,7 @@
-import { and, desc, eq, isNull } from "drizzle-orm";
+import { and, eq, sql } from "drizzle-orm";
 
 import { getDb } from "../../../../memory/db.js";
-import { memoryItems } from "../../../../memory/schema.js";
+import { memoryGraphNodes } from "../../../../memory/schema.js";
 import { parsePlaybookStatement } from "../../../../playbooks/types.js";
 import type {
   ToolContext,
@@ -23,22 +23,20 @@ export async function executePlaybookList(
 
     const rows = db
       .select({
-        id: memoryItems.id,
-        subject: memoryItems.subject,
-        statement: memoryItems.statement,
-        importance: memoryItems.importance,
-        lastSeenAt: memoryItems.lastSeenAt,
+        id: memoryGraphNodes.id,
+        content: memoryGraphNodes.content,
+        significance: memoryGraphNodes.significance,
+        lastAccessed: memoryGraphNodes.lastAccessed,
       })
-      .from(memoryItems)
+      .from(memoryGraphNodes)
       .where(
         and(
-          eq(memoryItems.kind, "playbook"),
-          eq(memoryItems.status, "active"),
-          eq(memoryItems.scopeId, scopeId),
-          isNull(memoryItems.invalidAt),
+          eq(memoryGraphNodes.scopeId, scopeId),
+          sql`${memoryGraphNodes.sourceConversations} LIKE '%playbook:%'`,
+          sql`${memoryGraphNodes.fidelity} != 'gone'`,
         ),
       )
-      .orderBy(desc(memoryItems.importance))
+      .orderBy(sql`${memoryGraphNodes.significance} DESC`)
       .all();
 
     if (rows.length === 0) {
@@ -47,12 +45,14 @@ export async function executePlaybookList(
 
     const entries: Array<{
       id: string;
-      subject: string;
-      statement: string;
       playbook: NonNullable<ReturnType<typeof parsePlaybookStatement>>;
     }> = [];
     for (const row of rows) {
-      const playbook = parsePlaybookStatement(row.statement);
+      // Content format: "Playbook: <trigger>\n<json statement>"
+      const newlineIdx = row.content.indexOf("\n");
+      if (newlineIdx === -1) continue;
+      const statement = row.content.slice(newlineIdx + 1);
+      const playbook = parsePlaybookStatement(statement);
       if (!playbook) continue;
 
       // Apply filters
@@ -66,8 +66,6 @@ export async function executePlaybookList(
 
       entries.push({
         id: row.id,
-        subject: row.subject,
-        statement: row.statement,
         playbook,
       });
     }

package/src/config/bundled-skills/playbooks/tools/playbook-update.ts

@@ -1,9 +1,9 @@
-import { and, eq } from "drizzle-orm";
+import { and, eq, sql } from "drizzle-orm";
 
 import { getDb } from "../../../../memory/db.js";
-import { computeMemoryFingerprint } from "../../../../memory/fingerprint.js";
+import { getNode, updateNode } from "../../../../memory/graph/store.js";
 import { enqueueMemoryJob } from "../../../../memory/jobs-store.js";
-import { memoryItems } from "../../../../memory/schema.js";
+import { memoryGraphNodes } from "../../../../memory/schema.js";
 import type {
   Playbook,
   PlaybookAutonomyLevel,
@@ -13,7 +13,6 @@ import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
-import { truncate } from "../../../../util/truncate.js";
 
 const VALID_AUTONOMY_LEVELS = new Set<string>(["auto", "draft", "notify"]);
 
@@ -32,28 +31,29 @@ export async function executePlaybookUpdate(
   const scopeId = context.memoryScopeId ?? "default";
 
   try {
-    const db = getDb();
-
-    const existing = db
-      .select()
-      .from(memoryItems)
-      .where(
-        and(
-          eq(memoryItems.id, playbookId),
-          eq(memoryItems.kind, "playbook"),
-          eq(memoryItems.scopeId, scopeId),
-        ),
-      )
-      .get();
-
-    if (!existing) {
+    const existing = getNode(playbookId);
+    if (
+      !existing ||
+      existing.scopeId !== scopeId ||
+      !existing.sourceConversations.some((s) => s.startsWith("playbook:")) ||
+      existing.fidelity === "gone"
+    ) {
       return {
         content: `Error: Playbook with ID "${playbookId}" not found`,
         isError: true,
       };
     }
 
-    const currentPlaybook = parsePlaybookStatement(existing.statement);
+    // Extract the JSON statement from the content (after the first newline)
+    const newlineIdx = existing.content.indexOf("\n");
+    if (newlineIdx === -1) {
+      return {
+        content: `Error: Playbook data is corrupted for ID "${playbookId}"`,
+        isError: true,
+      };
+    }
+    const currentStatement = existing.content.slice(newlineIdx + 1);
+    const currentPlaybook = parsePlaybookStatement(currentStatement);
     if (!currentPlaybook) {
       return {
         content: `Error: Playbook data is corrupted for ID "${playbookId}"`,
@@ -91,47 +91,39 @@ export async function executePlaybookUpdate(
     };
 
     const statement = JSON.stringify(updated);
-    const subject = truncate(`Playbook: ${updated.trigger}`, 80, "");
-    const now = Date.now();
-
-    const fingerprint = computeMemoryFingerprint(
-      scopeId,
-      "playbook",
-      subject,
-      statement,
-    );
+    const sanitizedTrigger = updated.trigger.replace(/[\r\n]+/g, " ");
+    const subject = `Playbook: ${sanitizedTrigger}`.slice(0, 80);
+    const content = `${subject}\n${statement}`;
 
-    // Check if another playbook already has this fingerprint
+    // Check for duplicate content among other playbook nodes
+    const db = getDb();
     const collision = db
-      .select({ id: memoryItems.id })
-      .from(memoryItems)
+      .select({ id: memoryGraphNodes.id })
+      .from(memoryGraphNodes)
       .where(
         and(
-          eq(memoryItems.fingerprint, fingerprint),
-          eq(memoryItems.scopeId, scopeId),
+          eq(memoryGraphNodes.scopeId, scopeId),
+          sql`${memoryGraphNodes.sourceConversations} LIKE '%playbook:%'`,
+          eq(memoryGraphNodes.content, content),
+          sql`${memoryGraphNodes.fidelity} != 'gone'`,
+          sql`${memoryGraphNodes.id} != ${existing.id}`,
         ),
       )
       .get();
-    if (collision && collision.id !== existing.id) {
+
+    if (collision) {
       return {
         content: `Error: Another playbook with this exact configuration already exists (ID: ${collision.id}).`,
         isError: true,
       };
     }
 
-    db.update(memoryItems)
-      .set({
-        subject,
-        statement,
-        fingerprint,
-        lastSeenAt: now,
-        sourceType: "tool",
-        verificationState: "user_confirmed",
-      })
-      .where(eq(memoryItems.id, existing.id))
-      .run();
+    updateNode(existing.id, {
+      content,
+      lastAccessed: Date.now(),
+    });
 
-    enqueueMemoryJob("embed_item", { itemId: existing.id });
+    enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
 
     const autonomyLabel =
       updated.autonomyLevel === "auto"

package/src/config/bundled-skills/schedule/SKILL.md

@@ -87,6 +87,14 @@ The `mode` parameter controls what happens when a schedule fires:
 
 Use `notify` for simple reminders ("remind me to take medicine at 9am") and `execute` for tasks that need assistant action ("check my calendar at 8am and send me a digest").
 
+## Conversation Reuse
+
+By default, each schedule run creates a new conversation. For recurring schedules that benefit from accumulating context across runs (e.g. polling-style jobs, daily digests that reference prior results), set `reuse_conversation: true`. When enabled, subsequent runs reuse the conversation from the last successful run instead of creating a new one.
+
+- Only applies to **recurring** schedules; ignored for one-shot schedules.
+- If the prior conversation has been deleted, a new one is created automatically.
+- On the first run (no prior conversation), a new conversation is created as usual.
+
 ## Routing (notify mode)
 
 Control how notify-mode schedules are delivered at trigger time with `routing_intent`:
@@ -101,9 +109,20 @@ Optionally pass `routing_hints` (a JSON object) to influence routing decisions (
 
 - **Default to `all_channels`** for most notifications. Users usually want to be notified wherever they are.
 - **Use `single_channel`** only when the user explicitly specifies a single channel (e.g. "remind me on Telegram").
-- **Check `user_message_channel` (or `channel` when all channels are the same)** from the turn context. If the user is currently active on a specific channel, include it as a routing hint:
+- **Determine the originating channel** for routing hints using this priority:
+  1. **`source_channel`** from `<turn_context>` — use directly if present. This is the authoritative channel name.
+  2. **`interface` fallback** — if `source_channel` is absent (common for guardian/direct users), map the `interface` value to a channel name:
+     | `interface` value | Channel name |
+     | --- | --- |
+     | `macos`, `ios` | `vellum` |
+     | `telegram` | `telegram` |
+     | `slack` | `slack` |
+     | `cli` | _(omit — no routable channel)_ |
+  3. If neither field is present or the interface is `cli`, omit `preferred_channels`.
+
+  When a channel is determined, include it as a routing hint:
   ```
-  routing_hints: { preferred_channels: ["vellum"] }
+  routing_hints: { preferred_channels: ["<resolved channel>"] }
   routing_intent: "all_channels"
   ```
 
@@ -119,6 +138,7 @@ Use `syntax` + `expression` to specify the schedule type explicitly, or just `ex
 
 ## Tips
 
+- **When the user specifies a name for the schedule, use it exactly as given.** Do not paraphrase, embellish, or generate a descriptive name.
 - Use `schedule_create` for both recurring automation ("every day at 9am") and one-time reminders ("remind me at 3pm").
 - For task tracking ("add to my tasks", "add to my queue"), use task_list_add instead.
 - `fire_at` must be a strict ISO 8601 timestamp with timezone offset or Z (e.g. `2025-03-15T09:00:00-05:00`).

package/src/config/bundled-skills/schedule/TOOLS.json

@@ -56,6 +56,10 @@
             "type": "boolean",
             "description": "When true, suppress completion notifications for this schedule. The job still runs and produces output, but no notification or conversation message is sent on completion. Useful for high-frequency recurring jobs that report findings separately. Defaults to false."
           },
+          "reuse_conversation": {
+            "type": "boolean",
+            "description": "When true, reuse the same conversation across recurring schedule runs instead of creating a new one each time. Useful for polling-style schedules that accumulate context over time. Ignored for one-shot schedules. Defaults to false."
+          },
           "activity": {
             "type": "string",
             "description": "Brief non-technical explanation of why this tool is being called"
@@ -147,6 +151,10 @@
             "type": "boolean",
             "description": "When true, suppress completion notifications for this schedule. Useful for high-frequency jobs that report findings separately."
           },
+          "reuse_conversation": {
+            "type": "boolean",
+            "description": "When true, reuse the same conversation across recurring schedule runs instead of creating a new one each time. Useful for polling-style schedules that accumulate context over time. Ignored for one-shot schedules."
+          },
           "activity": {
             "type": "string",
             "description": "Brief non-technical explanation of why this tool is being called"

package/src/config/bundled-skills/settings/tools/avatar-get.ts

@@ -7,27 +7,17 @@ import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
-import { getWorkspaceDir } from "../../../../util/platform.js";
+import { getAvatarDir, getAvatarImagePath } from "../../../../util/platform.js";
 
 export async function run(
   _input: Record<string, unknown>,
   _context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const avatarPath = join(
-    getWorkspaceDir(),
-    "data",
-    "avatar",
-    "avatar-image.png",
-  );
+  const avatarPath = getAvatarImagePath();
 
   if (!existsSync(avatarPath)) {
     // Check for native character traits and regenerate the static PNG
-    const traitsPath = join(
-      getWorkspaceDir(),
-      "data",
-      "avatar",
-      "character-traits.json",
-    );
+    const traitsPath = join(getAvatarDir(), "character-traits.json");
     if (existsSync(traitsPath)) {
       try {
         const traits = JSON.parse(readFileSync(traitsPath, "utf-8"));