@vellumai/assistant 0.10.4-staging.1 → 0.10.4

package/src/plugins/defaults/workspace/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "default-workspace",
+  "version": "1.0.0",
+  "description": "First-party default plugin contributing the workspace-grounding runtime injectors (workspace context, NOW.md scratchpad, config-quarantine notice, disk-pressure warning).",
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=20.12.0"
+  },
+  "peerDependencies": {
+    "@vellumai/plugin-api": "^0.8.0"
+  }
+}

package/src/plugins/injector-registry.ts

@@ -0,0 +1,127 @@
+/**
+ * Global runtime-injector registry.
+ *
+ * Runtime injectors are a first-party plugin contribution, registered the same
+ * way `tools` and `routes` are: the bootstrap (`external-plugins-bootstrap.ts`)
+ * reads each plugin's `injectors` field and registers it here before the
+ * plugin's `init()` runs. The per-turn injection walker
+ * (`collectInjectorBlocks` in `conversation-runtime-assembly.ts`) reads the
+ * union via {@link getRegisteredInjectors}.
+ *
+ * Ordering is a pure function of each injector's `order` field:
+ * {@link getRegisteredInjectors} stable-sorts the union ascending, so the
+ * sequence the model sees does not depend on which plugin contributes an
+ * injector or in what registration order — except as the deterministic
+ * tiebreak among injectors that share an `order`, which falls back to
+ * registration order (plugin registration order × each plugin's array order).
+ */
+
+import { getLogger } from "../util/logger.js";
+import { isPluginDisabled } from "./disabled-state.js";
+import type { Injector } from "./types.js";
+
+const log = getLogger("injector-registry");
+
+/**
+ * Injectors contributed by each plugin, keyed by plugin name. `Map` iteration
+ * preserves insertion (registration) order, and each plugin's array order is
+ * preserved within its entry — together these define the pre-sort sequence
+ * that {@link getRegisteredInjectors}'s stable sort uses as its tiebreak.
+ */
+const injectorsByPlugin = new Map<string, readonly Injector[]>();
+
+/**
+ * Memoized order-sorted union, each injector tagged with its contributing
+ * plugin so {@link getRegisteredInjectors} can filter by disabled-state at read
+ * time without re-sorting. Rebuilt lazily after any registration change so the
+ * sort runs once per stable registry state rather than once per turn.
+ */
+let cachedChain: Array<{ plugin: string; injector: Injector }> | null = null;
+
+/**
+ * Register the injectors contributed by `pluginName`. Injector names must be
+ * globally unique; a name already claimed by a *different* plugin throws.
+ * Re-registering the same plugin replaces its prior set (idempotent for hot
+ * reload and test re-setup), so a plugin re-running its own registration is a
+ * silent replace rather than a duplicate-name throw.
+ */
+export function registerPluginInjectors(
+  pluginName: string,
+  injectors: readonly Injector[],
+): void {
+  const seenInContribution = new Set<string>();
+  for (const injector of injectors) {
+    if (seenInContribution.has(injector.name)) {
+      throw new Error(
+        `Plugin "${pluginName}" contributes duplicate injector name "${injector.name}"`,
+      );
+    }
+    seenInContribution.add(injector.name);
+    for (const [owner, existing] of injectorsByPlugin) {
+      if (owner === pluginName) continue;
+      if (existing.some((e) => e.name === injector.name)) {
+        throw new Error(
+          `Injector "${injector.name}" contributed by plugin "${pluginName}" is already registered by plugin "${owner}"`,
+        );
+      }
+    }
+  }
+  injectorsByPlugin.set(pluginName, injectors);
+  cachedChain = null;
+  log.info(
+    { plugin: pluginName, count: injectors.length },
+    "Plugin injectors registered",
+  );
+}
+
+/**
+ * Remove the injectors contributed by `pluginName`. No-op when the plugin
+ * never contributed injectors, so it is safe to call on every teardown path.
+ */
+export function unregisterPluginInjectors(pluginName: string): void {
+  if (injectorsByPlugin.delete(pluginName)) {
+    cachedChain = null;
+    log.info({ plugin: pluginName }, "Plugin injectors unregistered");
+  }
+}
+
+/**
+ * The order-sorted union of every registered injector whose contributing plugin
+ * is currently enabled. Stable-sorted by ascending `order` (lower runs first);
+ * injectors sharing an `order` keep their registration order.
+ *
+ * Disabled-state is consulted at read time, once per contributing plugin, via
+ * {@link isPluginDisabled} — so `assistant plugins disable/enable <name>` takes
+ * effect on the next turn without a daemon restart, the same contract the hook
+ * and tool registries honor. The order-sorted union is memoized across the
+ * filter (rebuilt only on a registration change); only the small per-plugin
+ * disabled check re-runs each call.
+ */
+export function getRegisteredInjectors(): Injector[] {
+  if (cachedChain === null) {
+    const pairs: Array<{ plugin: string; injector: Injector }> = [];
+    for (const [plugin, injectors] of injectorsByPlugin) {
+      for (const injector of injectors) pairs.push({ plugin, injector });
+    }
+    pairs.sort((a, b) => a.injector.order - b.injector.order);
+    cachedChain = pairs;
+  }
+  const enabledByPlugin = new Map<string, boolean>();
+  const isEnabled = (plugin: string): boolean => {
+    let enabled = enabledByPlugin.get(plugin);
+    if (enabled === undefined) {
+      enabled = !isPluginDisabled(plugin);
+      enabledByPlugin.set(plugin, enabled);
+    }
+    return enabled;
+  };
+  return cachedChain
+    .filter(({ plugin }) => isEnabled(plugin))
+    .map(({ injector }) => injector);
+}
+
+/** Drop every registration. Exposed for test isolation. */
+export function clearInjectorRegistry(): void {
+  injectorsByPlugin.clear();
+  cachedChain = null;
+}

package/src/plugins/job-handler-registry.ts

@@ -0,0 +1,94 @@
+/**
+ * Global background-job-handler registry.
+ *
+ * Background-job handlers are a first-party plugin contribution, registered the
+ * same way `tools`, `routes`, and `injectors` are: the bootstrap
+ * (`external-plugins-bootstrap.ts`) reads each plugin's `jobHandlers` field and
+ * registers it here before the plugin's `init()` runs. The general job worker's
+ * registration entry (`jobs/register-job-handlers.ts`) reads the union via
+ * {@link getRegisteredJobHandlers} and forwards each handler into the worker's
+ * dispatch table (`registerJobHandler` in `persistence/jobs-worker.ts`).
+ *
+ * Unlike injectors, job handlers carry no order: dispatch is a keyed lookup by
+ * job `type`, so a `type` must be globally unique across every plugin. The
+ * registry rejects a duplicate `type` the same way the injector registry rejects
+ * a duplicate injector name. Contribution order is irrelevant — the worker's
+ * dispatch map is keyed by type — so {@link getRegisteredJobHandlers} returns the
+ * union in plain registration order with no sort.
+ */
+
+import { getLogger } from "../util/logger.js";
+import type { JobHandlerEntry } from "./types.js";
+
+const log = getLogger("job-handler-registry");
+
+/**
+ * Job handlers contributed by each plugin, keyed by plugin name. `Map` iteration
+ * preserves insertion (registration) order; within a plugin the array order is
+ * preserved. Neither affects dispatch (keyed by `type`).
+ */
+const jobHandlersByPlugin = new Map<string, readonly JobHandlerEntry[]>();
+
+/**
+ * Register the job handlers contributed by `pluginName`. Job-handler `type`s must
+ * be globally unique; a `type` already claimed by a *different* plugin throws.
+ * Re-registering the same plugin replaces its prior set (idempotent for hot
+ * reload and test re-setup), so a plugin re-running its own registration is a
+ * silent replace rather than a duplicate-type throw.
+ */
+export function registerPluginJobHandlers(
+  pluginName: string,
+  handlers: readonly JobHandlerEntry[],
+): void {
+  const seenInContribution = new Set<string>();
+  for (const entry of handlers) {
+    if (seenInContribution.has(entry.type)) {
+      throw new Error(
+        `Plugin "${pluginName}" contributes duplicate job-handler type "${entry.type}"`,
+      );
+    }
+    seenInContribution.add(entry.type);
+    for (const [owner, existing] of jobHandlersByPlugin) {
+      if (owner === pluginName) continue;
+      if (existing.some((e) => e.type === entry.type)) {
+        throw new Error(
+          `Job-handler type "${entry.type}" contributed by plugin "${pluginName}" is already registered by plugin "${owner}"`,
+        );
+      }
+    }
+  }
+  jobHandlersByPlugin.set(pluginName, handlers);
+  log.info(
+    { plugin: pluginName, count: handlers.length },
+    "Plugin job handlers registered",
+  );
+}
+
+/**
+ * Remove the job handlers contributed by `pluginName`. No-op when the plugin
+ * never contributed job handlers, so it is safe to call on every teardown path.
+ */
+export function unregisterPluginJobHandlers(pluginName: string): void {
+  if (jobHandlersByPlugin.delete(pluginName)) {
+    log.info({ plugin: pluginName }, "Plugin job handlers unregistered");
+  }
+}
+
+/**
+ * The union of every registered plugin's job-handler contributions, in
+ * registration order. `type`s are globally unique (enforced at registration), so
+ * the consumer can forward each entry into the worker's keyed dispatch table
+ * without further dedupe.
+ */
+export function getRegisteredJobHandlers(): JobHandlerEntry[] {
+  const all: JobHandlerEntry[] = [];
+  for (const handlers of jobHandlersByPlugin.values()) {
+    all.push(...handlers);
+  }
+  return all;
+}
+
+/** Drop every registration. Exposed for test isolation. */
+export function clearJobHandlerRegistry(): void {
+  jobHandlersByPlugin.clear();
+}

package/src/plugins/mtime-cache.ts

@@ -485,7 +485,7 @@ async function activatePlugin(
   }
 
   // Run the `init` hook if present.
-  await runInitHook(pluginName);
+  await runInitHook(pluginName, pluginDir);
 
   activatedPlugins.push({ name: pluginName });
 }

package/src/plugins/pipeline.ts

@@ -16,9 +16,9 @@
  * Design doc: `.private/plans/agent-plugin-system.md`.
  */
 
+import { getHooksFor } from "../hooks/registry.js";
 import type { HookName } from "../plugin-api/constants.js";
 import { getLogger } from "../util/logger.js";
-import { getHooksFor } from "./registry.js";
 import type { HookFunction } from "./types.js";
 
 // ─── Hook runner ────────────────────────────────────────────────────────────

package/src/plugins/registry.ts

@@ -1,93 +1,45 @@
 /**
- * Plugin registry with manifest validation.
+ * Plugin registry — tracks registered plugins by name and delegates hook
+ * registration to {@link ../hooks/registry.ts}.
  *
- * 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} and
- * {@link getHooksFor} reflect the order in which {@link registerPlugin} was
- * called, which in turn determines the order plugin hooks run.
- *
- * This module does not call `Plugin.init()` — that is the job of the
- * bootstrap. It also does not wire the registry into the daemon.
- *
- * Design doc: `.private/plans/agent-plugin-system.md`.
+ * `registerPlugin` validates a plugin manifest, records its name (so
+ * `getRegisteredPlugins` can enumerate registered plugins), and forwards the
+ * plugin's hooks to the hooks registry. The hook surface itself lives in
+ * `hooks/registry.ts`; this module owns only the plugin-name bookkeeping.
  */
 
-import { isPluginDisabled } from "./disabled-state.js";
-import { getUserHooksFor } from "./mtime-cache.js";
 import {
-  type HookFunction,
-  type Plugin,
-  PluginExecutionError,
-} from "./types.js";
+  registerPluginHooks,
+  resetHookRegistryForTests,
+  unregisterPluginHooks,
+} from "../hooks/registry.js";
+import { type Plugin, PluginExecutionError } from "./types.js";
 
 // ─── Internal state ──────────────────────────────────────────────────────────
 
 /**
- * Registered plugins keyed by `manifest.name`. A `Map` preserves insertion
- * order, which the registry relies on for hook ordering and
- * `getRegisteredPlugins()` output.
+ * Plugin names that have been registered, in registration order. Used by
+ * `getRegisteredPlugins` to provide the full plugin list to
+ * `bootstrapPlugins` (for test-registered plugins) and for test assertions.
  */
 const registeredPlugins = new Map<string, Plugin>();
 
 /**
- * Hook registry — the per-surface registry for default plugin hooks. Each
- * hook name maps to an ordered list of `{fn, pluginName}` entries, one per
- * plugin that contributes that hook. The list order matches registration
- * order (i.e. {@link getAllDefaultPlugins} array order), which fixes
- * hook-chain ordering the same way the old `registeredPlugins` map did.
- *
- * Populated by {@link registerPlugin} alongside `registeredPlugins` and
- * depleted by {@link unregisterPlugin}. {@link getHooksFor} reads from this
- * map (not `registeredPlugins`) so it can filter disabled plugins at read
- * time via {@link isPluginDisabled} — the key mechanism that makes
- * `assistant plugins disable default-*` take effect immediately in a
- * running assistant.
- */
-const hookRegistry = new Map<
-  string,
-  Array<{ fn: HookFunction; pluginName: string }>
->();
-
-/**
- * Latch that closes the per-boot registration window. Flipped to `true` by
- * {@link closeRegistration} once `loadUserPlugins()` has returned. After that,
- * any attempt to register a *new* plugin throws — this is the safety net
- * against a user plugin whose dynamic `import()` was timed out but whose
- * top-level `await` later resolves and still tries to call
- * {@link registerPlugin}. Without the latch such a late arrival would land in
- * the registry after `bootstrapPlugins()` has already walked it, leaving the
- * plugin visible in the registry with its `init()` hook never invoked.
+ * Latch that closes the per-boot registration window. No longer used in
+ * production (user plugins go through the mtime cache, not `registerPlugin`),
+ * but preserved for test compatibility.
  */
 let registrationClosed = false;
 
 // ─── Registration ────────────────────────────────────────────────────────────
 
 /**
- * Validate and register a plugin. Throws {@link PluginExecutionError} if:
- *
- * - `manifest`, `manifest.name`, or `manifest.version` are missing.
- * - a plugin with the same name is already registered.
- * - 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
- * runs in the bootstrap sequence.
+ * Validate and register a plugin's hooks. Throws {@link PluginExecutionError}
+ * if the manifest is malformed. Delegates hook registration to
+ * {@link registerPluginHooks} in the hooks registry. Also tracks the plugin
+ * name for `getRegisteredPlugins` test assertions.
  */
 export function registerPlugin(plugin: Plugin): void {
-  // Basic shape / required-field validation. The type system already enforces
-  // most of this at compile time; these runtime checks guard against
-  // JS-level callers and malformed manifests loaded dynamically.
   if (!plugin || typeof plugin !== "object") {
     throw new PluginExecutionError(
       "registerPlugin requires a Plugin object",
@@ -105,11 +57,6 @@ export function registerPlugin(plugin: Plugin): void {
       undefined,
     );
   }
-  // Plugin names flow into filesystem paths (e.g. `plugins-data/<name>/` in
-  // the bootstrap's `ensurePluginStorageDir`), so they must not contain path
-  // separators, `..`, or other characters that could escape the parent
-  // directory. Restrict to lowercase-kebab-case, which is the convention used
-  // by every first-party plugin and prevents path-traversal by construction.
   if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
     throw new PluginExecutionError(
       `plugin manifest.name "${name}" must be kebab-case (lowercase letters, digits, and single hyphens)`,
@@ -122,22 +69,18 @@ export function registerPlugin(plugin: Plugin): void {
       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
-  // after the registration window closes) keeps seeing the familiar
-  // "already registered" error it catches and swallows.
+  // Duplicate-name check — runs BEFORE the closed-registration check so
+  // `registerDefaultPlugins()` (which replays every default) keeps seeing
+  // the familiar "already registered" error it catches and swallows.
   if (registeredPlugins.has(name)) {
     throw new PluginExecutionError(
       `plugin ${name} is already registered`,
       name,
     );
   }
-
   // Closed-registration check — rejects a genuinely new plugin that arrives
-  // after {@link closeRegistration}. The canonical offender is a user plugin
-  // whose dynamic `import()` was timed out in `loadUserPlugins()` but whose
-  // module evaluation eventually completes and still calls this function.
+  // after `closeRegistration`. No longer used in production (user plugins go
+  // through the mtime cache), but preserved for test compatibility.
   if (registrationClosed) {
     throw new PluginExecutionError(
       `plugin ${name} cannot register: plugin registration is closed (late arrival after loadUserPlugins() returned)`,
@@ -147,118 +90,43 @@ export function registerPlugin(plugin: Plugin): void {
 
   registeredPlugins.set(name, plugin);
 
-  // Register each hook into the per-surface hook registry. `getHooksFor`
-  // reads from this map (filtered by `isPluginDisabled`) rather than from
-  // `registeredPlugins`, so toggling the `.disabled` sentinel at runtime
-  // takes effect on the next turn without mutating the plugin registry.
   if (plugin.hooks) {
-    for (const [hookName, fn] of Object.entries(plugin.hooks)) {
-      if (typeof fn !== "function") continue;
-      let list = hookRegistry.get(hookName);
-      if (!list) {
-        list = [];
-        hookRegistry.set(hookName, list);
-      }
-      list.push({ fn: fn as HookFunction, pluginName: name });
-    }
+    registerPluginHooks(name, plugin.hooks);
   }
 }
 
 // ─── Queries ─────────────────────────────────────────────────────────────────
 
 /**
- * All plugins registered so far, in registration order. Consumers must treat
- * the returned array as a read-only snapshot — mutating it does not mutate
- * the registry.
+ * All plugins registered so far, in registration order. In production this
+ * returns only the default plugins (registered by `registerDefaultPlugins`).
+ * Test fixtures registered via `registerPlugin` are also included.
  */
 export function getRegisteredPlugins(): Plugin[] {
   return Array.from(registeredPlugins.values());
 }
 
 /**
- * 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.
- *
- * This function is async because it pulls user-land hooks from the mtime
- * cache (filesystem-as-truth), which may need to re-import changed surface
- * files. First-party default plugin hooks are read synchronously from the
- * registry and prepended.
- *
- * The `TCtx` generic mirrors {@link HookFunction}'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 async function getHooksFor<TCtx = unknown>(
-  name: string,
-): Promise<HookFunction<TCtx>[]> {
-  // First-party defaults from the hook registry, filtered by the `.disabled`
-  // sentinel at read time. This is what makes `assistant plugins disable
-  // default-*` take effect immediately in a running assistant: the hooks stay
-  // registered but are filtered out on the next turn.
-  const defaultHooks: HookFunction<TCtx>[] = [];
-  for (const entry of hookRegistry.get(name) ?? []) {
-    if (!isPluginDisabled(entry.pluginName)) {
-      defaultHooks.push(entry.fn as HookFunction<TCtx>);
-    }
-  }
-
-  // User-land hooks from the mtime cache (async, may re-import).
-  const userHooks = await getUserHooksFor<TCtx>(name);
-
-  return [...defaultHooks, ...userHooks];
-}
-
-/**
- * Close the per-boot registration window. After this call, any attempt to
- * register a genuinely new plugin throws a {@link PluginExecutionError}.
- * Re-registering an already-registered plugin still hits the duplicate-name
- * check first (so idempotent callers like `registerDefaultPlugins()` keep
- * working unchanged).
- *
- * Called by `loadUserPlugins()` immediately before it returns so the
- * `bootstrapPlugins()` invariant ("registry has been fully populated for this
- * boot cycle") cannot be violated by a user plugin whose dynamic `import()`
- * timed out mid-load but whose top-level `await` resolves later and still
- * reaches `registerPlugin()`. Idempotent.
+ * Close the per-boot registration window. No-op in production (user plugins
+ * go through the mtime cache), but preserved for test compatibility.
  */
 export function closeRegistration(): void {
   registrationClosed = true;
 }
 
 /**
- * Remove a plugin from the registry. Invoked from the bootstrap's failure path
- * after {@link Plugin.onShutdown} and contribution teardown have run, so the
- * registry no longer exposes a plugin whose `init()` aborted mid-bootstrap.
- * Safe to call on an already-absent name (no-op).
+ * Remove a plugin's hooks from the hook registry and forget its name. Used by
+ * the bootstrap failure path and tests.
  */
 export function unregisterPlugin(name: string): void {
   registeredPlugins.delete(name);
-
-  // Remove all hooks contributed by this plugin from the hook registry.
-  // Used by the bootstrap failure path (init threw) and the feature-flag
-  // skip path — both are boot-time decisions where the plugin's hooks should
-  // never participate in the turn lifecycle.
-  for (const [, list] of hookRegistry) {
-    for (let i = list.length - 1; i >= 0; i--) {
-      if (list[i]!.pluginName === name) {
-        list.splice(i, 1);
-      }
-    }
-  }
+  unregisterPluginHooks(name);
 }
 
 // ─── Test hooks ──────────────────────────────────────────────────────────────
 
 /**
- * Clear the registry. Test-only — throws when invoked outside a test
- * environment so application code can never accidentally wipe the registry
- * at runtime. The guard recognizes `BUN_TEST=1` (set automatically by bun's
- * test runner) and `NODE_ENV=test` (the Node.js convention used elsewhere
- * in the codebase).
+ * Clear the plugin name set and the hook registry. Test-only.
  */
 export function resetPluginRegistryForTests(): void {
   const isTest =
@@ -270,9 +138,6 @@ export function resetPluginRegistryForTests(): void {
     );
   }
   registeredPlugins.clear();
-  hookRegistry.clear();
-  // Re-open the registration window so subsequent tests can register plugins
-  // again. Without this, the latch set by a prior `closeRegistration()` call
-  // would leak across test cases and reject legitimate registrations.
+  resetHookRegistryForTests();
   registrationClosed = false;
 }

package/src/plugins/types.ts

@@ -18,12 +18,13 @@ import type {
   InjectionMode,
 } from "../daemon/conversation-runtime-assembly.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
+import type { JobHandler } from "../persistence/jobs-worker.js";
 import type { HookFunction } from "../plugin-api/types.js";
 import type { Message } from "../providers/types.js";
 import type { SkillRoute } from "../runtime/skill-route-registry.js";
 import type { Tool } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
+import type { ConversationGraphMemory } from "./defaults/memory/graph/conversation-graph-memory.js";
 
 // ─── Manifest ────────────────────────────────────────────────────────────────
 
@@ -333,6 +334,22 @@ export interface Injector {
  */
 export type PluginRouteRegistration = SkillRoute;
 
+/**
+ * A single background-job-handler contribution: a job `type` string paired with
+ * the {@link JobHandler} that processes it. Plugins contribute these via the
+ * `jobHandlers` field; bootstrap registers them into the global job-handler
+ * registry, and the general job worker's registration entry
+ * (`jobs/register-job-handlers.ts`) forwards the union into the worker dispatch
+ * table. `type` must be globally unique across every plugin — dispatch is a
+ * keyed lookup. See `plugins/job-handler-registry.ts`.
+ */
+export interface JobHandlerEntry {
+  /** The job-queue type string this handler processes (globally unique). */
+  type: string;
+  /** Processes one claimed job of `type`. */
+  handler: JobHandler;
+}
+
 // ─── Plugin ──────────────────────────────────────────────────────────────────
 
 /**
@@ -374,6 +391,24 @@ export interface Plugin {
   tools?: Tool[];
   /** HTTP route registrations served by the assistant. */
   routes?: PluginRouteRegistration[];
+  /**
+   * Runtime injectors contributed to the per-turn injection chain. Bootstrap
+   * registers these into the global injector registry before `init()` runs,
+   * symmetric with `tools`/`routes`. The registry unions every plugin's
+   * injectors and stable-sorts by ascending `order`, so contribution order
+   * does not affect the produced sequence except as the tiebreak among
+   * injectors sharing an `order`. See `plugins/injector-registry.ts`.
+   */
+  injectors?: readonly Injector[];
+  /**
+   * Background-job handlers contributed to the general job worker. Bootstrap
+   * registers these into the global job-handler registry before `init()` runs,
+   * symmetric with `tools`/`routes`/`injectors`; the general worker's
+   * registration entry (`jobs/register-job-handlers.ts`) forwards the union into
+   * the worker dispatch table. Each `type` must be globally unique across every
+   * plugin. See `plugins/job-handler-registry.ts`.
+   */
+  jobHandlers?: readonly JobHandlerEntry[];
 }
 
 // ─── Errors ──────────────────────────────────────────────────────────────────

package/src/prompts/system-prompt.ts

@@ -11,7 +11,7 @@ import { join } from "node:path";
 import { getIsContainerized } from "../config/env-registry.js";
 import type { ChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import { markActivationSession } from "../memory/activation-session-store.js";
+import { markActivationSession } from "../plugins/defaults/memory/activation-session-store.js";
 import { ACTIVATION_RAIL_BOOTSTRAP_TEMPLATE } from "../telemetry/activation-funnel.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import { resolveBundledDir } from "../util/bundled-asset.js";

package/src/providers/__tests__/connection-model-compat.test.ts

@@ -84,7 +84,7 @@ mock.module("../../config/loader.js", () => ({
 }));
 
 const mockDbSentinel = { __mock: "db" };
-mock.module("../../memory/db-connection.js", () => ({
+mock.module("../../persistence/db-connection.js", () => ({
   getDb: () => mockDbSentinel,
 }));
 

package/src/providers/__tests__/dispatch-connection-routing.test.ts

@@ -47,7 +47,7 @@ mock.module("../../config/loader.js", () => ({
 // Mock the DB getter — we never actually hit SQLite since `getConnection` is
 // also mocked. Returning a sentinel keeps the call signature satisfied.
 const mockDbSentinel = { __mock: "db" };
-mock.module("../../memory/db-connection.js", () => ({
+mock.module("../../persistence/db-connection.js", () => ({
   getDb: () => mockDbSentinel,
 }));