@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/documents/document-store.ts

@@ -6,7 +6,6 @@
  * without going through the HTTP layer.
  */
 import { rawAll, rawGet, rawRun } from "../persistence/raw-query.js";
-import { writeWorkspaceFile } from "../runtime/routes/workspace-utils.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("document-store");
@@ -24,18 +23,13 @@ export interface DocumentRecord {
   wordCount: number;
   createdAt: number;
   updatedAt: number;
-  /**
-   * Workspace-relative path of the markdown file this document is bound to,
-   * or `null` when the document has no file behind it.
-   */
-  workspacePath: string | null;
 }
 
 /**
- * The listing projection: neither the body nor the file binding, which the
- * list and search queries deliberately leave out of their SELECTs.
+ * The listing projection: everything but the body, which the list and search
+ * queries deliberately leave out of their SELECTs.
  */
-export type DocumentSummary = Omit<DocumentRecord, "content" | "workspacePath">;
+export type DocumentSummary = Omit<DocumentRecord, "content">;
 
 /** Words in a markdown body, the count the `word_count` column stores. */
 function countWords(content: string): number {
@@ -72,10 +66,9 @@ interface DocumentRow {
   word_count: number;
   created_at: number;
   updated_at: number;
-  workspace_path: string | null;
 }
 
-type DocumentListRow = Omit<DocumentRow, "content" | "workspace_path">;
+type DocumentListRow = Omit<DocumentRow, "content">;
 
 function escapeSqlLikePattern(value: string): string {
   return value.replace(/[\\%_]/g, "\\$&");
@@ -90,7 +83,6 @@ function mapRowToRecord(row: DocumentRow): DocumentRecord {
     wordCount: row.word_count,
     createdAt: row.created_at,
     updatedAt: row.updated_at,
-    workspacePath: row.workspace_path,
   };
 }
 
@@ -99,7 +91,7 @@ export function getDocumentById(surfaceId: string): DocumentRecord | null {
   try {
     const row = rawGet<DocumentRow>(
       "documents:getDocumentById",
-      /*sql*/ `SELECT surface_id, conversation_id, title, content, word_count, created_at, updated_at, workspace_path
+      /*sql*/ `SELECT surface_id, conversation_id, title, content, word_count, created_at, updated_at
        FROM documents
        WHERE surface_id = ?`,
       surfaceId,
@@ -118,29 +110,6 @@ export function getDocumentById(surfaceId: string): DocumentRecord | null {
   }
 }
 
-/**
- * Look up the document bound to a workspace file. `workspacePath` must be the
- * normalized workspace-relative path stored on the row. Returns `null` when no
- * document is bound to that file.
- */
-export function getDocumentByWorkspacePath(
-  workspacePath: string,
-): DocumentRecord | null {
-  try {
-    const row = rawGet<DocumentRow>(
-      "documents:getDocumentByWorkspacePath",
-      /*sql*/ `SELECT surface_id, conversation_id, title, content, word_count, created_at, updated_at, workspace_path
-       FROM documents
-       WHERE workspace_path = ?`,
-      workspacePath,
-    );
-    return row ? mapRowToRecord(row) : null;
-  } catch (error) {
-    log.error({ err: error, workspacePath }, "Load-by-workspace-path error");
-    return null;
-  }
-}
-
 /** Return true when a document is associated with a conversation. */
 export function isDocumentAssociatedWithConversation(
   surfaceId: string,
@@ -429,202 +398,6 @@ export function findInDocument(
   }
 }
 
-// ---------------------------------------------------------------------------
-// Workspace file binding
-// ---------------------------------------------------------------------------
-
-/**
- * Mirror `content` onto the workspace file a document is bound to.
- *
- * This is the single write-through choke point: every path that persists
- * document content — {@link saveDocument} (client save and `document_create`),
- * {@link updateDocumentContent} (`document_update`), and
- * {@link replaceInDocument} (`document_replace_text`) — calls it immediately
- * before its own row write, so a file-backed document's markdown on disk always
- * matches the stored row.
- *
- * The file is written first and a failure throws: a rejected write aborts the
- * update before the row changes rather than leaving the two silently diverged.
- * Documents with no file behind them are a no-op.
- */
-function writeThroughToWorkspaceFile(surfaceId: string, content: string): void {
-  const row = rawGet<{ workspace_path: string | null }>(
-    "documents:writeThroughToWorkspaceFile:getPath",
-    /*sql*/ `SELECT workspace_path FROM documents WHERE surface_id = ?`,
-    surfaceId,
-  );
-  const workspacePath = row?.workspace_path;
-  if (!workspacePath) {
-    return;
-  }
-
-  try {
-    writeWorkspaceFile(workspacePath, Buffer.from(content, "utf-8"));
-    log.info({ surfaceId, workspacePath }, "Wrote document through to file");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Failed to write file-backed document to ${workspacePath}: ${message}`,
-    );
-  }
-}
-
-/**
- * Create a document seeded from a workspace markdown file and bind it to that
- * file. The returned surface ID is the file's document identity — comments,
- * assistant iteration, and PDF export all key off it.
- *
- * The partial unique index on `workspace_path` makes a concurrent second
- * create fail rather than produce a duplicate binding; callers re-read by path
- * on failure.
- */
-export function createFileBackedDocument(params: {
-  surfaceId: string;
-  conversationId: string;
-  title: string;
-  content: string;
-  workspacePath: string;
-}): { success: true } | { success: false; error: string } {
-  try {
-    const now = Date.now();
-    rawRun(
-      "documents:createFileBackedDocument",
-      /*sql*/ `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at, workspace_path)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-      params.surfaceId,
-      params.conversationId,
-      params.title,
-      params.content,
-      countWords(params.content),
-      now,
-      now,
-      params.workspacePath,
-    );
-    addDocumentConversation(params.surfaceId, params.conversationId);
-    log.info(
-      { surfaceId: params.surfaceId, workspacePath: params.workspacePath },
-      "Created file-backed document",
-    );
-    return { success: true };
-  } catch (error) {
-    log.error(
-      { err: error, workspacePath: params.workspacePath },
-      "File-backed document create error",
-    );
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error",
-    };
-  }
-}
-
-/**
- * Move file-backed documents onto the path a workspace rename moved their file
- * to. `oldPath` and `newPath` are canonical workspace-relative paths, the same
- * form {@link createFileBackedDocument} stores.
- *
- * A document bound to `oldPath` itself moves, and so does every document nested
- * under it (`oldPath + "/"` prefix), which is what a directory rename produces.
- *
- * The rename on disk has already happened by the time this runs, so it is best
- * effort and never throws: the caller has no way to undo the rename, and a
- * document left on a stale path is recoverable while a failed rename response
- * is not. Rows move one statement at a time so a single row that cannot move
- * does not strand its siblings.
- *
- * A row whose destination is already taken by another binding is one such case:
- * the partial unique index on `workspace_path` rejects the update, and the
- * losing row keeps pointing at the old path. That is deliberate. Overwriting
- * the winner would drop a binding that a client may have open, whereas the
- * stale binding self-heals: opening the file refreshes the row's content from
- * disk, and a document whose file is gone is reported as gone rather than
- * rewritten from the row.
- */
-export function rebindDocumentsToRenamedPath(params: {
-  oldPath: string;
-  newPath: string;
-}): void {
-  const { oldPath, newPath } = params;
-  if (!oldPath || !newPath || oldPath === newPath) {
-    return;
-  }
-
-  try {
-    const rows = rawAll<{ surface_id: string; workspace_path: string }>(
-      "documents:rebindRenamedPath:select",
-      /*sql*/ `SELECT surface_id, workspace_path
-       FROM documents
-       WHERE workspace_path = ? OR workspace_path LIKE ? ESCAPE '\\'`,
-      oldPath,
-      `${escapeSqlLikePattern(oldPath)}/%`,
-    );
-
-    for (const row of rows) {
-      const rebound =
-        row.workspace_path === oldPath
-          ? newPath
-          : newPath + row.workspace_path.slice(oldPath.length);
-      try {
-        rawRun(
-          "documents:rebindRenamedPath:update",
-          /*sql*/ `UPDATE documents SET workspace_path = ? WHERE surface_id = ?`,
-          rebound,
-          row.surface_id,
-        );
-        log.info(
-          {
-            surfaceId: row.surface_id,
-            from: row.workspace_path,
-            to: rebound,
-          },
-          "Rebound file-backed document to renamed path",
-        );
-      } catch (error) {
-        log.warn(
-          {
-            err: error,
-            surfaceId: row.surface_id,
-            from: row.workspace_path,
-            to: rebound,
-          },
-          "Left file-backed document on its old path after a rename",
-        );
-      }
-    }
-  } catch (error) {
-    log.error({ err: error, oldPath, newPath }, "Path rebind error");
-  }
-}
-
-/**
- * Replace a document's stored content with the current text of the file it is
- * bound to. The file is the source of truth when a document is opened, so this
- * deliberately skips the write-through step — disk and row already agree.
- */
-export function refreshDocumentContentFromFile(
-  surfaceId: string,
-  content: string,
-): { success: true } | { success: false; error: string } {
-  try {
-    rawRun(
-      "documents:refreshDocumentContentFromFile",
-      /*sql*/ `UPDATE documents SET content = ?, word_count = ?, updated_at = ? WHERE surface_id = ?`,
-      content,
-      countWords(content),
-      Date.now(),
-      surfaceId,
-    );
-    log.info({ surfaceId }, "Refreshed document content from file");
-    return { success: true };
-  } catch (error) {
-    log.error({ err: error, surfaceId }, "Document refresh error");
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error",
-    };
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Document persistence
 // ---------------------------------------------------------------------------
@@ -637,7 +410,6 @@ export function saveDocument(params: {
   wordCount: number;
 }): { success: true; surfaceId: string } | { success: false; error: string } {
   try {
-    writeThroughToWorkspaceFile(params.surfaceId, params.content);
     const now = Date.now();
     rawRun(
       "documents:saveDocument",
@@ -773,7 +545,6 @@ export function replaceInDocument(
       replacementsMade = totalMatches;
     }
 
-    writeThroughToWorkspaceFile(surfaceId, newContent);
     const wordCount = countWords(newContent);
     rawRun(
       "documents:replaceInDocument:update",
@@ -798,12 +569,125 @@ export function replaceInDocument(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Append idempotency
+// ---------------------------------------------------------------------------
+
+/** A blank-line-delimited block of markdown, located in its source string. */
+interface MarkdownBlock {
+  /** Whitespace-trimmed block text, the unit duplicate detection compares. */
+  text: string;
+  /** Offset of the block's first character in the source string. */
+  start: number;
+}
+
+/**
+ * Split markdown into blank-line-delimited blocks, dropping empty ones but
+ * keeping each surviving block's offset so a suffix of the source can be
+ * recovered verbatim.
+ */
+function splitIntoBlocks(content: string): MarkdownBlock[] {
+  const blocks: MarkdownBlock[] = [];
+  const separator = /\n[^\S\n]*\n/g;
+  let cursor = 0;
+  let match: RegExpExecArray | null;
+  const push = (start: number, end: number): void => {
+    const text = content.slice(start, end).trim();
+    if (text.length > 0) {
+      blocks.push({ text, start });
+    }
+  };
+  while ((match = separator.exec(content)) !== null) {
+    push(cursor, match.index);
+    cursor = match.index + match[0].length;
+  }
+  push(cursor, content.length);
+  return blocks;
+}
+
+/**
+ * An append has to repeat at least this many characters of the document's tail
+ * before the repetition is treated as an accident.
+ *
+ * The floor is what keeps legitimate repetition intact. A document can honestly
+ * repeat a heading, a refrain, a table row, or a bare "TODO" back to back, and
+ * those are all short. Only a substantial restatement (an opening paragraph
+ * passed to both `document_create` and the first append) clears the bar.
+ */
+const MIN_DUPLICATE_APPEND_CHARS = 40;
+
+/**
+ * Drop a leading run of blocks from `markdown` that exactly repeats the tail of
+ * `existing`, so an append that restates content already committed does not
+ * write it a second time.
+ *
+ * The guard is deliberately narrow: the repeated run must be an exact,
+ * block-aligned match, it must sit at the very start of the append and the very
+ * end of the document, and it must be at least
+ * {@link MIN_DUPLICATE_APPEND_CHARS} long. Anything else, including the same
+ * text reappearing further down the append, is passed through untouched.
+ */
+function stripDuplicateLeadingBlocks(
+  existing: string,
+  markdown: string,
+): string {
+  const existingBlocks = splitIntoBlocks(existing);
+  const incomingBlocks = splitIntoBlocks(markdown);
+  const maxOverlap = Math.min(existingBlocks.length, incomingBlocks.length);
+
+  let overlap = 0;
+  for (let candidate = maxOverlap; candidate >= 1; candidate--) {
+    const offset = existingBlocks.length - candidate;
+    let matches = true;
+    for (let i = 0; i < candidate; i++) {
+      if (existingBlocks[offset + i].text !== incomingBlocks[i].text) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      overlap = candidate;
+      break;
+    }
+  }
+  if (overlap === 0) {
+    return markdown;
+  }
+
+  const duplicatedChars = incomingBlocks
+    .slice(0, overlap)
+    .reduce((total, block) => total + block.text.length, 0);
+  if (duplicatedChars < MIN_DUPLICATE_APPEND_CHARS) {
+    return markdown;
+  }
+
+  if (overlap === incomingBlocks.length) {
+    return "";
+  }
+  return markdown
+    .slice(incomingBlocks[overlap].start)
+    .replace(/^(?:[^\S\n]*\n)+/, "");
+}
+
+/** Outcome of a successful {@link updateDocumentContent} call. */
+export interface DocumentContentUpdated {
+  success: true;
+  /**
+   * The markdown that actually landed. Equals the submitted markdown except
+   * when an append's leading blocks duplicated the document's tail, in which
+   * case it is the remainder. Clients render this so their view matches the row.
+   */
+  appliedMarkdown: string;
+  /** True when a duplicated leading run was dropped from an append. */
+  duplicateLeadingContentSkipped: boolean;
+}
+
 /** Update persisted document content (append or replace). */
 export function updateDocumentContent(
   surfaceId: string,
   markdown: string,
   mode: string,
-): { success: true } | { success: false; error: string } {
+): DocumentContentUpdated | { success: false; error: string } {
   try {
     const existing = rawGet<{ content: string }>(
       "documents:updateDocumentContent:get",
@@ -814,10 +698,19 @@ export function updateDocumentContent(
       log.info({ surfaceId }, "No persisted document to update");
       return { success: false, error: "Document not found" };
     }
-    const sep = mode === "append" && existing.content.length > 0 ? "\n\n" : "";
-    const newContent =
-      mode === "append" ? existing.content + sep + markdown : markdown;
-    writeThroughToWorkspaceFile(surfaceId, newContent);
+    const appending = mode === "append";
+    const appliedMarkdown = appending
+      ? stripDuplicateLeadingBlocks(existing.content, markdown)
+      : markdown;
+    const duplicateLeadingContentSkipped =
+      appending && appliedMarkdown !== markdown;
+    const sep =
+      appending && existing.content.length > 0 && appliedMarkdown.length > 0
+        ? "\n\n"
+        : "";
+    const newContent = appending
+      ? existing.content + sep + appliedMarkdown
+      : appliedMarkdown;
     const wordCount = countWords(newContent);
     rawRun(
       "documents:updateDocumentContent:update",
@@ -827,8 +720,18 @@ export function updateDocumentContent(
       Date.now(),
       surfaceId,
     );
+    if (duplicateLeadingContentSkipped) {
+      log.info(
+        { surfaceId, skippedChars: markdown.length - appliedMarkdown.length },
+        "Skipped append content duplicating the document tail",
+      );
+    }
     log.info({ surfaceId, mode }, "Updated document content");
-    return { success: true };
+    return {
+      success: true,
+      appliedMarkdown,
+      duplicateLeadingContentSkipped,
+    };
   } catch (error) {
     log.error({ err: error, surfaceId }, "Document content update error");
     return {

package/src/hooks/hook-loader.ts

@@ -39,9 +39,9 @@
  * registry, so the next read re-resolves fresh.
  *
  * Plugin *discovery* (which plugin directories exist, in what order) lives in
- * `../plugins/mtime-cache.ts`; the orchestrator there passes the discovered
- * directories into {@link collectUserHookEntries}. Keeping discovery out of
- * this module lets it sit below the plugin cache with no import cycle.
+ * `../plugins/mtime-cache.ts`; hook lookup in `./registry.ts` passes the
+ * discovered names into {@link collectUserHookEntries}. Keeping discovery out
+ * of this module lets it sit below the plugin cache with no import cycle.
  */
 
 import {

package/src/hooks/registry.ts

@@ -6,20 +6,25 @@
  * hook-chain ordering.
  *
  * User-land hooks (from the filesystem) are owned by
- * {@link ./hook-loader.ts} and surfaced through `getUserHooksFor` in
- * `plugins/mtime-cache.ts`. This module owns only the in-process hooks that
- * default plugins register at boot.
+ * {@link ./hook-loader.ts} and surfaced through {@link getUserHooksFor}.
+ * This module owns the in-process hooks that default plugins register at
+ * boot, plus the user-land lookup that walks discovered plugin names from
+ * the plugin cache.
  *
- * {@link getHooksFor} combines both sources: in-process hooks from this
- * registry (filtered by `isPluginDisabled` at read time) and user-land hooks
- * from the plugin cache. The read-time filtering 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.
+ * {@link getHooksFor} and {@link getUserHooksFor} both resolve through
+ * {@link getUserHookEntriesFor}, which prepends in-process default-plugin
+ * hooks from this registry (filtered by `isPluginDisabled` at read time)
+ * ahead of user-land hooks from the plugin cache. The read-time filtering
+ * 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.
  */
 
+import { isFirstPartyDefaultPlugin } from "../plugins/defaults/main.js";
 import { isPluginDisabled } from "../plugins/disabled-state.js";
-import { getUserHookEntriesFor } from "../plugins/mtime-cache.js";
+import { getDiscoveredUserPluginNames } from "../plugins/mtime-cache.js";
 import type { HookEntry, HookFunction } from "../plugins/types.js";
+import { collectUserHookEntries } from "./hook-loader.js";
 
 // ─── Internal state ──────────────────────────────────────────────────────────
 
@@ -75,6 +80,87 @@ export function unregisterPluginHooks(pluginName: string): void {
 
 // ─── Queries ─────────────────────────────────────────────────────────────────
 
+/**
+ * In-process (default plugin) hook entries for `name`, filtered by the
+ * `.disabled` sentinel at read time. First-party default plugins always pass
+ * the per-chat allowlist; other in-process registrations (test fixtures) honor
+ * it. Used by {@link getUserHookEntriesFor} so `getUserHooksFor` returns the
+ * same default-plugin hooks {@link getHooksFor} does.
+ */
+function collectInProcessHookEntries<TCtx = unknown>(
+  name: string,
+  effectiveEnabledPlugins?: Set<string> | null,
+): HookEntry<TCtx>[] {
+  const defaultEntries: HookEntry<TCtx>[] = [];
+  for (const entry of hookRegistry.get(name) ?? []) {
+    if (isPluginDisabled(entry.pluginName)) {
+      continue;
+    }
+    if (
+      effectiveEnabledPlugins != null &&
+      !effectiveEnabledPlugins.has(entry.pluginName) &&
+      !isFirstPartyDefaultPlugin(entry.pluginName)
+    ) {
+      continue;
+    }
+    defaultEntries.push({
+      fn: entry.fn as HookFunction<TCtx>,
+      owner: { kind: "plugin", id: entry.pluginName },
+    });
+  }
+  return defaultEntries;
+}
+
+/**
+ * Get all hooks for a given event name: in-process default-plugin hooks
+ * first, then user plugins and standalone workspace hooks. Plugin hooks run
+ * in install-date order, the workspace hook runs last.
+ *
+ * Default-plugin hooks come from the in-process registry (registration at
+ * boot). User-land hooks are a pure cache read: this never scans disk,
+ * activates a plugin, or runs `init`. Activation happens only at boot
+ * (`populateCacheAtBoot`) and through the imperative install/uninstall
+ * poke (`reconcilePluginSourcesNow`), both main-daemon paths, so a
+ * sidecar process that dispatches hooks (a worker running conversation
+ * turns) can never bring a plugin up in its own process.
+ *
+ * `effectiveEnabledPlugins` carries the per-chat plugin scope: when non-null,
+ * user plugins outside the set are skipped. First-party default plugins
+ * always pass that allowlist (a workspace `.disabled` sentinel still
+ * excludes them). Standalone workspace hooks always run. `null`/omitted
+ * means no per-chat restriction.
+ */
+export async function getUserHookEntriesFor<TCtx = unknown>(
+  hookName: string,
+  effectiveEnabledPlugins?: Set<string> | null,
+): Promise<HookEntry<TCtx>[]> {
+  const defaultEntries = collectInProcessHookEntries<TCtx>(
+    hookName,
+    effectiveEnabledPlugins,
+  );
+  const userEntries = await collectUserHookEntries<TCtx>(
+    hookName,
+    getDiscoveredUserPluginNames(),
+    effectiveEnabledPlugins,
+  );
+  return [...defaultEntries, ...userEntries];
+}
+
+/**
+ * {@link getUserHookEntriesFor} without owner attribution. Returns just the
+ * hook functions in the same order, including in-process default-plugin hooks.
+ */
+export async function getUserHooksFor<TCtx = unknown>(
+  hookName: string,
+  effectiveEnabledPlugins?: Set<string> | null,
+): Promise<HookFunction<TCtx>[]> {
+  const entries = await getUserHookEntriesFor<TCtx>(
+    hookName,
+    effectiveEnabledPlugins,
+  );
+  return entries.map((e) => e.fn);
+}
+
 /**
  * Collect every registered hook for the given name, in registration order.
  * Plugins that don't declare a hook for `name` are skipped. Used by the
@@ -87,17 +173,19 @@ export function unregisterPluginHooks(pluginName: string): void {
  * (async, pure cache read). Default hooks are prepended so they compose
  * innermost, ahead of any user plugins.
  *
- * The `TCtx` generic mirrors {@link HookFunction}'s — callers parameterize
+ * 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.
  *
  * When `conversationId` is given, the conversation's effective plugin scope is
  * resolved from it (memory, then DB) and layered on top of the global disabled
- * check: a hook's contributing plugin must also be a member of that set or the
- * hook is excluded for this turn (applies to both in-process default plugins
- * and user-land plugins). Omit it (or pass a conversation with no per-chat
- * restriction) and every globally-enabled plugin's hooks run, unchanged.
+ * check: a user plugin must also be a member of that set or its hook is
+ * excluded for this turn. First-party default plugins are not subject to the
+ * per-chat allowlist (they are core runtime infrastructure; the chat pills
+ * only list user-installed plugins), but a workspace `.disabled` sentinel
+ * still excludes them. Omit `conversationId` (or pass a conversation with no
+ * per-chat restriction) and every globally-enabled plugin's hooks run.
  */
 export async function getHookEntriesFor<TCtx = unknown>(
   name: string,
@@ -116,37 +204,7 @@ export async function getHookEntriesFor<TCtx = unknown>(
       options.conversationId,
     );
   }
-  // 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 defaultEntries: HookEntry<TCtx>[] = [];
-  for (const entry of hookRegistry.get(name) ?? []) {
-    if (isPluginDisabled(entry.pluginName)) {
-      continue;
-    }
-    if (
-      effectiveEnabledPlugins != null &&
-      !effectiveEnabledPlugins.has(entry.pluginName)
-    ) {
-      continue;
-    }
-    defaultEntries.push({
-      fn: entry.fn as HookFunction<TCtx>,
-      owner: { kind: "plugin", id: entry.pluginName },
-    });
-  }
-
-  // User-land hooks from the plugin cache (async, pure cache read; dispatch
-  // never activates plugins). The per-chat
-  // scope is threaded through so a deselected user plugin's hooks are excluded
-  // too — standalone workspace hooks (not owned by a plugin) always run.
-  const userEntries = await getUserHookEntriesFor<TCtx>(
-    name,
-    effectiveEnabledPlugins,
-  );
-
-  return [...defaultEntries, ...userEntries];
+  return getUserHookEntriesFor<TCtx>(name, effectiveEnabledPlugins);
 }
 
 /**

package/src/hooks/types.ts

@@ -173,6 +173,11 @@ export interface UserPromptSubmitInputContext {
    * user speech (e.g. title generation) should skip these turns.
    */
   readonly isHiddenPrompt?: boolean;
+  /**
+   * Daemon-authored kind from the triggering row's `metadata.messageKind`,
+   * when the turn needs a more specific identity than role or visibility.
+   */
+  readonly messageKind?: string;
   /**
    * The user's original message list, immutable for the hook. Plugins
    * may snapshot or compare against this but MUST NOT mutate it.