@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/plugins/defaults/memory/v3/selection-log-store.ts

@@ -20,6 +20,7 @@ import type { MemoryV3SelectionLog } from "../../../../api/responses/memory-v3-s
 import { getConfig } from "../../../../config/loader.js";
 import { isMemoryV3Live } from "../../../../config/memory-v3-gate.js";
 import { getDb, getSqliteFrom } from "../../../../persistence/db-connection.js";
+import { memorySqliteOrNull } from "../memory-db.js";
 import { getWorkspaceDir } from "../paths.js";
 import { readPage } from "../v2/page-store.js";
 import { capabilityOrDiskBody } from "./capabilities.js";
@@ -46,7 +47,11 @@ interface SelectionRow {
 const SELECTION_COLUMNS = `turn, slug, source, pinned, section_ordinal, section_title`;
 
 function rowsForTurn(conversationId: string, turn: number): SelectionRow[] {
-  return getSqliteFrom(getDb())
+  const raw = memorySqliteOrNull("rowsForTurn");
+  if (!raw) {
+    return [];
+  }
+  return raw
     .query(
       /*sql*/ `
       SELECT ${SELECTION_COLUMNS} FROM memory_v3_selections
@@ -59,8 +64,12 @@ function rowsForTurn(conversationId: string, turn: number): SelectionRow[] {
 
 function rowsForMessageIds(messageIds: string[]): SelectionRow[] {
   if (messageIds.length === 0) return [];
+  const raw = memorySqliteOrNull("rowsForMessageIds");
+  if (!raw) {
+    return [];
+  }
   const placeholders = messageIds.map(() => "?").join(", ");
-  return getSqliteFrom(getDb())
+  return raw
     .query(
       /*sql*/ `
       SELECT ${SELECTION_COLUMNS} FROM memory_v3_selections
@@ -249,18 +258,21 @@ function isSelectionSource(source: string): source is SelectionSource {
 }
 
 export function summarizeSelections(conversationId: string): SelectionSummary {
-  const rows = getSqliteFrom(getDb())
-    .query(
-      /*sql*/ `
+  const raw = memorySqliteOrNull("summarizeSelections");
+  const rows = raw
+    ? (raw
+        .query(
+          /*sql*/ `
       SELECT turn, slug, source FROM memory_v3_selections
       WHERE conversation_id = ?
     `,
-    )
-    .all(conversationId) as Array<{
-    turn: number;
-    slug: string;
-    source: string;
-  }>;
+        )
+        .all(conversationId) as Array<{
+        turn: number;
+        slug: string;
+        source: string;
+      }>)
+    : [];
 
   const bySource = Object.fromEntries(
     SELECTION_SOURCES.map((source) => [source, 0]),

package/src/plugins/defaults/memory/v3/shadow-plugin.ts

@@ -30,9 +30,9 @@ import {
 
 import { getConfig } from "../../../../config/loader.js";
 import type { AssistantConfig } from "../../../../config/schema.js";
-import { getDb, getSqliteFrom } from "../../../../persistence/db-connection.js";
 import { stripCommentLines } from "../host-utils.js";
 import { getLogger } from "../logging.js";
+import { memorySqliteOrNull } from "../memory-db.js";
 import { getWorkspaceDir, getWorkspacePromptPath } from "../paths.js";
 import { getPageIndex } from "../v2/page-index.js";
 import { readPage, renderPageContent } from "../v2/page-store.js";
@@ -229,15 +229,12 @@ async function initLanes(config: AssistantConfig): Promise<ShadowLanes> {
   const coreSlugs = loadCoreSet(getWorkspaceDir()).filter((slug) =>
     sectionIndex.byArticle.has(slug),
   );
-  const hotSlugs = computeHotSet(
-    { db: getDb() },
-    {
-      k: tuning.hotSetK,
-      halfLifeMs: config.memory.v3.hotSet.halfLifeDays * DAY_MS,
-      now: Date.now(),
-      excludeSlugs: new Set(coreSlugs),
-    },
-  )
+  const hotSlugs = computeHotSet({
+    k: tuning.hotSetK,
+    halfLifeMs: config.memory.v3.hotSet.halfLifeDays * DAY_MS,
+    now: Date.now(),
+    excludeSlugs: new Set(coreSlugs),
+  })
     .map((entry) => entry.slug)
     .filter((slug) => sectionIndex.byArticle.has(slug));
 
@@ -320,18 +317,15 @@ async function initLanes(config: AssistantConfig): Promise<ShadowLanes> {
   const learned = config.memory.v3.learnedEdges;
   const learnedGraph =
     tuning.learnedEdgesCap > 0 && learned.maxPerPage > 0
-      ? computeLearnedEdgeGraph(
-          { db: getDb() },
-          {
-            halfLifeMs: learned.halfLifeDays * DAY_MS,
-            minCount: learned.minCount,
-            npmiFloor: learned.npmiFloor,
-            maxPerPage: learned.maxPerPage,
-            now: Date.now(),
-            windowMs: LEARNED_EDGES_WINDOW_DAYS * DAY_MS,
-            knownSlugs: new Set(sectionIndex.byArticle.keys()),
-          },
-        )
+      ? computeLearnedEdgeGraph({
+          halfLifeMs: learned.halfLifeDays * DAY_MS,
+          minCount: learned.minCount,
+          npmiFloor: learned.npmiFloor,
+          maxPerPage: learned.maxPerPage,
+          now: Date.now(),
+          windowMs: LEARNED_EDGES_WINDOW_DAYS * DAY_MS,
+          knownSlugs: new Set(sectionIndex.byArticle.keys()),
+        })
       : undefined;
   // Ensuring the dense collection is best-effort: the needle + edge lanes and
   // the core/hot prefix are in-memory and independent of Qdrant, so a Qdrant outage
@@ -530,7 +524,11 @@ export function attributeSelections(result: OrchestrateResult): SelectionRow[] {
   });
 }
 
-/** Write the attributed selection rows to `memory_v3_selections`. */
+/**
+ * Write the attributed selection rows to `memory_v3_selections` over the
+ * dedicated memory connection. Best-effort: an unavailable memory database or
+ * a failed write drops the turn's log rows rather than affecting the turn.
+ */
 export function writeSelections(
   conversationId: string,
   turn: number,
@@ -539,30 +537,37 @@ export function writeSelections(
   if (rows.length === 0) {
     return;
   }
-  const raw = getSqliteFrom(getDb());
-  // PK is (conversation_id, turn, slug); OR REPLACE keeps the write
-  // idempotent if the same turn is observed twice (e.g. a retried turn).
-  // `message_id` is written NULL here (the assistant message does not exist at
-  // injection time) and stamped at turn end by
-  // `backfillMemoryV3SelectionMessageId`.
-  const stmt = raw.query(/*sql*/ `
-    INSERT OR REPLACE INTO memory_v3_selections (
-      conversation_id, turn, slug, source, pinned, created_at,
-      message_id, section_ordinal, section_title
-    ) VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)
-  `);
-  const now = Date.now();
-  for (const row of rows) {
-    stmt.run(
-      conversationId,
-      turn,
-      row.slug,
-      row.source,
-      row.pinned,
-      now,
-      row.sectionOrdinal,
-      row.sectionTitle,
-    );
+  try {
+    const raw = memorySqliteOrNull("writeSelections");
+    if (!raw) {
+      return;
+    }
+    // PK is (conversation_id, turn, slug); OR REPLACE keeps the write
+    // idempotent if the same turn is observed twice (e.g. a retried turn).
+    // `message_id` is written NULL here (the assistant message does not exist
+    // at injection time) and stamped at turn end by
+    // `backfillMemoryV3SelectionMessageId`.
+    const stmt = raw.query(/*sql*/ `
+      INSERT OR REPLACE INTO memory_v3_selections (
+        conversation_id, turn, slug, source, pinned, created_at,
+        message_id, section_ordinal, section_title
+      ) VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)
+    `);
+    const now = Date.now();
+    for (const row of rows) {
+      stmt.run(
+        conversationId,
+        turn,
+        row.slug,
+        row.source,
+        row.pinned,
+        now,
+        row.sectionOrdinal,
+        row.sectionTitle,
+      );
+    }
+  } catch (err) {
+    log.warn({ err }, "failed to write memory-v3 selections; continuing");
   }
 }
 
@@ -579,12 +584,23 @@ export function backfillMemoryV3SelectionMessageId(
   conversationId: string,
   assistantMessageId: string,
 ): void {
-  getSqliteFrom(getDb())
-    .query(
-      /*sql*/ `UPDATE memory_v3_selections SET message_id = ?
-               WHERE conversation_id = ? AND message_id IS NULL`,
-    )
-    .run(assistantMessageId, conversationId);
+  try {
+    const raw = memorySqliteOrNull("backfillMemoryV3SelectionMessageId");
+    if (!raw) {
+      return;
+    }
+    raw
+      .query(
+        /*sql*/ `UPDATE memory_v3_selections SET message_id = ?
+                 WHERE conversation_id = ? AND message_id IS NULL`,
+      )
+      .run(assistantMessageId, conversationId);
+  } catch (err) {
+    log.warn(
+      { err },
+      "failed to backfill memory-v3 selection messageId; continuing",
+    );
+  }
 }
 
 /**
@@ -633,6 +649,7 @@ export async function observeTurn(
       prefixCards: lanes.prefixCards,
       needleK: tuning.needleK,
       denseK: tuning.denseK,
+      realConceptPageCount: lanes.realConceptPageCount,
       entityCap: v3.entity.cap,
       replyQueryK: tuning.replyQueryK,
       edgeSeeds: tuning.edgeSeedCount,

package/src/plugins/defaults/surface-completion-nudge/hooks/post-model-call.ts

@@ -45,11 +45,12 @@
  * the `post-model-call` chain — later hooks see (and may override) its decision.
  */
 
-import type {
-  ContentBlock,
-  HookFunction,
-  Message,
-  PostModelCallContext,
+import {
+  type ContentBlock,
+  type HookFunction,
+  INTERNAL_NUDGE_OUTPUT_SUPPRESSION,
+  type Message,
+  type PostModelCallContext,
 } from "@vellumai/plugin-api";
 
 import {
@@ -64,7 +65,9 @@ import {
  * is genuinely still running.
  */
 export const SURFACE_COMPLETION_NUDGE_TEXT =
-  '<system_notice>You showed the user a progress surface this turn (a task_progress card or a work_result) and are about to end the turn with it still marked in_progress. If that work is finished, advance it to a terminal state now — call ui_update to set its status to "completed" (or "failed"), or ui_dismiss it — so the user is not left watching a card spin forever. Do this only if the work it represents is actually done; if it is genuinely still running, leave it. Then give your final reply.</system_notice>';
+  '<system_notice>You showed the user a progress surface this turn (a task_progress card or a work_result) and are about to end the turn with it still marked in_progress. If that work is finished, advance it to a terminal state now — call ui_update to set its status to "completed" (or "failed"), or ui_dismiss it — so the user is not left watching a card spin forever. Do this only if the work it represents is actually done; if it is genuinely still running, leave it. Then give your final reply.' +
+  INTERNAL_NUDGE_OUTPUT_SUPPRESSION +
+  "</system_notice>";
 
 /**
  * Surface statuses that mean the progress surface has reached a terminal state

package/src/plugins/external-plugin-loader.ts

@@ -42,7 +42,7 @@
 
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { pathToFileURL } from "node:url";
 
 import semver from "semver";
@@ -100,15 +100,6 @@ export interface LoadExternalPluginOptions {
   readonly importTimeoutMs?: number;
 }
 
-/**
- * Strip the npm scope from a package name. `@vellumai/simple-memory` →
- * `simple-memory`; an unscoped name passes through unchanged.
- */
-export function stripScope(name: string): string {
-  const match = /^@[^/]+\/(.+)$/.exec(name);
-  return match ? match[1]! : name;
-}
-
 export function toToolNameSegment(value: string): string {
   return value.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "tool";
 }
@@ -229,7 +220,15 @@ async function buildPluginFromDir(pluginDir: string): Promise<Plugin> {
     );
   }
   const pkg: PluginPackageJson = parsed.data;
-  const name = stripScope(pkg.name);
+  // A plugin's identity is its install directory name — the slug the plugin
+  // was installed under (a marketplace slug or a GitHub path leaf). This is
+  // the identity every other surface uses: `plugins list`, enable/disable,
+  // per-conversation plugin scoping, and resident-skill `owner.id`. The
+  // `package.json` `name` is authored by the plugin and routinely differs
+  // from the slug, so keying runtime registration off it would desync the
+  // registry from the identity the user toggles and the scope filters match.
+  // The manifest is still required (schema-validated above) as the load gate.
+  const name = basename(pluginDir);
   const version = pkg.version && pkg.version.length > 0 ? pkg.version : "0.0.0";
 
   // Host-compat negotiation: plugins declare their plugin-api version
@@ -381,11 +380,12 @@ export async function loadExternalPlugin(
 
 /**
  * Parse a plugin's `package.json` manifest from disk. Returns the plugin
- * name (scope-stripped) and version, or `undefined` when the file is
- * missing, unparseable, or fails schema validation.
+ * identity (its install directory name) and version, or `undefined` when the
+ * `package.json` is missing, unparseable, or fails schema validation.
  *
  * Exported so the mtime cache can discover plugin identity without going
- * through the full `buildExternalPlugin` path.
+ * through the full `buildExternalPlugin` path. The identity mirrors
+ * {@link buildPluginFromDir}: the directory name, not `package.json` `name`.
  */
 export async function parsePluginManifest(
   pluginDir: string,
@@ -411,7 +411,7 @@ export async function parsePluginManifest(
     return undefined;
   }
   const pkg: PluginPackageJson = parsed.data;
-  const name = stripScope(pkg.name);
+  const name = basename(pluginDir);
   const version = pkg.version && pkg.version.length > 0 ? pkg.version : "0.0.0";
   return { name, version };
 }

package/src/plugins/mtime-cache.ts

@@ -58,6 +58,7 @@ import {
   getWorkspaceHooksDir,
   getWorkspacePluginsDir,
 } from "../util/platform.js";
+import { collectSourceVersions } from "./collect-source-versions.js";
 import {
   deriveToolName,
   listSurfaceDir,
@@ -308,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

package/src/plugins/pipeline.ts

@@ -25,6 +25,7 @@ import { getHookEntriesFor } from "../hooks/registry.js";
 import type { BaseHookContext } from "../hooks/types.js";
 import { type HookName, HOOKS } from "../plugin-api/constants.js";
 import { getLogger } from "../util/logger.js";
+import { runInPluginContext } from "./plugin-execution-context.js";
 import type { HookEntry } from "./types.js";
 
 // ─── Hook runner ────────────────────────────────────────────────────────────
@@ -352,8 +353,15 @@ export async function runHook<TInput extends object>(
       broadcast: makeHookBroadcast({ conversationId, hookName: name, owner }),
     };
     try {
+      // Mark the contributing plugin as in context so host APIs the hook
+      // reaches (e.g. resolveCredential) can scope to it. Standalone workspace
+      // hooks are not plugins and establish no context.
+      const invokeHook =
+        owner.kind === "plugin"
+          ? () => runInPluginContext(owner.id, () => fn(draft))
+          : () => fn(draft);
       const result = await callWithTimeout(
-        () => fn(draft),
+        invokeHook,
         HOOK_TIMEOUT_MS,
         `plugin hook '${name}' (${owner.id}) timed out after ${HOOK_TIMEOUT_MS}ms`,
       );

package/src/plugins/plugin-execution-context.ts

@@ -0,0 +1,44 @@
+/**
+ * Plugin execution context — tracks which plugin's code is currently running.
+ *
+ * Host APIs exposed to plugins through `@vellumai/plugin-api` sometimes need to
+ * know *which* plugin is calling them so they can scope their behavior to that
+ * plugin (e.g. {@link ../plugin-api/resolve-credential.resolveCredential} limits
+ * a plugin to its own credentials). A plugin's manifest name is not threaded
+ * through every host call, so the pipeline that invokes a plugin's hook — and
+ * the tool executor that runs a plugin's tool — mark the plugin as "in context"
+ * for the duration of that invocation via an {@link AsyncLocalStorage}. Host
+ * APIs read {@link getCurrentPluginName} to recover it.
+ *
+ * The store propagates across `await` boundaries, so a plugin that awaits a
+ * host API deep inside its hook/tool body is still seen as in context. When no
+ * plugin is in context (host-internal callers, the CLI, tests), the store is
+ * empty and scoped APIs fall back to their unscoped behavior.
+ */
+
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export interface PluginExecutionContext {
+  /** Manifest name of the plugin whose hook or tool is currently executing. */
+  pluginName: string;
+}
+
+const storage = new AsyncLocalStorage<PluginExecutionContext>();
+
+/**
+ * Run `fn` with `pluginName` marked as the plugin currently in context. The
+ * returned value (including a promise) carries the context across its async
+ * continuations, so callers pass the promise straight to a timeout wrapper
+ * without losing the binding.
+ */
+export function runInPluginContext<T>(pluginName: string, fn: () => T): T {
+  return storage.run({ pluginName }, fn);
+}
+
+/**
+ * Name of the plugin whose hook or tool is currently executing, or `undefined`
+ * when no plugin is in context.
+ */
+export function getCurrentPluginName(): string | undefined {
+  return storage.getStore()?.pluginName;
+}

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

@@ -41,10 +41,10 @@ export const PRESERVED_ENTRIES = [
 ] as const;
 
 /**
- * A generated app build directory: `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 every fingerprint walk excludes
- * it:
+ * 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
@@ -52,27 +52,24 @@ export const PRESERVED_ENTRIES = [
  * - the **install/drift** fingerprint (`../cli/lib/plugin-fingerprint.ts`), so
  *   generated output is not reported as drift/added against the pinned commit.
  *
- * Scoped to `apps/<app>/dist` specifically — a plugin's own top-level `dist/`
- * (if it ships built code its hooks import) is still tracked.
+ * 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 function isGeneratedAppBuildDir(relDir: string): boolean {
-  const parts = relDir.split("/");
-  return parts.length === 3 && parts[0] === "apps" && parts[2] === "dist";
-}
+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>;
-  /** Directory names skipped at any depth (e.g. `node_modules`). */
-  readonly excludeDirsAnywhere?: ReadonlySet<string>;
   /**
-   * Skip a directory (and its whole subtree) by its POSIX path relative to the
-   * walk root. Called for each directory before descending — use for
-   * path-scoped exclusions a bare directory name can't express (e.g. generated
-   * `apps/<app>/dist`, via {@link isGeneratedAppBuildDir}).
+   * 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 excludeDir?: (relDir: string) => boolean;
+  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. */
   readonly excludeDotEntries?: boolean;
   /**
@@ -94,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;
@@ -109,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(".")) {
@@ -119,13 +126,13 @@ 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;
         }
-        if (options.excludeDir?.(rel) === true) {
-          continue;
-        }
         walk(rel);
       } else if (entry.isFile()) {
         visit(rel, join(absDir, name));

package/src/plugins/source-fingerprint.ts

@@ -19,7 +19,7 @@
  * Exclusions: dot-entries anywhere (`.disabled`, `.git`, …), `node_modules`
  * anywhere (vendored deps change only through install flows, which recycle
  * the plugin directory), generated app build output ({@link
- * isGeneratedAppBuildDir}, so the watcher's own compile does not re-trigger a
+ * 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
@@ -33,7 +33,7 @@
 import { realpathSync, statSync } from "node:fs";
 
 import {
-  isGeneratedAppBuildDir,
+  GENERATED_APP_BUILD_DIR,
   PRESERVED_ENTRIES,
   walkPluginTree,
 } from "./plugin-tree-walk.js";
@@ -82,9 +82,8 @@ export function snapshotPluginSource(pluginDir: string): SourceSnapshot {
   walkPluginTree(
     realRoot,
     {
-      excludeRootEntries: PRESERVED_ENTRIES,
+      excludeRootEntries: [...PRESERVED_ENTRIES, GENERATED_APP_BUILD_DIR],
       excludeDirsAnywhere: EXCLUDED_DIRS_ANYWHERE,
-      excludeDir: isGeneratedAppBuildDir,
       excludeDotEntries: true,
       bestEffort: true,
     },

package/src/prompts/normalize-onboarding.ts

@@ -85,6 +85,8 @@ export interface NormalizedOnboarding {
   occupation?: string;
   commonWork: string[];
   dailyTools: string[];
+  /** User-confirmed findings from onboarding research; absent when none. */
+  researchFindings?: string[];
   tone?: string;
   assistantName?: string;
   priorAssistants?: string[];
@@ -127,6 +129,16 @@ export function normalizeOnboardingContext(
     occupation: ctx.occupation?.trim() || undefined,
     commonWork: normalizeTasks(ctx.tasks),
     dailyTools: normalizeTools(ctx.tools),
+    // Findings are model-extracted from arbitrary web content and get written
+    // into persisted persona markdown as single bullets. Collapse ALL runs of
+    // whitespace (incl. newlines) so one finding can never mint extra lines —
+    // injected bullets, headings, or a `## ` that would corrupt the managed
+    // section boundary on later rewrites.
+    researchFindings: ctx.researchFindings?.length
+      ? ctx.researchFindings
+          .map((finding) => finding.replace(/\s+/g, " ").trim())
+          .filter(Boolean)
+      : undefined,
     tone: ctx.tone,
     assistantName: ctx.assistantName,
     googleConnected: ctx.googleConnected,

package/src/prompts/persona-resolver.ts

@@ -421,6 +421,14 @@ function buildOnboardingSection(normalized: NormalizedOnboarding): string {
   if (normalized.dailyTools.length > 0) {
     lines.push(`- **Daily tools:** ${normalized.dailyTools.join(", ")}`);
   }
+  if (normalized.researchFindings?.length) {
+    lines.push(
+      "- **Research findings** (surfaced during onboarding, confirmed by the user):",
+    );
+    for (const finding of normalized.researchFindings) {
+      lines.push(`  - ${finding}`);
+    }
+  }
 
   lines.push("");
   return lines.join("\n");

package/src/prompts/templates/BOOTSTRAP-ACTIVATION-RAIL.md

@@ -83,7 +83,7 @@ These are enforcement rules, not advice.
 
 Identity writes (IDENTITY.md, SOUL.md), user-profile writes, journal entries: all wait until the rail produces real signal, which is Moment 1 output at the earliest. None of them delay a user-visible response. None of them happen alongside the opening turn.
 
-The base BOOTSTRAP task_preferences fallback is not on this rail. Your opener is the Port pitch.
+Your opener is the Port pitch — no other intake surface precedes it.
 
 ## Telemetry: tag your `ui_show` surfaces