@vellumai/assistant 0.8.0 → 0.8.1

package/src/plugins/user-loader.ts

@@ -1,28 +1,39 @@
 /**
- * User plugin loader — discovers plugins under `<workspaceDir>/plugins/*` and
- * invokes each plugin's registration side effect via a dynamic import.
+ * User plugin loader — discovers plugins under `<workspaceDir>/plugins/*` via
+ * one of two paths, gated by the contents of each candidate directory.
  *
- * A user plugin is a directory under `getWorkspaceDir()/plugins/` that contains a
- * `register.ts` (or `register.js` after compilation). The file is expected to
- * call {@link registerPlugin} at import time so the plugin ends up in the
- * registry before {@link bootstrapPlugins} runs during daemon startup.
+ * **External plugin framework path** (`package.json` present **and** no
+ * `register.{ts,js}`): the harness delegates to {@link loadExternalPlugin},
+ * which builds a `Plugin` from the directory's interface dirs (`hooks/`,
+ * `tools/`) and registers it directly. This path is opt-in by the plugin
+ * author and currently experimental — see
+ * `assistant/src/plugins/external-plugin-loader.ts` for the full
+ * convention.
+ *
+ * **Legacy path** (`register.{ts,js}` present): the file is dynamic-imported
+ * and expected to call {@link registerPlugin} at import time as a side
+ * effect, populating the registry before {@link bootstrapPlugins} runs.
+ *
+ * The legacy path takes precedence when a directory contains both
+ * `package.json` and `register.{ts,js}` — a migration-friendly default
+ * that keeps existing plugins (including the in-repo `examples/plugins/echo`
+ * reference) working unchanged while we iterate the external-plugin
+ * convention. A directory matching neither path is skipped silently.
  *
  * The loader deliberately:
  *
  * - Uses `getWorkspaceDir()` so each instance loads its own plugin set
  *   when `VELLUM_WORKSPACE_DIR` is set.
- * - Prefers `register.js` over `register.ts` when both exist (compiled plugins
- *   always win; this matches how `bun`/Node consumers resolve modules at
- *   runtime in the compiled binary).
- * - Treats any error from the dynamic import as a per-plugin isolation
- *   boundary: the offending directory is logged with `"Failed to load user
- *   plugin <dir>: <err>"` and the loader moves on to the next candidate.
- *   One bad user plugin must not crash the daemon.
- * - Bounds each dynamic import with a timeout
- *   ({@link USER_PLUGIN_IMPORT_TIMEOUT_MS}) so a plugin whose top-level
- *   `await` hangs or whose module evaluation never resolves cannot stall
- *   daemon startup. Timed-out plugins are logged and skipped just like
- *   thrown-error plugins.
+ * - Prefers `.js` over `.ts` per surface file (compiled-binary semantics).
+ *   The external loader applies the same rule per surface file; the
+ *   legacy path picks between `register.js` and `register.ts`.
+ * - Treats any error from a plugin load as a per-plugin isolation
+ *   boundary. {@link loadExternalPlugin} owns its own try/catch/timeout;
+ *   the legacy path is wrapped here. One bad user plugin must not crash
+ *   the daemon.
+ * - Bounds each plugin load with {@link USER_PLUGIN_IMPORT_TIMEOUT_MS}
+ *   so a plugin whose top-level `await` hangs or whose module evaluation
+ *   never resolves cannot stall daemon startup.
  *
  * Call order relative to the rest of the plugin system:
  *
@@ -39,6 +50,7 @@ import { pathToFileURL } from "node:url";
 
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
+import { loadExternalPlugin } from "./external-plugin-loader.js";
 import { closeRegistration } from "./registry.js";
 
 const log = getLogger("user-plugin-loader");
@@ -55,9 +67,10 @@ const log = getLogger("user-plugin-loader");
 const USER_PLUGIN_IMPORT_TIMEOUT_MS = 10_000;
 
 /**
- * Scan `getWorkspaceDir()/plugins/` for subdirectories containing a
- * `register.{ts,js}` file, and dynamic-import each one so the module's
- * side-effecting {@link registerPlugin} calls populate the registry.
+ * Scan `getWorkspaceDir()/plugins/` for subdirectories, then dispatch each
+ * one to the external loader (if `package.json` is present and there is no
+ * `register.{ts,js}`) or the legacy side-effect importer (if
+ * `register.{ts,js}` is present).
  *
  * Invariants:
  *
@@ -68,24 +81,24 @@ const USER_PLUGIN_IMPORT_TIMEOUT_MS = 10_000;
  * - Does not return plugin instances. The registry is the single source of
  *   truth for who got registered, and the caller inspects it directly.
  *
- * Must be called after first-party plugin side-effect imports have run and
- * before {@link bootstrapPlugins} — see the module docstring for the ordering
- * contract.
+ * Caller responsibilities:
+ *
+ * - Must be invoked exactly once during daemon startup, before
+ *   `bootstrapPlugins()` walks the registry.
+ * - Holds no locks during the import — bun's dynamic `import()` resolution
+ *   is concurrency-safe.
  */
 export async function loadUserPlugins(
   options: { importTimeoutMs?: number } = {},
 ): Promise<void> {
-  const importTimeoutMs =
-    options.importTimeoutMs ?? USER_PLUGIN_IMPORT_TIMEOUT_MS;
+  const importTimeoutMs = options.importTimeoutMs ?? USER_PLUGIN_IMPORT_TIMEOUT_MS;
+
   const pluginsDir = join(getWorkspaceDir(), "plugins");
+
   if (!existsSync(pluginsDir)) {
-    log.debug(
-      { pluginsDir },
-      "loadUserPlugins: no plugins directory — skipping",
-    );
-    // Close the registration window even on the fast path so a late arrival
-    // from an unrelated source (e.g. a mis-ordered static import) still can't
-    // slip in after bootstrap walks the registry.
+    // The clean-install case. Closing the registration window keeps the
+    // post-loader invariant uniform: `bootstrapPlugins()` may rely on the
+    // registry being final by the time `loadUserPlugins()` resolves.
     closeRegistration();
     return;
   }
@@ -118,10 +131,12 @@ export async function loadUserPlugins(
     }
     if (!stats.isDirectory()) continue;
 
-    // Prefer the compiled `register.js` over the TypeScript source. In the
-    // bun-compiled daemon binary only the compiled file can be imported;
-    // in development both may exist, in which case resolving the compiled
-    // artifact matches how the runtime would behave in production.
+    // Path selection: the legacy side-effect path takes precedence when
+    // both a `register.{ts,js}` and a `package.json` are present.
+    // Migration-friendly: any plugin in the wild today that happens to
+    // ship a `package.json` keeps loading via its existing register entry.
+    // The external-plugin path only fires when the directory is
+    // unambiguously the new convention.
     const jsPath = join(pluginDir, "register.js");
     const tsPath = join(pluginDir, "register.ts");
     let registerPath: string | undefined;
@@ -130,16 +145,24 @@ export async function loadUserPlugins(
     } else if (existsSync(tsPath)) {
       registerPath = tsPath;
     }
-    if (!registerPath) {
+
+    if (registerPath === undefined) {
+      // External plugin framework path. `loadExternalPlugin` owns its own
+      // try/catch + timeout, so a `continue` is the entire branch here.
+      if (existsSync(join(pluginDir, "package.json"))) {
+        await loadExternalPlugin(pluginDir, { importTimeoutMs });
+        continue;
+      }
       log.debug(
         { pluginDir },
-        "loadUserPlugins: no register.{ts,js} — skipping",
+        "loadUserPlugins: no register.{ts,js} or package.json — skipping",
       );
       continue;
     }
 
-    // `import()` with a `file://` URL works identically under Node and bun
-    // and sidesteps platform-specific absolute-path quirks on Windows.
+    // Legacy side-effect import path. `import()` with a `file://` URL
+    // works identically under Node and bun and sidesteps platform-specific
+    // absolute-path quirks on Windows.
     const moduleUrl = pathToFileURL(registerPath).href;
     let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
     try {

package/src/proactive-artifact/job.test.ts

@@ -51,9 +51,15 @@ mock.module("../providers/provider-send-message.js", () => ({
 
 // rawAll mock
 let rawAllRows: Array<{ role: string; content: string }> = [];
+let rawAllLastSql = "";
+let rawAllLastArgs: unknown[] = [];
 
 mock.module("../memory/raw-query.js", () => ({
-  rawAll: () => rawAllRows,
+  rawAll: (sql: string, ...args: unknown[]) => {
+    rawAllLastSql = sql;
+    rawAllLastArgs = args;
+    return rawAllRows;
+  },
   rawRun: () => 0,
 }));
 
@@ -279,6 +285,8 @@ function resetState() {
   copyResponse = "";
   providerSendCalls = [];
   rawAllRows = [];
+  rawAllLastSql = "";
+  rawAllLastArgs = [];
   bootstrapCalls = [];
   processMessageCalls = [];
   processMessageShouldThrow = false;
@@ -645,7 +653,7 @@ describe("runProactiveArtifactJob", () => {
   });
 
   describe("Transcript collection", () => {
-    test("dual-condition transcript query uses userMessageCutoff and assistantMessageId", async () => {
+    test("transcript query is scoped to the triggering conversation", async () => {
       rawAllRows = defaultTranscript;
       decisionResponse = decisionNo;
 
@@ -656,8 +664,8 @@ describe("runProactiveArtifactJob", () => {
         broadcastMessage: mockBroadcast,
       });
 
-      // The rawAll mock captures all calls; verify the decision was called
-      // (proving transcript was collected and passed to decision)
+      expect(rawAllLastSql).toContain("AND m.conversation_id = ?");
+      expect(rawAllLastArgs).toEqual(["conv-1", 5000, "asst-msg-99"]);
       expect(
         providerSendCalls.some(
           (c) => c.callSite === "proactiveArtifactDecision",

package/src/proactive-artifact/job.ts

@@ -57,12 +57,16 @@ export async function runProactiveArtifactJob(params: {
   let buildSucceeded = false;
   try {
     // ── Collect transcript (bounded) ────────────────────────────────
+    // The trigger window is workspace-wide, but raw transcript context sent to
+    // the LLM must stay scoped to the conversation that fired the job.
     const rows = rawAll<{ role: string; content: string }>(
       `SELECT m.role, m.content FROM messages m
        JOIN conversations c ON m.conversation_id = c.id
        WHERE c.conversation_type = 'standard'
+         AND m.conversation_id = ?
          AND (m.created_at <= ? OR m.id = ?)
        ORDER BY m.created_at ASC`,
+      params.conversationId,
       params.userMessageCutoff,
       params.assistantMessageId ?? "",
     );

package/src/proactive-artifact/trigger-state.test.ts

@@ -123,6 +123,15 @@ describe("trigger-state", () => {
       expect(getUserMessageCountUpTo(350)).toBe(3);
     });
 
+    test("counts user messages across standard conversations", () => {
+      seedUserMessage(100);
+      seedUserMessage(200);
+      seedUserMessage(300);
+      seedUserMessage(400);
+
+      expect(getUserMessageCountUpTo(400)).toBe(4);
+    });
+
     test("caps at 11 due to LIMIT", () => {
       for (let i = 1; i <= 15; i++) {
         seedUserMessage(i * 100);

package/src/proactive-artifact/trigger-state.ts

@@ -16,6 +16,10 @@ function guardPath(): string {
 
 /**
  * Count user messages in standard conversations with created_at <= beforeOrAt.
+ * This is intentionally cross-conversation: a user who starts a new thread
+ * early should still enter the proactive artifact trigger window. The job
+ * separately scopes raw transcript context to the triggering conversation.
+ *
  * LIMIT caps scan cost since we only care about thresholds up to TRIGGER_MAX.
  */
 export function getUserMessageCountUpTo(beforeOrAt: number): number {

package/src/prompts/__tests__/system-prompt.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tests for the Background Conversation gating in buildSystemPrompt.
+ *
+ * The Background Conversation guidance is gated on
+ * `options.isBackgroundConversation === true`.  Interactive (default)
+ * conversations must pay zero token cost — the section must be entirely
+ * absent unless the flag is explicitly true.
+ */
+
+import { mkdirSync } from "node:fs";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+
+const noopLogger: Record<string, unknown> = new Proxy(
+  {} as Record<string, unknown>,
+  {
+    get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
+  },
+);
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../../util/logger.js");
+mock.module("../../util/logger.js", () => ({
+  ...realLogger,
+  getLogger: () => noopLogger,
+  getCliLogger: () => noopLogger,
+  truncateForLog: (v: string) => v,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
+}));
+
+const mockLoadedConfig: Record<string, unknown> = {};
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
+  }),
+  loadConfig: () => mockLoadedConfig,
+  loadRawConfig: () => ({}),
+  saveConfig: () => {},
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+const { buildSystemPrompt, SYSTEM_PROMPT_CACHE_BOUNDARY } =
+  await import("../system-prompt.js");
+
+describe("buildSystemPrompt — Background Conversation gating", () => {
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  test("isBackgroundConversation: true — appends the Background Conversation section", () => {
+    const result = buildSystemPrompt({ isBackgroundConversation: true });
+    expect(result).toContain("## Background Conversation");
+    expect(result).toContain("`notifications` skill");
+    expect(result).toContain("assistant notifications send");
+  });
+
+  test("isBackgroundConversation: false — section is omitted", () => {
+    const result = buildSystemPrompt({ isBackgroundConversation: false });
+    expect(result).not.toContain("## Background Conversation");
+  });
+
+  test("options undefined — section is omitted (interactive default)", () => {
+    const result = buildSystemPrompt(undefined);
+    expect(result).not.toContain("## Background Conversation");
+  });
+
+  test("options provided without the flag — section is omitted", () => {
+    const result = buildSystemPrompt({});
+    expect(result).not.toContain("## Background Conversation");
+  });
+
+  test("section lives in the static (cached) block, not the dynamic suffix", () => {
+    // The section is deterministic for a given conversationType, so it
+    // belongs in staticParts to share the cache block with other
+    // call-time-stable instructions.
+    const result = buildSystemPrompt({ isBackgroundConversation: true });
+    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+    expect(boundaryIdx).toBeGreaterThan(-1);
+    const staticBlock = result.slice(0, boundaryIdx);
+    const dynamicBlock = result.slice(
+      boundaryIdx + SYSTEM_PROMPT_CACHE_BOUNDARY.length,
+    );
+    expect(staticBlock).toContain("## Background Conversation");
+    expect(dynamicBlock).not.toContain("## Background Conversation");
+  });
+});

package/src/prompts/system-prompt.ts

@@ -219,10 +219,19 @@ export function ensurePromptFiles(): void {
 export interface BuildSystemPromptOptions {
   hasNoClient?: boolean;
   excludeBootstrap?: boolean;
+  excludeCustomPrefix?: boolean;
   userPersona?: string | null;
   channelPersona?: string | null;
   userSlug?: string | null;
   onboardingContext?: OnboardingContext;
+  /**
+   * When true, append the Background Conversation guidance instructing the
+   * model to invoke the `notifications` skill for progress, blockers, and
+   * completion. Set by callers when running a non-interactive
+   * background/scheduled conversation. Interactive conversations leave this
+   * unset so they pay zero token cost.
+   */
+  isBackgroundConversation?: boolean;
 }
 
 /**
@@ -242,7 +251,8 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
   // (IDENTITY.md, SOUL.md, users/<slug>.md, etc.) are edited between turns.
   const staticParts: string[] = [];
   const customPrefix = readCustomSystemPromptPrefix();
-  if (customPrefix) staticParts.push(customPrefix);
+  if (customPrefix && !options?.excludeCustomPrefix)
+    staticParts.push(customPrefix);
   staticParts.push(buildParallelToolCallsSection());
   if (getIsContainerized()) staticParts.push(buildContainerizedSection());
   staticParts.push(buildCliReferenceSection());
@@ -254,6 +264,9 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
   staticParts.push(buildAccessPreferenceSection(hasNoClient));
   staticParts.push(buildCredentialSecuritySection());
   staticParts.push(buildExternalContentSection());
+  if (options?.isBackgroundConversation) {
+    staticParts.push(buildBackgroundConversationSection());
+  }
   // Memory Persistence, Memory Recall, Workspace Reflection, Learning from Mistakes
   // sections removed — guidance lives in memory_manage/memory_recall tool descriptions
   // and the Proactive Workspace Editing subsection in Configuration.
@@ -407,6 +420,14 @@ function buildExternalContentSection(): string {
   ].join("\n");
 }
 
+function buildBackgroundConversationSection(): string {
+  return [
+    "## Background Conversation",
+    "",
+    'You are running as a non-interactive background job — the user is not watching this conversation. To surface progress, blockers, or completion to the user, invoke the `notifications` skill (`assistant notifications send --message "..." --source-channel assistant_tool --is-async-background`). Finishing silently means the user sees nothing.',
+  ].join("\n");
+}
+
 function buildIntegrationSection(): string {
   let connections: { provider: string; accountInfo?: string | null }[];
   try {

package/src/prompts/update-bulletin-job.ts

@@ -2,14 +2,12 @@ import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 
 import { getConfig } from "../config/loader.js";
-import { INTERNAL_GUARDIAN_TRUST_CONTEXT } from "../daemon/trust-context.js";
 import {
   getMemoryCheckpoint,
   setMemoryCheckpoint,
 } from "../memory/checkpoints.js";
-import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
-import { deleteConversation } from "../memory/conversation-crud.js";
-import { wakeAgentForOpportunity } from "../runtime/agent-wake.js";
+import { runBackgroundJob } from "../runtime/background-job-runner.js";
+import { hasReceivedUserMessage } from "../runtime/pre-first-message-gate.js";
 import { getLogger } from "../util/logger.js";
 import {
   getWorkspaceDirDisplay,
@@ -20,6 +18,12 @@ const log = getLogger("update-bulletin-job");
 
 const HASH_CHECKPOINT_KEY = "updates:last_processed_hash";
 const EMPTY_HASH = "empty";
+/**
+ * Hard timeout for the update-bulletin agent turn. The agent reads a small
+ * markdown file and (usually) deletes it; 10 minutes is generous headroom for
+ * a slow model + any tool calls (e.g. memory writes).
+ */
+const UPDATE_BULLETIN_TIMEOUT_MS = 10 * 60 * 1000;
 
 function updateBulletinHint(): string {
   const workspace = getWorkspaceDirDisplay();
@@ -47,31 +51,48 @@ function readTrimmedContent(path: string): ReadResult {
 /**
  * Fire-and-forget background processor for the release-notes bulletin.
  *
- * If `<workspace>/UPDATES.md` has new (unprocessed) content, this
- * bootstraps a background conversation and wakes the agent loop with a hint
- * pointing at the file. De-duplication uses a sha256 content hash stored in
- * the `updates:last_processed_hash` memory checkpoint — an `"empty"` sentinel
+ * If `<workspace>/UPDATES.md` has new (unprocessed) content, this drives a
+ * background conversation through `runBackgroundJob` with a hint pointing at
+ * the file. De-duplication uses a sha256 content hash stored in the
+ * `updates:last_processed_hash` memory checkpoint — an `"empty"` sentinel
  * represents a missing/blank file so the job skips the common no-op case.
  *
- * The function never throws: any error inside the bootstrap/wake flow is
- * logged at `warn` and swallowed, so callers can safely invoke it in a
- * non-awaited context.
+ * The function never throws: any error inside `runBackgroundJob` is captured
+ * in its structured result (which already emits an `activity.failed`
+ * notification) and surrounding errors are logged at `warn` and swallowed,
+ * so callers can safely invoke it in a non-awaited context.
  *
  * Checkpoint write rules (intentionally conservative — prefer retry over
  * poisoning the checkpoint when state is ambiguous):
  *   - File missing → checkpoint = `EMPTY_HASH`.
  *   - File present but unreadable → checkpoint UNCHANGED, warn logged.
- *   - Wake not invoked (e.g. resolver not yet registered) → UNCHANGED.
- *   - Wake invoked but no tool calls AND file unchanged → UNCHANGED
- *     (indistinguishable from a silent failure; safer to retry).
- *   - Wake invoked + (produced tool calls OR file deleted) → checkpoint
- *     reflects the post-wake state.
+ *   - `runBackgroundJob` returned `ok: false` → checkpoint UNCHANGED so the
+ *     next startup retries. The runner has already emitted an
+ *     `activity.failed` notification.
+ *   - Job ran successfully + file deleted/empty → checkpoint = `EMPTY_HASH`.
+ *   - Job ran successfully + file unchanged → checkpoint = current hash
+ *     (agent intentionally left the file).
  */
 export async function runUpdateBulletinJobIfNeeded(): Promise<void> {
   if (getConfig().updates.enabled === false) {
     return;
   }
 
+  // Warm-pool guard: don't process release notes before a real user has
+  // interacted with the assistant. Provider credentials are typically not
+  // registered until the user hatches the image, so this job would fail
+  // and leave a "Background job failed: update-bulletin" row in the
+  // sidebar the user inherits at hatch time. The checkpoint is left
+  // untouched on purpose — once the user sends their first message, the
+  // job runs on the next daemon start (or after the next UPDATES.md
+  // change) with normal semantics.
+  if (!hasReceivedUserMessage()) {
+    log.info(
+      "update-bulletin-job: skipped — daemon has not received a first user message yet",
+    );
+    return;
+  }
+
   try {
     const updatesPath = getWorkspacePromptPath("UPDATES.md");
     const initial = readTrimmedContent(updatesPath);
@@ -98,60 +119,39 @@ export async function runUpdateBulletinJobIfNeeded(): Promise<void> {
       return;
     }
 
-    const conv = bootstrapConversation({
-      conversationType: "background",
-      source: "updates_bulletin",
+    const result = await runBackgroundJob({
+      jobName: "update-bulletin",
+      source: "update-bulletin",
       origin: "updates_bulletin",
-      systemHint: "Processing release updates",
-      groupId: "system:background",
-    });
-    const wakeResult = await wakeAgentForOpportunity({
-      conversationId: conv.id,
-      hint: updateBulletinHint(),
-      source: "updates_bulletin",
-      trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
+      prompt: updateBulletinHint(),
+      trustContext: {
+        sourceChannel: "vellum",
+        trustClass: "guardian",
+      },
+      callSite: "mainAgent",
+      timeoutMs: UPDATE_BULLETIN_TIMEOUT_MS,
     });
 
-    if (!wakeResult.invoked) {
+    if (!result.ok) {
       log.warn(
-        { conversationId: conv.id, reason: wakeResult.reason },
-        "Update bulletin wake silently no-op'd (invoked=false); cleaning up orphan background conversation and leaving checkpoint unchanged so next startup retries",
+        {
+          conversationId: result.conversationId,
+          errorKind: result.errorKind,
+          err: result.error?.message,
+        },
+        "update-bulletin-job: runBackgroundJob returned ok=false; leaving checkpoint unchanged so next startup retries (failure notification already emitted by runner)",
       );
-      // Belt-and-suspenders cleanup: `wakeAgentForOpportunity()` can return
-      // `{invoked: false}` for reasons unrelated to the wake-resolver
-      // registration order (resolver returns null because the conversation
-      // cannot be hydrated, etc.). Without this cleanup each such occurrence
-      // leaks a conversation DB row.
-      //
-      // Wrapped in its own try/catch so a cleanup failure never propagates
-      // out of this fire-and-forget task.
-      //
-      // TODO: the `queueGenerateConversationTitle()` call that
-      // `bootstrapConversation()` fires is already in flight by the time we
-      // reach here. The title service checks `isReplaceableTitle()` before
-      // writing, but the LLM sidechain call itself still runs against the
-      // now-deleted conversation id. Adding a cancellation/existence hook
-      // in `conversation-title-service.ts` would plug this one-call waste,
-      // but this code path is rare, so we accept the one-time cost.
-      try {
-        deleteConversation(conv.id);
-      } catch (err) {
-        log.warn(
-          { err, conversationId: conv.id },
-          "update-bulletin-job: failed to delete orphan background conversation; continuing",
-        );
-      }
       return;
     }
 
-    // Re-read after the wake. We need to know whether the file was deleted
-    // or modified to decide whether to advance the checkpoint.
+    // Re-read after the job completed. We need to know whether the file was
+    // deleted or modified to decide whether to advance the checkpoint.
     const after = readTrimmedContent(updatesPath);
 
     if (after.kind === "error") {
       log.warn(
         { err: after.err, path: updatesPath },
-        "update-bulletin-job: failed to re-read UPDATES.md after wake; leaving checkpoint unchanged so next startup retries",
+        "update-bulletin-job: failed to re-read UPDATES.md after job; leaving checkpoint unchanged so next startup retries",
       );
       return;
     }
@@ -166,26 +166,14 @@ export async function runUpdateBulletinJobIfNeeded(): Promise<void> {
       return;
     }
 
-    if (!wakeResult.producedToolCalls) {
-      // Wake returned cleanly but the agent did nothing observable AND the
-      // file is still here. We can't distinguish "agent processed and chose
-      // to no-op" from "silent failure", so leave the checkpoint alone and
-      // let the next startup retry.
-      log.warn(
-        { conversationId: conv.id },
-        "update-bulletin-job: wake produced no tool calls and file is unchanged; leaving checkpoint unchanged so next startup retries",
-      );
-      return;
-    }
-
-    // Wake produced tool calls and the file is still present — the agent
-    // intentionally left it (or modified it). Record the current hash so we
-    // don't re-wake on the same content.
+    // Job succeeded and the file is still present — the agent intentionally
+    // left it (or modified it). Record the current hash so we don't re-process
+    // the same content on next startup.
     setMemoryCheckpoint(HASH_CHECKPOINT_KEY, computeHash(after.content));
   } catch (err) {
     log.warn(
       { err },
-      "update-bulletin-job: wake flow threw; swallowing so callers can fire-and-forget",
+      "update-bulletin-job: outer flow threw; swallowing so callers can fire-and-forget",
     );
     return;
   }