@vellumai/assistant 0.6.3 → 0.6.4

package/src/memory/graph/scoring.test.ts

@@ -5,9 +5,12 @@ import {
   computeEffectiveSignificance,
   computeRecencyBoost,
   computeTemporalBoost,
+  DEFAULT_WEIGHTS,
   PER_TURN_WEIGHTS,
+  PROCEDURAL_WEIGHTS,
   scoreCandidate,
   type ScoringWeights,
+  weightsForContextLoad,
 } from "./scoring.js";
 import type { MemoryNode } from "./types.js";
 
@@ -546,3 +549,186 @@ describe("scoreCandidate", () => {
     expect(result.scoreBreakdown.effectiveSignificance).toBe(0.7);
   });
 });
+
+// ---------------------------------------------------------------------------
+// weightsForContextLoad + PROCEDURAL_WEIGHTS
+// ---------------------------------------------------------------------------
+
+describe("weightsForContextLoad", () => {
+  test("returns PROCEDURAL_WEIGHTS for procedural nodes", () => {
+    const node = makeNode({ type: "procedural" });
+    expect(weightsForContextLoad(node)).toBe(PROCEDURAL_WEIGHTS);
+  });
+
+  test("returns DEFAULT_WEIGHTS for episodic nodes", () => {
+    const node = makeNode({ type: "episodic" });
+    expect(weightsForContextLoad(node)).toBe(DEFAULT_WEIGHTS);
+  });
+
+  test("returns DEFAULT_WEIGHTS for semantic/emotional/prospective/behavioral/narrative/shared nodes", () => {
+    for (const type of [
+      "semantic",
+      "emotional",
+      "prospective",
+      "behavioral",
+      "narrative",
+      "shared",
+    ] as const) {
+      const node = makeNode({ type });
+      expect(weightsForContextLoad(node)).toBe(DEFAULT_WEIGHTS);
+    }
+  });
+});
+
+describe("PROCEDURAL_WEIGHTS", () => {
+  test("weights sum to 1.0", () => {
+    const sum =
+      PROCEDURAL_WEIGHTS.semanticSimilarity +
+      PROCEDURAL_WEIGHTS.effectiveSignificance +
+      PROCEDURAL_WEIGHTS.emotionalIntensity +
+      PROCEDURAL_WEIGHTS.temporalBoost +
+      PROCEDURAL_WEIGHTS.recencyBoost +
+      PROCEDURAL_WEIGHTS.triggerBoost +
+      PROCEDURAL_WEIGHTS.activationBoost;
+    expect(sum).toBeCloseTo(1.0, 5);
+  });
+
+  test("zeroes out emotionalIntensity and temporalBoost", () => {
+    // Procedural memories have no emotional charge and no time-of-day pattern
+    // by nature — grading on these signals is just dead weight.
+    expect(PROCEDURAL_WEIGHTS.emotionalIntensity).toBe(0);
+    expect(PROCEDURAL_WEIGHTS.temporalBoost).toBe(0);
+  });
+
+  test("weights semanticSimilarity and effectiveSignificance more heavily than DEFAULT_WEIGHTS", () => {
+    expect(PROCEDURAL_WEIGHTS.semanticSimilarity).toBeGreaterThan(
+      DEFAULT_WEIGHTS.semanticSimilarity,
+    );
+    expect(PROCEDURAL_WEIGHTS.effectiveSignificance).toBeGreaterThan(
+      DEFAULT_WEIGHTS.effectiveSignificance,
+    );
+  });
+
+  test("procedural node outscores otherwise-identical episodic node under type-aware weights", () => {
+    // A procedural memory with zero emotional charge, zero recency, zero
+    // trigger — all dead signals — should still surface under PROCEDURAL_WEIGHTS
+    // thanks to semantic relevance and significance. Under DEFAULT_WEIGHTS the
+    // same signals would leave ~45% of the budget dead.
+    const proceduralNode = makeNode({ type: "procedural" });
+    const episodicNode = makeNode({ id: "node-2", type: "episodic" });
+
+    // Components a procedural memory typically carries: semantic hit + stable
+    // significance, but no emotional charge, no recency, no trigger.
+    const proceduralComponents = {
+      semanticSimilarity: 0.8,
+      effectiveSignificance: 0.7,
+      emotionalIntensity: 0,
+      temporalBoost: 0.5, // neutral
+      recencyBoost: 0,
+      triggerBoost: 0,
+      activationBoost: 0,
+    };
+
+    const proceduralScore = scoreCandidate(
+      proceduralNode,
+      proceduralComponents,
+      weightsForContextLoad(proceduralNode),
+    ).score;
+    const episodicScore = scoreCandidate(
+      episodicNode,
+      proceduralComponents,
+      weightsForContextLoad(episodicNode),
+    ).score;
+
+    expect(proceduralScore).toBeGreaterThan(episodicScore);
+  });
+
+  test("episodic node with full signal still outscores procedural with only semantic signal", () => {
+    // The change must NOT break episodic retrieval: an episodic memory with
+    // emotional charge + recency + moderate significance should still outrank
+    // a procedural memory that only has semantic relevance.
+    const episodicNode = makeNode({ type: "episodic" });
+    const proceduralNode = makeNode({ id: "node-2", type: "procedural" });
+
+    const episodicComponents = {
+      semanticSimilarity: 0.5,
+      effectiveSignificance: 0.6,
+      emotionalIntensity: 0.7,
+      temporalBoost: 0.6,
+      recencyBoost: 0.9,
+      triggerBoost: 0.4,
+      activationBoost: 0.3,
+    };
+
+    const proceduralComponents = {
+      semanticSimilarity: 0.5,
+      effectiveSignificance: 0.3,
+      emotionalIntensity: 0,
+      temporalBoost: 0.5,
+      recencyBoost: 0,
+      triggerBoost: 0,
+      activationBoost: 0,
+    };
+
+    const episodicScore = scoreCandidate(
+      episodicNode,
+      episodicComponents,
+      weightsForContextLoad(episodicNode),
+    ).score;
+    const proceduralScore = scoreCandidate(
+      proceduralNode,
+      proceduralComponents,
+      weightsForContextLoad(proceduralNode),
+    ).score;
+
+    expect(episodicScore).toBeGreaterThan(proceduralScore);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Regression: DEFAULT_WEIGHTS behavior unchanged
+// ---------------------------------------------------------------------------
+
+describe("DEFAULT_WEIGHTS (regression)", () => {
+  test("weights sum to 1.0", () => {
+    const sum =
+      DEFAULT_WEIGHTS.semanticSimilarity +
+      DEFAULT_WEIGHTS.effectiveSignificance +
+      DEFAULT_WEIGHTS.emotionalIntensity +
+      DEFAULT_WEIGHTS.temporalBoost +
+      DEFAULT_WEIGHTS.recencyBoost +
+      DEFAULT_WEIGHTS.triggerBoost +
+      DEFAULT_WEIGHTS.activationBoost;
+    expect(sum).toBeCloseTo(1.0, 5);
+  });
+
+  test("preserves exact weight values", () => {
+    expect(DEFAULT_WEIGHTS).toEqual({
+      semanticSimilarity: 0.25,
+      effectiveSignificance: 0.15,
+      emotionalIntensity: 0.15,
+      temporalBoost: 0.05,
+      recencyBoost: 0.15,
+      triggerBoost: 0.15,
+      activationBoost: 0.1,
+    });
+  });
+
+  test("scoreCandidate without weights argument uses DEFAULT_WEIGHTS", () => {
+    // Backwards-compat: existing callers that pass no weights argument should
+    // continue to get DEFAULT_WEIGHTS scoring.
+    const node = makeNode({ type: "episodic" });
+    const components = {
+      semanticSimilarity: 1.0,
+      effectiveSignificance: 1.0,
+      emotionalIntensity: 1.0,
+      temporalBoost: 1.0,
+      recencyBoost: 1.0,
+      triggerBoost: 1.0,
+      activationBoost: 1.0,
+    };
+    const implicit = scoreCandidate(node, components).score;
+    const explicit = scoreCandidate(node, components, DEFAULT_WEIGHTS).score;
+    expect(implicit).toBe(explicit);
+  });
+});

package/src/memory/graph/scoring.ts

@@ -166,7 +166,7 @@ export interface ScoringWeights {
 }
 
 /** Weights for context-load (conversation start): balanced across all signals. */
-const DEFAULT_WEIGHTS: ScoringWeights = {
+export const DEFAULT_WEIGHTS: ScoringWeights = {
   semanticSimilarity: 0.25,
   effectiveSignificance: 0.15,
   emotionalIntensity: 0.15,
@@ -176,6 +176,28 @@ const DEFAULT_WEIGHTS: ScoringWeights = {
   activationBoost: 0.1,
 };
 
+/**
+ * Weights for context-load of procedural memories (learned skills, how-to).
+ * Procedural memories have no emotional charge, no time-of-day pattern, and
+ * are often old-but-stable (a workaround learned months ago stays useful).
+ * Grading them on DEFAULT_WEIGHTS wastes ~45% of the budget on signals that
+ * are structurally ~0 for procedurals, causing them to lose out to episodic
+ * and emotional memories that simply have more signals lit up.
+ *
+ * This redistributes the dead weight onto semantic similarity and
+ * significance — the signals that actually differentiate useful procedurals
+ * from stale ones.
+ */
+export const PROCEDURAL_WEIGHTS: ScoringWeights = {
+  semanticSimilarity: 0.45,
+  effectiveSignificance: 0.25,
+  emotionalIntensity: 0.0,
+  temporalBoost: 0.0,
+  recencyBoost: 0.05,
+  triggerBoost: 0.1,
+  activationBoost: 0.15,
+};
+
 /**
  * Weights for per-turn injection: heavily biased toward semantic similarity.
  * Per-turn injections should only surface memories directly relevant to
@@ -191,6 +213,14 @@ export const PER_TURN_WEIGHTS: ScoringWeights = {
   activationBoost: 0.05,
 };
 
+/**
+ * Pick the appropriate context-load weights for a node based on its type.
+ * Procedural nodes use PROCEDURAL_WEIGHTS; everything else uses DEFAULT_WEIGHTS.
+ */
+export function weightsForContextLoad(node: MemoryNode): ScoringWeights {
+  return node.type === "procedural" ? PROCEDURAL_WEIGHTS : DEFAULT_WEIGHTS;
+}
+
 /**
  * Compute the final retrieval score for a candidate node.
  * All components should be in [0, 1] range before weighting.

package/src/memory/graph/tools.ts

@@ -82,7 +82,7 @@ export const graphRecallDefinition: ToolDefinition = {
 export const graphRememberDefinition: ToolDefinition = {
   name: "remember",
   description:
-    "Save a fact to your knowledge base. Call this AGGRESSIVELY — every preference, location, name, date, habit, opinion, health detail, plan, relationship fact, routine, or commitment. The bar is: if you wouldn't want to ask about it again, remember it. Examples: 'Prefers UberEats over DoorDash', 'Lives in NYC, from Texas', 'Takes 45mg nicotine daily, tapering', 'Girlfriend Yen is in Texas', 'Watches vampire show Saturday nights', 'NYU Summit April 10-11'. Call this multiple times per conversation — it's cheap (one line appended to a file). Don't wait until the end. Don't batch. Every new fact, immediately. Remembering too much is infinitely better than forgetting something that mattered.",
+    "Save a fact to your knowledge base. Call this AGGRESSIVELY — capture anything concrete about their life: preferences, locations, names, dates, habits, opinions, health details, plans, relationship facts, routines, commitments. Default to remembering; only skip obvious noise (small talk, hypotheticals, things they're just musing about). Don't judge importance — filing decides that later. Examples: 'Prefers UberEats over DoorDash', 'Lives in NYC, from Texas', 'Takes 45mg nicotine daily, tapering', 'Girlfriend Yen is in Texas', 'Watches vampire show Saturday nights', 'NYU Summit April 10-11'. Call this multiple times per conversation — it's cheap (one line appended to a file). Don't wait until the end. Don't batch. Every new fact, immediately. Remembering too much is infinitely better than forgetting something that mattered. CORRECTIONS are the highest priority — when the user corrects a fact you had wrong, `remember` the correction immediately. The wrong version is already propagated in your prior turns and memory graph; skipping a correction means future-you keeps operating on the old value. Never skip a correction even if you'd skip the equivalent fresh fact.",
   input_schema: {
     type: "object",
     properties: {

package/src/memory/group-crud.ts

@@ -25,6 +25,11 @@ export interface ConversationGroupRow {
 
 export function listGroups(): ConversationGroupRow[] {
   ensureGroupMigration();
+  // Migration markers are stored as rows in conversation_groups with a leading
+  // underscore (e.g. `_backfill_complete`). System groups use the `system:`
+  // prefix and custom groups use UUIDs, so no legitimate group id starts with
+  // `_`. GLOB treats `_` as literal (unlike LIKE), so `_*` matches any id
+  // whose first character is an underscore.
   const rows = rawAll<{
     id: string;
     name: string;
@@ -33,7 +38,7 @@ export function listGroups(): ConversationGroupRow[] {
     created_at: number;
     updated_at: number;
   }>(
-    "SELECT id, name, sort_position, is_system_group, created_at, updated_at FROM conversation_groups WHERE id NOT IN ('_backfill_complete', '_backfill_all_complete', '_sort_shift_complete') ORDER BY sort_position ASC",
+    "SELECT id, name, sort_position, is_system_group, created_at, updated_at FROM conversation_groups WHERE id NOT GLOB '_*' ORDER BY sort_position ASC",
   );
   return rows.map((r) => ({
     id: r.id,

package/src/memory/indexer.ts

@@ -1,10 +1,13 @@
 import { createHash } from "crypto";
 import { desc, eq } from "drizzle-orm";
 
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
 import type { MemoryConfig } from "../config/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
+import { enqueueAutoAnalysisIfEnabled } from "./auto-analysis-enqueue.js";
+import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import { getDb } from "./db.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
@@ -154,6 +157,7 @@ export async function indexMessageNow(
   // ── Batch extraction tracking ──────────────────────────────────────
   // Instead of per-message extraction, track pending unextracted messages
   // and trigger batch extraction when the threshold is reached or after idle.
+  const isAutoAnalysisSource = isAutoAnalysisConversation(input.conversationId);
   if (
     shouldExtract &&
     isTrustedActor &&
@@ -163,26 +167,89 @@ export async function indexMessageNow(
     const batchSize = config.extraction.batchSize ?? 10;
     const idleTimeoutMs = config.extraction.idleTimeoutMs ?? 300_000;
 
-    // ── Graph extraction ────────────────────────────────────────────
-    const graphPendingKey = `graph_extract:${input.conversationId}:pending_count`;
-    const graphCurrentVal = getMemoryCheckpoint(graphPendingKey);
-    const graphPendingCount =
-      (graphCurrentVal ? parseInt(graphCurrentVal, 10) : 0) + 1;
-    setMemoryCheckpoint(graphPendingKey, String(graphPendingCount));
+    // Recursion guard: skip graph extraction + auto-analysis enqueues
+    // when the source conversation is itself an auto-analysis
+    // conversation. The analysis agent writes memory directly via tools,
+    // so extracting from its reflective musings would double-count and
+    // analyzing its own output would loop indefinitely.
+    // Summaries still run — they feed the graph retrieval pipeline and
+    // are not recursion-prone.
+    if (!isAutoAnalysisSource) {
+      // ── Graph extraction ────────────────────────────────────────────
+      const graphPendingKey = `graph_extract:${input.conversationId}:pending_count`;
+      const graphCurrentVal = getMemoryCheckpoint(graphPendingKey);
+      const graphPendingCount =
+        (graphCurrentVal ? parseInt(graphCurrentVal, 10) : 0) + 1;
+      setMemoryCheckpoint(graphPendingKey, String(graphPendingCount));
 
-    if (graphPendingCount >= batchSize) {
-      enqueueMemoryJob("graph_extract", {
+      const graphBatchFired = graphPendingCount >= batchSize;
+      if (graphBatchFired) {
+        setMemoryCheckpoint(graphPendingKey, "0");
+      }
+
+      // Single pending `graph_extract` row per conversation. If the
+      // batch threshold just fired, pull `runAfter` back to now so the
+      // job runs immediately; otherwise debounce by the idle timeout.
+      // Routing both paths through `upsertDebouncedJob` ensures the
+      // row's `runAfter` reflects whichever trigger ran last, so a
+      // batch crossing always takes effect immediately.
+      upsertDebouncedJob(
+        "graph_extract",
+        {
+          conversationId: input.conversationId,
+          scopeId: input.scopeId ?? "default",
+        },
+        graphBatchFired ? Date.now() : Date.now() + idleTimeoutMs,
+      );
+
+      // ── Auto-analysis triggers ─────────────────────────────────────
+      // Both triggers route through `upsertDebouncedJob` in the helper,
+      // so a single pending row is shared. Order matters: the idle
+      // upsert runs first (pushing `runAfter` into the future); the
+      // batch trigger runs last so a threshold crossing pulls
+      // `runAfter` back to "now" and overrides the idle debounce.
+      enqueueAutoAnalysisIfEnabled({
         conversationId: input.conversationId,
-        scopeId: input.scopeId ?? "default",
+        trigger: "idle",
       });
-      setMemoryCheckpoint(graphPendingKey, "0");
-    }
 
-    upsertDebouncedJob(
-      "graph_extract",
-      { conversationId: input.conversationId },
-      Date.now() + idleTimeoutMs,
-    );
+      // Auto-analysis cadence is tracked by its own pending-count
+      // checkpoint so it fires at `analysis.batchSize` (default 30).
+      // Gated behind the `auto-analyze` feature flag so the counter
+      // does not accumulate stale counts while the flag is off — if it
+      // did, flipping the flag on would trigger an immediate batch from
+      // messages buffered during the disabled period. Reading config
+      // here is best-effort: if it fails we skip the batch trigger
+      // (the idle-debounced enqueue above still runs).
+      let analysisConfig: ReturnType<typeof getConfig> | null = null;
+      try {
+        analysisConfig = getConfig();
+      } catch (err) {
+        log.debug(
+          { err, conversationId: input.conversationId },
+          "Skipping auto-analysis batch trigger: failed to load config",
+        );
+      }
+      if (
+        analysisConfig != null &&
+        isAssistantFeatureFlagEnabled("auto-analyze", analysisConfig)
+      ) {
+        const analysisBatchSize = analysisConfig.analysis.batchSize;
+        const analysisPendingKey = `conversation_analyze:${input.conversationId}:pending_count`;
+        const analysisCurrentVal = getMemoryCheckpoint(analysisPendingKey);
+        const analysisPendingCount =
+          (analysisCurrentVal ? parseInt(analysisCurrentVal, 10) : 0) + 1;
+        setMemoryCheckpoint(analysisPendingKey, String(analysisPendingCount));
+
+        if (analysisPendingCount >= analysisBatchSize) {
+          setMemoryCheckpoint(analysisPendingKey, "0");
+          enqueueAutoAnalysisIfEnabled({
+            conversationId: input.conversationId,
+            trigger: "batch",
+          });
+        }
+      }
+    }
 
     // ── Conversation summarization (independent of extraction) ────────
     // Summaries feed the graph retrieval pipeline via fetchRecentSummaries().
@@ -228,6 +295,18 @@ export async function indexMessageNow(
     );
   }
 
+  if (
+    isAutoAnalysisSource &&
+    shouldExtract &&
+    isTrustedActor &&
+    !input.automated &&
+    config.extraction.useLLM
+  ) {
+    log.debug(
+      "Skipping graph_extract + auto-analysis enqueues: source is an auto-analysis conversation",
+    );
+  }
+
   const storedSegments = segments.length - skippedShortSegments;
   const enqueuedJobs = storedSegments - skippedEmbedJobs + mediaBlocks.length;
   return {

package/src/memory/job-handlers/cleanup.ts

@@ -17,15 +17,18 @@ export function pruneOldLlmRequestLogsJob(
   job: MemoryJob,
   config: AssistantConfig,
 ): void {
+  const rawRetention = job.payload.retentionMs;
   const retentionMs =
-    typeof job.payload.retentionMs === "number" &&
-    Number.isFinite(job.payload.retentionMs) &&
-    job.payload.retentionMs >= 0
-      ? job.payload.retentionMs
-      : config.memory.cleanup.llmRequestLogRetentionMs;
-
-  // 0 means disabled
-  if (retentionMs === 0) return;
+    rawRetention === null
+      ? null
+      : typeof rawRetention === "number" &&
+          Number.isFinite(rawRetention) &&
+          rawRetention >= 0
+        ? rawRetention
+        : config.memory.cleanup.llmRequestLogRetentionMs;
+
+  // null means "keep forever" — skip pruning entirely
+  if (retentionMs === null || retentionMs === undefined) return;
 
   const cutoffMs = Date.now() - retentionMs;
 

package/src/memory/job-handlers/conversation-starters.ts

@@ -197,7 +197,7 @@ async function generateStarters(scopeId: string): Promise<GeneratedStarter[]> {
   })}`;
 
   // Truncate identity context to prevent oversized prompts when SOUL.md /
-  // IDENTITY.md / USER.md are large.
+  // IDENTITY.md / users/<slug>.md are large.
   const rawIdentityContext = buildCoreIdentityContext({
     userPersona: resolveGuardianPersona(),
   });
@@ -205,11 +205,11 @@ async function generateStarters(scopeId: string): Promise<GeneratedStarter[]> {
     ? truncate(rawIdentityContext, 2000, "\n…[truncated]")
     : null;
 
-  const systemPrompt = `You are generating 4 conversation starters for a personal assistant app. These appear as clickable chips on the empty conversation page — the first thing the user sees when they open the app. Clicking a chip sends its prompt as a message from the user.
+  const systemPrompt = `You are generating conversation starters for a personal assistant app. These appear as clickable chips on the empty conversation page — the first thing the user sees when they open the app. Clicking a chip sends its prompt as a message from the user.
 
 ${timeContext}
 
-Your goal: suggest the 4 most useful things this person could ask you to do right now.
+Your goal: suggest the most useful things this person could ask you to do right now. Produce 8 candidates, ranked best-first; only the top 4 will be shown.
 
 ${
   identityContext
@@ -223,7 +223,7 @@ ${skills}
 
 ## Selection
 
-Generate exactly 4 starters, ranked #1 (best) to #4.
+Generate exactly 8 starters, ranked #1 (best) to #8. The top 4 will be shown; the rest are fallbacks in case any fail downstream validation (e.g. label too long). Put real effort into every slot — any of them may end up displayed.
 
 Start from the user's situation, not from the skill list. Ask yourself:
 - What is this person likely dealing with right now (given the day/time and their context)?
@@ -250,7 +250,7 @@ Favor what is live over what is merely true. Recent changes matter more than old
 ## Output format
 
 Each starter has:
-- label: 3-6 words, max 40 chars, starts with a verb. Written in the user's voice — something they'd want to do, not something the assistant is offering.
+- label: 3-6 words, max 40 chars, starts with a verb. Written in the user's voice — something they'd want to do, not something the assistant is offering. MUST be a grammatically complete phrase: if it uses an adjective ("quarterly", "weekly"), include the noun it modifies ("quarterly review", "weekly sync"). Never end on a dangling modifier, preposition, or trailing "the/my/a". Prefer completeness over tightness when you have room under 40 chars.
 - prompt: 1-2 natural sentences, as the user would actually say them.
 - category: one of ${CONVERSATION_STARTER_CATEGORIES.join(", ")}
 
@@ -258,9 +258,9 @@ Each starter has:
 
 **Voice**: The user clicks these chips to send a message. Every label must read as something the user is asking to do, never something the assistant is saying to the user.
 
-**Coherence**: The 4 starters should feel like one set — similar abstraction level, no jarring mix of mundane chores and life strategy.
+**Coherence**: The top 4 starters should feel like one set — similar abstraction level, no jarring mix of mundane chores and life strategy. The remaining 4 fallbacks may branch into adjacent topics.
 
-**Diversity**: Each chip covers a distinct topic. Never two chips about the same tool, project, or theme. Four topics, four chips.
+**Diversity**: Each chip covers a distinct topic. Never two chips about the same tool, project, or theme. Across all 8 starters, avoid repeating topics.
 
 **No setup chips**: Never include a chip whose primary meaning is configuration or "set up X for Y" unless it solves an urgent pain the user is actively feeling. Prefer the outcome over the mechanism.
 
@@ -276,7 +276,12 @@ Bad → Good (ticket-speak → natural):
 
 Bad → Good (assistant voice → user voice):
 - "You've got a busy week ahead" → "Plan my week ahead"
-- "Let me check your calendar" → "Check my Thursday schedule"`;
+- "Let me check your calendar" → "Check my Thursday schedule"
+
+Bad → Good (incomplete phrase → complete):
+- "Prep for Friday's quarterly" → "Prep for Friday's quarterly review"
+- "Finish the onboarding" → "Finish the onboarding guide"
+- "Draft the release" → "Draft the release notes"`;
 
   const { signal, cleanup } = createTimeout(20000);
   try {
@@ -326,7 +331,7 @@ Bad → Good (assistant voice → user voice):
       {
         config: {
           modelIntent: "quality-optimized",
-          max_tokens: 1024,
+          max_tokens: 2048,
           tool_choice: {
             type: "tool" as const,
             name: "store_conversation_starters",
@@ -356,12 +361,13 @@ Bad → Good (assistant voice → user voice):
         (s) =>
           typeof s.label === "string" &&
           s.label.length > 0 &&
+          s.label.length <= 40 &&
           typeof s.prompt === "string" &&
           s.prompt.length > 0
       )
       .slice(0, 4)
       .map((s) => ({
-        label: truncate(s.label, 40, ""),
+        label: s.label,
         prompt: truncate(s.prompt, 500, ""),
         category:
           typeof s.category === "string" &&

package/src/memory/jobs-store.ts

@@ -18,6 +18,7 @@ export type MemoryJobType =
   | "prune_old_conversations"
   | "prune_old_llm_request_logs"
   | "build_conversation_summary"
+  | "conversation_analyze"
   | "backfill"
   | "rebuild_index"
   | "delete_qdrant_vectors"
@@ -89,15 +90,19 @@ export function enqueueMemoryJob(
 
 /**
  * Upsert a debounced job: if a pending job of the same type and conversation
- * already exists, push its `runAfter` forward instead of creating a duplicate.
- * This prevents rapid message indexing from spawning redundant jobs.
+ * already exists, merge the new payload into the existing row and update
+ * `runAfter` instead of creating a duplicate. This prevents rapid message
+ * indexing from spawning redundant jobs while ensuring the latest payload
+ * keys (e.g. `scopeId`) reach the handler — including on upgraded instances
+ * where the existing pending row was enqueued by an older build that did
+ * not write those keys.
  *
  * Pass a `dbOverride` (transaction handle) to make this call atomic with
  * surrounding writes.
  */
 export function upsertDebouncedJob(
   type: MemoryJobType,
-  payload: { conversationId: string },
+  payload: { conversationId: string } & Record<string, unknown>,
   runAfter: number,
   dbOverride?: Parameters<ReturnType<typeof getDb>["transaction"]>[0] extends (
     tx: infer T,
@@ -118,8 +123,19 @@ export function upsertDebouncedJob(
     )
     .get();
   if (existing) {
+    let existingPayload: Record<string, unknown> = {};
+    try {
+      existingPayload = JSON.parse(existing.payload) as Record<string, unknown>;
+    } catch {
+      existingPayload = {};
+    }
+    const mergedPayload = { ...existingPayload, ...payload };
     db.update(memoryJobs)
-      .set({ runAfter, updatedAt: Date.now() })
+      .set({
+        payload: JSON.stringify(mergedPayload),
+        runAfter,
+        updatedAt: Date.now(),
+      })
       .where(eq(memoryJobs.id, existing.id))
       .run();
   } else {
@@ -127,6 +143,50 @@ export function upsertDebouncedJob(
   }
 }
 
+/**
+ * Upsert a pending `conversation_analyze` job keyed by both
+ * `conversationId` and `triggerGroup`. Immediate triggers (batch,
+ * compaction) and debounced triggers (idle, lifecycle) live in separate
+ * rows so an idle enqueue cannot push an already-scheduled immediate
+ * row's `runAfter` into the future (and vice versa). Each group still
+ * coalesces within itself: two batch crossings, or two idle triggers,
+ * collapse to a single pending row.
+ */
+export function upsertAutoAnalysisJob(
+  payload: {
+    conversationId: string;
+    triggerGroup: "immediate" | "debounced";
+  },
+  runAfter: number,
+  dbOverride?: Parameters<ReturnType<typeof getDb>["transaction"]>[0] extends (
+    tx: infer T,
+  ) => unknown
+    ? T
+    : never,
+): void {
+  const db = dbOverride ?? getDb();
+  const existing = db
+    .select()
+    .from(memoryJobs)
+    .where(
+      and(
+        eq(memoryJobs.type, "conversation_analyze"),
+        eq(memoryJobs.status, "pending"),
+        sql`json_extract(${memoryJobs.payload}, '$.conversationId') = ${payload.conversationId}`,
+        sql`json_extract(${memoryJobs.payload}, '$.triggerGroup') = ${payload.triggerGroup}`,
+      ),
+    )
+    .get();
+  if (existing) {
+    db.update(memoryJobs)
+      .set({ runAfter, updatedAt: Date.now() })
+      .where(eq(memoryJobs.id, existing.id))
+      .run();
+  } else {
+    enqueueMemoryJob("conversation_analyze", payload, runAfter, dbOverride);
+  }
+}
+
 /**
  * Check whether a pending or running job of the given type already exists.
  * Used to prevent duplicate enqueues for long-running maintenance jobs.