@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/plugins/defaults/memory/memory-retrospective-job.ts

@@ -42,6 +42,7 @@
 
 import {
   addMessage,
+  type AgentLoopExitReason,
   type ContentBlock,
   type ConversationRow,
   deleteConversation,
@@ -51,8 +52,10 @@ import {
 } from "@vellumai/plugin-api";
 
 import {
+  type ClientOs,
   type InterfaceId,
   isInteractiveInterface,
+  parseClientOs,
   parseInterfaceId,
 } from "../../../channels/types.js";
 import { isV3TierActive } from "../../../config/memory-v3-gate.js";
@@ -88,7 +91,6 @@ import {
   MEMORY_RETROSPECTIVE_FORK_SOURCE,
   MEMORY_RETROSPECTIVE_GROUP_ID,
   MEMORY_RETROSPECTIVE_INSTRUCTION_KIND,
-  MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT,
   MEMORY_RETROSPECTIVE_ORIGIN,
   MEMORY_RETROSPECTIVE_SOURCE,
   SKILL_MANAGEMENT_SKILL_ID,
@@ -128,6 +130,14 @@ export const STALE_SOURCE_PROCESSING_OVERRIDE_MS = 6 * 60 * 60 * 1000;
 /** Watchdog check_name for the per-run retrospective outcome counter. */
 const MEMORY_RETROSPECTIVE_RUN_CHECK_NAME = "memory_retrospective_run";
 
+/**
+ * The agent-loop exit that means the MODEL ended the run: it answered without
+ * asking for another tool. Under every other exit something ended the run for
+ * it, so whatever it had said by then is a fragment of a review rather than a
+ * verdict on the window.
+ */
+const MODEL_DRIVEN_STOP_EXIT_REASON: AgentLoopExitReason = "no_tool_calls";
+
 export type MemoryRetrospectiveOutcome =
   | { kind: "disabled" }
   | { kind: "no_new_messages" }
@@ -142,6 +152,12 @@ export type MemoryRetrospectiveOutcome =
       cutoffMessageId: string;
       newMessageCount: number;
       followUpJobIds: string[];
+      /**
+       * The pass reviewed its window and had nothing durable to save, so it
+       * advanced the cursor without writing a memory. Separates the two
+       * shapes a healthy run takes, which the outcome kind alone conflates.
+       */
+      noFindings: boolean;
     };
 
 export async function memoryRetrospectiveJob(
@@ -176,14 +192,20 @@ export async function memoryRetrospectiveJob(
   // resolved model) is visible without log access. The emitter itself
   // never throws — the run's outcome must reach the jobs worker
   // regardless.
-  const emitRunOutcome = (outcome: string, reason?: string): void => {
+  const emitRunOutcome = (
+    outcome: string,
+    detail?: { reason?: string; noFindings?: boolean },
+  ): void => {
     try {
       recordWatchdogEvent({
         checkName: MEMORY_RETROSPECTIVE_RUN_CHECK_NAME,
         value: 1,
         detail: {
           outcome,
-          ...(reason ? { reason: reason.slice(0, 200) } : {}),
+          ...(detail?.reason ? { reason: detail.reason.slice(0, 200) } : {}),
+          ...(detail?.noFindings !== undefined
+            ? { noFindings: detail.noFindings }
+            : {}),
         },
       });
     } catch {
@@ -199,15 +221,17 @@ export async function memoryRetrospectiveJob(
       enforceUserActivityGate: true,
     });
   } catch (err) {
-    emitRunOutcome("error", err instanceof Error ? err.message : String(err));
+    emitRunOutcome("error", {
+      reason: err instanceof Error ? err.message : String(err),
+    });
     throw err;
   }
-  emitRunOutcome(
-    outcome.kind,
-    outcome.kind === "wake_failed" || outcome.kind === "no_usable_output"
-      ? outcome.reason
-      : undefined,
-  );
+  emitRunOutcome(outcome.kind, {
+    ...(outcome.kind === "wake_failed" || outcome.kind === "no_usable_output"
+      ? { reason: outcome.reason }
+      : {}),
+    ...(outcome.kind === "invoked" ? { noFindings: outcome.noFindings } : {}),
+  });
   return outcome;
 }
 
@@ -396,16 +420,16 @@ export async function runForkBasedRetrospective(
   // advances to `cutoffMessageId`, causing the next retrospective to
   // reprocess (and potentially re-`remember`) those same turns.
   //
-  // The fork copies only the source's visible tail and carries the inherited
-  // compaction summary on its own row (with a fork-local compacted count of
-  // 0). Compacted source ⇒ summary + tail visible to the agent natively.
+  // The fork is referential: it carries the inherited compaction summary
+  // and the source's hidden-prefix count, and reads the source's rows
+  // through the fork point. Compacted source ⇒ summary + tail visible to
+  // the agent natively.
   let forkConversationRow: Awaited<
     ReturnType<typeof forkConversationForRetrospective>
   >;
   try {
-    // Async variant: the source message-row copy runs off the event loop in a
-    // sqlite3 subprocess so this background pass cannot freeze the daemon's
-    // event loop (health probes / gateway IPC) on a large database.
+    // Referential fork: one conversation row plus memory-state seeding.
+    // There is no source message-row copy.
     forkConversationRow = await forkConversationForRetrospective({
       conversationId: sourceConversationId,
       throughMessageId: cutoffMessageId,
@@ -493,6 +517,7 @@ export async function runForkBasedRetrospective(
   // persisted message — the wake's hint sandwich would only duplicate it.
   let wakeSucceeded = false;
   let failureReason: string | undefined;
+  let wakeExitReason: AgentLoopExitReason | undefined;
   let threw: unknown;
   try {
     const result = await wakeAgentForOpportunity({
@@ -562,6 +587,7 @@ export async function runForkBasedRetrospective(
     });
     wakeSucceeded = result.invoked;
     failureReason = result.reason;
+    wakeExitReason = result.exitReason;
   } catch (err) {
     threw = err;
     failureReason = err instanceof Error ? err.message : String(err);
@@ -576,15 +602,21 @@ export async function runForkBasedRetrospective(
     // went live, not that the run produced anything. The agent loop swallows
     // provider rejections into a normal no-output return, an exhausted output
     // budget can stop a run before any visible text or tool call, and a
-    // model may reply with analysis (or nothing) without saving. Advancement
-    // past the window therefore requires POSITIVE evidence from THIS run,
-    // one of:
+    // model may stop mid-review without saving. Advancement past the window
+    // therefore requires POSITIVE evidence from THIS run, one of:
     //   - a memory-writing tool call on the fork's post-boundary tail whose
     //     execution verifiably succeeded (matching non-error tool_result), or
-    //   - the explicit no-findings reply the instruction mandates (an
-    //     assistant text block that is exactly the sentinel phrase), with no
-    //     memory-writing tool attempts at all; a run that attempted a save
-    //     and failed cannot advance by also claiming no findings.
+    //   - a reviewed-and-nothing-to-save pass: the model ENDED the run by
+    //     answering in its own words (its final assistant row carries text),
+    //     attempted no memory write at all, and the loop ended because IT
+    //     stopped asking for tools rather than because something cut the run
+    //     short. A run that attempted a save and failed cannot advance by
+    //     talking instead, a run whose narration went live but whose final
+    //     response was empty has not concluded, and a run the provider or
+    //     the output ceiling ended mid-review has not reviewed its window.
+    // The proof of an empty-handed review is the shape of the run, never the
+    // wording of the reply: a model that reaches its own end with nothing to
+    // write has reviewed the window, in whatever words it says so.
     // The evidence read is run-specific by construction
     // (`loadRetrospectiveRunMessages` scopes to rows after the fork
     // boundary), so a prior run's persisted saves can never satisfy it, and
@@ -596,8 +628,9 @@ export async function runForkBasedRetrospective(
     // remains retryable.
     const runEvidence = await collectRetrospectiveRunEvidence(forkId);
     const reviewedNoFindings =
-      runEvidence.explicitNoFindings &&
-      runEvidence.durableToolAttemptCount === 0;
+      runEvidence.committedTextReply &&
+      runEvidence.durableToolAttemptCount === 0 &&
+      wakeExitReason === MODEL_DRIVEN_STOP_EXIT_REASON;
     if (runEvidence.durableToolCallCount === 0 && !reviewedNoFindings) {
       log.warn(
         {
@@ -605,9 +638,12 @@ export async function runForkBasedRetrospective(
           forkId,
           newMessageCount: newMessages.length,
           durableToolAttempts: runEvidence.durableToolAttemptCount,
+          committedTextReply: runEvidence.committedTextReply,
+          exitReason: wakeExitReason ?? null,
         },
-        "memory-retrospective (fork): run produced neither a verified durable write nor an explicit no-findings reply; leaving window retryable",
+        "memory-retrospective (fork): run produced neither a verified durable write nor a completed empty-handed review; leaving window retryable",
       );
+      failureReason = describeUnusableRun(runEvidence, wakeExitReason);
     } else {
       return await finalizeSuccessfulRetrospective({
         config,
@@ -618,11 +654,11 @@ export async function runForkBasedRetrospective(
         prior,
         priorRemembers,
         runRemembers: runEvidence.remembers,
+        noFindings: reviewedNoFindings,
         logFields: {
           kind: "fork",
           windowStartTimestamp,
           durationMs: Date.now() - startedAtMs,
-          noFindings: reviewedNoFindings,
         },
       });
     }
@@ -642,12 +678,15 @@ export async function runForkBasedRetrospective(
   }
 
   if (wakeSucceeded) {
+    // Reached only through the evidence gate above, which set `failureReason`
+    // to why the run could not consume its window.
     return {
       kind: "no_usable_output",
-      reason: failureReason ?? "run persisted no memory-writing tool call",
+      reason: failureReason,
       conversationId: forkId,
     };
   }
+
   return {
     kind: "wake_failed",
     reason: failureReason,
@@ -655,6 +694,26 @@ export async function runForkBasedRetrospective(
   };
 }
 
+/**
+ * Why a run that went live still could not consume its window, phrased for
+ * the job row's `last_error` and the CLI. The distinction it draws is the one
+ * an operator needs: a lost memory write reads differently from a review that
+ * never reached a conclusion, and the fork is deleted on failure, so this
+ * string is what survives the run.
+ */
+function describeUnusableRun(
+  evidence: { durableToolAttemptCount: number; committedTextReply: boolean },
+  exitReason: AgentLoopExitReason | undefined,
+): string {
+  if (evidence.durableToolAttemptCount > 0) {
+    return `run attempted ${evidence.durableToolAttemptCount} memory write(s), none of which persisted a successful result`;
+  }
+  if (!evidence.committedTextReply) {
+    return "run committed neither a memory write nor a concluding reply";
+  }
+  return `run replied without saving anything, but ended on ${exitReason ?? "no terminal exit"} rather than a completed review`;
+}
+
 function enqueueFollowUpJobs(): string[] {
   const followUpJobIds: string[] = [];
   for (const jobType of FOLLOW_UP_JOB_TYPES) {
@@ -711,6 +770,8 @@ interface SourceParityPins {
  *
  * `toolContextPin.transportInterface` — the interface the source's most
  * recent live turns ran on (see {@link resolveSourceLiveInterface}).
+ * `toolContextPin.clientOs` is recovered from the same persisted user-message
+ * metadata, with the transport interface as a fallback.
  * `channelCapabilities` is left unset: desktop/web HTTP turns never set
  * channel capabilities, and for channel-routed sources (whose live turns do
  * carry them) every tool gate resolves identically under
@@ -745,6 +806,7 @@ function resolveSourceParityPins(
   // with an unmappable channel stay undefined (their live turns were
   // clientless either way).
   const transportInterface = recovered ?? (channelRouted ? undefined : "web");
+  const clientOs = resolveSourceLiveClientOs(sliceMessages, transportInterface);
   const hasNoClient =
     transportInterface == null || !isInteractiveInterface(transportInterface);
   const personaOverride: SystemPromptPersonaOverride = channelRouted
@@ -763,6 +825,7 @@ function resolveSourceParityPins(
     toolContextPin: {
       hasNoClient,
       transportInterface,
+      clientOs,
       requestOrigin: MEMORY_RETROSPECTIVE_ORIGIN,
     },
   };
@@ -814,6 +877,37 @@ function resolveSourceLiveInterface(
   );
 }
 
+/** Pin the source's live client OS so OS-gated tools match on wake. */
+function resolveSourceLiveClientOs(
+  sliceMessages: Array<{ role: string; metadata: string | null }>,
+  transportInterface: InterfaceId | undefined,
+): ClientOs | undefined {
+  for (let i = sliceMessages.length - 1; i >= 0; i--) {
+    const row = sliceMessages[i]!;
+    if (row.role !== "user" || !row.metadata) {
+      continue;
+    }
+    let meta: unknown;
+    try {
+      meta = JSON.parse(row.metadata);
+    } catch {
+      continue;
+    }
+    if (!meta || typeof meta !== "object") {
+      continue;
+    }
+    const { clientOsFromRequest, client } = meta as Record<string, unknown>;
+    if (clientOsFromRequest !== true || !client || typeof client !== "object") {
+      continue;
+    }
+    const clientOs = parseClientOs((client as Record<string, unknown>).os);
+    if (clientOs) {
+      return clientOs;
+    }
+  }
+  return parseClientOs(transportInterface) ?? undefined;
+}
+
 type PriorRetrospective = NonNullable<
   ReturnType<typeof findMostRecentRetrospectiveFor>
 >;
@@ -862,6 +956,8 @@ async function finalizeSuccessfulRetrospective(args: {
    * advancement is exactly the evidence folded into the log.
    */
   runRemembers: string[];
+  /** Whether the run advanced on a reviewed-and-nothing-to-save pass. */
+  noFindings: boolean;
   /** Per-kind extras for the success log line (e.g. `kind`, fork anchor). */
   logFields: Record<string, unknown>;
 }): Promise<MemoryRetrospectiveOutcome> {
@@ -874,6 +970,7 @@ async function finalizeSuccessfulRetrospective(args: {
     prior,
     priorRemembers,
     runRemembers,
+    noFindings,
     logFields,
   } = args;
 
@@ -901,6 +998,7 @@ async function finalizeSuccessfulRetrospective(args: {
       cutoffMessageId,
       newMessageCount,
       priorRememberCount: priorRemembers.length,
+      noFindings,
       ...logFields,
     },
     "memory-retrospective invoked",
@@ -911,6 +1009,7 @@ async function finalizeSuccessfulRetrospective(args: {
     cutoffMessageId,
     newMessageCount,
     followUpJobIds,
+    noFindings,
   };
 }
 
@@ -1119,12 +1218,14 @@ async function collectRetrospectiveRunEvidence(
   /** Memory-writing tool calls the run attempted, regardless of outcome. */
   durableToolAttemptCount: number;
   /**
-   * The run replied with exactly the mandated no-findings sentinel text
-   * ({@link MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT}) in a persisted assistant
-   * text block. Strict whole-block equality: prose that merely mentions the
-   * phrase does not qualify, so an analysis-only reply stays unusable.
+   * The run ENDED by answering in its own words: the last persisted
+   * assistant row carries a text block with non-whitespace content. Any
+   * wording qualifies, so a pass that found nothing durable proves it
+   * reviewed the window by replying, not by reproducing a phrase; but the
+   * reply must be the run's final word, so narration followed by an empty
+   * last response does not qualify.
    */
-  explicitNoFindings: boolean;
+  committedTextReply: boolean;
 }> {
   const conv = await getConversation(conversationId);
   const runMessages = await loadRetrospectiveRunMessages(
@@ -1136,7 +1237,7 @@ async function collectRetrospectiveRunEvidence(
       remembers: [],
       durableToolCallCount: 0,
       durableToolAttemptCount: 0,
-      explicitNoFindings: false,
+      committedTextReply: false,
     };
   }
   const succeededIds = collectSuccessfulToolResultIds(runMessages);
@@ -1144,46 +1245,34 @@ async function collectRetrospectiveRunEvidence(
     remembers: extractRememberContents(runMessages, succeededIds),
     durableToolCallCount: countDurableToolUses(runMessages, succeededIds),
     durableToolAttemptCount: countDurableToolUses(runMessages, null),
-    explicitNoFindings: hasExplicitNoFindingsReply(runMessages),
+    committedTextReply: hasCommittedTextReply(runMessages),
   };
 }
 
 /**
- * Whether any persisted assistant row on the run's tail carries a text block
- * that is exactly the no-findings sentinel (after trimming). The instruction
- * template mandates this exact reply for a reviewed-and-nothing-to-save
- * pass, making it the positive persisted artifact that distinguishes a
- * legitimate no-findings review from an empty or unusable response.
+ * Whether the LAST persisted assistant row on the run's tail carries a text
+ * block with non-whitespace content. Paired with a model-driven stop and
+ * zero memory-write attempts, that closing reply is the persisted artifact
+ * of a pass that read its window and had nothing to save: the model spoke
+ * and then chose to end the run. Reading only the final row separates it
+ * from a run whose narration went live but whose actual conclusion was
+ * empty, as well as from a response that committed nothing at all
+ * (thinking-only output, an empty content array).
  */
-function hasExplicitNoFindingsReply(messages: MessageLike[]): boolean {
-  for (const msg of messages) {
+function hasCommittedTextReply(messages: MessageLike[]): boolean {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]!;
     if (msg.role !== "assistant") {
       continue;
     }
-    let blocks: unknown = msg.content;
-    if (typeof blocks === "string") {
-      try {
-        blocks = JSON.parse(blocks);
-      } catch {
-        continue;
-      }
-    }
-    if (!Array.isArray(blocks)) {
-      continue;
-    }
-    for (const block of blocks) {
-      if (!block || typeof block !== "object") {
-        continue;
-      }
-      const b = block as Record<string, unknown>;
-      if (
-        b.type === "text" &&
-        typeof b.text === "string" &&
-        b.text.trim() === MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT
-      ) {
-        return true;
-      }
+    const blocks = parseMessageBlocks(msg);
+    if (blocks === null) {
+      return false;
     }
+    return blocks.some(
+      (b) =>
+        b.type === "text" && typeof b.text === "string" && b.text.trim() !== "",
+    );
   }
   return false;
 }
@@ -1199,22 +1288,7 @@ function collectSuccessfulToolResultIds(messages: MessageLike[]): Set<string> {
     if (msg.role !== "user") {
       continue;
     }
-    let blocks: unknown = msg.content;
-    if (typeof blocks === "string") {
-      try {
-        blocks = JSON.parse(blocks);
-      } catch {
-        continue;
-      }
-    }
-    if (!Array.isArray(blocks)) {
-      continue;
-    }
-    for (const block of blocks) {
-      if (!block || typeof block !== "object") {
-        continue;
-      }
-      const b = block as Record<string, unknown>;
+    for (const b of parseMessageBlocks(msg) ?? []) {
       // guard:allow-tool-result-only: success evidence for locally-executed
       // durable memory tools; server-side web_search_tool_result never
       // corresponds to a durable write and carries no is_error flag.
@@ -1246,22 +1320,7 @@ function countDurableToolUses(
     if (msg.role !== "assistant") {
       continue;
     }
-    let blocks: unknown = msg.content;
-    if (typeof blocks === "string") {
-      try {
-        blocks = JSON.parse(blocks);
-      } catch {
-        continue;
-      }
-    }
-    if (!Array.isArray(blocks)) {
-      continue;
-    }
-    for (const block of blocks) {
-      if (!block || typeof block !== "object") {
-        continue;
-      }
-      const b = block as Record<string, unknown>;
+    for (const b of parseMessageBlocks(msg) ?? []) {
       if (
         b.type === "tool_use" &&
         DURABLE_RETROSPECTIVE_TOOLS.has(String(b.name)) &&
@@ -1280,6 +1339,32 @@ interface MessageLike {
   content: string | ContentBlock[];
 }
 
+/**
+ * Parse a message row's content into its block objects, or `null` when the
+ * content is malformed (unparseable JSON, not an array). Non-object entries
+ * are dropped. Every evidence reader in this module goes through this so
+ * malformed rows degrade the same way everywhere: skipped, not propagated.
+ */
+function parseMessageBlocks(
+  msg: MessageLike,
+): Record<string, unknown>[] | null {
+  let blocks: unknown = msg.content;
+  if (typeof blocks === "string") {
+    try {
+      blocks = JSON.parse(blocks);
+    } catch {
+      return null;
+    }
+  }
+  if (!Array.isArray(blocks)) {
+    return null;
+  }
+  return blocks.filter(
+    (block): block is Record<string, unknown> =>
+      typeof block === "object" && block !== null,
+  );
+}
+
 /**
  * Scan an array of message rows for `tool_use` blocks where `name` is
  * `"remember"` and return the `input.content` strings in order. Robust to
@@ -1294,22 +1379,7 @@ function extractRememberContents(
     if (msg.role !== "assistant") {
       continue;
     }
-    let blocks: unknown = msg.content;
-    if (typeof blocks === "string") {
-      try {
-        blocks = JSON.parse(blocks);
-      } catch {
-        continue;
-      }
-    }
-    if (!Array.isArray(blocks)) {
-      continue;
-    }
-    for (const block of blocks) {
-      if (!block || typeof block !== "object") {
-        continue;
-      }
-      const b = block as Record<string, unknown>;
+    for (const b of parseMessageBlocks(msg) ?? []) {
       if (b.type !== "tool_use") {
         continue;
       }

package/src/plugins/defaults/memory/memory-retrospective-prompt.ts

@@ -27,7 +27,6 @@
  */
 
 import { getLogger } from "./logging.js";
-import { MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT } from "./memory-retrospective-constants.js";
 import { getWorkspaceDir } from "./paths.js";
 import { loadPromptOverride } from "./prompt-override.js";
 
@@ -45,11 +44,13 @@ function neutralizeSentinels(s: string): string {
 }
 
 /**
- * The sentence mandating the exact no-findings reply. Built from
- * {@link MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT} so the instruction and the
- * finalizer's acceptance check can never drift apart.
+ * The sentence asking a pass that found nothing to say so and stop. The
+ * finalizer reads the SHAPE of such a run (a committed reply, no memory-write
+ * attempts, a model-driven stop), so the wording is free; what the sentence
+ * buys is a run that answers at all rather than committing nothing.
  */
-const NO_FINDINGS_MANDATE = `If nothing new is worth saving, reply with exactly "${MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT}" and stop.`;
+const NO_FINDINGS_MANDATE =
+  "If nothing new is worth saving, say so briefly and stop.";
 
 /**
  * Bundled fork-instruction template. Exported so tests (and any future
@@ -149,8 +150,8 @@ export interface ForkInstructionArgs {
  * the shared {@link loadPromptOverride}), else the bundled
  * {@link RETROSPECTIVE_INSTRUCTION_TEMPLATE}; both get the same placeholder
  * substitution. An override additionally gets the no-findings mandate
- * appended after its body: the exact-reply sentinel is the finalizer's
- * advancement contract, so it holds regardless of what the override says.
+ * appended after its body: a no-findings pass advances only by replying,
+ * so the ask-for-a-reply holds regardless of what the override says.
  */
 export function buildForkInstruction({
   windowStartTimestamp,
@@ -199,12 +200,11 @@ export function buildForkInstruction({
   if (override == null) {
     return rendered;
   }
-  // The finalizer recognizes a no-findings review only by the exact
-  // MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT reply, so the mandate is part of
-  // the advancement contract, not prompt styling: an override body that
-  // drops it would leave every no-findings window permanently retryable.
-  // Appended outside the override so a custom prompt cannot break the
-  // contract.
+  // A pass that saves nothing advances only on a committed reply, so the
+  // mandate is part of the advancement contract, not prompt styling: an
+  // override body that leaves a no-findings pass free to answer with nothing
+  // at all would leave those windows permanently retryable. Appended outside
+  // the override so a custom prompt cannot break the contract.
   return `${rendered}\n\n${NO_FINDINGS_MANDATE}`;
 }
 

package/src/plugins/defaults/memory/src/memory-v2-routes.ts

@@ -7,7 +7,7 @@ import { join } from "node:path";
 
 import { z } from "zod";
 
-import { getEffectiveProfilesForProvider } from "../../../../config/default-profile-catalog.js";
+import { getUserSelectableProfilesForProvider } from "../../../../config/default-profile-catalog.js";
 import { loadConfig } from "../../../../config/loader.js";
 import { usesConceptPageMemory } from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
@@ -523,7 +523,7 @@ export async function handleSimulateRouter({
   // through (the resolver tolerates missing override-profile references by
   // design, but the playground wants the user to know they typo'd).
   if (profileOverride !== undefined) {
-    const profiles = getEffectiveProfilesForProvider(
+    const profiles = getUserSelectableProfilesForProvider(
       liveConfig.llm?.profiles,
       liveConfig.llm?.defaultProvider ?? null,
     );

package/src/plugins/defaults/memory/substrate/__tests__/consolidation-job.test.ts

@@ -1138,7 +1138,7 @@ describe("memoryV2ConsolidateJob — consecutive-failure state", () => {
       ok: false,
       error: new Error("provider refused"),
       errorKind: "model_provider",
-      ...(failureCode !== undefined ? { failureCode } : {}),
+      ...(failureCode !== undefined ? { turnFailure: { failureCode } } : {}),
     });
   }
 

package/src/plugins/defaults/memory/substrate/consolidation-job.ts

@@ -486,12 +486,14 @@ export async function memoryV2ConsolidateJob(
       // everything else (network blip, model hiccup, timeout) is transient
       // and stays on the short curve.
       const failureKind: ConsolidationFailureKind =
-        runResult.failureCode === "PROVIDER_BILLING" ? "billing" : "transient";
+        runResult.turnFailure?.failureCode === "PROVIDER_BILLING"
+          ? "billing"
+          : "transient";
       log.error(
         {
           conversationId: runResult.conversationId,
           errorKind: runResult.errorKind,
-          failureCode: runResult.failureCode,
+          failureCode: runResult.turnFailure?.failureCode,
           failureKind,
           err: runResult.error?.message,
         },