@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/plugins/defaults/memory-v3-shadow/pool-select.ts

@@ -41,16 +41,15 @@
  *   - infrastructure failure (selector provider unavailable — e.g. a transient
  *     CES credential blip drops the API key — or no usable `tool_use` / schema
  *     mismatch surviving the short re-prompt retry) → throw
- *     {@link MemoryV3RetrievalUnavailableError}. The live injector treats this
- *     as a logged memory miss for the turn; shadow/observation callers swallow
- *     it so v2 retrieval can serve the turn.
+ *     {@link MemoryV3RetrievalUnavailableError}. There is NO deterministic-lane
+ *     fallback: the LIVE injector propagates this to hard-fail the turn
+ *     (retryable) rather than silently shipping it with no `<memory>` block,
+ *     while the shadow/observation path swallows it and lets v2 retrieval serve
+ *     the turn.
  */
 
 import { z } from "zod";
 
-import { classifyConversationError } from "../../../daemon/conversation-error.js";
-import type { PendingConversationNotice } from "../../../daemon/conversation-notices.js";
-import { loadPromptOverride } from "../../../memory/prompt-override.js";
 import { cachedTextBlock } from "../../../providers/cache-control.js";
 import {
   extractToolUse,
@@ -77,43 +76,17 @@ const log = getLogger("memory-v3-pool-select");
  * re-prompt retry. Deliberately DISTINCT from a deliberate empty selection
  * (`ids: []`) and an empty candidate pool, both of which return normally.
  *
- * The live memory-v3 injector logs this as a memory miss for the turn; the
+ * The LIVE memory-v3 injector propagates this to hard-fail the turn (a clean,
+ * retryable failure) rather than silently shipping with no memory; the
  * shadow/observation path catches and swallows it.
  */
 export class MemoryV3RetrievalUnavailableError extends Error {
-  readonly conversationNotice?: PendingConversationNotice;
-
-  constructor(
-    message: string,
-    options?: {
-      cause?: unknown;
-      conversationNotice?: PendingConversationNotice;
-    },
-  ) {
-    super(
-      message,
-      options?.cause === undefined ? undefined : { cause: options.cause },
-    );
+  constructor(message: string) {
+    super(message);
     this.name = "MemoryV3RetrievalUnavailableError";
-    this.conversationNotice = options?.conversationNotice;
   }
 }
 
-function providerBillingNoticeFromError(
-  error: unknown,
-): PendingConversationNotice | undefined {
-  const classified = classifyConversationError(error, {
-    phase: "agent_loop",
-  });
-  if (classified.code !== "PROVIDER_BILLING") return undefined;
-  return {
-    source: "memory_v3",
-    code: classified.code,
-    userMessage: classified.userMessage,
-    errorCategory: classified.errorCategory,
-  };
-}
-
 /** A dynamic-tail (finder) candidate: the slug plus the descriptor that
  *  justifies it — a matched section for a needle/dense hit, or a curated link
  *  description for an edge page. Rendered as a one-line snippet, prefixed
@@ -228,28 +201,6 @@ A page can be relevant because of the current situation — the date or the live
 
 If the conversation is centrally ABOUT a page (rather than only peripherally relevant to it), mark that page as pinned. Call \`select_pages\` with the chosen IDs. Omit \`ids\` only as a recall-safe fallback when you cannot judge the pool (keeps every candidate); return \`[]\` when candidates are present but none are relevant.`;
 
-/**
- * Resolve the selector system prompt: the file at `overridePath` when it is set
- * and usable, otherwise the bundled {@link SYSTEM_PROMPT}. Path resolution and
- * fallback follow the shared override loader (workspace-relative; a missing,
- * empty, oversized, or unreadable file degrades to the bundled prompt with a
- * warning). The selector prompt takes no placeholders — the candidate pool is
- * the user message — so an override file is used verbatim.
- */
-export function resolveSelectorPrompt(
-  overridePath: string | null,
-  workspaceDir: string,
-): string {
-  return (
-    loadPromptOverride({
-      overridePath,
-      workspaceDir,
-      log,
-      label: "memory-v3 selector prompt",
-    }) ?? SYSTEM_PROMPT
-  );
-}
-
 /** Collapse a descriptor to one line and cap its length for a finder line. */
 function renderSnippet(descriptor: string): string {
   return truncate(descriptor.replace(/\s+/g, " ").trim(), SNIPPET_MAX_CHARS);
@@ -364,15 +315,10 @@ function dedupeBySlug(
  * relevant" signal); an explicit `[]` keeps none; an infrastructure failure
  * (after a short re-prompt retry) keeps none, degrading to the deterministic
  * recall lanes the orchestrator unions in.
- *
- * `systemPrompt` is the selector's instruction scaffold; it defaults to the
- * bundled {@link SYSTEM_PROMPT} and is overridable via `memory.v3.selectorPromptPath`
- * (resolved by {@link resolveSelectorPrompt} at the call site).
  */
 export async function selectPool(
   pool: SelectorPool,
   turn: MemoryRoutingTurn,
-  systemPrompt: string = SYSTEM_PROMPT,
 ): Promise<SelectedPage[]> {
   // The concatenated numbering: ids 1…m are the stable-prefix cards, ids
   // m+1… are the finder lines.
@@ -394,7 +340,7 @@ export async function selectPool(
         stableCount: pool.stable.length,
         finderCount: pool.finder.length,
       },
-      "pool selector provider unavailable",
+      "pool selector provider unavailable — failing the turn rather than dropping memory",
     );
     throw new MemoryV3RetrievalUnavailableError(
       "memory-v3 pool selector provider unavailable",
@@ -448,12 +394,6 @@ export async function selectPool(
   // (no usable tool_use, or tool input that fails the schema) re-prompts before
   // we give up. `null` from an attempt means "unusable, retry"; the provider
   // layer already backs off transient throws, so this loop adds no delay.
-  //
-  // `lastError` captures the most recent attempt's thrown provider error —
-  // `retryForResult` swallows attempt throws, so without this an infrastructure
-  // failure (e.g. an upstream HTTP 4xx/5xx) is indistinguishable from a 200 that
-  // carried no usable tool_use. It is cleared on every attempt that reaches a
-  // response, so it reflects the LAST attempt's failure mode.
   let lastError: unknown = null;
   const parsed = await retryForResult(async () => {
     attempt += 1;
@@ -461,7 +401,7 @@ export async function selectPool(
     try {
       response = await provider.sendMessage([userMsg], {
         tools: [SELECT_PAGES_TOOL],
-        systemPrompt,
+        systemPrompt: SYSTEM_PROMPT,
         config: {
           callSite: MEMORY_V3_SELECT_CALL_SITE,
           tool_choice: { type: "tool" as const, name: SELECT_PAGES_TOOL_NAME },
@@ -536,14 +476,10 @@ export async function selectPool(
           providerName: provider.name,
           failures,
         },
-        "pool selector provider call failed after retries",
+        "pool selector provider call failed after retries — failing the turn rather than dropping memory",
       );
       throw new MemoryV3RetrievalUnavailableError(
         `memory-v3 pool selector provider call failed after retries: ${redactedDetail}`,
-        {
-          cause: lastError,
-          conversationNotice: providerBillingNoticeFromError(lastError),
-        },
       );
     }
     log.warn(
@@ -555,7 +491,7 @@ export async function selectPool(
         providerName: provider.name,
         failures,
       },
-      "pool selector returned no usable tool_use after retries",
+      "pool selector returned no usable tool_use after retries — failing the turn rather than dropping memory",
     );
     throw new MemoryV3RetrievalUnavailableError(
       "memory-v3 pool selector returned no usable selection after retries",

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

@@ -56,10 +56,7 @@ import { computeHotSet } from "./hot-set.js";
 import { computeLearnedEdgeGraph } from "./learned-edges.js";
 import type { OrchestrateResult } from "./orchestrate.js";
 import { orchestrate } from "./orchestrate.js";
-import {
-  MemoryV3RetrievalUnavailableError,
-  resolveSelectorPrompt,
-} from "./pool-select.js";
+import { MemoryV3RetrievalUnavailableError } from "./pool-select.js";
 import { ensureSectionCollection } from "./section-dense-store.js";
 import type { SectionNeedle } from "./section-needle.js";
 import { buildSectionNeedle } from "./section-needle.js";
@@ -579,10 +576,6 @@ export async function observeTurn(
       learnedGraph: lanes.learnedGraph,
       learnedPerSeed: v3.learnedEdges.perSeed,
       learnedCap: v3.learnedEdges.cap,
-      selectorPrompt: resolveSelectorPrompt(
-        v3.selectorPromptPath,
-        getWorkspaceDir(),
-      ),
     });
 
     // A zero-selection turn over a non-trivial pool is unusual enough to be
@@ -605,9 +598,13 @@ export async function observeTurn(
     writeSelections(conversationId, turnIndex, rows);
     return result;
   } catch (err) {
-    // Infrastructure failures are surfaced to callers that want distinct
-    // logging from ordinary orchestration misses. Observation callers swallow
-    // them so memory-v3 never fails the turn.
+    // An INFRASTRUCTURE failure (the selector lost its provider — e.g. a
+    // transient CES credential blip) must NOT be silently swallowed: re-throw
+    // so the LIVE injector hard-fails the turn (a clean, retryable failure)
+    // rather than shipping it with no `<memory>` block. The shadow/observation
+    // callers (the injector in shadow mode, runShadowObservation) catch this
+    // and swallow it, so observation never fails a turn. Other (non-infra)
+    // errors stay non-fatal and degrade to no v3 block, as before.
     if (err instanceof MemoryV3RetrievalUnavailableError) {
       throw err;
     }
@@ -637,6 +634,8 @@ export async function runShadowObservation(
   try {
     await observeTurn(conversationId, turnIndex);
   } catch {
-    // Shadow observation is fire-and-forget and must never fail a turn.
+    // Shadow observation is fire-and-forget and must NEVER fail a turn.
+    // `observeTurn` now re-throws infra failures so the LIVE injector can
+    // hard-fail on them; here (observation only) we swallow them.
   }
 }