@vellumai/assistant 0.8.0 → 0.8.2

package/src/plugins/registry.ts

@@ -1,12 +1,13 @@
 /**
- * Plugin registry with manifest validation and capability-based API versioning.
+ * Plugin registry with manifest validation.
  *
- * Plugins declare the assistant capabilities they need via
- * `manifest.requires` (a `{ capability: version }` map). The registry checks
- * each entry against {@link ASSISTANT_API_VERSIONS} — the canonical table of
- * capability → supported-version-list pairs the assistant exposes — and
- * refuses to register plugins that ask for a version the assistant does not
- * support.
+ * Host-compat negotiation lives in the plugin's `package.json`
+ * `peerDependencies["@vellumai/plugin-api"]` semver range — the
+ * external-plugin loader checks it against the assistant version at
+ * load time. This module owns the rest of the manifest validation
+ * contract: name/version presence, duplicate-name detection, and the
+ * closed-registration latch that protects `bootstrapPlugins()` from
+ * late-arriving registrations.
  *
  * Registration is order-preserving: {@link getRegisteredPlugins},
  * {@link getMiddlewaresFor}, and (secondarily) {@link getInjectors} all reflect
@@ -26,49 +27,9 @@ import {
   type PipelineName,
   type Plugin,
   PluginExecutionError,
+  type PluginHookFn,
 } from "./types.js";
 
-/**
- * Capability table declaring which plugin-facing API versions the assistant
- * runtime exposes. Each capability maps to the list of supported semver-lite
- * tags (currently a single `"v1"` per capability).
- *
- * New capabilities must be added here AND in their corresponding pipeline /
- * runtime module so plugins can negotiate against them. Removing a version
- * tag is a breaking change — all consumers in the plugin ecosystem relying on
- * it will fail to register until they update their `requires` map.
- *
- * The `pluginRuntime` capability is the base runtime API every plugin must
- * negotiate for; the remaining entries mirror {@link PipelineName} and the
- * top-level context APIs plugins most commonly consume.
- */
-export const ASSISTANT_API_VERSIONS: Record<string, string[]> = {
-  // Runtime APIs every plugin interacts with at some level. `memoryApi` is the
-  // broader memory-subsystem capability (distinct from the `memoryRetrieval`
-  // pipeline, which gets its own `memoryRetrievalApi` entry below).
-  pluginRuntime: ["v1"],
-  memoryApi: ["v1"],
-  compactionApi: ["v1"],
-  persistenceApi: ["v1"],
-
-  // Per-pipeline APIs. One entry for every slot in {@link PipelineName} that
-  // isn't already covered by the runtime-APIs block above (`compaction` and
-  // `persistence` live there because plugins commonly interact with them
-  // outside a pipeline middleware context).
-  turnApi: ["v1"],
-  llmCallApi: ["v1"],
-  toolExecuteApi: ["v1"],
-  memoryRetrievalApi: ["v1"],
-  historyRepairApi: ["v1"],
-  tokenEstimateApi: ["v1"],
-  overflowReduceApi: ["v1"],
-  titleGenerateApi: ["v1"],
-  toolResultTruncateApi: ["v1"],
-  emptyResponseApi: ["v1"],
-  toolErrorApi: ["v1"],
-  circuitBreakerApi: ["v1"],
-};
-
 // ─── Internal state ──────────────────────────────────────────────────────────
 
 /**
@@ -96,11 +57,13 @@ let registrationClosed = false;
 /**
  * Validate and register a plugin. Throws {@link PluginExecutionError} if:
  *
- * - `manifest`, `manifest.name`, `manifest.version`, or `manifest.requires`
- *   are missing.
+ * - `manifest`, `manifest.name`, or `manifest.version` are missing.
  * - a plugin with the same name is already registered.
- * - any entry in `manifest.requires` names an unknown capability or a version
- *   the assistant does not expose.
+ * - registration has been closed by {@link closeRegistration}.
+ *
+ * Host-compat is checked upstream by the external-plugin loader against
+ * the plugin's `peerDependencies["@vellumai/plugin-api"]` semver range —
+ * the registry does not re-validate it here.
  *
  * On success the plugin is appended to the registry in the order this
  * function is called. This function does NOT invoke `plugin.init()` — that
@@ -144,13 +107,6 @@ export function registerPlugin(plugin: Plugin): void {
       name,
     );
   }
-  if (!manifest.requires || typeof manifest.requires !== "object") {
-    throw new PluginExecutionError(
-      `plugin ${name} manifest.requires is required`,
-      name,
-    );
-  }
-
   // Duplicate-name check — plugins must be uniquely addressable in logs,
   // storage paths, and error messages. Runs BEFORE the closed-registration
   // check so `registerDefaultPlugins()` (which replays every default even
@@ -174,27 +130,6 @@ export function registerPlugin(plugin: Plugin): void {
     );
   }
 
-  // Capability negotiation. Every plugin must negotiate against
-  // `pluginRuntime`; we enforce that by requiring an entry to exist rather
-  // than special-casing it here, so the per-entry mismatch error is uniform.
-  if (!("pluginRuntime" in manifest.requires)) {
-    throw new PluginExecutionError(
-      `plugin ${name} must declare requires.pluginRuntime (e.g. "v1")`,
-      name,
-    );
-  }
-
-  for (const [api, requiredVersion] of Object.entries(manifest.requires)) {
-    const supported = ASSISTANT_API_VERSIONS[api];
-    if (!supported || !supported.includes(requiredVersion)) {
-      const exposed = supported ? supported.join(", ") : "(none)";
-      throw new PluginExecutionError(
-        `plugin ${name} requires ${api}@${requiredVersion}, assistant exposes ${exposed}`,
-        name,
-      );
-    }
-  }
-
   registeredPlugins.set(name, plugin);
 }
 
@@ -230,6 +165,31 @@ export function getMiddlewaresFor<P extends PipelineName>(
   return out;
 }
 
+/**
+ * Collect every registered plugin's hook for the given name, in
+ * registration order. Plugins that don't declare a hook for `name` are
+ * skipped. Used by the daemon to invoke chain-style hooks like
+ * `user-prompt-submit` where each plugin's hook may transform a shared
+ * context.
+ *
+ * The `TCtx` generic mirrors {@link PluginHookFn}'s — callers parameterize
+ * over the concrete context type their hook receives. Hooks that mutate
+ * the context in place return `void`; hooks that return a new context
+ * replace the threaded value for the next hook in the chain.
+ */
+export function getHooksFor<TCtx = unknown>(
+  name: string,
+): PluginHookFn<TCtx>[] {
+  const out: PluginHookFn<TCtx>[] = [];
+  for (const plugin of registeredPlugins.values()) {
+    const hook = plugin.hooks?.[name];
+    if (hook) {
+      out.push(hook as PluginHookFn<TCtx>);
+    }
+  }
+  return out;
+}
+
 /**
  * Flatten every registered plugin's `injectors` array and sort the result by
  * `order` ascending. Two injectors with the same `order` retain their relative
@@ -275,6 +235,14 @@ export function unregisterPlugin(name: string): void {
   registeredPlugins.delete(name);
 }
 
+export function getRegisteredPlugin(name: string): Plugin | undefined {
+  return registeredPlugins.get(name);
+}
+
+export function setRegisteredPlugin(plugin: Plugin): void {
+  registeredPlugins.set(plugin.manifest.name, plugin);
+}
+
 // ─── Test hooks ──────────────────────────────────────────────────────────────
 
 /**

package/src/plugins/types.ts

@@ -42,7 +42,11 @@ import type {
   ToolDefinition,
 } from "../providers/types.js";
 import type { SkillRoute } from "../runtime/skill-route-registry.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
+import type {
+  PluginTool,
+  ToolContext,
+  ToolExecutionResult,
+} from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
 
 // ─── Manifest ────────────────────────────────────────────────────────────────
@@ -60,22 +64,13 @@ import { AssistantError, ErrorCode } from "../util/errors.js";
 export interface PluginManifest {
   /** Unique plugin identifier (kebab-case). Duplicate names fail registration. */
   name: string;
-  /** Plugin version (semver). Informational — the registry compares
-   *  capability versions via `requires`, not this field. */
-  version: string;
   /**
-   * Capabilities this plugin exposes to other plugins.
-   *
-   * **Reserved for future cross-plugin composition — not currently consumed
-   * by any runtime code.** The field is declared so future cross-plugin work
-   * can land without a manifest version bump, but today nothing reads it and
-   * plugins must not depend on it for capability discovery. See
-   * `assistant/docs/plugins.md` (Cross-plugin communication) for the
-   * rationale.
+   * Plugin version (semver). Informational. Host-compat negotiation lives
+   * in the plugin's `package.json` `peerDependencies["@vellumai/plugin-api"]`
+   * range — checked by the external-plugin loader against the assistant's
+   * own version at load time.
    */
-  provides?: Record<string, string>;
-  /** Capabilities this plugin needs from the assistant runtime. */
-  requires: Record<string, string>;
+  version: string;
   /** Credential keys the plugin needs resolved before `init()` runs. */
   requiresCredential?: string[];
   /**
@@ -93,30 +88,14 @@ export interface PluginManifest {
   config?: unknown;
 }
 
-// ─── Init context ────────────────────────────────────────────────────────────
-
-/**
- * Context passed to `Plugin.init()` during bootstrap. Carries resolved
- * config/credentials, a pino-compatible logger scoped to the plugin, a
- * per-plugin writable data directory, and the assistant's version metadata.
- */
-export interface PluginInitContext {
-  /** Parsed config for this plugin (may be `unknown` until the manifest validates). */
-  config: unknown;
-  /** Resolved credential values keyed by the entries of `manifest.requiresCredential`. */
-  credentials: Record<string, string>;
-  /**
-   * Pino-compatible child logger bound to `{ plugin: <name> }`. Untyped here
-   * to avoid pulling pino into the types module.
-   */
-  logger: unknown;
-  /** Absolute path to `<workspaceDir>/plugins-data/<plugin>/` (created by bootstrap). */
-  pluginStorageDir: string;
-  /** Assistant semver for compatibility checks inside the plugin. */
-  assistantVersion: string;
-  /** Capability → version-list map (`ASSISTANT_API_VERSIONS`) for defensive runtime checks. */
-  apiVersions: Record<string, string[]>;
-}
+// ─── Init / Shutdown context ─────────────────────────────────────────────────
+// Public types — defined in `assistant/src/plugin-api/types.ts` and re-exported
+// here so existing internal call sites keep working. Plugin authors will
+// import these from `@vellumai/plugin-api` once that package is published.
+export type {
+  PluginInitContext,
+  PluginShutdownContext,
+} from "../plugin-api/types.js";
 
 // ─── Middleware ──────────────────────────────────────────────────────────────
 
@@ -860,6 +839,17 @@ export interface TurnInjectionInputs {
    * knows no human is present to answer clarification questions.
    */
   readonly isNonInteractive?: boolean;
+  /**
+   * Active documents open in this conversation — surfaced by the
+   * `active-documents` injector so the assistant can target existing docs
+   * with `document_update` instead of creating duplicates.
+   */
+  readonly activeDocuments?: ReadonlyArray<{
+    surfaceId: string;
+    title: string;
+    wordCount: number;
+    updatedAt: number;
+  }> | null;
 }
 
 export interface DiskPressureInjectionContext {
@@ -1011,15 +1001,16 @@ export interface Injector {
 // catalog-discoverable skills today.
 
 /**
- * Tool registration contributed by a plugin. Uses the canonical {@link Tool}
- * interface from the tool registry — the bootstrap stamps `origin: "plugin"`
- * and `ownerPluginId: <plugin.name>` before handing the batch to
- * `registerPluginTools`, which keeps plugin ref-counts and conflict detection
- * in a namespace disjoint from real skills. Plugin authors supply the
- * functional fields (`name`, `description`, `getDefinition`, `execute`, etc.)
- * and leave the ownership metadata to the bootstrap to set authoritatively.
+ * Tool registration contributed by a plugin. Uses the narrow
+ * {@link PluginTool} shape — plugin authors declare functional fields
+ * (`name`, `description`, `input_schema`, `execute`, etc.) and leave category
+ * / ownership metadata to the bootstrap, which stamps `category: "plugin"`,
+ * `origin: "plugin"`, and `ownerPluginId: <plugin.name>` before handing the
+ * batch to `registerPluginTools`. The registration boundary synthesizes
+ * `getDefinition()` from `{name, description, input_schema}` so the canonical
+ * {@link Tool} interface used by the internal registry stays unchanged.
  */
-export type PluginToolRegistration = Tool;
+export type PluginToolRegistration = PluginTool;
 /**
  * HTTP route registration contributed by a plugin. Plugins express routes as
  * {@link SkillRoute} values — the same shape the skill-route registry
@@ -1077,19 +1068,49 @@ export interface PluginSkillRegistration {
 
 // ─── Plugin ──────────────────────────────────────────────────────────────────
 
+/**
+ * A plugin lifecycle hook. Receives a per-lifecycle context shape and
+ * may return either a transformed context or `void`. Today's runtime
+ * consumes only the resolved-or-rejected nature of the promise; the
+ * `TCtx` return is reserved for future hooks that fan a transformed
+ * context out to downstream plugins.
+ *
+ * Each known hook key has a documented context shape:
+ *   - `init` — {@link PluginInitContext}
+ *   - `shutdown` — {@link PluginShutdownContext}
+ *
+ * Unknown keys are populated by the loader for forward compatibility
+ * but are not invoked by today's runtime.
+ */
+export type PluginHookFn<TCtx = unknown> = (ctx: TCtx) => Promise<TCtx | void>;
+
+/**
+ * Map of lifecycle hooks contributed by a plugin. Keys match file
+ * basenames under `<plugin>/hooks/` — the external loader populates one
+ * entry per `hooks/<name>.{ts,js}` it finds. The runtime invokes
+ * known keys (`init`, `shutdown`) at the matching lifecycle event;
+ * unknown keys are forward-compat scaffolding.
+ *
+ * See `assistant/src/daemon/external-plugins-bootstrap.ts` for the
+ * full lifecycle, and {@link PluginHookFn} for the per-entry signature.
+ */
+// The map stores hooks for arbitrary keys with arbitrary context shapes.
+// `any` (rather than `unknown`) is required so concrete plugin signatures
+// like `(ctx: PluginInitContext) => Promise<void>` and `() => Promise<void>`
+// both assign in/out of slot entries under strict-function-types contravariance.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type PluginHooks = Record<string, PluginHookFn<any>>;
+
 /**
  * A registered plugin. Every field besides `manifest` is optional — a plugin
  * may contribute any combination of middleware, injectors, and model-visible
- * capabilities. Lifecycle hooks (`init`, `onShutdown`) run sequentially
- * during daemon startup/shutdown.
+ * capabilities. Lifecycle hooks live under `hooks`.
  */
 export interface Plugin {
   /** Static manifest validated by the registry. */
   manifest: PluginManifest;
-  /** Optional async initializer. Runs once during bootstrap, before traffic. */
-  init?(ctx: PluginInitContext): Promise<void>;
-  /** Optional shutdown hook. Runs during daemon shutdown in reverse-registration order. */
-  onShutdown?(): Promise<void>;
+  /** Lifecycle hooks (init, shutdown). See {@link PluginHooks}. */
+  hooks?: PluginHooks;
   /** Tool registrations visible to the model. */
   tools?: PluginToolRegistration[];
   /** HTTP route registrations served by the assistant. */

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:
  *
@@ -38,7 +49,9 @@ import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 
 import { getLogger } from "../util/logger.js";
-import { getWorkspaceDir } from "../util/platform.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+import { ensurePluginApiShim } from "./ensure-plugin-api-shim.js";
+import { loadExternalPlugin } from "./external-plugin-loader.js";
 import { closeRegistration } from "./registry.js";
 
 const log = getLogger("user-plugin-loader");
@@ -55,9 +68,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 +82,42 @@ 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 pluginsDir = join(getWorkspaceDir(), "plugins");
-  if (!existsSync(pluginsDir)) {
-    log.debug(
-      { pluginsDir },
-      "loadUserPlugins: no plugins directory — skipping",
+  const importTimeoutMs = options.importTimeoutMs ?? USER_PLUGIN_IMPORT_TIMEOUT_MS;
+
+  // Materialize the workspace-level `@vellumai/plugin-api` shim *before*
+  // we dynamic-import any user plugins. The shim file must exist on disk
+  // before the first plugin's `import "@vellumai/plugin-api"` is parsed.
+  //
+  // Wrapped in try/catch because per `AGENTS.md` the daemon must never
+  // block startup. A shim-write failure (ENOSPC, read-only workspace,
+  // perms) is logged and we continue — plugins that try to import the
+  // public specifier will fail individually inside the per-plugin import
+  // loop below, which is already isolated.
+  try {
+    await ensurePluginApiShim();
+  } catch (err) {
+    log.warn(
+      { err },
+      "loadUserPlugins: plugin-api shim materialization failed — continuing with degraded plugin support",
     );
-    // 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.
+  }
+
+  const pluginsDir = getWorkspacePluginsDir();
+
+  if (!existsSync(pluginsDir)) {
+    // 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 +150,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 +164,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/aux-message-injector.ts

@@ -8,6 +8,10 @@
 
 import { createAssistantMessage } from "../agent/message-types.js";
 import { findConversation } from "../daemon/conversation-store.js";
+import {
+  conversationMessagesSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
 import { addMessage } from "../memory/conversation-crud.js";
 import type { BroadcastFn } from "../notifications/adapters/macos.js";
 import { getLogger } from "../util/logger.js";
@@ -71,4 +75,11 @@ export async function injectAuxAssistantMessage(params: {
     type: "conversation_list_invalidated",
     reason: "reordered",
   });
+  params.broadcastMessage({
+    type: "sync_changed",
+    tags: [
+      SYNC_TAGS.conversationsList,
+      conversationMessagesSyncTag(params.conversationId),
+    ],
+  });
 }