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

package/src/{persistence → plugins/defaults/memory}/worker-control.ts

@@ -2,13 +2,13 @@
  * Shared control surface for the memory jobs worker *process* — the background
  * OS process whose entry point is `worker.ts`.
  *
- * Both the `assistant memory worker` CLI and the daemon lifecycle (when
- * `memory.worker.enabled` is set) need to probe, spawn, and stop this process.
- * The generic PID-file mechanics live in `util/worker-process.ts`; this module
- * binds them to the memory worker's PID path and entry point.
+ * The daemon lifecycle spawns and stops this process, and the memory worker
+ * status route probes it. The generic PID-file mechanics live in
+ * `util/worker-process.ts`; this module binds them to the memory worker's PID
+ * path and entry point.
  */
 
-import { getMemoryWorkerPidPath } from "../util/platform.js";
+import { getMemoryWorkerPidPath } from "../../../util/platform.js";
 import {
   probeWorkerPidFile,
   spawnWorkerProcess,
@@ -16,7 +16,7 @@ import {
   stopWorkerProcess,
   WorkerProcessSpawnError,
   type WorkerProcessStatus,
-} from "../util/worker-process.js";
+} from "../../../util/worker-process.js";
 
 /**
  * Inspect the PID file to determine whether the worker process is alive.
@@ -36,20 +36,11 @@ export class MemoryWorkerSpawnError extends WorkerProcessSpawnError {}
  * during startup or never writes its PID file within the wait window (i.e.
  * failed to start).
  *
- * Beyond the generic option semantics documented on
- * {@link SpawnWorkerProcessOptions}, two flags carry queue-ownership
- * consequences specific to the memory worker:
- *
- *   - `terminateOnTimeout` — callers that leave `memory.worker.enabled` off
- *     on failure (the CLI `memory worker start`) MUST set this: otherwise the
- *     detached worker keeps coming up and drains the queue behind the
- *     daemon's still-active synchronous runner — two drainers racing on the
- *     same jobs. The daemon's own startup spawn leaves the flag on, so a late
- *     worker there becomes the sole drainer; it passes `false` to let that
- *     worker live.
- *   - `detached` — `true` for the short-lived CLI (the worker outlives the
- *     command); `false` for the daemon (the worker appears in `assistant ps`
- *     and is torn down with the daemon).
+ * See {@link SpawnWorkerProcessOptions} for the generic option semantics. The
+ * daemon's boot spawn passes `detached: false` (so the worker appears in
+ * `assistant ps` and is torn down with the daemon) and leaves
+ * `terminateOnTimeout` unset (a worker that comes up late is still the desired
+ * sole drainer).
  */
 export async function spawnMemoryWorkerProcess(
   opts: SpawnWorkerProcessOptions = {},
@@ -60,7 +51,7 @@ export async function spawnMemoryWorkerProcess(
   try {
     return await spawnWorkerProcess({
       pidPath: getMemoryWorkerPidPath(),
-      entry: new URL("../plugins/defaults/memory/worker.ts", import.meta.url),
+      entry: new URL("./worker.ts", import.meta.url),
       workerLabel: "Memory worker",
       options: opts,
     });

package/src/plugins/defaults/memory/worker.ts

@@ -13,9 +13,11 @@
 import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 
 import { getConfig } from "../../../config/loader.js";
+import { rehydratePlatformCredentials } from "../../../config/platform-rehydration.js";
+import { resetDb } from "../../../persistence/db-connection.js";
 import { initializeTools } from "../../../tools/registry.js";
 import { registerMemoryPluginJobHandlers } from "./job-handler-registration.js";
-import { startInProcessMemoryJobsWorker } from "./jobs-worker.js";
+import { startMemoryJobsWorkerLoop } from "./jobs-worker.js";
 import { getLogger } from "./logging.js";
 import { getMemoryWorkerPidPath } from "./paths.js";
 
@@ -45,6 +47,16 @@ async function main(): Promise<void> {
   writeFileSync(pidPath, String(process.pid), { flag: "w" });
   log.info({ pid: process.pid, pidPath }, "Memory worker process started");
 
+  // Rehydrate the platform base URL and IDs from the credential store before
+  // any job runs. The daemon does this in initializeProvidersAndTools(); this
+  // standalone process must do it itself so getPlatformBaseUrl() resolves to
+  // the persisted platform environment instead of the VELLUM_ENVIRONMENT
+  // default. Retrospective and consolidation passes wake real agent
+  // conversations whose inference and background-wake requests go through the
+  // platform proxy — without rehydration those requests hit the wrong platform
+  // and are rejected.
+  await rehydratePlatformCredentials();
+
   // This process does not run plugin bootstrap, so self-register the job
   // handlers the worker dispatches from before starting it — the memory
   // plugin's own plus the host's non-plugin domain handlers.
@@ -67,7 +79,7 @@ async function main(): Promise<void> {
     );
   }
 
-  const worker = startInProcessMemoryJobsWorker();
+  const worker = startMemoryJobsWorkerLoop();
 
   // Keep-alive: the worker's setTimeout timers are unref'd, so without
   // this interval the process would exit immediately.
@@ -84,6 +96,11 @@ async function main(): Promise<void> {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
 
+  process.on("SIGUSR1", () => {
+    log.info("Received SIGUSR1 — refreshing database connections");
+    resetDb();
+  });
+
   // Catch stray exceptions that escape the worker loop so they produce a
   // clean pino-formatted log entry (and PID-file cleanup) instead of a raw
   // stack trace on stderr. The stderr fd is already piped to the log file

package/src/plugins/mtime-cache.ts

@@ -51,10 +51,6 @@ import {
   WORKSPACE_HOOKS_OWNER,
 } from "../hooks/hook-loader.js";
 import type { HookFunction, ShutdownReason } from "../plugin-api/types.js";
-import {
-  registerPluginTools,
-  unregisterPluginTools,
-} from "../tools/registry.js";
 import { finalizeTool } from "../tools/tool-defaults.js";
 import type { Tool, ToolDefinition } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
@@ -62,6 +58,7 @@ import {
   getWorkspaceHooksDir,
   getWorkspacePluginsDir,
 } from "../util/platform.js";
+import { collectSourceVersions } from "./collect-source-versions.js";
 import {
   deriveToolName,
   listSurfaceDir,
@@ -76,6 +73,7 @@ import {
 import {
   clearSurfaceImportInflight,
   evictModule,
+  getFileSignature,
   getMtime,
   importWithTimeout,
   setSurfaceImportTimeout,
@@ -164,8 +162,9 @@ function getInstallDate(pluginDir: string): number {
 
 /**
  * A cached tool plus the mtime of its source file. When the on-disk mtime
- * changes, the tool is re-imported, the old tool is unregistered from the
- * global tool registry, and the new one is registered.
+ * changes, the tool is re-imported and the cache entry replaced; the tool
+ * registry picks the new version up on its next pull reconcile (the mtime is
+ * part of the {@link ActivePluginTools} fingerprint).
  */
 interface CachedTool {
   readonly tool: Tool;
@@ -207,8 +206,13 @@ const disabledPluginDirs = new Set<string>();
  */
 let lastVersions: Record<string, PluginSourceVersion> = {};
 
-/** mtime of the sentinel document as of the last look; 0 = never seen. */
-let lastSentinelMtime = 0;
+/**
+ * Change signature (`mtimeMs:size:ino`) of the sentinel document as of the last
+ * look; `""` = never seen. A composite signature rather than mtime alone so a
+ * publish is detected even when the filesystem's mtime granularity can't move
+ * the timestamp between two rewrites (see {@link getFileSignature}).
+ */
+let lastSentinelSignature = "";
 
 /** In-flight reconcile — concurrent dispatches await it rather than racing. */
 let reconcileInFlight: Promise<void> | null = null;
@@ -257,11 +261,18 @@ export async function getUserHooksFor<TCtx = unknown>(
 
 /**
  * Dispatch-path gate: one stat of the source-versions sentinel. When its
- * mtime is unchanged since the last look (the overwhelmingly common case)
- * this returns immediately, and dispatch runs entirely on memory. When the
- * watcher published a change, the document is applied before the dispatch
+ * change signature is unchanged since the last look (the overwhelmingly common
+ * case) this returns immediately, and dispatch runs entirely on memory. When
+ * the watcher published a change, the document is applied before the dispatch
  * proceeds, so the turn that follows an edit already runs the new code.
  *
+ * The signature is `mtimeMs:size:ino`, not mtime alone: the sentinel is
+ * published via temp-file + atomic rename, which swaps in a fresh inode on
+ * every write, so a runtime install is picked up even on filesystems whose
+ * mtime granularity is too coarse to move the timestamp between two publishes
+ * (virtiofs / 9p / network mounts). With an mtime-only gate such a publish is
+ * invisible until the next daemon restart re-walks the plugins directory.
+ *
  * A missing or unreadable sentinel is degraded mode, not an error: the
  * boot-time state keeps serving, and live reload resumes when the monitor
  * publishes again.
@@ -276,14 +287,14 @@ async function maybeReconcileFromSentinel(): Promise<void> {
       await reconcileInFlight;
       continue;
     }
-    const mtime = getMtime(getSourceVersionsPath());
-    if (mtime === lastSentinelMtime) {
+    const signature = getFileSignature(getSourceVersionsPath());
+    if (signature === lastSentinelSignature) {
       return;
     }
-    // Claim the mtime before any async work, so a concurrent dispatch either
-    // finds the in-flight promise above or skips on the updated mtime.
-    lastSentinelMtime = mtime;
-    if (mtime === 0) {
+    // Claim the signature before any async work, so a concurrent dispatch
+    // either finds the in-flight promise above or skips on the updated value.
+    lastSentinelSignature = signature;
+    if (signature === "") {
       return;
     }
     const doc = readSourceVersions();
@@ -298,6 +309,52 @@ async function maybeReconcileFromSentinel(): Promise<void> {
   }
 }
 
+/**
+ * Imperatively reconcile the plugin caches against the current on-disk state
+ * *now* — without waiting for the resource monitor to republish the
+ * source-versions sentinel or for the next hook dispatch to notice it.
+ *
+ * An install / uninstall / enable / disable materializes files on disk; the
+ * steady-state path picks that up eventually — the monitor republishes the
+ * sentinel and the dispatch-path gate applies the diff on the next turn. That
+ * is eventually-correct but not immediate: nothing runs a newly installed
+ * plugin's `init` until some later turn dispatches a hook. Callers that just
+ * changed the plugin set on disk (the install / uninstall routes, and the
+ * CLI's best-effort post-install poke) call this to bring the change up
+ * deterministically, so a freshly installed plugin's `init` fires as part of
+ * the install rather than at the next daemon boot.
+ *
+ * Reuses the same collector the monitor writes into the sentinel, so the map
+ * applied here is identical to the monitor's next publish — which then diffs to
+ * a no-op. Idempotent and safe to call redundantly: `applySourceVersions` only
+ * redeploys directories whose fingerprint moved, and activation is guarded so a
+ * plugin already up is never re-initialized. Never throws — a failure is
+ * contained inside `applySourceVersions` and logged there.
+ *
+ * Coordinates with the sentinel gate through the shared `reconcileInFlight`
+ * latch: it waits out any dispatch-driven reconcile already running, then
+ * claims the latch for its own apply, so the two paths never overlap.
+ */
+export async function reconcilePluginSourcesNow(): Promise<void> {
+  while (reconcileInFlight !== null) {
+    await reconcileInFlight;
+  }
+  // `applySourceVersions` contains its own failures, but the `collectSourceVersions()`
+  // walk that feeds it runs outside that guard — wrap the whole thing so an
+  // imperative reconcile never rejects into its callers (the install route must
+  // still return success for an install whose files already landed on disk).
+  reconcileInFlight = (async () => {
+    try {
+      await applySourceVersions(collectSourceVersions());
+    } catch (err) {
+      log.error({ err }, "imperative plugin reconcile failed");
+    }
+  })().finally(() => {
+    reconcileInFlight = null;
+  });
+  await reconcileInFlight;
+}
+
 /**
  * Validate that a directory path from the sentinel is an allowed plugin
  * source: either under the workspace plugins directory or the standalone
@@ -547,7 +604,7 @@ function seedVersionBaseline(): void {
     };
   }
   lastVersions = seeded;
-  lastSentinelMtime = getMtime(getSourceVersionsPath());
+  lastSentinelSignature = getFileSignature(getSourceVersionsPath());
 }
 
 // ─── Tool cache ──────────────────────────────────────────────────────────────
@@ -561,10 +618,11 @@ function toolKey(pluginName: string, toolName: string): string {
 
 /**
  * Reconcile the tool cache for a single plugin directory. Re-imports
- * changed tool files, unregisters deleted tools, and registers new ones.
+ * changed tool files, evicts cache entries for deleted files, and caches
+ * newly appeared ones.
  *
- * Called during `scanPlugins()` so that by the time any consumer reads
- * the tool registry, the cache is fresh.
+ * Called during `scanPlugins()` so that by the time the tool registry pulls
+ * via {@link getActiveUserPluginTools}, the cache is fresh.
  */
 async function reconcilePluginTools(
   pluginDir: string,
@@ -632,13 +690,77 @@ async function reconcilePluginTools(
 }
 
 /**
- * Get all cached tools from user plugins. Called by the tool registry
- * to supplement the core + default plugin tools.
+ * Get all cached tools from user plugins, active or not. Test/diagnostic
+ * read; production consumers go through {@link getActiveUserPluginTools}.
  */
 export function getCachedUserTools(): Tool[] {
   return Array.from(toolCache.values()).map((c) => c.tool);
 }
 
+/**
+ * A single active plugin's tool contribution, as pulled by the tool
+ * registry's plugin reconcile (`loadPluginTools` in `tools/registry.ts`).
+ */
+export interface ActivePluginTools {
+  /**
+   * Change stamp for this plugin's tool set: tool names paired with their
+   * source-file mtimes. The registry reconcile re-registers a plugin's tools
+   * only when this moves, so an unchanged plugin costs a string compare.
+   */
+  fingerprint: string;
+  tools: Tool[];
+}
+
+/**
+ * Sync the plugin caches with the source-versions sentinel, then return the
+ * tool contributions of every *active* (discovered, enabled, activated)
+ * user plugin, keyed by plugin name in install-date order.
+ *
+ * This is the pull half of the tool-registry relationship: the registry's
+ * `loadPluginTools()` reconcile calls this and diffs the result into its own
+ * maps — this module never writes to the registry. Mirrors how hook reads
+ * pull through {@link getUserHookEntriesFor}.
+ */
+export async function getActiveUserPluginTools(): Promise<
+  Map<string, ActivePluginTools>
+> {
+  await maybeReconcileFromSentinel();
+
+  const byPlugin = new Map<string, CachedTool[]>();
+  for (const cached of toolCache.values()) {
+    if (!activatedNames.has(cached.pluginName)) {
+      continue;
+    }
+    const list = byPlugin.get(cached.pluginName);
+    if (list) {
+      list.push(cached);
+    } else {
+      byPlugin.set(cached.pluginName, [cached]);
+    }
+  }
+
+  // Emit in install-date order (discoveredPluginDirs is kept sorted), so the
+  // registry registers plugin tools in the same deterministic order the push
+  // model used. Plugins activated but no longer discovered (mid-teardown)
+  // simply don't appear.
+  const result = new Map<string, ActivePluginTools>();
+  for (const pluginName of discoveredPluginDirs.values()) {
+    const cachedTools = byPlugin.get(pluginName);
+    if (cachedTools === undefined || result.has(pluginName)) {
+      continue;
+    }
+    const fingerprint = cachedTools
+      .map((c) => `${c.tool.name}:${c.sourceMtime}`)
+      .sort()
+      .join("\n");
+    result.set(pluginName, {
+      fingerprint,
+      tools: cachedTools.map((c) => c.tool),
+    });
+  }
+  return result;
+}
+
 // ─── Plugin discovery ────────────────────────────────────────────────────────
 
 /**
@@ -739,8 +861,8 @@ async function scanPlugins(): Promise<void> {
   // Activate any plugin not yet brought up. Idempotent: already-active plugins
   // are skipped by the `activatedNames` guard, so steady-state scans (one per
   // hook dispatch) cost only a membership check per plugin. Tools were imported
-  // into `toolCache` by `reconcilePluginTools` above, so they are ready to
-  // register here.
+  // into `toolCache` by `reconcilePluginTools` above, so they are visible to
+  // the registry's pull reconcile as soon as activation flips.
   for (const [dir, name] of discoveredPluginDirs) {
     await activatePlugin(dir, name);
   }
@@ -834,8 +956,9 @@ const activatedPlugins: Array<{ kind: HookOwnerKind; name: string }> = [];
 const activatedNames = new Set<string>();
 
 /**
- * Activate a single discovered plugin: register its tools into the global tool
- * registry and run its `init` hook. Running `init` also resolves the owner's
+ * Activate a single discovered plugin: mark its cached tools live (the tool
+ * registry pulls them via {@link getActiveUserPluginTools} on its next
+ * reconcile) and run its `init` hook. Running `init` also resolves the owner's
  * `shutdown` (caching it for teardown), so no separate pre-import step is
  * needed; dispatch hooks resolve on their first read. Idempotent — a plugin
  * already activated (or mid-activation) is skipped. Never throws; per-surface
@@ -854,30 +977,10 @@ async function activatePlugin(
     return;
   }
   // Reserve synchronously, before any await, so a re-entrant or concurrent
-  // scan observes this plugin as already handled.
+  // scan observes this plugin as already handled. From this point the
+  // plugin's cached tools are visible to the registry's pull reconcile.
   activatedNames.add(pluginName);
 
-  // Register this plugin's tools into the global tool registry so
-  // `getAllTools()` and `getTool()` can find them. Tools were already imported
-  // and cached by `reconcilePluginTools` during the scan.
-  const pluginTools = Array.from(toolCache.values())
-    .filter((c) => c.pluginName === pluginName)
-    .map((c) => c.tool);
-  if (pluginTools.length > 0) {
-    try {
-      registerPluginTools(pluginName, pluginTools);
-      log.info(
-        { plugin: pluginName, count: pluginTools.length },
-        "user plugin tools registered",
-      );
-    } catch (err) {
-      log.error(
-        { err, plugin: pluginName },
-        `Failed to register tools for user plugin ${pluginName}`,
-      );
-    }
-  }
-
   // Run the `init` hook if present.
   await runInitHook(pluginName, pluginDir);
 
@@ -886,9 +989,11 @@ async function activatePlugin(
 
 /**
  * Deactivate a plugin that was disabled (`disable`), removed (`uninstall`), or
- * is being redeployed (`reload`) at runtime: unregister its tools and run its
- * `shutdown` hook. Must run *before* `evictPlugin` / `evictHooksForOwner` clear
- * the owner's cache. Idempotent — a plugin that was never activated is a no-op.
+ * is being redeployed (`reload`) at runtime: drop it from the active set (the
+ * tool registry's pull reconcile removes its tools on its next pass) and run
+ * its `shutdown` hook. Must run *before* `evictPlugin` / `evictHooksForOwner`
+ * clear the owner's cache. Idempotent — a plugin that was never activated is a
+ * no-op.
  *
  * `disable` and `reload` keep the directory present, so {@link runShutdownHook}
  * resolves and runs the on-disk `shutdown` (via the same resolution the dispatch
@@ -911,17 +1016,6 @@ async function deactivatePlugin(
     activatedPlugins.splice(idx, 1);
   }
 
-  // Unregister tools before running shutdown so the model-visible surface is
-  // clean before teardown.
-  try {
-    unregisterPluginTools(pluginName);
-  } catch (err) {
-    log.warn(
-      { err, plugin: pluginName },
-      "user plugin tool unregister failed (continuing)",
-    );
-  }
-
   if (reason !== "uninstall") {
     await runShutdownHook("plugin", pluginName, reason);
   }
@@ -931,7 +1025,7 @@ async function deactivatePlugin(
 
 /**
  * Populate the caches at boot by scanning the plugins directory once (which
- * imports surfaces, registers tools, and runs `init` hooks via `activatePlugin`
+ * imports surfaces into the caches and runs `init` hooks via `activatePlugin`
  * inside `scanPlugins`) and activating standalone workspace hooks. At daemon
  * shutdown these owners' `shutdown` hooks fire through the unified
  * `runHook(HOOKS.SHUTDOWN)` pipeline; a runtime uninstall/disable tears a single
@@ -939,13 +1033,15 @@ async function deactivatePlugin(
  *
  * This replaces the old `loadExternalPlugin` → `registerPlugin` →
  * `bootstrapPlugins` path for user plugins. Instead of registering whole
- * `Plugin` objects into the plugin registry, we register individual tools into
- * the tool registry and cache hooks by mtime.
+ * `Plugin` objects into the plugin registry, we cache individual surfaces by
+ * mtime; the tool registry pulls the active tool set through
+ * {@link getActiveUserPluginTools}.
  *
  * Called by `loadUserPlugins()` during daemon startup. After boot, the same
- * `scanPlugins` → `activatePlugin`/`deactivatePlugin` reconciliation runs on
- * every turn via `getUserHooksFor` (plugin hook dispatch), so plugins whose
- * files appear or disappear at runtime are picked up without a restart.
+ * `activatePlugin`/`deactivatePlugin` reconciliation runs via the
+ * source-versions sentinel on every hook dispatch and registry pull, so
+ * plugins whose files appear or disappear at runtime are picked up without a
+ * restart.
  */
 export async function populateCacheAtBoot(
   opts: { importTimeoutMs?: number } = {},
@@ -995,7 +1091,7 @@ export function resetPluginCacheForTests(): void {
   activatedNames.clear();
   disabledPluginDirs.clear();
   lastVersions = {};
-  lastSentinelMtime = 0;
+  lastSentinelSignature = "";
   reconcileInFlight = null;
 }
 

package/src/plugins/plugin-tree-walk.ts

@@ -40,10 +40,34 @@ export const PRESERVED_ENTRIES = [
   ".disabled",
 ] as const;
 
+/**
+ * Generated app build output: `apps/<app>/dist`. This is compiled output (the
+ * plugin source watcher builds each multi-file app's `src/` into its sibling
+ * `dist/`), never tracked source, so — like {@link PRESERVED_ENTRIES} — every
+ * fingerprint walk excludes it:
+ *
+ * - the **live-reload** change detector (`./source-fingerprint.ts`), so the
+ *   watcher's own compile does not read as a source change and re-trigger
+ *   itself in a loop, and
+ * - the **install/drift** fingerprint (`../cli/lib/plugin-fingerprint.ts`), so
+ *   generated output is not reported as drift/added against the pinned commit.
+ *
+ * A path pattern rather than a bare name so it stays scoped to `apps/<app>/dist`
+ * — a plugin's own top-level `dist/` (if it ships built code its hooks import)
+ * is still tracked. Matched against the POSIX path relative to the plugin root.
+ */
+export const GENERATED_APP_BUILD_DIR = /^apps\/[^/]+\/dist$/;
+
 /** Options controlling which entries a {@link walkPluginTree} visits. */
 export interface PluginTreeWalkOptions {
-  /** Top-level entry names to skip (e.g. {@link PRESERVED_ENTRIES}). */
-  readonly excludeRootEntries?: Iterable<string>;
+  /**
+   * Entries to exclude. A `string` matches a top-level entry by name (e.g.
+   * {@link PRESERVED_ENTRIES}); a `RegExp` matches any entry — at any depth —
+   * by its POSIX path relative to the walk root, and when it matches a
+   * directory the whole subtree is skipped (e.g. {@link
+   * GENERATED_APP_BUILD_DIR}).
+   */
+  readonly excludeRootEntries?: Iterable<string | RegExp>;
   /** Directory names skipped at any depth (e.g. `node_modules`). */
   readonly excludeDirsAnywhere?: ReadonlySet<string>;
   /** Skip entries whose name starts with `.`, at any depth. */
@@ -67,7 +91,17 @@ export function walkPluginTree(
   options: PluginTreeWalkOptions,
   visit: (rel: string, abs: string) => void,
 ): void {
-  const excludedRoot = new Set(options.excludeRootEntries ?? []);
+  // Split the exclusion list: bare strings match a top-level entry name;
+  // RegExps match an entry's relative path at any depth.
+  const excludedRootNames = new Set<string>();
+  const excludePatterns: RegExp[] = [];
+  for (const entry of options.excludeRootEntries ?? []) {
+    if (typeof entry === "string") {
+      excludedRootNames.add(entry);
+    } else {
+      excludePatterns.push(entry);
+    }
+  }
 
   const walk = (relDir: string): void => {
     const absDir = relDir ? join(root, relDir) : root;
@@ -82,7 +116,7 @@ export function walkPluginTree(
     }
     for (const entry of entries) {
       const name = entry.name;
-      if (relDir === "" && excludedRoot.has(name)) {
+      if (relDir === "" && excludedRootNames.has(name)) {
         continue;
       }
       if (options.excludeDotEntries === true && name.startsWith(".")) {
@@ -92,6 +126,9 @@ export function walkPluginTree(
         continue;
       }
       const rel = relDir ? `${relDir}/${name}` : name;
+      if (excludePatterns.some((pattern) => pattern.test(rel))) {
+        continue;
+      }
       if (entry.isDirectory()) {
         if (options.excludeDirsAnywhere?.has(name) === true) {
           continue;

package/src/plugins/source-fingerprint.ts

@@ -18,7 +18,9 @@
  *
  * Exclusions: dot-entries anywhere (`.disabled`, `.git`, …), `node_modules`
  * anywhere (vendored deps change only through install flows, which recycle
- * the plugin directory), and — at the plugin root only — the runtime-owned
+ * the plugin directory), generated app build output ({@link
+ * GENERATED_APP_BUILD_DIR}, so the watcher's own compile does not re-trigger a
+ * pass), and — at the plugin root only — the runtime-owned
  * {@link PRESERVED_ENTRIES} (`data/`, `config.json`, `install-meta.json`),
  * none of which are importable source. Symlinked entries inside the tree are
  * neither watched nor followed (see {@link walkPluginTree}); a symlinked
@@ -30,7 +32,11 @@
 
 import { realpathSync, statSync } from "node:fs";
 
-import { PRESERVED_ENTRIES, walkPluginTree } from "./plugin-tree-walk.js";
+import {
+  GENERATED_APP_BUILD_DIR,
+  PRESERVED_ENTRIES,
+  walkPluginTree,
+} from "./plugin-tree-walk.js";
 
 /** Directory names skipped at any depth. */
 const EXCLUDED_DIRS_ANYWHERE = new Set(["node_modules"]);
@@ -76,7 +82,7 @@ export function snapshotPluginSource(pluginDir: string): SourceSnapshot {
   walkPluginTree(
     realRoot,
     {
-      excludeRootEntries: PRESERVED_ENTRIES,
+      excludeRootEntries: [...PRESERVED_ENTRIES, GENERATED_APP_BUILD_DIR],
       excludeDirsAnywhere: EXCLUDED_DIRS_ANYWHERE,
       excludeDotEntries: true,
       bestEffort: true,

package/src/plugins/surface-import.ts

@@ -50,6 +50,34 @@ export function getMtime(filePath: string): number {
   }
 }
 
+/**
+ * Composite change signature for a file — `mtimeMs:size:ino` — or `""` when the
+ * file is absent or can't be stat'd.
+ *
+ * Unlike {@link getMtime}, this detects a rewrite even when the filesystem's
+ * mtime resolution is too coarse to move the timestamp (or two rewrites land in
+ * the same timestamp granule). The source-versions sentinel is published via a
+ * temp-file + atomic rename, which swaps in a fresh inode on every write, so
+ * `ino` changes even when `mtimeMs` does not — and `size` shifts too whenever
+ * the plugin set does. Gating the reconcile on this signature (rather than
+ * mtime alone) is what lets a plugin installed at runtime go live on
+ * filesystems whose mtime granularity is coarse (virtiofs / 9p / network mounts
+ * — the same mounts the plugin-source watcher polls precisely because their
+ * timestamps are unreliable) instead of only after the next daemon restart.
+ *
+ * Change detection only — the exact numbers are never interpreted, so inode
+ * values above 2^53 losing float precision cannot cause a missed update: `mtime`
+ * and `size` still move on a real publish.
+ */
+export function getFileSignature(filePath: string): string {
+  try {
+    const st = statSync(filePath);
+    return `${st.mtimeMs}:${st.size}:${st.ino}`;
+  } catch {
+    return "";
+  }
+}
+
 /**
  * Evict `filePath` from the runtime module registry so the next dynamic
  * `import()` of that path re-evaluates the file from disk.