@anuma/sdk 6.10.0 → 6.12.0

package/dist/server/index.cjs

@@ -20236,9 +20236,9 @@ function recencyMultiplier(updatedAt, opts = {}) {
   const updatedMs = updatedAt.getTime();
   if (!Number.isFinite(updatedMs)) return noDate;
   const now = opts.now ?? /* @__PURE__ */ new Date();
-  const nowMs2 = now.getTime();
-  if (!Number.isFinite(nowMs2)) return noDate;
-  const ageDays2 = Math.max(0, (nowMs2 - updatedMs) / DAY_MS2);
+  const nowMs3 = now.getTime();
+  if (!Number.isFinite(nowMs3)) return noDate;
+  const ageDays2 = Math.max(0, (nowMs3 - updatedMs) / DAY_MS2);
   const perYearDecay = opts.perYearDecay ?? DEFAULT_PER_YEAR_DECAY;
   const floor = opts.floor ?? DEFAULT_FLOOR;
   const decay = perYearDecay * (ageDays2 / 365);
@@ -20915,6 +20915,9 @@ async function decomposeQuery(query, options) {
       ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
       model: options.model ?? DEFAULT_MODEL,
       systemPrompt: SYSTEM_PROMPT,
+      // The query itself rides the user turn below, so SYSTEM_PROMPT is the whole
+      // fixed instruction — which is what lets the portal own it outright.
+      taskType: "memory_decompose",
       // Wrap the bare query in a task framing so the model treats it as
       // input to classify, not as a question to answer conversationally.
       // Bare-query inputs caused Anthropic models to respond with prose
@@ -21220,24 +21223,19 @@ function createLlmNeighborRefiner(options) {
     async refine(query, candidates, limit) {
       if (candidates.length === 0) return [];
       const numbered = candidates.map((name, i) => `[${i + 1}] ${name}`).join("\n");
-      const systemPrompt = `You help a memory-retrieval system decide which related topics to explore.
-
-Given a user's question and a numbered list of candidate topics/entities linked to memories found so far, pick the ones most likely to lead to memories that help ANSWER the question. Choose at most ${limit}. Prefer topics semantically related to the question; ignore incidental ones.
-
-Output strict JSON, no prose: { "expand": [<entity names to expand, verbatim from the list>] }`;
       const parsed = await callPortalJsonCompletion({
         ...options.apiKey !== void 0 && { apiKey: options.apiKey },
         ...options.getToken !== void 0 && { getToken: options.getToken },
         ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
         taskType: "memory_graph",
         model: options.model ?? DEFAULT_REFINER_MODEL,
-        systemPrompt,
+        systemPrompt: REFINER_SYSTEM_PROMPT,
         userMessage: `Question: ${query}
 
 Candidate topics:
 ${numbered}
 
-Which should be expanded?`,
+Which should be expanded? Choose at most ${limit}.`,
         tag: "memory/graph-refine",
         maxAttempts: options.maxAttempts ?? DEFAULT_REFINER_ATTEMPTS,
         totalTimeoutMs: options.totalTimeoutMs ?? DEFAULT_REFINER_TOTAL_TIMEOUT_MS,
@@ -21258,7 +21256,7 @@ Which should be expanded?`,
     }
   };
 }
-var MAX_HOPS, ENTITY_FANOUT, MIN_REFINER_CANDIDATES, MAX_REFINER_CANDIDATES, NODE_BUDGET, VAULT_SIZE_HOP_CAP, DEFAULT_REFINER_MODEL, DEFAULT_REFINER_ATTEMPTS, DEFAULT_REFINER_TOTAL_TIMEOUT_MS;
+var MAX_HOPS, ENTITY_FANOUT, MIN_REFINER_CANDIDATES, MAX_REFINER_CANDIDATES, NODE_BUDGET, VAULT_SIZE_HOP_CAP, DEFAULT_REFINER_MODEL, DEFAULT_REFINER_ATTEMPTS, DEFAULT_REFINER_TOTAL_TIMEOUT_MS, REFINER_SYSTEM_PROMPT;
 var init_graphTraversal = __esm({
   "src/lib/memory/graphTraversal.ts"() {
     "use strict";
@@ -21277,6 +21275,11 @@ var init_graphTraversal = __esm({
     DEFAULT_REFINER_MODEL = "inclusionai/ling-2.6-flash";
     DEFAULT_REFINER_ATTEMPTS = 1;
     DEFAULT_REFINER_TOTAL_TIMEOUT_MS = 8e3;
+    REFINER_SYSTEM_PROMPT = `You help a memory-retrieval system decide which related topics to explore.
+
+Given a user's question and a numbered list of candidate topics/entities linked to memories found so far, pick the ones most likely to lead to memories that help ANSWER the question. Never return more than the maximum the user turn asks for. Prefer topics semantically related to the question; ignore incidental ones.
+
+Output strict JSON, no prose: { "expand": [<entity names to expand, verbatim from the list>] }`;
   }
 });
 
@@ -21576,6 +21579,9 @@ async function recall(query, ctx, options = {}) {
   const chunkResults = [];
   let vaultSize;
   let didRerank = false;
+  let rerankMs = 0;
+  let queryEmbedMs = 0;
+  let vaultRowsEmbedded;
   let hadV2Head = false;
   let embeddingsUnavailable = false;
   let chunkEmbedFailed = false;
@@ -21600,12 +21606,15 @@ async function recall(query, ctx, options = {}) {
       ...vaultSize !== void 0 && { vaultSize },
       ...decryptLastRan !== void 0 && { decryptLast: decryptLastRan },
       ...vaultRowsDecrypted !== void 0 && { vaultRowsDecrypted },
+      ...vaultRowsEmbedded !== void 0 && { vaultRowsEmbedded },
       factCount: factResults.length,
       chunkCount: chunkResults.length,
       timings: {
         total: nowMs() - t0,
         prep: prepMs,
         factLane: factLaneMs,
+        rerank: rerankMs,
+        queryEmbed: queryEmbedMs,
         chunkLane: chunkLaneMs,
         fuse: fuseMs
       },
@@ -21669,6 +21678,9 @@ async function recall(query, ctx, options = {}) {
       results,
       vaultSize: size,
       reranked,
+      rerankMs: factRerankMs,
+      queryEmbedMs: factQueryEmbedMs,
+      rowsEmbedded: factRowsEmbedded,
       hadV2Head: v2Head,
       embeddingsUnavailable: factEmbeddingsUnavailable,
       rankedOnCosine: factRankedOnCosine,
@@ -21727,6 +21739,9 @@ async function recall(query, ctx, options = {}) {
     );
     vaultSize = size;
     didRerank = reranked;
+    rerankMs = factRerankMs;
+    queryEmbedMs = factQueryEmbedMs;
+    vaultRowsEmbedded = factRowsEmbedded;
     hadV2Head = v2Head;
     if (factEmbeddingsUnavailable) embeddingsUnavailable = true;
     factLaneRankedOnCosine = factRankedOnCosine;
@@ -22191,6 +22206,7 @@ async function rankFusedVaultMemoriesAsync(query, queryEmbedding, items, options
     const rerankTopN = options.rerankTopN ?? 30;
     const ceWeight = options.ceWeight ?? 0.1;
     const headSlice = v2Ranked.slice(0, rerankTopN);
+    const ceStart = nowMs2();
     try {
       const reranked = await rerankPairs(
         query,
@@ -22218,6 +22234,8 @@ async function rankFusedVaultMemoriesAsync(query, queryEmbedding, items, options
         getLogger().warn("[memory/search] cross-encoder rerank failed; using V2 ranking", err);
       }
       combined = v2Ranked;
+    } finally {
+      if (options.rerankStats) options.rerankStats.ms += nowMs2() - ceStart;
     }
   } else {
     combined = v2Ranked;
@@ -22384,6 +22402,7 @@ async function rankComposite(originalQuery, originalQueryEmbedding, subQueries,
     const ceWeight = options.ceWeight ?? 0.1;
     const headSlice = combined.slice(0, rerankTopN);
     const tailSlice = combined.slice(rerankTopN);
+    const ceStart = nowMs2();
     try {
       const reranked = await rerankPairs(
         originalQuery,
@@ -22411,6 +22430,8 @@ async function rankComposite(originalQuery, originalQueryEmbedding, subQueries,
           err
         );
       }
+    } finally {
+      if (options.rerankStats) options.rerankStats.ms += nowMs2() - ceStart;
     }
   }
   if (options?.mmr) {
@@ -22537,11 +22558,13 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
       rowsDecrypted: 0
     };
   }
+  const queryEmbedStart = nowMs2();
   const queryEmbedding = await embedQueryOrDegrade(
     query,
     embeddingOptions,
     opts.onEmbeddingDegraded
   );
+  if (opts.embedStats) opts.embedStats.queryMs += nowMs2() - queryEmbedStart;
   const embeddingsDegraded = queryEmbedding.length === 0;
   const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
   const vectored = [];
@@ -22594,6 +22617,7 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
     const laneRows = laneFetched.filter((m) => !isEncrypted(m.content));
     if (laneRows.length > 0) {
       let laneVecs;
+      if (opts.embedStats) opts.embedStats.rowsEmbedded += laneRows.length;
       try {
         laneVecs = await generateEmbeddings(
           laneRows.map((m) => m.content),
@@ -22672,6 +22696,10 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
 async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache, searchOptions) {
   if (!query || typeof query !== "string") {
     return {
+      // Nothing was read and nothing was embedded — the short-circuit fires
+      // before either.
+      queryEmbedMs: 0,
+      rowsEmbedded: 0,
       memories: [],
       embeddedItems: [],
       queryEmbedding: [],
@@ -22704,6 +22732,7 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
     embeddingsUnavailable = true;
     embeddingFailure = true;
   };
+  const embedStats = { queryMs: 0, rowsEmbedded: 0 };
   if (searchOptions?.decryptLast) {
     const forceIncludeIds = [
       ...searchOptions.entityRanking ?? [],
@@ -22715,7 +22744,8 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       admitFloor: ADMIT_FLOOR,
       unembeddedCap: UNEMBEDDED_CAP,
       ...forceIncludeIds.length > 0 && { forceIncludeIds },
-      onEmbeddingDegraded
+      onEmbeddingDegraded,
+      embedStats
     });
     if (corpus.vaultSize === 0) {
       return {
@@ -22726,7 +22756,9 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
         embeddingsUnavailable: false,
         embeddingFailure: false,
         decryptLast: true,
-        rowsDecrypted: corpus.rowsDecrypted
+        rowsDecrypted: corpus.rowsDecrypted,
+        queryEmbedMs: embedStats.queryMs,
+        rowsEmbedded: embedStats.rowsEmbedded
       };
     }
     ({ memories, embeddedItems, queryEmbedding, vaultSize } = corpus);
@@ -22743,7 +22775,9 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
         decryptLast: true,
         // Rows WERE decrypt-attempted even though none came back readable — that
         // is the whole point of reporting attempts rather than successes.
-        rowsDecrypted: corpus.rowsDecrypted
+        rowsDecrypted: corpus.rowsDecrypted,
+        queryEmbedMs: embedStats.queryMs,
+        rowsEmbedded: embedStats.rowsEmbedded
       };
     }
   } else {
@@ -22768,10 +22802,14 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
         embeddingsUnavailable: false,
         embeddingFailure: false,
         decryptLast: false,
-        rowsDecrypted: loaded.length
+        rowsDecrypted: loaded.length,
+        queryEmbedMs: embedStats.queryMs,
+        rowsEmbedded: embedStats.rowsEmbedded
       };
     }
+    const legacyEmbedStart = nowMs2();
     queryEmbedding = await embedQueryOrDegrade(query, embeddingOptions, onEmbeddingDegraded);
+    embedStats.queryMs += nowMs2() - legacyEmbedStart;
     const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
     const uncachedTexts = [];
     const uncachedIndices = [];
@@ -22805,6 +22843,7 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
     }
     if (uncachedTexts.length > 0) {
       let newEmbeddings;
+      embedStats.rowsEmbedded += uncachedTexts.length;
       try {
         newEmbeddings = await generateEmbeddings(uncachedTexts, embeddingOptions);
       } catch (err) {
@@ -22848,6 +22887,8 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
     embeddingsUnavailable = true;
   }
   return {
+    queryEmbedMs: embedStats.queryMs,
+    rowsEmbedded: embedStats.rowsEmbedded,
     memories,
     embeddedItems,
     queryEmbedding,
@@ -22898,11 +22939,15 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
       results: results2,
       vaultSize: out.vaultSize,
       reranked: out.reranked ?? false,
+      // Read straight off the shared stats object rather than being passed in at
+      // each call site: every return in this function funnels through here, so a
+      // path added later reports the CE bill without having to remember to.
+      rerankMs: rerankStats.ms,
       hadV2Head: out.hadV2Head ?? false,
       embeddingsUnavailable
     };
   };
-  const rerankStats = { applied: false };
+  const rerankStats = { applied: false, ms: 0 };
   const useFusion = searchOptions?.useFusion ?? true;
   const tuning = {
     ...searchOptions?.recencyAlpha !== void 0 && { recencyAlpha: searchOptions.recencyAlpha },
@@ -23021,13 +23066,16 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       results: [],
       vaultSize: 0,
       reranked: false,
+      rerankMs: 0,
       hadV2Head: false,
       embeddingsUnavailable: false,
       rankedOnCosine: false,
       // No storage read happened, so nothing was decrypted; report the path the
       // caller asked for so this turn is still attributable.
       decryptLast: !!searchOptions?.decryptLast,
-      rowsDecrypted: 0
+      rowsDecrypted: 0,
+      queryEmbedMs: 0,
+      rowsEmbedded: 0
     };
   }
   if (searchOptions?.decompose === "llm" && normalizeSubQueries(searchOptions.subQueries).length < 2 && !warnedProgrammaticDecomposeIgnored) {
@@ -23048,11 +23096,14 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       results: [],
       vaultSize: 0,
       reranked: false,
+      rerankMs: 0,
       hadV2Head: false,
       embeddingsUnavailable: prepared.embeddingsUnavailable,
       rankedOnCosine: false,
       decryptLast: prepared.decryptLast,
-      rowsDecrypted: prepared.rowsDecrypted
+      rowsDecrypted: prepared.rowsDecrypted,
+      queryEmbedMs: prepared.queryEmbedMs,
+      rowsEmbedded: prepared.rowsEmbedded
     };
   }
   if (prepared.memories.length === 0) {
@@ -23060,11 +23111,14 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       results: [],
       vaultSize: prepared.vaultSize,
       reranked: false,
+      rerankMs: 0,
       hadV2Head: false,
       embeddingsUnavailable: prepared.embeddingsUnavailable,
       rankedOnCosine: false,
       decryptLast: prepared.decryptLast,
-      rowsDecrypted: prepared.rowsDecrypted
+      rowsDecrypted: prepared.rowsDecrypted,
+      queryEmbedMs: prepared.queryEmbedMs,
+      rowsEmbedded: prepared.rowsEmbedded
     };
   }
   const ranked = await rankPreparedVaultCandidates(
@@ -23077,7 +23131,9 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
     ...ranked,
     rankedOnCosine: !ranked.embeddingsUnavailable,
     decryptLast: prepared.decryptLast,
-    rowsDecrypted: prepared.rowsDecrypted
+    rowsDecrypted: prepared.rowsDecrypted,
+    queryEmbedMs: prepared.queryEmbedMs,
+    rowsEmbedded: prepared.rowsEmbedded
   };
 }
 async function searchVaultMemories(query, vaultCtx, embeddingOptions, cache, searchOptions) {
@@ -23227,7 +23283,7 @@ ${formatted}`;
     }
   };
 }
-var warnedProgrammaticDecomposeIgnored, SUPERSESSION_SIMILARITY_THRESHOLD, SUPERSESSION_MIN_AGE_GAP_MS, SUPERSESSION_BOOST_FACTOR, SUPERSESSION_MAX_WINDOW, EMBEDDINGS_DEGRADED_EMPTY_NO_LEXICAL;
+var nowMs2, warnedProgrammaticDecomposeIgnored, SUPERSESSION_SIMILARITY_THRESHOLD, SUPERSESSION_MIN_AGE_GAP_MS, SUPERSESSION_BOOST_FACTOR, SUPERSESSION_MAX_WINDOW, EMBEDDINGS_DEGRADED_EMPTY_NO_LEXICAL;
 var init_searchTool = __esm({
   "src/lib/memoryVault/searchTool.ts"() {
     "use strict";
@@ -23245,6 +23301,7 @@ var init_searchTool = __esm({
     init_bm25();
     init_decomposeQuery();
     init_lruCache();
+    nowMs2 = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
     warnedProgrammaticDecomposeIgnored = false;
     SUPERSESSION_SIMILARITY_THRESHOLD = 0.7;
     SUPERSESSION_MIN_AGE_GAP_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -30602,6 +30659,7 @@ ${TRUNCATION_NOTICE}` : formatted;
 // src/lib/memory/reflect.ts
 init_clientConfig();
 init_logger();
+init_taskType();
 init_portalLlm();
 init_recall();
 var DEFAULT_BASE_URL2 = BASE_URL;
@@ -30647,11 +30705,13 @@ Respond with ONLY a single JSON object conforming to this JSON Schema, with no p
 ${JSON.stringify(
     options.responseSchema
   )}` : basePrompt;
-  const userMessage = `Question:
-${trimmed}
-
-Memories (use only these as evidence):
-${evidence}`;
+  const userMessage = [
+    `Question:
+${trimmed}`,
+    ...options.userInstructions ? [options.userInstructions] : [],
+    `Memories (use only these as evidence):
+${evidence}`
+  ].join("\n\n");
   const maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
   const fetchImpl = options.fetchFn ?? fetch;
   const log = getLogger();
@@ -30665,7 +30725,13 @@ ${evidence}`;
   try {
     response = await fetchImpl(`${baseUrl}/api/v1/chat/completions`, {
       method: "POST",
-      headers: { ...authHeaders, "Content-Type": "application/json" },
+      // No task type unless the caller named one — an undeclared task adds no
+      // header at all, which is what keeps user-facing reflect() unlabelled.
+      headers: {
+        ...authHeaders,
+        ...taskTypeHeader(options.taskType),
+        "Content-Type": "application/json"
+      },
       body: JSON.stringify({
         model,
         // Modern OpenAI field; the portal reads only `max_completion_tokens`
@@ -31117,10 +31183,15 @@ async function synthesizeFacet(facet, ctx, options, prior) {
     limit,
     types: ["fact"],
     maxTokens: DEFAULT_FACET_MAX_TOKENS,
-    // Profile-facet synthesis is a background op, so it marks its own prompt.
-    // reflect() itself must NOT mark — it also serves the user's own questions,
-    // and that traffic is chat, not an internal flow. See ../internalFlowMarker.
-    systemPrompt: withInternalFlowMarker(buildFacetSystemPrompt(facet)),
+    // Profile-facet synthesis is a background op, so it marks its own prompt AND
+    // names its own task. reflect() itself must do neither — it also serves the
+    // user's own questions, and that traffic is chat, not an internal flow. See
+    // ../internalFlowMarker and ReflectOptions.taskType.
+    taskType: "memory_profile_synth",
+    systemPrompt: withInternalFlowMarker(FACET_SYSTEM_PROMPT),
+    // The facet's label/guidance/response-fields, on the user turn — what keeps
+    // the system half fixed and therefore server-ownable.
+    userInstructions: buildFacetUserInstructions(facet),
     responseSchema: facetResponseSchema(facet.key),
     memories
   });
@@ -31178,19 +31249,22 @@ function fallbackSection(facet, prior) {
     stale: true
   };
 }
-function buildFacetSystemPrompt(facet) {
-  const structuredField = FACET_STRUCTURED_RESPONSE_HINT[facet.key] ?? "";
-  return `You are writing the "${facet.label}" section of a person's shareable profile, using their private memories (supplied as evidence) as the only source of truth.
-
-Task for this section:
-${facet.guidance}
+var FACET_SYSTEM_PROMPT = `You are writing one section of a person's shareable profile, using their private memories (supplied as evidence) as the only source of truth. The user turn names the section, states the task for it, and gives the exact JSON shape to respond in.
 
 Rules:
 - Ground every claim in the supplied memories \u2014 never invent, infer beyond, or embellish what they support.
 - If the memories don't cover this section, return an empty summary with hasEvidence=false. Do not pad or guess.
 - Write in third person about the person, in a natural voice suitable for a public profile (no "I"/"you", no name repetition).
 - Be concise and specific; no preamble, hedging, or meta-commentary.
-- Respond as JSON: { "summary": <the section text, or "">, "hasEvidence": <true|false>${structuredField} }.`;
+- Respond as JSON in exactly the shape the user turn states, with no extra fields.`;
+function buildFacetUserInstructions(facet) {
+  const structuredField = FACET_STRUCTURED_RESPONSE_HINT[facet.key] ?? "";
+  return `Section: "${facet.label}"
+
+Task for this section:
+${facet.guidance}
+
+Respond as JSON: { "summary": <the section text, or "">, "hasEvidence": <true|false>${structuredField} }.`;
 }
 function extractFacetText(structured) {
   if (structured && typeof structured === "object") {

package/dist/server/index.d.mts

@@ -4698,6 +4698,51 @@ interface EntityOperationsContext {
     allowUnscopedRows?: boolean;
 }
 
+/**
+ * Class-B task types — the vocabulary of the `X-Anuma-Task-Type` header.
+ *
+ * A Class-B flow has ONE fixed purpose and no conversation: extract memories
+ * from a snippet, pick a topic, consolidate duplicates, classify a query. Today
+ * each of those builds its own system prompt on the client and sends it as a
+ * `role:system` message, which makes the prompt a suggestion rather than a
+ * contract — a caller can reword it into "you are a general assistant" and get
+ * general chat at internal-endpoint prices.
+ *
+ * The fix is that the SERVER owns the text and the client only names the task.
+ * This header is the name. The portal allowlists it against its own copy of this
+ * enum (ai-portal `internal/systemprompt/tasks.go`) and DROPS anything it does
+ * not recognise, so an unknown value degrades to "no task declared" rather than
+ * failing the request.
+ *
+ * ⚠ These string values are a wire contract with ai-portal. Adding one here
+ * before the portal knows it is harmless (it is dropped); renaming or removing
+ * one silently stops that flow being counted. Keep them in step with
+ * `AllTaskTypes` on the portal side, and see ai-portal
+ * `docs/BACKEND_OWNED_TASK_PROMPTS.md` for the rollout.
+ *
+ * ⚠ RELEASE ORDER. This union is a PUBLIC type, so a split is breaking in both
+ * directions and has to be sequenced:
+ *
+ *   1. merge + publish this package;
+ *   2. bump `@anuma/sdk` in the consumer and switch its call sites to the new
+ *      names in the same commit.
+ *
+ * A consumer on the OLD version cannot compile the new names, and a consumer on
+ * the NEW version cannot compile the retired ones (`app_inspiration` is gone
+ * here, replaced by the three `app_inspiration_*` names). Both halves of that
+ * are type-only — the wire itself always degrades safely, because the portal
+ * drops any value it does not recognise. Concretely: ai-memoryless-client#5782
+ * is blocked on this publish for exactly that reason.
+ *
+ * Deliberately ABSENT: agent personas, `reflect()` when it answers the user, and
+ * the app-idea chat. Those carry an open conversation with the user, so a fixed
+ * server-owned prompt would be wrong rather than merely premature — the same
+ * boundary {@link INTERNAL_FLOW_MARKER} draws.
+ *
+ * @public
+ */
+type TaskType = "title" | "commit_message" | "memory_extract" | "memory_dedup" | "memory_decay" | "memory_injection_check" | "memory_verify_support" | "memory_autosort" | "memory_topic" | "memory_consolidate" | "memory_decompose" | "memory_profile_synth" | "memory_graph" | "folder_context" | "selection_memory" | "summarize" | "style_analysis" | "classify_search" | "app_inspiration_generate" | "app_inspiration_trends" | "app_inspiration_remix" | "spotlight_image" | "slide_image" | "slide_video" | "slide_music" | "slide_sfx" | "media_video" | "media_audio" | "media_bg_removal" | "media_image_preset" | "tool_app_builder" | "tool_document_builder" | "tool_slides" | "tool_slides_image_gen" | "connector_guidance" | "cf_task" | "xbot_intent" | "xbot_council" | "scheduled_task";
+
 /**
  * Shared portal LLM call for the memory pipeline.
  *
@@ -5641,6 +5686,17 @@ interface RecallDiagnostics {
      * never the cost.
      */
     vaultRowsDecrypted?: number;
+    /**
+     * Rows the fact lane had to re-embed through the portal because their stored
+     * vector was unusable — stale `embedding_model`, wrong dimension, or
+     * unparseable. Absent when the fact lane didn't run.
+     *
+     * Expected to be 0 on a healthy vault: rows are embedded at write time and the
+     * re-embed writes the current model back, so a persistently non-zero value
+     * means the writeback is not sticking and every turn is paying for it. On the
+     * LEGACY read path this batch is uncapped, so it can be the whole vault.
+     */
+    vaultRowsEmbedded?: number;
     /** Facts the fact lane returned (post-dedupe, pre-fusion). */
     factCount: number;
     /** Chunks the chunk lane returned (post-dedupe, pre-fusion). */
@@ -5653,6 +5709,37 @@ interface RecallDiagnostics {
         prep: number;
         /** Vault fact-lane search (`searchVaultMemoriesWithSize`). */
         factLane: number;
+        /**
+         * The cross-encoder's share of {@link factLane} — wall-clock spent inside
+         * `rerankPairs`. Billed even when the CE threw partway through, because a
+         * rerank that burned three seconds and then failed still cost them.
+         *
+         * A SUBSET of `factLane`, not a sibling: read `factLane - rerank` for
+         * everything else the lane did (query embed, vault read, fused ranking).
+         * 0 when the CE did not run; `reranked` is what distinguishes that from a
+         * rerank that cost nothing.
+         *
+         * Exists because #845 spent three rounds arguing about which stage inside
+         * the fact lane dominated — whole-vault read, then admission window, then
+         * the CE — with one aggregate number for all of them. Every hypothesis was
+         * an inference; this makes the question a query.
+         */
+        rerank: number;
+        /**
+         * The query embed's share of {@link factLane} — one portal round trip.
+         *
+         * Also a SUBSET of `factLane`. Together with `rerank` this makes the lane
+         * decomposable: `factLane - queryEmbed - rerank` is the local work (vault
+         * read, decrypt, BM25/cosine fusion), and each of the three implies a
+         * completely different fix.
+         *
+         * 0 when the lane returned before embedding, which includes every empty
+         * vault — `prepareVaultCandidates` short-circuits first. That is why the
+         * fast `vault_size = 0` population never established a baseline for this
+         * cost, and why the ~850ms floor on the smallest NON-empty vaults had no
+         * attributable owner.
+         */
+        queryEmbed: number;
         /** Chunk-lane search (`searchChunksOp`). */
         chunkLane: number;
         /** Cross-lane RRF fusion + provenance dedup after both lanes. */
@@ -8757,6 +8844,28 @@ interface ReflectOptions extends RecallOptions, PortalLlmAuth {
     maxTokens?: number;
     /** Override the grounding system prompt. */
     systemPrompt?: string;
+    /**
+     * Extra caller instruction to carry on the USER turn, between the question and
+     * the evidence block (see the `userMessage` assembly below). This is the slot a
+     * background caller uses to keep its per-request data OUT of the system message
+     * without colliding with the numbered evidence list — profile-facet synthesis
+     * puts its section label, guidance and response-field hint here so its system
+     * half can stay fixed and server-ownable.
+     */
+    userInstructions?: string;
+    /**
+     * Class-B task name for the `X-Anuma-Task-Type` header, or nothing.
+     *
+     * Deliberately OPTIONAL and unset by default. reflect() also answers the user's
+     * OWN question, and that traffic is chat, not an internal flow — declaring a
+     * task type unconditionally here would put an internal-flow name on real
+     * conversation, which is the same boundary `INTERNAL_FLOW_MARKER` draws
+     * (reflect is deliberately unmarked; its background caller marks its own
+     * prompt — see ../internalFlowMarker.ts). So the name is per call: only a
+     * caller with ONE fixed purpose passes
+     * one, and today that is profile-facet synthesis (`memory_profile_synth`).
+     */
+    taskType?: TaskType;
     /** Endpoint for the answer LLM. */
     baseUrl?: string;
     /** Override fetch (for tests). */