@vellumai/assistant 0.8.8 → 0.8.9-staging.2

package/src/plugins/defaults/memory-retrieval/hooks/user-prompt-submit-temp.ts

@@ -1,75 +1,107 @@
 /**
- * Default `user-prompt-submit-temp` hook: runs the memory-graph retrieval the
- * agent loop needs before building a turn's runtime-injection block.
+ * Default `user-prompt-submit-temp` hook: prepares a turn's prompt before the
+ * first provider call by running memory-graph retrieval and then applying the
+ * runtime injections that assemble the turn.
  *
  * **Memory graph** via {@link ConversationGraphMemory.prepareMemory} —
  * dispatches to context-load or per-turn retrieval depending on initialization
- * state; gated on the actor being trusted (guardian).
+ * state; gated on the actor being trusted (guardian). The hook owns the
+ * retrieval's side effects — persisting the injected block onto the user
+ * message's metadata, writing the recall log, and emitting the
+ * `memory_recalled` event. The PKB query-vector pair is recorded on the
+ * conversation's graph handle for the PKB-reminder injector to read back. PKB
+ * context and NOW.md are sourced directly by their injectors (gated on block
+ * presence), not produced here.
  *
- * The hook also owns the retrieval's side effects — persisting the injected
- * block onto the user message's metadata, writing the recall log, and emitting
- * the `memory_recalled` event — so the loop only consumes the turn-scoped
- * `latestMessages` written back onto the context. The PKB query-vector pair is
- * recorded on the conversation's graph handle for the PKB-reminder injector to
- * read back. PKB context and NOW.md are sourced directly by their injectors
- * (gated on block presence), not produced here.
+ * **Runtime injection** via {@link applyRuntimeInjections} — runs for every
+ * actor (not just trusted ones) on the retrieved history, assembling the Slack
+ * chronological transcript, the unified `<turn_context>` block,
+ * channel/voice/transport hints, and the NOW.md / PKB / memory-v2 / workspace
+ * blocks, then persisting the assembled blocks onto the user message's metadata
+ * so they survive reloads. This is the first-call counterpart of the
+ * post-compaction hook, which re-applies the same injections after a mid-loop
+ * compaction.
  *
  * This fires at the early "prompt submitted, before context assembly" moment,
- * distinct from the canonical late `user-prompt-submit` hook (history repair,
- * title): memory's outputs feed the injection and overflow-reduction transforms
- * that run between the two moments. The `-temp` suffix marks this as a
- * transitional staging point that folds into `user-prompt-submit` once
+ * ahead of the canonical late `user-prompt-submit` hook (history repair,
+ * title), which normalizes the assembled history after the overflow-reduction
+ * transform that runs between the two moments. The `-temp` suffix marks this as
+ * a transitional staging point that folds into `user-prompt-submit` once
  * compaction is cleared from the gap between the two call sites.
  */
 
 import type { PluginHookFn } from "@vellumai/plugin-api";
 import type { Logger } from "pino";
 
-import type { AssistantConfig } from "../../../../config/schema.js";
+import { getConfig } from "../../../../config/loader.js";
+import { findConversationOrSubagent } from "../../../../daemon/conversation-registry.js";
+import {
+  applyRuntimeInjections,
+  type InboundActorContext,
+  type InjectionMode,
+  type RuntimeInjectionResult,
+} from "../../../../daemon/conversation-runtime-assembly.js";
 import type { ServerMessage } from "../../../../daemon/message-protocol.js";
 import type { MemoryRecalled } from "../../../../daemon/message-types/memory.js";
+import { resolveTrustClass } from "../../../../daemon/trust-context.js";
 import { updateMessageMetadata } from "../../../../memory/conversation-crud.js";
-import type { ConversationGraphMemory } from "../../../../memory/graph/conversation-graph-memory.js";
 import { recordMemoryRecallLog } from "../../../../memory/memory-recall-log-store.js";
 import type { Message } from "../../../../providers/types.js";
 import type { GraphMemoryResult } from "../../../types.js";
 
 /**
- * Context threaded through the `user-prompt-submit-temp` hook. The readonly
- * fields carry the conversation-scoped state the retriever needs (graph
- * handle, event sink, abort signal); the output fields are populated by the
- * hook and read back by the agent loop. `latestMessages` straddles both: the
- * loop seeds it with the pre-injection array and the hook overwrites it with
- * the injected result.
+ * Context threaded through the `user-prompt-submit-temp` hook. The
+ * conversation-scoped retrieval state (graph handle, abort signal, trust
+ * class) is self-resolved from the live conversation by id; the readonly
+ * fields here carry the event sink and the turn-start injection snapshot,
+ * while `latestMessages` straddles input and output — the loop seeds it with
+ * the pre-injection array and the hook overwrites it with the injected result.
  */
 export interface MemoryRetrievalHookContext {
-  /** Per-conversation memory graph handle. */
-  readonly graphMemory: ConversationGraphMemory;
-  /** Assistant config snapshot. */
-  readonly config: AssistantConfig;
   /** Event sink used by the graph retriever and `memory_recalled` emission. */
   readonly onEvent: (msg: ServerMessage) => void;
-  /** True when the actor for this turn is trusted (guardian-class). */
-  readonly isTrustedActor: boolean;
   /** Conversation the turn belongs to — keys the recall-log row. */
   readonly conversationId: string;
   /** User message the injected memory block is persisted onto. */
   readonly userMessageId: string;
   /** Turn-scoped logger for non-fatal persistence warnings. */
   readonly logger: Logger;
-  /**
-   * Per-turn abort signal forwarded to `prepareMemory`. An external cancel
-   * aborts the underlying retrieval instead of letting it run to completion.
-   */
-  readonly signal: AbortSignal;
   /**
    * Working message list for the turn. Seeded by the loop with the
    * pre-injection messages and consumed as the retrieval input; the hook
-   * overwrites it with the memory-graph block injected, or leaves it
-   * unchanged when no graph retrieval ran (untrusted actor, or a no-op
-   * retrieval). Read back by the loop.
+   * overwrites it with the fully injected result (the memory-graph block, when
+   * the actor is trusted, plus the runtime injections). Read back by the loop.
    */
   latestMessages: Message[];
+  /**
+   * Stable ID for the current request, forwarded onto the injector turn
+   * context. The one turn-identity field the live conversation can't recover.
+   */
+  readonly requestId: string | undefined;
+  /**
+   * Injection volume for the assembled blocks. `"full"` on the first call;
+   * overflow reduction downgrades subsequent re-injection, but the first-call
+   * assembly this hook performs runs at the loop's committed mode.
+   */
+  readonly mode: InjectionMode;
+  /**
+   * Whether the in-flight turn has no human present to answer clarification
+   * questions. Resolved once at turn start and threaded in so injection uses
+   * the turn-start snapshot rather than live state that can flip mid-turn.
+   */
+  readonly isNonInteractive: boolean;
+  /**
+   * The `model_profile:` turn-context label, or `null` when the active
+   * inference profile is unchanged since the last notified one. Resolved once
+   * at turn start, so it is threaded in rather than re-derived.
+   */
+  readonly modelProfile: string | null;
+  /**
+   * Inbound actor identity and trust fields for the unified `<turn_context>`
+   * block, or `null` on guardian turns (which suppress the actor section).
+   * Resolved once at turn start from the actor-trust resolver and threaded in.
+   */
+  readonly actorContext: InboundActorContext | null;
 }
 
 /**
@@ -160,10 +192,63 @@ function recordRecallSideEffects(
 }
 
 /**
- * Run the default retrieval, writing `latestMessages` back onto the context and
- * recording the PKB query-vector pair on the graph handle. Skips the
- * memory-graph call entirely (leaving `latestMessages` as the seeded input
- * messages and no query pair recorded) when the actor is not trusted.
+ * Persist the assembled runtime-injection blocks onto the user message's
+ * metadata so they survive conversation reloads (eviction, restart, fork) —
+ * loadFromDb re-injects from metadata. Only this first-call site persists: the
+ * mid-loop re-entry sites send identical bytes and their tail row may not
+ * correspond to `userMessageId`. All present blocks are written in a single
+ * update to avoid doubling SQLite SELECT+UPDATE work each turn. Best-effort — a
+ * persistence failure must not abort the turn.
+ */
+function persistInjectionBlocks(
+  blocks: RuntimeInjectionResult["blocks"],
+  ctx: MemoryRetrievalHookContext,
+): void {
+  if (
+    !blocks.unifiedTurnContext &&
+    !blocks.pkbSystemReminder &&
+    !blocks.workspaceBlock &&
+    !blocks.nowScratchpadBlock &&
+    !blocks.pkbContextBlock &&
+    !blocks.memoryV2StaticBlock
+  ) {
+    return;
+  }
+  try {
+    const metadataUpdates: Record<string, unknown> = {};
+    if (blocks.unifiedTurnContext) {
+      metadataUpdates.turnContextBlock = blocks.unifiedTurnContext;
+    }
+    if (blocks.pkbSystemReminder) {
+      metadataUpdates.pkbSystemReminderBlock = blocks.pkbSystemReminder;
+    }
+    if (blocks.workspaceBlock) {
+      metadataUpdates.workspaceBlock = blocks.workspaceBlock;
+    }
+    if (blocks.nowScratchpadBlock) {
+      metadataUpdates.nowScratchpadBlock = blocks.nowScratchpadBlock;
+    }
+    if (blocks.pkbContextBlock) {
+      metadataUpdates.pkbContextBlock = blocks.pkbContextBlock;
+    }
+    if (blocks.memoryV2StaticBlock) {
+      metadataUpdates.memoryV2StaticBlock = blocks.memoryV2StaticBlock;
+    }
+    updateMessageMetadata(ctx.userMessageId, metadataUpdates);
+  } catch (err) {
+    ctx.logger.warn(
+      { err },
+      "Failed to persist injection metadata (non-fatal)",
+    );
+  }
+}
+
+/**
+ * Run the default retrieval and assemble the turn's prompt. Memory-graph
+ * retrieval is gated on the actor being trusted (guardian); untrusted actors
+ * skip it, leaving `latestMessages` as the seeded input. Runtime injection then
+ * runs for every actor, writing the fully injected result back onto
+ * `latestMessages` and persisting the assembled blocks.
  *
  * Memory retrieval blocks the turn — there is no soft timeout here. Memory is
  * critical context, and silently dropping it produces a worse outcome than a
@@ -173,44 +258,69 @@ function recordRecallSideEffects(
 const userPromptSubmitMemoryRetrieval: PluginHookFn<
   MemoryRetrievalHookContext
 > = async (ctx) => {
-  if (!ctx.isTrustedActor) {
-    // Untrusted actors skip memory-graph retrieval entirely.
-    return;
-  }
+  // The conversation-scoped retrieval state — graph handle, abort signal, and
+  // trust class — is resolved from the live conversation by id rather than
+  // threaded in, mirroring how `applyRuntimeInjections` self-resolves its
+  // per-turn inputs.
+  const conversation = findConversationOrSubagent(ctx.conversationId);
+  const abortSignal = conversation?.abortController?.signal;
+  const isTrustedActor =
+    resolveTrustClass(conversation?.trustContext) === "guardian";
 
-  const graphResult = await ctx.graphMemory.prepareMemory(
-    ctx.latestMessages,
-    ctx.config,
-    ctx.signal,
-    ctx.onEvent,
-  );
+  if (conversation && isTrustedActor && abortSignal) {
+    const graphResult = await conversation.graphMemory.prepareMemory(
+      ctx.latestMessages,
+      getConfig(),
+      abortSignal,
+      ctx.onEvent,
+    );
 
-  recordRecallSideEffects(graphResult, ctx);
+    recordRecallSideEffects(graphResult, ctx);
 
-  ctx.latestMessages = graphResult.runMessages;
-  // Select dense+sparse as a matched pair so RRF fusion combines two signals
-  // aligned to the same query text:
-  //   1. Context-load with a user query: user-query dense + user-query sparse
-  //      — the cleanest pairing.
-  //   2. Otherwise (context-load without a user query, or per-turn): whatever
-  //      `queryVector` / `sparseVector` the retriever produced, which are
-  //      themselves co-aligned (both summary-derived in context-load, both
-  //      user-last-message-derived in per-turn).
-  // Never pair a user-query dense with a summary-aligned sparse.
-  // The PKB-reminder injector reads this pair back off the same graph handle
-  // (looked up by conversation id) rather than receiving it threaded through
-  // the agent loop.
-  if (graphResult.userQueryVector) {
-    ctx.graphMemory.recordPkbQueryVectors(
-      graphResult.userQueryVector,
-      graphResult.userQuerySparseVector,
-    );
-  } else {
-    ctx.graphMemory.recordPkbQueryVectors(
-      graphResult.queryVector,
-      graphResult.sparseVector,
-    );
+    ctx.latestMessages = graphResult.runMessages;
+    // Select dense+sparse as a matched pair so RRF fusion combines two signals
+    // aligned to the same query text:
+    //   1. Context-load with a user query: user-query dense + user-query sparse
+    //      — the cleanest pairing.
+    //   2. Otherwise (context-load without a user query, or per-turn): whatever
+    //      `queryVector` / `sparseVector` the retriever produced, which are
+    //      themselves co-aligned (both summary-derived in context-load, both
+    //      user-last-message-derived in per-turn).
+    // Never pair a user-query dense with a summary-aligned sparse.
+    // The PKB-reminder injector reads this pair back off the same graph handle
+    // (looked up by conversation id) rather than receiving it threaded through
+    // the agent loop.
+    if (graphResult.userQueryVector) {
+      conversation.graphMemory.recordPkbQueryVectors(
+        graphResult.userQueryVector,
+        graphResult.userQuerySparseVector,
+      );
+    } else {
+      conversation.graphMemory.recordPkbQueryVectors(
+        graphResult.queryVector,
+        graphResult.sparseVector,
+      );
+    }
   }
+
+  // Runtime injection assembles the turn's prompt onto the retrieved history.
+  // It runs for every actor (untrusted actors skip only the memory-graph step
+  // above). `applyRuntimeInjections` self-resolves every per-turn injection
+  // input — the Slack chronological transcript, the unified `<turn_context>`
+  // block, channel/voice/transport hints, and the turn's trust/index/call-site
+  // — from the live conversation, so we hand in only the request id and
+  // conversation id plus the fields resolved once at turn start (`mode`,
+  // `isNonInteractive`, `modelProfile`, `actorContext`).
+  const injection = await applyRuntimeInjections(ctx.latestMessages, {
+    isNonInteractive: ctx.isNonInteractive,
+    modelProfile: ctx.modelProfile,
+    actorContext: ctx.actorContext,
+    mode: ctx.mode,
+    requestId: ctx.requestId,
+    conversationId: ctx.conversationId,
+  });
+  ctx.latestMessages = injection.messages;
+  persistInjectionBlocks(injection.blocks, ctx);
 };
 
 export default userPromptSubmitMemoryRetrieval;

package/src/plugins/defaults/memory-retrieval/injector-chain.ts

@@ -18,9 +18,9 @@
  * ordering assumptions about when `defaultInjectors` finishes initializing.
  */
 
-import { memoryV3Injector } from "../../../memory/v3/shadow-plugin.js";
 import type { Injector } from "../../types.js";
-import { defaultInjectors } from "../injectors/register.js";
+import { memoryV3Injector } from "../memory-v3-shadow/injector.js";
+import { defaultInjectors } from "./injectors.js";
 
 let cachedChain: Injector[] | null = null;