@vellumai/assistant 0.8.0 → 0.8.1

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

@@ -532,7 +532,7 @@ describe("GET /v1/suggestion", () => {
     );
   });
 
-  test("uses conversationStarters call site", async () => {
+  test("uses replySuggestion call site", async () => {
     const provider = makeMockProvider("Quick reply");
     mockGetConfiguredProvider.mockImplementation(async () => provider);
     mockGetConversationByKey.mockImplementation(() => ({
@@ -558,7 +558,7 @@ describe("GET /v1/suggestion", () => {
     const options = callArgs[3] as
       | { config?: { callSite?: string } }
       | undefined;
-    expect(options?.config?.callSite).toBe("conversationStarters");
+    expect(options?.config?.callSite).toBe("replySuggestion");
   });
 
   test("disables thinking and zeros effort to avoid Anthropic temp/thinking 400", async () => {
@@ -612,7 +612,7 @@ describe("GET /v1/suggestion", () => {
     // whenever the request triggers extended thinking (e.g. Opus 4.x at
     // `effort: "xhigh"`). The suggestion generator must only send a
     // single user-role message so it stays compatible with every
-    // possible `conversationStarters` call-site config.
+    // possible `replySuggestion` call-site config.
     const provider = makeMockProvider("<reply>Sure, works for me</reply>");
     mockGetConfiguredProvider.mockImplementation(async () => provider);
     mockGetConversationByKey.mockImplementation(() => ({

package/src/__tests__/sync-message-contract.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  buildSyncChangedMessage,
+  conversationMessagesSyncTag,
+  type ServerMessage,
+  SYNC_TAGS,
+  SyncChangedMessageSchema,
+} from "../daemon/message-protocol.js";
+
+describe("sync message contract", () => {
+  test("sync_changed is assignable to ServerMessage", () => {
+    const message: ServerMessage = {
+      type: "sync_changed",
+      tags: [SYNC_TAGS.assistantAvatar],
+    };
+
+    expect(message).toEqual({
+      type: "sync_changed",
+      tags: [SYNC_TAGS.assistantAvatar],
+    });
+  });
+
+  test("buildSyncChangedMessage dedupes tags", () => {
+    const message = buildSyncChangedMessage([
+      SYNC_TAGS.assistantAvatar,
+      SYNC_TAGS.assistantAvatar,
+      conversationMessagesSyncTag("conversation-123"),
+    ]);
+
+    expect(message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.assistantAvatar,
+        "conversation:conversation-123:messages",
+      ],
+    });
+  });
+
+  test("schema rejects malformed sync_changed payloads", () => {
+    expect(() =>
+      SyncChangedMessageSchema.parse({
+        type: "sync_changed",
+        tags: [],
+      }),
+    ).toThrow();
+
+    expect(() =>
+      SyncChangedMessageSchema.parse({
+        type: "sync_changed",
+        tags: [""],
+      }),
+    ).toThrow();
+
+    expect(() =>
+      SyncChangedMessageSchema.parse({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantAvatar],
+        cursor: 1,
+      }),
+    ).toThrow();
+  });
+});

package/src/__tests__/task-scheduler.test.ts

@@ -7,6 +7,57 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+// Mock the shared `runBackgroundJob` runner so the scheduler's fresh-bootstrap
+// talk-mode path stays observable. Each invocation creates a new conversation
+// row and pushes the prompt onto the per-test handler set via
+// `onRunBackgroundJobCall`. `run_task:` schedules use a different code path
+// and do not invoke this runner.
+let onRunBackgroundJobCall:
+  | ((info: {
+      conversationId: string;
+      prompt: string;
+      trustContext: { sourceChannel: string; trustClass: string };
+    }) => void)
+  | null = null;
+mock.module("../runtime/background-job-runner.js", () => ({
+  runBackgroundJob: async (opts: {
+    prompt: string;
+    groupId?: string;
+    trustContext: { sourceChannel: string; trustClass: string };
+  }) => {
+    const { createConversation } =
+      await import("../memory/conversation-crud.js");
+    const conv = createConversation({
+      title: "(test stub)",
+      conversationType: "background",
+      source: "schedule",
+      ...(opts.groupId ? { groupId: opts.groupId } : {}),
+    });
+    onRunBackgroundJobCall?.({
+      conversationId: conv.id,
+      prompt: opts.prompt,
+      trustContext: opts.trustContext,
+    });
+    return { conversationId: conv.id, ok: true };
+  },
+}));
+
+// Capture `emitNotificationSignal` calls so tests can assert that scheduled
+// task failures surface via the notification pipeline (home feed + native).
+const emitNotificationCalls: Array<Record<string, unknown>> = [];
+mock.module("../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async (params: Record<string, unknown>) => {
+    emitNotificationCalls.push(params);
+    return {
+      signalId: "stub-signal",
+      deduplicated: false,
+      dispatched: true,
+      reason: "ok",
+      deliveryResults: [],
+    };
+  },
+}));
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
@@ -111,6 +162,8 @@ describe("scheduler run_task detection", () => {
     db.run("DELETE FROM tasks");
     db.run("DELETE FROM messages");
     db.run("DELETE FROM conversations");
+    onRunBackgroundJobCall = null;
+    emitNotificationCalls.length = 0;
   });
 
   test("run_task:<id> messages trigger runTask instead of processMessage", async () => {
@@ -163,7 +216,7 @@ describe("scheduler run_task detection", () => {
     expect(typeof runTaskCalls[0].options?.taskRunId).toBe("string");
   });
 
-  test("regular messages still go through processMessage normally", async () => {
+  test("regular messages route through the runBackgroundJob runner", async () => {
     // Create a regular schedule (no run_task: prefix)
     const schedule = createSchedule({
       name: "Regular Schedule",
@@ -174,36 +227,32 @@ describe("scheduler run_task detection", () => {
 
     forceScheduleDue(schedule.id);
 
-    const processedMessages: Array<{
+    const runnerCalls: Array<{
       conversationId: string;
-      message: string;
-      options?: { trustClass?: string; taskRunId?: string };
+      prompt: string;
+      trustContext: { sourceChannel: string; trustClass: string };
     }> = [];
-    const processMessage = async (
-      conversationId: string,
-      message: string,
-      options?: { trustClass?: string; taskRunId?: string },
-    ) => {
-      processedMessages.push({ conversationId, message, options });
+    onRunBackgroundJobCall = (info) => {
+      runnerCalls.push(info);
     };
 
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler(
+      async () => {},
+      () => {},
+    );
 
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
-    // processMessage should have been called with the regular message
-    expect(
-      processedMessages.some((m) => m.message === "Do something normal"),
-    ).toBe(true);
-    expect(
-      processedMessages.some(
-        (m) =>
-          m.message === "Do something normal" &&
-          m.options?.trustClass === "guardian" &&
-          m.options?.taskRunId === undefined,
-      ),
-    ).toBe(true);
+    // The runner should have been invoked with the schedule message and a
+    // guardian trust context, mirroring the historical inline `processMessage`
+    // call that the migration replaced.
+    expect(runnerCalls.length).toBe(1);
+    expect(runnerCalls[0].prompt).toBe("Do something normal");
+    expect(runnerCalls[0].trustContext).toEqual({
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    });
   });
 
   test("handles task not found gracefully", async () => {
@@ -232,5 +281,21 @@ describe("scheduler run_task detection", () => {
     expect(runs.length).toBeGreaterThanOrEqual(1);
     expect(runs[0].status).toBe("error");
     expect(runs[0].error).toContain("Task not found");
+
+    // Failed scheduled tasks must surface via the notification pipeline so
+    // they reach the home feed and native macOS notifications. The shape
+    // mirrors what `runBackgroundJob` emits for its own failures.
+    const failureSignal = emitNotificationCalls.find(
+      (p) => p.sourceEventName === "activity.failed",
+    );
+    expect(failureSignal).toBeDefined();
+    expect(failureSignal?.sourceChannel).toBe("scheduler");
+    const payload = failureSignal?.contextPayload as Record<string, unknown>;
+    expect(payload.jobName).toBe("task:nonexistent-task-id");
+    expect(payload.errorKind).toBe("exception");
+    expect(typeof payload.errorMessage).toBe("string");
+    expect(failureSignal?.dedupeKey).toMatch(
+      /^activity-failed:task:nonexistent-task-id:\d{4}-\d{2}-\d{2}$/,
+    );
   });
 });

package/src/__tests__/update-bulletin-job.test.ts

@@ -1,17 +1,10 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { getWorkspacePromptPath } from "../util/platform.js";
 
-// ── fs.readFileSync override (for gap 3 test) ────────────────────────
+// ── fs.readFileSync override (for read-failure test) ─────────────────
 // We mock node:fs so we can inject a readFileSync that throws for the
 // workspace path. All other call sites fall through to the real fs.
 const realReadFileSync = readFileSync;
@@ -54,62 +47,58 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => ({ updates: updatesConfig }),
 }));
 
-// ── bootstrapConversation + wakeAgentForOpportunity mocks ────────────
-let bootstrapCalls = 0;
-let bootstrapLastArgs: Record<string, unknown> | null = null;
-let wakeCalls = 0;
-let wakeLastArgs: Record<string, unknown> | null = null;
-let wakeShouldThrow = false;
-let wakeInvoked = true;
-let wakeProducedToolCalls = false;
-// A side-effect function invoked during wake. Lets tests simulate the
-// agent deleting UPDATES.md while the wake is in flight.
-let wakeSideEffect: (() => void) | null = null;
-
-mock.module("../memory/conversation-bootstrap.js", () => ({
-  bootstrapConversation: (opts: Record<string, unknown>) => {
-    bootstrapCalls += 1;
-    bootstrapLastArgs = opts;
-    return { id: `conv-${bootstrapCalls}` };
-  },
-}));
+// ── pre-first-message gate stub ──────────────────────────────────────
+// Default: gate open (user has interacted) so the existing happy/sad
+// paths exercise the bulletin logic. A dedicated test below flips this
+// to false to assert the gate trips.
+let preFirstMessageGateOpen = true;
 
-// ── deleteConversation mock (orphan cleanup path) ────────────────────
-let deleteCalls = 0;
-const deletedIds: string[] = [];
-let deleteShouldThrow = false;
-
-mock.module("../memory/conversation-crud.js", () => ({
-  deleteConversation: (id: string) => {
-    deleteCalls += 1;
-    deletedIds.push(id);
-    if (deleteShouldThrow) {
-      throw new Error("simulated delete failure");
-    }
-    return { segmentIds: [], deletedSummaryIds: [] };
-  },
+mock.module("../runtime/pre-first-message-gate.js", () => ({
+  hasReceivedUserMessage: () => preFirstMessageGateOpen,
 }));
 
-mock.module("../runtime/agent-wake.js", () => ({
-  wakeAgentForOpportunity: async (opts: Record<string, unknown>) => {
-    wakeCalls += 1;
-    wakeLastArgs = opts;
-    if (wakeSideEffect) {
-      wakeSideEffect();
+// ── runBackgroundJob mock ────────────────────────────────────────────
+let runBackgroundJobCalls = 0;
+let runBackgroundJobLastArgs: Record<string, unknown> | null = null;
+let runBackgroundJobShouldThrow = false;
+let runBackgroundJobOk = true;
+let runBackgroundJobErrorKind:
+  | "timeout"
+  | "model_provider"
+  | "exception"
+  | undefined = undefined;
+let runBackgroundJobErrorMessage: string | undefined = undefined;
+// A side-effect function invoked during the job. Lets tests simulate the
+// agent deleting UPDATES.md while the job is running.
+let runBackgroundJobSideEffect: (() => void) | null = null;
+
+mock.module("../runtime/background-job-runner.js", () => ({
+  runBackgroundJob: async (opts: Record<string, unknown>) => {
+    runBackgroundJobCalls += 1;
+    runBackgroundJobLastArgs = opts;
+    if (runBackgroundJobSideEffect) {
+      runBackgroundJobSideEffect();
     }
-    if (wakeShouldThrow) {
-      throw new Error("simulated wake failure");
+    if (runBackgroundJobShouldThrow) {
+      throw new Error("simulated runner failure");
+    }
+    if (runBackgroundJobOk) {
+      return {
+        conversationId: `conv-${runBackgroundJobCalls}`,
+        ok: true,
+      };
     }
     return {
-      invoked: wakeInvoked,
-      producedToolCalls: wakeProducedToolCalls,
+      conversationId: `conv-${runBackgroundJobCalls}`,
+      ok: false,
+      error: new Error(runBackgroundJobErrorMessage ?? "simulated failure"),
+      errorKind: runBackgroundJobErrorKind ?? "exception",
     };
   },
 }));
 
-const { runUpdateBulletinJobIfNeeded } = await import(
-  "../prompts/update-bulletin-job.js"
-);
+const { runUpdateBulletinJobIfNeeded } =
+  await import("../prompts/update-bulletin-job.js");
 
 const HASH_CHECKPOINT_KEY = "updates:last_processed_hash";
 const EMPTY_HASH = "empty";
@@ -124,19 +113,16 @@ describe("runUpdateBulletinJobIfNeeded", () => {
   beforeEach(() => {
     store.clear();
     setCheckpointCallCount = 0;
-    bootstrapCalls = 0;
-    bootstrapLastArgs = null;
-    wakeCalls = 0;
-    wakeLastArgs = null;
-    wakeShouldThrow = false;
-    wakeInvoked = true;
-    wakeProducedToolCalls = false;
-    wakeSideEffect = null;
+    runBackgroundJobCalls = 0;
+    runBackgroundJobLastArgs = null;
+    runBackgroundJobShouldThrow = false;
+    runBackgroundJobOk = true;
+    runBackgroundJobErrorKind = undefined;
+    runBackgroundJobErrorMessage = undefined;
+    runBackgroundJobSideEffect = null;
     readFileSyncOverride = null;
     updatesConfig.enabled = true;
-    deleteCalls = 0;
-    deletedIds.length = 0;
-    deleteShouldThrow = false;
+    preFirstMessageGateOpen = true;
     if (existsSync(workspacePath)) {
       rmSync(workspacePath);
     }
@@ -148,38 +134,45 @@ describe("runUpdateBulletinJobIfNeeded", () => {
     }
   });
 
-  test("config disabled — no bootstrap, no wake, no checkpoint change", async () => {
+  test("config disabled — no job, no checkpoint change", async () => {
     updatesConfig.enabled = false;
     writeFileSync(workspacePath, "## Real content", "utf-8");
 
     await runUpdateBulletinJobIfNeeded();
 
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
+    expect(runBackgroundJobCalls).toBe(0);
+    expect(setCheckpointCallCount).toBe(0);
+    expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
+  });
+
+  test("pre-first-message gate closed — no job, checkpoint left UNCHANGED so the job retries after the user interacts", async () => {
+    preFirstMessageGateOpen = false;
+    writeFileSync(workspacePath, "## Real content", "utf-8");
+
+    await runUpdateBulletinJobIfNeeded();
+
+    expect(runBackgroundJobCalls).toBe(0);
     expect(setCheckpointCallCount).toBe(0);
     expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
   });
 
-  test("file missing, stored hash absent — no wake; stored becomes 'empty'", async () => {
+  test("file missing, stored hash absent — no job; stored becomes 'empty'", async () => {
     expect(existsSync(workspacePath)).toBe(false);
     expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
 
     await runUpdateBulletinJobIfNeeded();
 
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
+    expect(runBackgroundJobCalls).toBe(0);
     expect(store.get(HASH_CHECKPOINT_KEY)).toBe(EMPTY_HASH);
   });
 
-  test("file missing, stored hash already 'empty' — no wake; no checkpoint write", async () => {
+  test("file missing, stored hash already 'empty' — no job; no checkpoint write", async () => {
     store.set(HASH_CHECKPOINT_KEY, EMPTY_HASH);
-    // Reset the counter to ignore the priming write above.
     setCheckpointCallCount = 0;
 
     await runUpdateBulletinJobIfNeeded();
 
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
+    expect(runBackgroundJobCalls).toBe(0);
     expect(setCheckpointCallCount).toBe(0);
     expect(store.get(HASH_CHECKPOINT_KEY)).toBe(EMPTY_HASH);
   });
@@ -189,28 +182,25 @@ describe("runUpdateBulletinJobIfNeeded", () => {
 
     await runUpdateBulletinJobIfNeeded();
 
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
+    expect(runBackgroundJobCalls).toBe(0);
     expect(store.get(HASH_CHECKPOINT_KEY)).toBe(EMPTY_HASH);
   });
 
-  test("file present with content, wake produced tool calls — bootstrap + wake; stored hash is sha256(trimmed); source/origin are snake_case", async () => {
+  test("file present, job ok=true, file unchanged — stored hash is sha256(trimmed); jobName/source are kebab-case", async () => {
     const content = "## Release 1.2.3\n\nNew thing.\n";
     writeFileSync(workspacePath, content, "utf-8");
-    wakeProducedToolCalls = true;
 
     await runUpdateBulletinJobIfNeeded();
 
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
+    expect(runBackgroundJobCalls).toBe(1);
     expect(store.get(HASH_CHECKPOINT_KEY)).toBe(sha256(content.trim()));
-    // Gap 4: confirm snake_case reached the downstream mocks.
-    expect(bootstrapLastArgs?.source).toBe("updates_bulletin");
-    expect(bootstrapLastArgs?.origin).toBe("updates_bulletin");
-    expect(wakeLastArgs?.source).toBe("updates_bulletin");
+    expect(runBackgroundJobLastArgs?.jobName).toBe("update-bulletin");
+    expect(runBackgroundJobLastArgs?.source).toBe("update-bulletin");
+    expect(runBackgroundJobLastArgs?.origin).toBe("updates_bulletin");
+    expect(runBackgroundJobLastArgs?.callSite).toBe("mainAgent");
   });
 
-  test("file present, stored hash matches current — no wake", async () => {
+  test("file present, stored hash matches current — no job", async () => {
     const content = "## Release 1.2.3\n\nSame content.\n";
     writeFileSync(workspacePath, content, "utf-8");
     store.set(HASH_CHECKPOINT_KEY, sha256(content.trim()));
@@ -218,138 +208,53 @@ describe("runUpdateBulletinJobIfNeeded", () => {
 
     await runUpdateBulletinJobIfNeeded();
 
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
-    expect(setCheckpointCallCount).toBe(0);
-  });
-
-  test("wake returns invoked:false — checkpoint UNCHANGED + orphan conversation is cleaned up", async () => {
-    const content = "## Release Q\n\nResolver-missing scenario.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-    wakeInvoked = false;
-    wakeProducedToolCalls = false;
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
-    // Critical: do NOT poison the checkpoint (round-1 behavior preserved).
-    expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
-    expect(setCheckpointCallCount).toBe(0);
-    // Belt-and-suspenders: the orphan background conversation bootstrapped
-    // before the wake must be deleted so we don't leak DB rows on every
-    // silent no-op.
-    expect(deleteCalls).toBe(1);
-    expect(deletedIds).toEqual(["conv-1"]);
-  });
-
-  test("wake returns invoked:false AND deleteConversation throws — function still returns (cleanup error is swallowed)", async () => {
-    const content = "## Release Q2\n\nDelete-throws scenario.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-    wakeInvoked = false;
-    wakeProducedToolCalls = false;
-    deleteShouldThrow = true;
-
-    await expect(runUpdateBulletinJobIfNeeded()).resolves.toBeUndefined();
-
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
-    expect(deleteCalls).toBe(1);
-    // Checkpoint still untouched.
-    expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
+    expect(runBackgroundJobCalls).toBe(0);
     expect(setCheckpointCallCount).toBe(0);
   });
 
-  test("wake invoked normally — deleteConversation is NOT called (happy path)", async () => {
-    const content = "## Release Q3\n\nNormal happy-path scenario.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-    wakeInvoked = true;
-    wakeProducedToolCalls = true;
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
-    expect(deleteCalls).toBe(0);
-    expect(deletedIds).toEqual([]);
-  });
-
-  test("wake invoked but no tool calls AND file unchanged — checkpoint UNCHANGED (retry next startup)", async () => {
-    const content = "## Release R\n\nSilent no-op scenario.\n";
+  test("runBackgroundJob returns ok=false — checkpoint UNCHANGED so next startup retries", async () => {
+    const content = "## Release Q\n\nFailure scenario.\n";
     writeFileSync(workspacePath, content, "utf-8");
-    wakeInvoked = true;
-    wakeProducedToolCalls = false;
+    runBackgroundJobOk = false;
+    runBackgroundJobErrorKind = "exception";
+    runBackgroundJobErrorMessage = "boom";
 
     await runUpdateBulletinJobIfNeeded();
 
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
+    expect(runBackgroundJobCalls).toBe(1);
+    // Critical: do NOT poison the checkpoint when the job fails.
     expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
     expect(setCheckpointCallCount).toBe(0);
   });
 
-  test("wake invoked, no tool calls, but file deleted mid-wake — checkpoint becomes 'empty'", async () => {
-    const content = "## Release S\n\nAgent deleted file.\n";
+  test("runBackgroundJob ok=true + agent deletes file mid-run — stored hash becomes 'empty'", async () => {
+    const content = "## Release X\n\nStuff to process.\n";
     writeFileSync(workspacePath, content, "utf-8");
-    wakeInvoked = true;
-    wakeProducedToolCalls = false;
-    wakeSideEffect = () => {
+    runBackgroundJobSideEffect = () => {
       rmSync(workspacePath);
     };
 
     await runUpdateBulletinJobIfNeeded();
 
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
+    expect(runBackgroundJobCalls).toBe(1);
     expect(existsSync(workspacePath)).toBe(false);
     expect(store.get(HASH_CHECKPOINT_KEY)).toBe(EMPTY_HASH);
   });
 
-  test("wake invoked + produced tool calls + file unchanged — checkpoint = hash of content (agent decided this is the right state)", async () => {
-    const content = "## Release T\n\nAgent processed, chose to leave file.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-    wakeInvoked = true;
-    wakeProducedToolCalls = true;
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
-    expect(store.get(HASH_CHECKPOINT_KEY)).toBe(sha256(content.trim()));
-  });
-
-  test("file present, stored hash differs — wake invoked; stored hash updates", async () => {
+  test("file present, stored hash differs — job invoked; stored hash updates", async () => {
     const oldContent = "## Old";
     const newContent = "## New content v2";
     writeFileSync(workspacePath, newContent, "utf-8");
     store.set(HASH_CHECKPOINT_KEY, sha256(oldContent));
-    wakeProducedToolCalls = true;
 
     await runUpdateBulletinJobIfNeeded();
 
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
+    expect(runBackgroundJobCalls).toBe(1);
     expect(store.get(HASH_CHECKPOINT_KEY)).toBe(sha256(newContent.trim()));
     expect(store.get(HASH_CHECKPOINT_KEY)).not.toBe(sha256(oldContent));
   });
 
-  test("agent deletes file mid-wake (producedToolCalls=true) — stored hash becomes 'empty'", async () => {
-    const content = "## Release X\n\nStuff to process.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-    wakeProducedToolCalls = true;
-    wakeSideEffect = () => {
-      rmSync(workspacePath);
-    };
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
-    expect(existsSync(workspacePath)).toBe(false);
-    expect(store.get(HASH_CHECKPOINT_KEY)).toBe(EMPTY_HASH);
-  });
-
-  test("file present but readFileSync throws — checkpoint UNCHANGED; warn logged (gap 3)", async () => {
+  test("file present but readFileSync throws — checkpoint UNCHANGED; warn logged", async () => {
     const content = "## Release U\n\nSimulated read failure.\n";
     writeFileSync(workspacePath, content, "utf-8");
 
@@ -366,22 +271,20 @@ describe("runUpdateBulletinJobIfNeeded", () => {
       readFileSyncOverride = null;
     }
 
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
+    expect(runBackgroundJobCalls).toBe(0);
     expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
     expect(setCheckpointCallCount).toBe(0);
   });
 
-  test("wake throws — function does not reject; warning logged", async () => {
+  test("runBackgroundJob throws — function does not reject; warning logged", async () => {
     const content = "## Release Z";
     writeFileSync(workspacePath, content, "utf-8");
-    wakeShouldThrow = true;
+    runBackgroundJobShouldThrow = true;
 
     // Must not throw.
     await expect(runUpdateBulletinJobIfNeeded()).resolves.toBeUndefined();
 
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
+    expect(runBackgroundJobCalls).toBe(1);
     // Hash was never updated because the try/catch returned before the
     // self-healing step.
     expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);