@vellumai/assistant 0.8.0 → 0.8.1

package/src/memory/conversation-queries.ts

@@ -51,9 +51,13 @@ export function listConversations(
   ensureDisplayOrderMigration();
   ensureGroupMigration();
   const db = getDb();
+  // 'private' is excluded defensively: in-place snapshot restore swaps the
+  // SQLite file without running migrations in-process, so legacy private rows
+  // can briefly exist before migration cleanup. Hide them from foreground
+  // lists until the next migration pass deletes them.
   const typeCond = backgroundOnly
     ? sql`${conversations.conversationType} IN ('background', 'scheduled') AND (${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`
-    : sql`${conversations.conversationType} NOT IN ('background', 'scheduled')`;
+    : sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private')`;
   const where = includeArchived
     ? typeCond
     : sql`${typeCond} AND ${conversations.archivedAt} IS NULL`;
@@ -80,7 +84,7 @@ export function listPinnedConversations(): ConversationRow[] {
     .from(conversations)
     .where(
       and(
-        sql`${conversations.conversationType} NOT IN ('background', 'scheduled')`,
+        sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private')`,
         sql`is_pinned = 1`,
       ),
     )
@@ -258,7 +262,7 @@ export function searchConversations(
         FROM messages_fts f
         JOIN messages m ON m.id = f.message_id
         JOIN conversations c ON c.id = m.conversation_id
-        WHERE messages_fts MATCH ? AND c.conversation_type NOT IN ('background', 'scheduled') AND c.archived_at IS NULL
+        WHERE messages_fts MATCH ? AND c.conversation_type NOT IN ('background', 'scheduled', 'private') AND c.archived_at IS NULL
         LIMIT 1000
       `,
         ftsMatch,
@@ -283,7 +287,7 @@ export function searchConversations(
       SELECT DISTINCT m.conversation_id
       FROM messages m
       JOIN conversations c ON c.id = m.conversation_id
-      WHERE m.content LIKE ? ESCAPE '\\' AND c.conversation_type NOT IN ('background', 'scheduled') AND c.archived_at IS NULL
+      WHERE m.content LIKE ? ESCAPE '\\' AND c.conversation_type NOT IN ('background', 'scheduled', 'private') AND c.archived_at IS NULL
       LIMIT 1000
     `,
       likePattern,
@@ -297,7 +301,7 @@ export function searchConversations(
     .from(conversations)
     .where(
       and(
-        sql`${conversations.conversationType} NOT IN ('background', 'scheduled')`,
+        sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private')`,
         sql`${conversations.title} LIKE ${titlePattern} ESCAPE '\\'`,
         sql`${conversations.archivedAt} IS NULL`,
       ),

package/src/memory/conversation-title-service.ts

@@ -39,6 +39,7 @@ export type TitleOrigin =
   | "task_submit"
   | "updates_bulletin"
   | "memory_consolidation"
+  | "memory_retrospective"
   | "misc";
 
 export interface TitleContext {

package/src/memory/conversation-types.ts

@@ -0,0 +1,16 @@
+// Re-exports the canonical conversation-type union (defined alongside the
+// create path in `conversation-crud.ts`) under a read-side name and provides
+// the shared "is this a non-interactive / background conversation?" predicate
+// used by notification-feed and memory filters.
+
+import type { ConversationCreateType } from "./conversation-crud.js";
+
+export type ConversationType = ConversationCreateType;
+
+// Tolerant of null/undefined/unknown strings so it can be called directly on
+// raw DB column values without pre-validation.
+export function isBackgroundConversationType(
+  t: ConversationType | string | null | undefined,
+): boolean {
+  return t === "background" || t === "scheduled";
+}

package/src/memory/db-init.ts

@@ -39,6 +39,7 @@ import {
   migrate230AcpSessionHistory,
   migrate231RepairMemoryGraphEventDates,
   migrateActivationState,
+  migrateActivationStateFkCascade,
   migrateAddConversationInferenceProfile,
   migrateAddSourceTypeColumns,
   migrateAssistantContactMetadata,
@@ -46,6 +47,7 @@ import {
   migrateBackfillContactInteractionStats,
   migrateBackfillGuardianPrincipalId,
   migrateBackfillInlineAttachmentsToDisk,
+  migrateBackfillProviderConnectionLabel,
   migrateBackfillUsageCacheAccounting,
   migrateCallSessionInviteMetadata,
   migrateCallSessionMode,
@@ -63,6 +65,7 @@ import {
   migrateContactsUserFileColumn,
   migrateConversationForkLineage,
   migrateConversationHostAccess,
+  migrateConversationInferenceProfileSession,
   migrateConversationsArchivedAt,
   migrateConversationsLastMessageAt,
   migrateConversationsThreadTypeIndex,
@@ -71,6 +74,7 @@ import {
   migrateCreateMemoryGraphNodeEdits,
   migrateCreateMemoryGraphTables,
   migrateCreateMemoryRecallLogs,
+  migrateCreateProviderConnections,
   migrateCreateThreadStartersTable,
   migrateCreateTraceEventsTable,
   migrateDeletePrivateConversations,
@@ -112,7 +116,9 @@ import {
   migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
   migrateMemoryRecallLogsQueryContext,
+  migrateMemoryRetrospectiveState,
   migrateMemoryV2ActivationLogs,
+  migrateMessageBookmarks,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
   migrateNormalizePhoneIdentities,
@@ -133,6 +139,7 @@ import {
   migrateOAuthProvidersScopeSeparator,
   migrateOAuthProvidersTokenAuthMethodDefault,
   migrateOAuthProvidersTokenExchangeBodyFormat,
+  migrateProviderConnectionStatusLabel,
   migrateReminderRoutingIntent,
   migrateRemindersToSchedules,
   migrateRenameConversationTypeColumn,
@@ -399,6 +406,7 @@ export function initializeDb(): void {
     migrate230AcpSessionHistory,
     migrate231RepairMemoryGraphEventDates,
     migrateActivationState,
+    migrateActivationStateFkCascade,
     migrateMemoryV2ActivationLogs,
     migrateCreateDocumentConversations,
     migrateLlmUsageAttribution,
@@ -410,6 +418,12 @@ export function initializeDb(): void {
     },
     migrateScheduleRetryPolicy,
     migrateTraceEventsCreatedAtIndex,
+    migrateConversationInferenceProfileSession,
+    migrateMessageBookmarks,
+    migrateCreateProviderConnections,
+    migrateProviderConnectionStatusLabel,
+    migrateMemoryRetrospectiveState,
+    migrateBackfillProviderConnectionLabel,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/embedding-backend.ts

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getOllamaBaseUrlEnv } from "../config/env.js";
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import type { AssistantConfig } from "../config/types.js";
 import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
 import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
@@ -778,7 +779,7 @@ export async function selectedBackendSupportsMultimodal(
 
 async function isOllamaConfigured(config: AssistantConfig): Promise<boolean> {
   return (
-    config.llm.default.provider === "ollama" ||
+    resolveCallSiteConfig("mainAgent", config.llm).provider === "ollama" ||
     Boolean(await getProviderKeyAsync("ollama")) ||
     Boolean(getOllamaBaseUrlEnv())
   );

package/src/memory/embedding-runtime-manager.ts

@@ -44,7 +44,7 @@ const JINJA_VERSION = "0.5.5";
  * scripts when the worker IPC contract or spawn-args list changes (without
  * requiring an `@huggingface/transformers` version bump).
  */
-const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}_workers-v2`;
+const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}_workers-v3`;
 
 const WORKER_FILENAME = "embed-worker.mjs";
 const RERANK_WORKER_FILENAME = "rerank-worker.mjs";
@@ -252,7 +252,6 @@ async function processQueue() {
         text_pair: passages,
         padding: true,
         truncation: true,
-        return_tensors: 'pt',
       });
       const out = await session(inputs);
       const logits = out.logits.data;

package/src/memory/graph/__tests__/remember-description.test.ts

@@ -0,0 +1,55 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let flagEnabled = false;
+
+mock.module("../../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (_key: string, _config: unknown) =>
+    flagEnabled,
+}));
+
+import { getRememberDescription } from "../tools.js";
+
+const stubConfig = {} as unknown as Parameters<
+  typeof getRememberDescription
+>[0];
+
+describe("getRememberDescription", () => {
+  beforeEach(() => {
+    flagEnabled = false;
+  });
+
+  test("flag off — returns the default high-pressure description", () => {
+    const desc = getRememberDescription(stubConfig);
+    expect(desc).toContain("**CRITICAL:**");
+    expect(desc).toContain("most frequently used tool");
+    expect(desc).toContain("almost every turn");
+  });
+
+  test("flag on — returns the relaxed judgment-framing description", () => {
+    flagEnabled = true;
+    const desc = getRememberDescription(stubConfig);
+    expect(desc).not.toContain("**CRITICAL:**");
+    expect(desc).not.toContain("almost every turn");
+    expect(desc).toContain("a retrospective pass");
+    expect(desc).toContain("Use judgment");
+  });
+
+  test("the two variants differ", () => {
+    flagEnabled = false;
+    const off = getRememberDescription(stubConfig);
+    flagEnabled = true;
+    const on = getRememberDescription(stubConfig);
+    expect(off).not.toBe(on);
+  });
+
+  test("corrections-are-priority language is preserved in BOTH variants", () => {
+    flagEnabled = false;
+    expect(getRememberDescription(stubConfig)).toMatch(
+      /Corrections are.*highest priority/i,
+    );
+    flagEnabled = true;
+    expect(getRememberDescription(stubConfig)).toMatch(
+      /Corrections are.*highest priority/i,
+    );
+  });
+});

package/src/memory/graph/conversation-graph-memory.ts

@@ -7,6 +7,7 @@
 // ---------------------------------------------------------------------------
 
 import { and, desc, eq, inArray, ne, notInArray } from "drizzle-orm";
+import { z } from "zod";
 
 import type { AssistantConfig } from "../../config/types.js";
 import { estimateTextTokens } from "../../context/token-estimator.js";
@@ -19,6 +20,8 @@ import type {
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { getDb } from "../db-connection.js";
+import { embedWithRetry } from "../embed.js";
+import { generateSparseEmbedding } from "../embedding-backend.js";
 import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
@@ -388,8 +391,15 @@ export class ConversationGraphMemory {
 
       return await this.runPerTurn(messages, config, abortSignal);
     } catch (err) {
+      const errCode =
+        err instanceof z.ZodError ? err.issues[0]?.code : undefined;
       log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
+        {
+          err: err instanceof Error ? err.message : String(err),
+          conversationId: this.conversationId,
+          turn: this.tracker.getTurn(),
+          errCode,
+        },
         "Memory retrieval failed (non-fatal)",
       );
       return noopResult;
@@ -422,10 +432,19 @@ export class ConversationGraphMemory {
       "",
       signal,
     );
-    this.initialized = true;
-    this.needsReload = false;
 
     if (v2.routed) {
+      // Surface a user-query embedding so PKB hint search still runs on v2
+      // turns. v1's `loadContextMemory` produced these as a side effect of
+      // hybrid retrieval; the v2 path skips that retrieval, so embed
+      // explicitly here.
+      const userQueryEmbed = await this.computeQueryVectors(
+        rawUserText ?? userQuery ?? "",
+        config,
+        signal,
+      );
+      this.initialized = true;
+      this.needsReload = false;
       this.lastInjectedBlock = v2.injectedBlockText;
       this.lastInjectedNodeIds = [];
       this.lastInjectedImages = new Map();
@@ -438,6 +457,8 @@ export class ConversationGraphMemory {
         mode: "context-load" as const,
         injectedBlockText: v2.injectedBlockText,
         metrics: null,
+        userQueryVector: userQueryEmbed.dense,
+        userQuerySparseVector: userQueryEmbed.sparse,
       };
     }
 
@@ -449,6 +470,12 @@ export class ConversationGraphMemory {
       config,
       signal,
     });
+    // Set initialized only after v1 retrieval succeeds. If `loadContextMemory`
+    // throws (transient DB/Qdrant failure), `prepareMemory` catches and
+    // returns noop, but we want the next turn to retry the bootstrap path
+    // rather than be stuck in per-turn mode.
+    this.initialized = true;
+    this.needsReload = false;
 
     if (result.nodes.length === 0) {
       this.lastInjectedBlock = null;
@@ -569,6 +596,14 @@ export class ConversationGraphMemory {
       signal,
     );
     if (v2.routed) {
+      // Surface a per-turn query embedding so PKB hint search still runs
+      // on v2 turns. v1's `retrieveForTurn` produced these as a side effect;
+      // the v2 path skips that retrieval, so embed explicitly here.
+      const perTurnEmbed = await this.computeQueryVectors(
+        userLast,
+        config,
+        signal,
+      );
       this.lastInjectedBlock = v2.injectedBlockText;
       this.lastInjectedNodeIds = [];
       this.lastInjectedImages = new Map();
@@ -581,6 +616,8 @@ export class ConversationGraphMemory {
         mode: "per-turn" as const,
         injectedBlockText: v2.injectedBlockText,
         metrics: null,
+        queryVector: perTurnEmbed.dense,
+        sparseVector: perTurnEmbed.sparse,
       };
     }
 
@@ -652,6 +689,35 @@ export class ConversationGraphMemory {
     };
   }
 
+  /**
+   * Embed a query string for PKB hint search on v2 turns. v1 retrieval
+   * produced these vectors as a side effect; on v2 we skip retrieval, so
+   * the agent loop loses the dense/sparse pair it needs to drive
+   * `buildPkbReminderWithHints`. Failures here degrade PKB hints to the
+   * static fallback rather than blocking the turn.
+   */
+  private async computeQueryVectors(
+    text: string,
+    config: AssistantConfig,
+    signal: AbortSignal,
+  ): Promise<{ dense?: number[]; sparse?: QdrantSparseVector }> {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) return {};
+    let dense: number[] | undefined;
+    try {
+      const result = await embedWithRetry(config, [trimmed], { signal });
+      dense = result.vectors[0];
+    } catch (err) {
+      log.warn(
+        { err: err instanceof Error ? err.message : String(err) },
+        "Failed to embed query for PKB hints on v2 path",
+      );
+    }
+    const sparseRaw = generateSparseEmbedding(trimmed);
+    const sparse = sparseRaw.indices.length > 0 ? sparseRaw : undefined;
+    return { dense, sparse };
+  }
+
   /**
    * Run the v2 activation pipeline when the workspace config
    * (`memory.v2.enabled`) is on.
@@ -716,7 +782,11 @@ export class ConversationGraphMemory {
  * Count the leading content blocks on a user message that were added by
  * `injectMemoryBlock`. Memory-injected images use a 3-block pattern
  * (opening `<memory_image>` text + image + closing `</memory_image>` text),
- * followed by a `<memory>…</memory>` text block (legacy `<memory __injected>` is also accepted). A legacy
+ * followed by a `<memory>…</memory>` text block (legacy `<memory __injected>` is also accepted).
+ * The bare `<memory>` form is matched only when the block also ends with
+ * `\n</memory>`, so user-authored content that happens to begin with
+ * `<memory>` (for example, a message discussing the XML-like markup) is not
+ * mistaken for an injected prefix and stripped on re-injection. A legacy
  * 2-block image pattern (no closing tag) is also accepted for backward
  * compatibility. The injection prefix is always contiguous at the start,
  * so we stop at the first non-memory block.
@@ -729,7 +799,8 @@ export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
     const block = content[firstNonMemory];
     if (
       block.type === "text" &&
-      (block.text.startsWith("<memory>\n") ||
+      ((block.text.startsWith("<memory>\n") &&
+        block.text.endsWith("\n</memory>")) ||
         block.text.startsWith("<memory __injected>\n"))
     ) {
       firstNonMemory++;

package/src/memory/graph/extraction.ts

@@ -723,8 +723,12 @@ export function parseExtractionResponse(
 
     // Auto-create event trigger when event_date is set but LLM didn't include one,
     // or replace a malformed event trigger (event_date unset) with a valid one.
+    // Only auto-create for future events — past-dated memories (historical
+    // milestones, dated events that already happened) shouldn't generate
+    // ramp/follow-up reminders.
     if (
       node.eventDate != null &&
+      node.eventDate > now &&
       (!Array.isArray(raw.triggers) ||
         !raw.triggers.some((t) => t.type === "event" && t.event_date != null))
     ) {

package/src/memory/graph/graph-memory-state-store.ts

@@ -24,9 +24,7 @@ export function saveGraphMemoryState(
 /**
  * Load graph memory state for a conversation, or null if none exists.
  */
-export function loadGraphMemoryState(
-  conversationId: string,
-): string | null {
+export function loadGraphMemoryState(conversationId: string): string | null {
   const db = getDb();
   const row = db
     .select({ stateJson: conversationGraphMemoryState.stateJson })
@@ -35,3 +33,18 @@ export function loadGraphMemoryState(
     .get();
   return row?.stateJson ?? null;
 }
+
+/**
+ * Copy the parent conversation's graph memory state row to a new conversation
+ * id so the forked conversation resumes with the parent's InContextTracker
+ * snapshot (in-context node IDs, per-node turn log, current turn). No-op if
+ * the parent has no row yet.
+ */
+export function forkGraphMemoryState(
+  parentConversationId: string,
+  newConversationId: string,
+): void {
+  const stateJson = loadGraphMemoryState(parentConversationId);
+  if (stateJson == null) return;
+  saveGraphMemoryState(newConversationId, stateJson);
+}

package/src/memory/graph/tool-handlers.ts

@@ -69,6 +69,22 @@ export function handleRemember(
   return { success: true, message: "Saved to knowledge base." };
 }
 
+/**
+ * Format `now` as a buffer-entry timestamp (`Mon D, h:mm AM/PM`). Exported so
+ * the memory v2 consolidation job can present its cutoff in the same shape
+ * the buffer entries use, making the agent's "timestamp ≥ cutoff" comparison
+ * unambiguous at minute precision.
+ */
+export function formatBufferTimestamp(now: Date): string {
+  const month = now.toLocaleString("en-US", { month: "short" });
+  const day = now.getDate();
+  const hours = now.getHours();
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const ampm = hours >= 12 ? "PM" : "AM";
+  const displayHour = hours % 12 || 12;
+  return `${month} ${day}, ${displayHour}:${minutes} ${ampm}`;
+}
+
 /**
  * Build a timestamped bullet entry for `buffer.md` / `archive/<date>.md`.
  *
@@ -80,13 +96,7 @@ export function handleRemember(
  * entries identically to user-facing `remember()` calls.
  */
 export function formatRememberEntry(content: string, now: Date): string {
-  const month = now.toLocaleString("en-US", { month: "short" });
-  const day = now.getDate();
-  const hours = now.getHours();
-  const minutes = String(now.getMinutes()).padStart(2, "0");
-  const ampm = hours >= 12 ? "PM" : "AM";
-  const displayHour = hours % 12 || 12;
-  return `- [${month} ${day}, ${displayHour}:${minutes} ${ampm}] ${content}\n`;
+  return `- [${formatBufferTimestamp(now)}] ${content}\n`;
 }
 
 /**

package/src/memory/graph/tools.ts

@@ -2,6 +2,8 @@
 // Memory Tool definitions for agentic recall and remember.
 // ---------------------------------------------------------------------------
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../../config/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import {
   ALL_RECALL_SOURCES,
@@ -12,13 +14,13 @@ import {
 const RECALL_DEPTHS = ["fast", "standard", "deep"] as const;
 
 /**
- * Explicit local information search across memory, PKB, conversations, and
+ * Explicit local information search across memory, conversations, and
  * workspace files.
  */
 export const graphRecallDefinition: ToolDefinition = {
   name: "recall",
   description:
-    'Search local information the moment you feel uncertain. Use recall for memory, the personal knowledge base, past conversations, and workspace files — before you guess, before you ask, before you hedge. Auto-injection is incomplete by design; it surfaces patterns, not the specifics you need to answer well. If you catch yourself reaching for "I think", "I believe", "if I remember", "didn\'t we", "last time" — that\'s the signal. Recall. If the user references someone, a place, a decision, a document, or prior work you should be able to find locally — recall. Call it multiple times per conversation if the turn warrants it. Be specific in your query for best results.',
+    'Search local information the moment you feel uncertain. Use recall for memory, past conversations, and workspace files — before you guess, before you ask, before you hedge. Auto-injection is incomplete by design; it surfaces patterns, not the specifics you need to answer well. If you catch yourself reaching for "I think", "I believe", "if I remember", "didn\'t we", "last time" — that\'s the signal. Recall. If the user references someone, a place, a decision, a document, or prior work you should be able to find locally — recall. Call it multiple times per conversation if the turn warrants it. Be specific in your query for best results.',
   input_schema: {
     type: "object",
     properties: {
@@ -34,7 +36,7 @@ export const graphRecallDefinition: ToolDefinition = {
           enum: [...ALL_RECALL_SOURCES],
         },
         description:
-          "Optional local sources to search. Omit to search memory, PKB, conversations, and workspace files.",
+          "Optional local sources to search. Omit to search memory, conversations, and workspace files.",
       },
       max_results: {
         type: "integer",
@@ -53,6 +55,38 @@ export const graphRecallDefinition: ToolDefinition = {
   },
 };
 
+/**
+ * Default (high-pressure) `remember` tool description. Used when the
+ * `memory-retrospective` feature flag is OFF. The volume-shaming language
+ * ("almost every turn", "most frequently used tool") drives aggressive
+ * in-conversation capture for users who don't have the retrospective
+ * backstop enabled.
+ */
+const REMEMBER_DESCRIPTION_DEFAULT =
+  "Remember anything concrete: facts, preferences, corrections, plans, felt moments, names, dates, decisions. Default to remembering. Never wait until end of conversation. Corrections are highest priority — call remember the same turn the correction lands. **CRITICAL:** You should be calling remember on almost every turn. This should be your most frequently used tool.";
+
+/**
+ * Relaxed `remember` tool description used when `memory-retrospective` is
+ * ON. The retrospective pass catches what isn't captured in the moment, so
+ * the in-conversation pressure eases to a judgment framing: pause when
+ * something feels worth marking, not because the volume is required.
+ */
+const REMEMBER_DESCRIPTION_RELAXED =
+  "Remember anything concrete the user shared: corrections, plans, decisions, felt moments, names, dates, commitments, preferences. Corrections are the highest priority — call `remember` the same turn the correction lands. You don't have to call this on every turn; a retrospective pass reviews the conversation after each message-count / time interval and saves what you didn't capture. Use judgment: pause and remember when something feels worth marking, not because the volume is required.";
+
+/**
+ * Return the description that should appear in the `remember` tool
+ * registration for the current config. The variant is selected by the
+ * `memory-retrospective` assistant feature flag. Exposed as a function so
+ * the tool registrar can compute the value at registration time without
+ * importing config layers into the static definition.
+ */
+export function getRememberDescription(config: AssistantConfig): string {
+  return isAssistantFeatureFlagEnabled("memory-retrospective", config)
+    ? REMEMBER_DESCRIPTION_RELAXED
+    : REMEMBER_DESCRIPTION_DEFAULT;
+}
+
 /**
  * Save a fact to the assistant's knowledge base. The fact is appended to
  * `buffer.md` (immediately available in the next conversation) and the daily
@@ -60,11 +94,16 @@ export const graphRecallDefinition: ToolDefinition = {
  * writes go under `memory/`; otherwise they go under `pkb/`. Consolidation
  * of the buffer into longer-form storage runs as a separate periodic job in
  * both modes.
+ *
+ * The static `description` field carries the default (high-pressure) text
+ * so any direct importer that doesn't go through `getRememberDescription`
+ * still gets a valid tool definition. The registered `RememberTool` in
+ * `tools/memory/register.ts` overrides this at registration time with the
+ * flag-aware variant.
  */
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",
-  description:
-    "Remember anything concrete: facts, preferences, corrections, plans, felt moments, names, dates, decisions. Default to remembering. Never wait until end of conversation. Corrections are highest priority — call remember the same turn the correction lands. **CRITICAL:** You should be calling remember on almost every turn. This should be your most frequently used tool.",
+  description: REMEMBER_DESCRIPTION_DEFAULT,
   input_schema: {
     type: "object",
     properties: {

package/src/memory/indexer.ts

@@ -12,6 +12,8 @@ import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import { getDb } from "./db-connection.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
 import { enqueueMemoryJob, upsertDebouncedJob } from "./jobs-store.js";
+import { isMemoryRetrospectiveConversation } from "./memory-retrospective-enqueue.js";
+import { maybeEnqueueRetrospective } from "./memory-retrospective-trigger-check.js";
 import {
   extractMediaBlockMeta,
   extractTextFromStoredMessageContent,
@@ -283,6 +285,21 @@ export async function indexMessageNow(
           });
         }
       }
+
+      // ── Memory retrospective triggers ─────────────────────────────────
+      // Independent of auto-analyze: the retrospective is a focused,
+      // memory-only pass that re-reads messages since its last successful
+      // run and saves what the in-conversation `remember` calls didn't
+      // capture. Triggers (interval / message_count) are evaluated by
+      // `maybeEnqueueRetrospective`, which also enforces the per-conversation
+      // cooldown gate against retry storms. Recursion guard skips the
+      // memory-retrospective background conversation itself.
+      if (
+        triggerConfig != null &&
+        !isMemoryRetrospectiveConversation(input.conversationId)
+      ) {
+        maybeEnqueueRetrospective(input.conversationId, triggerConfig);
+      }
     }
 
     // ── Conversation summarization (independent of extraction) ────────