@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/__tests__/schedule-routes.test.ts

@@ -441,6 +441,57 @@ describe("GET /schedules — default defer exclusion", () => {
     expect(noSource.createdFromConversationArchivedAt).toBeNull();
   });
 
+  test("returns authored descriptions separately from cadence descriptions", () => {
+    createSchedule({
+      name: "Described schedule",
+      description: "Review the morning queue",
+      cronExpression: "0 9 * * *",
+      message: "review queue",
+      syntax: "cron",
+    });
+
+    const route = findRoute("schedules", "GET");
+    const result = route.handler({}) as {
+      schedules: Array<{
+        name: string;
+        description: string;
+        cadenceDescription: string;
+      }>;
+    };
+
+    expect(result.schedules).toHaveLength(1);
+    expect(result.schedules[0]).toMatchObject({
+      name: "Described schedule",
+      description: "Review the morning queue",
+      cadenceDescription: "Every day at 9:00 AM",
+    });
+  });
+
+  test("returns One-time as the cadence description for one-shot schedules", () => {
+    createSchedule({
+      name: "One-shot schedule",
+      description: "Send a one-time reminder",
+      cronExpression: null,
+      nextRunAt: Date.now() + 60_000,
+      message: "remember this",
+    });
+
+    const route = findRoute("schedules", "GET");
+    const result = route.handler({}) as {
+      schedules: Array<{
+        name: string;
+        description: string;
+        cadenceDescription: string;
+      }>;
+    };
+
+    expect(result.schedules[0]).toMatchObject({
+      name: "One-shot schedule",
+      description: "Send a one-time reminder",
+      cadenceDescription: "One-time",
+    });
+  });
+
   test("mutation responses also exclude deferred wakes", () => {
     createSchedule({
       name: "Agent schedule",
@@ -997,6 +1048,7 @@ describe("POST /schedules — create", () => {
   test("creates a recurring execute schedule with defaults", () => {
     const result = postCreate({
       name: "Morning ping",
+      description: "Start the morning workflow",
       expression: "0 9 * * *",
       message: "good morning",
     });
@@ -1006,6 +1058,7 @@ describe("POST /schedules — create", () => {
     expect(job.mode).toBe("execute");
     expect(job.expression).toBe("0 9 * * *");
     expect(job.syntax).toBe("cron");
+    expect(job.description).toBe("Start the morning workflow");
     expect(job.enabled).toBe(true);
     expect(job.timezone).toBeNull();
   });
@@ -1013,12 +1066,14 @@ describe("POST /schedules — create", () => {
   test("trims whitespace and accepts an explicit timezone", () => {
     postCreate({
       name: "  Trimmed  ",
+      description: "  Trimmed description  ",
       expression: "  0 9 * * *  ",
       message: "hi",
       timezone: " America/New_York ",
     });
     const job = listSchedules()[0];
     expect(job.name).toBe("Trimmed");
+    expect(job.description).toBe("Trimmed description");
     expect(job.expression).toBe("0 9 * * *");
     expect(job.timezone).toBe("America/New_York");
   });
@@ -1027,6 +1082,7 @@ describe("POST /schedules — create", () => {
     const expression = "DTSTART:20260101T000000Z\nRRULE:FREQ=WEEKLY;BYDAY=MO";
     postCreate({
       name: "Weekly",
+      description: "Weekly wake",
       expression,
       message: "monday wake",
     });
@@ -1045,12 +1101,32 @@ describe("POST /schedules — create", () => {
     expect(() => postCreate({ name: "x", expression: "* * * * *" })).toThrow(
       "message is required",
     );
+    expect(() =>
+      postCreate({
+        name: "x",
+        description: "   ",
+        expression: "* * * * *",
+        message: "hi",
+      }),
+    ).toThrow("description is required");
+  });
+
+  test("defaults omitted create descriptions for backward compatibility", () => {
+    postCreate({
+      name: "Description fallback",
+      expression: "0 9 * * *",
+      message: "hi",
+    });
+
+    const job = listSchedules()[0];
+    expect(job.description).toBe("Description fallback");
   });
 
   test("rejects non-execute modes", () => {
     expect(() =>
       postCreate({
         name: "x",
+        description: "Run the thing",
         expression: "* * * * *",
         message: "hi",
         mode: "notify",
@@ -1060,7 +1136,12 @@ describe("POST /schedules — create", () => {
 
   test("rejects an unparseable expression", () => {
     expect(() =>
-      postCreate({ name: "x", expression: "not-a-cron", message: "hi" }),
+      postCreate({
+        name: "x",
+        description: "Run the thing",
+        expression: "not-a-cron",
+        message: "hi",
+      }),
     ).toThrow("could not be parsed");
   });
 
@@ -1068,6 +1149,7 @@ describe("POST /schedules — create", () => {
     expect(() =>
       postCreate({
         name: "x",
+        description: "Run the thing",
         expression: "99 99 99 99 99",
         message: "hi",
       }),
@@ -1077,6 +1159,7 @@ describe("POST /schedules — create", () => {
   test("respects enabled=false", () => {
     postCreate({
       name: "Off",
+      description: "Disabled schedule",
       expression: "0 9 * * *",
       message: "hi",
       enabled: false,
@@ -1086,6 +1169,38 @@ describe("POST /schedules — create", () => {
   });
 });
 
+// ── PATCH /schedules/:id — description ───────────────────────────────────
+
+describe("PATCH /schedules/:id — description", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("updates authored descriptions", () => {
+    const schedule = createSchedule({
+      name: "Description update",
+      description: "Original description",
+      cronExpression: "0 9 * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+
+    const route = findRoute("schedules/:id", "PATCH");
+    const result = route.handler({
+      pathParams: { id: schedule.id },
+      body: { description: "Updated description" },
+    }) as {
+      schedules: Array<{ id: string; description: string }>;
+    };
+
+    expect(result.schedules[0]).toMatchObject({
+      id: schedule.id,
+      description: "Updated description",
+    });
+    expect(listSchedules()[0].description).toBe("Updated description");
+  });
+});
+
 // ── Wake mode support ─────────────────────────────────────────────────────
 
 describe("wake mode in schedule routes", () => {

package/src/__tests__/schedule-store.test.ts

@@ -160,6 +160,7 @@ describe("createSchedule (cron)", () => {
     expect(job.syntax).toBe("cron");
     expect(job.expression).toBe("0 9 * * *");
     expect(job.cronExpression).toBe("0 9 * * *");
+    expect(job.description).toBe("Morning ping");
     expect(job.nextRunAt).toBeGreaterThan(Date.now() - 1000);
     expect(job.enabled).toBe(true);
   });
@@ -167,6 +168,7 @@ describe("createSchedule (cron)", () => {
   test("persisted cron schedule is retrievable with new fields", () => {
     const job = createSchedule({
       name: "Hourly",
+      description: "Check the hourly status report",
       cronExpression: "0 * * * *",
       message: "hourly check",
       syntax: "cron",
@@ -177,6 +179,32 @@ describe("createSchedule (cron)", () => {
     expect(retrieved!.syntax).toBe("cron");
     expect(retrieved!.expression).toBe("0 * * * *");
     expect(retrieved!.cronExpression).toBe("0 * * * *");
+    expect(retrieved!.description).toBe("Check the hourly status report");
+  });
+
+  test("normalizes schedule descriptions on create and update", () => {
+    const job = createSchedule({
+      name: "Description normalization",
+      description: "  Daily executive summary  ",
+      cronExpression: "0 8 * * *",
+      message: "summarize the day",
+      syntax: "cron",
+    });
+
+    expect(job.description).toBe("Daily executive summary");
+
+    const raw = getRawDb()
+      .query("SELECT description FROM cron_jobs WHERE id = ?")
+      .get(job.id) as { description: string };
+    expect(raw.description).toBe("Daily executive summary");
+
+    const updated = updateSchedule(job.id, {
+      description: "  Updated summary prompt  ",
+    });
+    expect(updated).not.toBeNull();
+    expect(updated!.description).toBe("Updated summary prompt");
+    expect(getSchedule(job.id)!.description).toBe("Updated summary prompt");
+    expect(listSchedules()[0].description).toBe("Updated summary prompt");
   });
 
   test("defaults source conversation metadata to null", () => {

package/src/__tests__/schedule-tools.test.ts

@@ -18,7 +18,7 @@ import type { Database } from "bun:sqlite";
 
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
-import { executeScheduleCreate } from "../tools/schedule/create.js";
+import { executeScheduleCreate as rawExecuteScheduleCreate } from "../tools/schedule/create.js";
 import { executeScheduleDelete } from "../tools/schedule/delete.js";
 import { executeScheduleList } from "../tools/schedule/list.js";
 import { executeScheduleUpdate } from "../tools/schedule/update.js";
@@ -41,6 +41,16 @@ const trustedCtx: ToolContext = {
   trustClass: "trusted_contact",
 };
 
+function executeScheduleCreate(
+  input: Record<string, unknown>,
+  context: ToolContext,
+) {
+  return rawExecuteScheduleCreate(
+    { description: "Test schedule description", ...input },
+    context,
+  );
+}
+
 // ── schedule_create ─────────────────────────────────────────────────
 
 describe("schedule_create tool", () => {
@@ -53,6 +63,7 @@ describe("schedule_create tool", () => {
     const result = await executeScheduleCreate(
       {
         name: "Daily standup",
+        description: "Remind the team to join the daily standup.",
         expression: "0 9 * * 1-5",
         message: "Time for standup!",
       },
@@ -62,8 +73,16 @@ describe("schedule_create tool", () => {
     expect(result.isError).toBe(false);
     expect(result.content).toContain("schedule created successfully");
     expect(result.content).toContain("Daily standup");
+    expect(result.content).toContain(
+      "Description: Remind the team to join the daily standup.",
+    );
     expect(result.content).toContain("Every weekday at 9:00 AM");
     expect(result.content).toContain("Enabled: true");
+
+    const row = getRawDb()
+      .query("SELECT description FROM cron_jobs LIMIT 1")
+      .get() as { description: string };
+    expect(row.description).toBe("Remind the team to join the daily standup.");
   });
 
   test("persists the creating conversation for recurring schedules", async () => {
@@ -126,6 +145,35 @@ describe("schedule_create tool", () => {
     expect(result.content).toContain("name is required");
   });
 
+  test("rejects missing description", async () => {
+    const result = await rawExecuteScheduleCreate(
+      {
+        name: "No description",
+        expression: "0 9 * * *",
+        message: "test",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("description is required");
+  });
+
+  test("rejects blank description", async () => {
+    const result = await rawExecuteScheduleCreate(
+      {
+        name: "Blank description",
+        description: "   ",
+        expression: "0 9 * * *",
+        message: "test",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("description is required");
+  });
+
   test("rejects missing expression when no fire_at", async () => {
     const result = await executeScheduleCreate(
       {
@@ -195,6 +243,7 @@ describe("schedule_create with fire_at (one-shot)", () => {
     const result = await executeScheduleCreate(
       {
         name: "One-time reminder",
+        description: "Remind the user about a one-time event.",
         fire_at: futureDate,
         message: "Don't forget!",
       },
@@ -206,7 +255,15 @@ describe("schedule_create with fire_at (one-shot)", () => {
     expect(result.content).toContain("Type: one-shot");
     expect(result.content).toContain("Mode: execute");
     expect(result.content).toContain("One-time reminder");
+    expect(result.content).toContain(
+      "Description: Remind the user about a one-time event.",
+    );
     expect(result.content).toContain("Status: active");
+
+    const row = getRawDb()
+      .query("SELECT description FROM cron_jobs LIMIT 1")
+      .get() as { description: string };
+    expect(row.description).toBe("Remind the user about a one-time event.");
   });
 
   test("persists the creating conversation for one-shot schedules", async () => {
@@ -547,6 +604,7 @@ describe("schedule_list tool", () => {
     await executeScheduleCreate(
       {
         name: "Detail Job",
+        description: "Describe the detail job purpose.",
         expression: "30 14 * * *",
         message: "Afternoon check",
       },
@@ -561,6 +619,9 @@ describe("schedule_list tool", () => {
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain("Schedule: Detail Job");
+    expect(result.content).toContain(
+      "Description: Describe the detail job purpose.",
+    );
     expect(result.content).toContain("Every day at 2:30 PM");
     expect(result.content).toContain("Message: Afternoon check");
     expect(result.content).toContain("Enabled: true");
@@ -598,6 +659,7 @@ describe("schedule_list with one-shot schedules", () => {
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain("One-shot Event");
+    expect(result.content).toContain("Test schedule description");
     expect(result.content).toContain("one-shot");
     expect(result.content).toContain("fire at:");
     expect(result.content).toContain("active");
@@ -719,6 +781,37 @@ describe("schedule_update tool", () => {
     expect(result.content).toContain("New Name");
   });
 
+  test("updates the description of a schedule", async () => {
+    await executeScheduleCreate(
+      {
+        name: "Description update",
+        description: "Original purpose.",
+        expression: "0 9 * * *",
+        message: "test",
+      },
+      ctx,
+    );
+
+    const row = getRawDb().query("SELECT id FROM cron_jobs LIMIT 1").get() as {
+      id: string;
+    };
+    const result = await executeScheduleUpdate(
+      {
+        job_id: row.id,
+        description: "Updated purpose.",
+      },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Description: Updated purpose.");
+
+    const dbRow = getRawDb()
+      .query("SELECT description FROM cron_jobs WHERE id = ?")
+      .get(row.id) as { description: string };
+    expect(dbRow.description).toBe("Updated purpose.");
+  });
+
   test("updates the cron expression", async () => {
     await executeScheduleCreate(
       {

package/src/__tests__/server-history-render.test.ts

@@ -808,6 +808,45 @@ describe("renderHistoryContent contentBlocks", () => {
     );
   });
 
+  test("surfaces persisted thinking timing onto the thinking block", () => {
+    // GIVEN a thinking block the daemon stamped with internal `_startedAt` /
+    // `_completedAt` timing at message_complete
+    const output = renderHistoryContent([
+      {
+        type: "thinking",
+        thinking: "reasoning",
+        signature: "sig",
+        _startedAt: 1000,
+        _completedAt: 1500,
+      },
+    ]);
+
+    // THEN the rendered block exposes them as the wire schema's
+    // startedAt/completedAt so the client can show the duration + hover state
+    expect(output.contentBlocks).toEqual([
+      {
+        type: "thinking",
+        thinking: "reasoning",
+        startedAt: 1000,
+        completedAt: 1500,
+      },
+    ]);
+  });
+
+  test("omits thinking timing when the block carries none", () => {
+    // GIVEN a thinking block with no persisted timing (older daemon / thinking
+    // streaming disabled)
+    const output = renderHistoryContent([
+      { type: "thinking", thinking: "reasoning", signature: "sig" },
+    ]);
+
+    // THEN the rendered block has no startedAt/completedAt and the client hides
+    // the duration, exactly as a tool call with no timing
+    expect(output.contentBlocks).toEqual([
+      { type: "thinking", thinking: "reasoning" },
+    ]);
+  });
+
   const pdfBlock = {
     type: "file",
     source: {

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -222,6 +222,19 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
+// Mock the skill_loaded telemetry dependencies of conversation-skill-tools so
+// their heavy transitive imports (catalog-install → CLI program, sqlite) stay
+// out of this import-light test.
+mock.module("../skills/catalog-cache.js", () => ({
+  getCachedCatalogSync: () => [],
+}));
+mock.module("../skills/install-meta.js", () => ({
+  readInstallMeta: () => null,
+}));
+mock.module("../memory/skill-loaded-events-store.js", () => ({
+  recordSkillLoadedEvent: () => {},
+}));
+
 // ---------------------------------------------------------------------------
 // Import module under test (after mocks)
 // ---------------------------------------------------------------------------

package/src/__tests__/skill-projection.benchmark.test.ts

@@ -96,6 +96,19 @@ mock.module("../skills/version-hash.js", () => ({
   computeSkillVersionHash: () => "v1:deadbeef",
 }));
 
+// Mock the skill_loaded telemetry dependencies of conversation-skill-tools so
+// their heavy transitive imports (catalog-install → CLI program, sqlite) stay
+// out of this import-light test.
+mock.module("../skills/catalog-cache.js", () => ({
+  getCachedCatalogSync: () => [],
+}));
+mock.module("../skills/install-meta.js", () => ({
+  readInstallMeta: () => null,
+}));
+mock.module("../memory/skill-loaded-events-store.js", () => ({
+  recordSkillLoadedEvent: () => {},
+}));
+
 // Mock createSkillToolsFromManifest to return lightweight Tool-like objects
 mock.module("../tools/skills/skill-tool-factory.js", () => ({
   createSkillToolsFromManifest: (
@@ -153,22 +166,27 @@ mock.module("node:fs", () => ({
   Stats: class {},
 }));
 
-const benchmarkRegistry = new Map<string, unknown>();
+// Mirrors the current registry contract: ownership is recorded from the
+// `registerSkillTools(skillId, tools)` call and reported via `getToolOwner`.
+const benchmarkRegistry = new Map<string, { tool: unknown; skillId: string }>();
 mock.module("../tools/registry.js", () => ({
   registerSkillTools: (
+    skillId: string,
     tools: Array<{ name: string; [k: string]: unknown }>,
   ) => {
-    for (const t of tools) benchmarkRegistry.set(t.name, t);
+    for (const t of tools) benchmarkRegistry.set(t.name, { tool: t, skillId });
     return tools;
   },
   unregisterSkillTools: (skillId: string) => {
-    for (const [name, t] of benchmarkRegistry) {
-      const owner = (t as { owner?: { kind: string; id: string } }).owner;
-      if (owner?.kind === "skill" && owner.id === skillId)
-        benchmarkRegistry.delete(name);
+    for (const [name, entry] of benchmarkRegistry) {
+      if (entry.skillId === skillId) benchmarkRegistry.delete(name);
     }
   },
-  getTool: (name: string) => benchmarkRegistry.get(name),
+  getTool: (name: string) => benchmarkRegistry.get(name)?.tool,
+  getToolOwner: (name: string) => {
+    const entry = benchmarkRegistry.get(name);
+    return entry ? { kind: "skill" as const, id: entry.skillId } : undefined;
+  },
 }));
 
 // ---------------------------------------------------------------------------