@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/__tests__/{scheduler-worker-standdown.test.ts → run-due-schedules.test.ts}

@@ -1,44 +1,16 @@
 /**
- * Scheduler ↔ schedule-worker ownership: while `schedules.worker.enabled` is
- * set, the daemon's in-process scheduler must leave every due schedule
- * unclaimed (the worker process owns schedule execution), while
- * `runDueSchedulesOnce` — the worker's tick — claims and executes them.
+ * `runDueSchedulesOnce` — the schedule worker's tick — claims and executes
+ * every due schedule across modes. Schedule execution is owned by the schedule
+ * worker process; the daemon's own scheduler tick runs only watchers and
+ * sequences.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 mock.module("../background-wake/publisher.js", () => ({
   refreshBackgroundWakeIntent: () => {},
 }));
 
-let workerEnabled = false;
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    schedules: { worker: { enabled: workerEnabled } },
-    timeouts: { scheduleTurnTimeoutSec: 1800 },
-  }),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getConfigReadOnly: () => ({}),
-  applyNestedDefaults: (config: unknown) => config,
-  deepMergeOverwrite: (base: unknown) => base,
-  mergeDefaultWorkspaceConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  API_KEY_PROVIDERS: [],
-  _writeQuarantineNotice: () => {},
-  invalidateConfigCache: () => {},
-}));
-
 mock.module("../daemon/disk-pressure-background-gate.js", () => ({
   checkDiskPressureBackgroundGate: () => ({
     action: "allow",
@@ -72,10 +44,7 @@ mock.module("../notifications/emit-signal.js", () => ({
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { createSchedule } from "../schedule/schedule-store.js";
-import {
-  runDueSchedulesOnce,
-  runScheduleDueWorkOnce,
-} from "../schedule/scheduler.js";
+import { runDueSchedulesOnce } from "../schedule/scheduler.js";
 
 await initializeDb();
 
@@ -85,7 +54,6 @@ function rawDb(): import("bun:sqlite").Database {
 }
 
 beforeEach(() => {
-  workerEnabled = false;
   mockEmitNotificationSignal.mockClear();
   const db = getDb();
   db.run("DELETE FROM cron_runs");
@@ -117,48 +85,8 @@ function runsFor(jobId: string): Array<{ status: string }> {
     .all(jobId) as Array<{ status: string }>;
 }
 
-describe("scheduler stand-down for the schedule worker", () => {
-  test("flag on: leaves every due schedule unclaimed and reports none pending", async () => {
-    workerEnabled = true;
-    const { script } = await createDueScriptAndNotifyJobs();
-    const dueBefore = rawDb()
-      .query("SELECT id, next_run_at FROM cron_jobs")
-      .all() as Array<{ id: string; next_run_at: number }>;
-
-    const result = await runScheduleDueWorkOnce({
-      includeStillPending: true,
-    });
-
-    expect(result.claimed).toBe(0);
-    expect(result.stillPending).toBe(0);
-    expect(mockEmitNotificationSignal).not.toHaveBeenCalled();
-    expect(runsFor(script.id)).toHaveLength(0);
-    // Nothing advanced — every schedule stays due for the worker to claim.
-    const dueAfter = rawDb()
-      .query("SELECT id, next_run_at FROM cron_jobs")
-      .all() as Array<{ id: string; next_run_at: number }>;
-    expect(dueAfter).toEqual(dueBefore);
-  });
-
-  test("flag off: the in-process scheduler claims and runs due schedules itself", async () => {
-    workerEnabled = false;
-    const { script } = await createDueScriptAndNotifyJobs();
-
-    const result = await runScheduleDueWorkOnce();
-
-    expect(result.claimed).toBe(2);
-    const scriptRuns = runsFor(script.id);
-    expect(scriptRuns).toHaveLength(1);
-    expect(scriptRuns[0].status).toBe("ok");
-    expect(mockEmitNotificationSignal).toHaveBeenCalled();
-  });
-});
-
 describe("runDueSchedulesOnce (the schedule worker's tick)", () => {
   test("claims and executes due schedules across modes", async () => {
-    // The worker runs with the flag on; runDueSchedulesOnce itself does not
-    // consult the flag — its caller owns schedule execution.
-    workerEnabled = true;
     const { script } = await createDueScriptAndNotifyJobs();
 
     const result = await runDueSchedulesOnce();

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -10,24 +10,6 @@ import {
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-  }),
-}));
-
 // The inbound handler imports processMessage directly — stub it so it doesn't
 // attempt to spin up an LLM turn. The background dispatch is fire-and-forget;
 // tests only assert on the synchronous HTTP response.
@@ -61,6 +43,11 @@ import {
   resolveLocalTrustVerdict,
   seedContactChannel,
 } from "./helpers/channel-test-adapter.js";
+import { setConfig } from "./helpers/set-config.js";
+
+// Tests call addMessage without skipIndexing — keep memory indexing off so no
+// background memory work runs against the test DB.
+setConfig("memory", { enabled: false, v2: { enabled: false } });
 
 await initializeDb();
 

package/src/__tests__/runtime-events-sse-bilingual.test.ts

@@ -13,25 +13,7 @@
  * `?conversationKey=` happy/error path.
  */
 
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-  }),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { getOrCreateConversation } from "../persistence/conversation-key-store.js";
 import { getDb } from "../persistence/db-connection.js";

package/src/__tests__/runtime-events-sse-parity.test.ts

@@ -15,26 +15,7 @@
  *   - generation_handoff (terminal)
  *   - generation_cancelled (terminal)
  */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-  }),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { getOrCreateConversation } from "../persistence/conversation-key-store.js";

package/src/__tests__/runtime-events-sse-reconnect.test.ts

@@ -10,25 +10,7 @@
  *   - dedup against live events that race in mid-replay
  *   - malformed `lastSeenSeq` query param rejected with 400
  */
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-  }),
-}));
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { getOrCreateConversation } from "../persistence/conversation-key-store.js";
 import { getDb } from "../persistence/db-connection.js";

package/src/__tests__/runtime-events-sse.test.ts

@@ -7,26 +7,7 @@
  *   - Happy path: stream receives a published AssistantEvent
  *   - Unfiltered: streams events from multiple conversations
  */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-  }),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { getOrCreateConversation } from "../persistence/conversation-key-store.js";
 import { getDb } from "../persistence/db-connection.js";

package/src/__tests__/scaffold-managed-skill-tool.test.ts

@@ -13,17 +13,55 @@ import type { SkillSource } from "../config/skills.js";
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 const mockRefreshSkillCapabilityMemories = mock(() => {});
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
+const watchdogEvents: Array<{
+  checkName: string;
+  value?: number | null;
+  detail?: Record<string, unknown> | null;
+}> = [];
+mock.module("../telemetry/watchdog-events-store.js", () => ({
+  recordWatchdogEvent: (record: {
+    checkName: string;
+    value?: number | null;
+    detail?: Record<string, unknown> | null;
+  }) => {
+    watchdogEvents.push(record);
+  },
 }));
 
 mock.module("../daemon/skill-memory-refresh.js", () => ({
   refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
 }));
 
+// Skill-card enqueue recorder. Snapshot + override (rather than a full module
+// replacement) because other modules in this import graph (e.g. the managed
+// store's capability seeding) import sibling jobs-store exports that must
+// keep working.
+import * as realJobsStore from "../persistence/jobs-store.js";
+
+let skillCardJobUpserts: Array<{
+  payload: {
+    sourceConversationId: string;
+    runConversationId: string;
+  } & Record<string, unknown>;
+  runAfter: number | undefined;
+}> = [];
+let skillCardUpsertThrows = false;
+mock.module("../persistence/jobs-store.js", () => ({
+  ...realJobsStore,
+  upsertSkillCardInsertJob: (
+    payload: {
+      sourceConversationId: string;
+      runConversationId: string;
+    } & Record<string, unknown>,
+    runAfter?: number,
+  ) => {
+    if (skillCardUpsertThrows) {
+      throw new Error("jobs db unavailable");
+    }
+    skillCardJobUpserts.push({ payload, runAfter });
+  },
+}));
+
 /**
  * Build the injected catalog seam for the ownership-backstop tests. Seeds the
  * given non-managed (bundled / plugin / workspace) or managed entry so the
@@ -63,6 +101,9 @@ function installMetaFor(skillId: string) {
 beforeEach(() => {
   mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
   mockRefreshSkillCapabilityMemories.mockClear();
+  skillCardJobUpserts = [];
+  skillCardUpsertThrows = false;
+  watchdogEvents.length = 0;
 });
 
 afterEach(() => {
@@ -121,6 +162,16 @@ describe("scaffold_managed_skill tool", () => {
     expect(skill).toBeDefined();
     expect(skill!.name).toBe("Test Skill");
     expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+
+    // A genuine create emits the central authoring counter, attributed to
+    // the user for a non-retrospective origin.
+    expect(watchdogEvents).toEqual([
+      {
+        checkName: "skill_authored",
+        value: 1,
+        detail: { authored_by: "user" },
+      },
+    ]);
   });
 
   test("accepts legacy add_to_index input without returning index metadata", async () => {
@@ -177,6 +228,12 @@ describe("scaffold_managed_skill tool", () => {
       makeContext(),
     );
     expect(result3.isError).toBe(false);
+
+    // Only the original create counts — the overwrite refined an existing
+    // skill and must not emit a second authoring event.
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "skill_authored"),
+    ).toHaveLength(1);
   });
 
   test("rejects missing required fields", async () => {
@@ -666,6 +723,15 @@ describe("scaffold_managed_skill tool", () => {
 
     expect(result.isError).toBe(false);
     expect(installMetaFor("retro-skill")?.author).toBe("assistant");
+    // The central authoring counter attributes the create to the
+    // retrospective.
+    expect(watchdogEvents).toEqual([
+      {
+        checkName: "skill_authored",
+        value: 1,
+        detail: { authored_by: "retrospective" },
+      },
+    ]);
   });
 
   test('tags author "user" for a normal (non-retrospective) scaffold', async () => {
@@ -826,6 +892,12 @@ describe("scaffold_managed_skill tool", () => {
         ),
       ),
     ).toBe(true);
+
+    // Only the V1 create counts toward authoring — the V2 refinement of an
+    // existing skill emits no second event.
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "skill_authored"),
+    ).toHaveLength(1);
   });
 
   // ── Conversation lineage (retrospective-authored skills) ───────────────────
@@ -1100,4 +1172,233 @@ describe("scaffold_managed_skill tool", () => {
       true,
     );
   });
+
+  // ── Skill-card enqueue at the creation site ─────────────────────────────
+
+  /** Lineage seam resolving the fork parent of the retrospective run. */
+  function lineageSeam() {
+    return {
+      getConversation: (id: string) =>
+        id === "retro-run-conv"
+          ? { forkParentConversationId: "source-conv" }
+          : null,
+    };
+  }
+
+  test("retrospective CREATE enqueues one skill_card_insert job with the normalized payload and resolved source id", async () => {
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: " card-skill ",
+        name: "  Card\nSkill  ",
+        description: " Does\r\ncard things ",
+        body_markdown: "Do the procedure.",
+        emoji: " 🧭 ",
+      },
+      makeRetrospectiveContext({ conversationId: "retro-run-conv" }),
+      lineageSeam(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(skillCardJobUpserts).toHaveLength(1);
+    // The payload carries the executor's post-normalization values — the
+    // same trimmed/newline-collapsed strings persisted to the frontmatter —
+    // so the card links and labels the skill exactly as it exists on disk.
+    expect(skillCardJobUpserts[0]!.payload).toEqual({
+      sourceConversationId: "source-conv",
+      runConversationId: "retro-run-conv",
+      skills: [
+        {
+          skillId: "card-skill",
+          name: "Card Skill",
+          description: "Does card things",
+          emoji: "🧭",
+        },
+      ],
+    });
+  });
+
+  test("a whitespace-only emoji is omitted from the card payload", async () => {
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "no-emoji-card",
+        name: "No Emoji",
+        description: "Card without an emoji",
+        body_markdown: "Do the procedure.",
+        emoji: " \n ",
+      },
+      makeRetrospectiveContext({ conversationId: "retro-run-conv" }),
+      lineageSeam(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(skillCardJobUpserts).toHaveLength(1);
+    const skill = (
+      skillCardJobUpserts[0]!.payload.skills as Record<string, unknown>[]
+    )[0]!;
+    expect(skill.skillId).toBe("no-emoji-card");
+    expect("emoji" in skill).toBe(false);
+  });
+
+  test("retrospective CREATE with an unresolvable fork parent skips the enqueue but the scaffold still succeeds", async () => {
+    // Three unresolvable shapes: the run row is gone, the run is not a fork,
+    // and the lineage lookup throws.
+    const cases: Array<{
+      skillId: string;
+      lookup: () => { forkParentConversationId: string | null } | null;
+    }> = [
+      { skillId: "no-card-no-row", lookup: () => null },
+      {
+        skillId: "no-card-no-parent",
+        lookup: () => ({ forkParentConversationId: null }),
+      },
+      {
+        skillId: "no-card-throwing-lookup",
+        lookup: () => {
+          throw new Error("db unavailable");
+        },
+      },
+    ];
+
+    for (const { skillId, lookup } of cases) {
+      const result = await executeScaffoldManagedSkill(
+        {
+          skill_id: skillId,
+          name: "No Card",
+          description: "Fork parent not resolvable",
+          body_markdown: "Do the procedure.",
+        },
+        makeRetrospectiveContext({ conversationId: "retro-run-conv" }),
+        { getConversation: lookup },
+      );
+
+      expect(result.isError).toBe(false);
+      expect(existsSync(join(TEST_DIR, "skills", skillId, "SKILL.md"))).toBe(
+        true,
+      );
+    }
+    expect(skillCardJobUpserts).toHaveLength(0);
+  });
+
+  test("retrospective overwrite of an EXISTING skill (a refinement) does not enqueue a card", async () => {
+    // First pass: genuine create — enqueues.
+    await executeScaffoldManagedSkill(
+      {
+        skill_id: "refined-skill",
+        name: "Refined Skill",
+        description: "First pass",
+        body_markdown: "V1 procedure.",
+      },
+      makeRetrospectiveContext({ conversationId: "retro-run-conv" }),
+      lineageSeam(),
+    );
+    expect(skillCardJobUpserts).toHaveLength(1);
+    skillCardJobUpserts = [];
+
+    // Second pass: overwrite of the pre-existing skill — a refinement, no card.
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "refined-skill",
+        name: "Refined Skill",
+        description: "Refined",
+        body_markdown: "V2 procedure.",
+        overwrite: true,
+      },
+      makeRetrospectiveContext({ conversationId: "retro-run-conv" }),
+      lineageSeam(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(skillCardJobUpserts).toHaveLength(0);
+  });
+
+  test("retrospective overwrite:true on a skill that did NOT previously exist is still a create and enqueues", async () => {
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "overwrite-fresh",
+        name: "Overwrite Fresh",
+        description: "Overwrite flag on a fresh id",
+        body_markdown: "Do the procedure.",
+        overwrite: true,
+      },
+      makeRetrospectiveContext({ conversationId: "retro-run-conv" }),
+      lineageSeam(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(skillCardJobUpserts).toHaveLength(1);
+    expect(skillCardJobUpserts[0]!.payload.skills).toEqual([
+      {
+        skillId: "overwrite-fresh",
+        name: "Overwrite Fresh",
+        description: "Overwrite flag on a fresh id",
+      },
+    ]);
+  });
+
+  test("user-origin create never enqueues a card, even with resolvable lineage", async () => {
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "user-no-card",
+        name: "User No Card",
+        description: "Authored interactively",
+        body_markdown: "Do the thing.",
+      },
+      makeContext({ conversationId: "retro-run-conv" }),
+      lineageSeam(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(skillCardJobUpserts).toHaveLength(0);
+  });
+
+  test("a throwing enqueue never fails the scaffold — the skill is already created", async () => {
+    skillCardUpsertThrows = true;
+
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "enqueue-throws",
+        name: "Enqueue Throws",
+        description: "Jobs DB unavailable at enqueue time",
+        body_markdown: "Do the procedure.",
+      },
+      makeRetrospectiveContext({ conversationId: "retro-run-conv" }),
+      lineageSeam(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(
+      existsSync(join(TEST_DIR, "skills", "enqueue-throws", "SKILL.md")),
+    ).toBe(true);
+    expect(installMetaFor("enqueue-throws")?.author).toBe("assistant");
+  });
+
+  test("two creates in the same run enqueue one upsert per skill under the same run id (merge happens in the jobs store)", async () => {
+    for (const skillId of ["run-skill-a", "run-skill-b"]) {
+      const result = await executeScaffoldManagedSkill(
+        {
+          skill_id: skillId,
+          name: `Skill ${skillId}`,
+          description: `Does ${skillId}`,
+          body_markdown: "Do the procedure.",
+        },
+        makeRetrospectiveContext({ conversationId: "retro-run-conv" }),
+        lineageSeam(),
+      );
+      expect(result.isError).toBe(false);
+    }
+
+    // One upsert per created skill, all keyed to the same run + source — the
+    // jobs-store upsert coalesces them into a single pending payload (covered
+    // by jobs-store-skill-card-upsert.test.ts).
+    expect(skillCardJobUpserts).toHaveLength(2);
+    for (const upsert of skillCardJobUpserts) {
+      expect(upsert.payload.sourceConversationId).toBe("source-conv");
+      expect(upsert.payload.runConversationId).toBe("retro-run-conv");
+    }
+    expect(
+      skillCardJobUpserts.flatMap((u) =>
+        (u.payload.skills as Array<{ skillId: string }>).map((s) => s.skillId),
+      ),
+    ).toEqual(["run-skill-a", "run-skill-b"]);
+  });
 });