@vellumai/assistant 0.5.6 → 0.5.8

package/src/memory/retriever.test.ts

@@ -337,10 +337,7 @@ describe("Memory Retriever Pipeline", () => {
     expect(result.tier1Count).toBeDefined();
     expect(result.tier2Count).toBeDefined();
     expect(result.hybridSearchMs).toBeDefined();
-    // Recency search finds raw candidates from this conversation…
-    expect(result.recencyHits).toBeGreaterThan(0);
-    // …but they are filtered out because they belong to the active
-    // conversation and are already present in the conversation history.
+    // Without semantic search, no candidates are found.
     expect(result.mergedCount).toBe(0);
   });
 
@@ -403,11 +400,7 @@ describe("Memory Retriever Pipeline", () => {
     );
 
     expect(result.enabled).toBe(true);
-    // Recency search finds segments from the active conversation
-    expect(result.recencyHits).toBeGreaterThan(0);
-    // But they are filtered out of merged results; only other-conversation
-    // segments would survive (none in this case since recency is scoped to
-    // the active conversation).
+    // Without semantic search, no candidates are found.
     expect(result.mergedCount).toBe(0);
   });
 
@@ -506,10 +499,6 @@ describe("Memory Retriever Pipeline", () => {
     );
 
     expect(result.enabled).toBe(true);
-    // Recency search finds segments from this conversation
-    expect(result.recencyHits).toBeGreaterThan(0);
-    // Compacted segments survive filtering — they are no longer in context
-    expect(result.mergedCount).toBeGreaterThan(0);
   });
 
   // -----------------------------------------------------------------------
@@ -716,9 +705,7 @@ describe("Memory Retriever Pipeline", () => {
     expect(result.enabled).toBe(true);
     // Semantic/hybrid search should be skipped
     expect(result.semanticHits).toBe(0);
-    // Recency search finds raw candidates…
-    expect(result.recencyHits).toBeGreaterThan(0);
-    // …but current-conversation segments are filtered out
+    // Without semantic search, no candidates are found.
     expect(result.mergedCount).toBe(0);
   });
 
@@ -752,7 +739,7 @@ describe("Memory Retriever Pipeline", () => {
     expect(result.degradation).toBeDefined();
     expect(result.degradation!.semanticUnavailable).toBe(true);
     expect(result.degradation!.reason).toBe("embedding_provider_down");
-    expect(result.degradation!.fallbackSources).toContain("recency");
+    expect(result.degradation!.fallbackSources).toEqual([]);
   });
 
   // -----------------------------------------------------------------------
@@ -864,9 +851,7 @@ describe("Memory Retriever Pipeline", () => {
     // pipeline proceeds non-degraded end-to-end.
     expect(result.enabled).toBe(true);
     expect(result.degraded).toBe(false);
-    // Recency search finds raw candidates; hybrid search returns empty from mock
-    expect(result.recencyHits).toBeGreaterThan(0);
-    // Current-conversation segments are filtered out of merged results
+    // Without semantic search, no candidates are found.
     expect(result.mergedCount).toBe(0);
   });
 
@@ -1142,8 +1127,7 @@ describe("Memory Retriever Pipeline", () => {
       );
 
       // Simulate Qdrant returning the parent-conversation segment as a
-      // semantic hit so it enters the candidate map (recency search is scoped
-      // to forkConv and would never find it).
+      // semantic hit so it enters the candidate map.
       mockQdrantResults.push({
         id: "qdrant-fork-1",
         score: 0.9,
@@ -1264,6 +1248,35 @@ describe("Memory Retriever Pipeline", () => {
         now - 50_000,
       );
 
+      // Simulate Qdrant returning both segments as semantic hits so they
+      // enter the candidate map (recency search was removed).
+      mockQdrantResults.push(
+        {
+          id: "qdrant-compact-fork-1",
+          score: 0.9,
+          payload: {
+            target_type: "segment",
+            target_id: "seg-compact-fork",
+            text: "compacted parent topic detail",
+            created_at: now - 100_000,
+            message_id: "fork-compact-msg-1",
+            conversation_id: forkConv,
+          },
+        },
+        {
+          id: "qdrant-compact-fork-2",
+          score: 0.85,
+          payload: {
+            target_type: "segment",
+            target_id: "seg-in-context-fork",
+            text: "recent fork topic detail",
+            created_at: now - 50_000,
+            message_id: "fork-compact-msg-3",
+            conversation_id: forkConv,
+          },
+        },
+      );
+
       const result = await buildMemoryRecall(
         "compacted parent topic",
         forkConv,
@@ -1273,7 +1286,7 @@ describe("Memory Retriever Pipeline", () => {
       expect(result.enabled).toBe(true);
       // The segment from the compacted fork message survives filtering
       // (its source message is no longer in context). The in-context segment
-      // is filtered out. Recency search returns both, but only the compacted
+      // is filtered out. Semantic search returns both, but only the compacted
       // one survives step 5b.
       expect(result.mergedCount).toBeGreaterThan(0);
     });
@@ -1342,8 +1355,7 @@ describe("Memory Retriever Pipeline", () => {
       );
 
       // Simulate Qdrant returning the grandparent segment as a semantic hit
-      // so it enters the candidate map (recency search is scoped to childConv
-      // and would never find it).
+      // so it enters the candidate map.
       mockQdrantResults.push({
         id: "qdrant-gp-1",
         score: 0.9,

package/src/memory/retriever.ts

@@ -29,7 +29,6 @@ import {
   IDENTITY_KINDS,
   PREFERENCE_KINDS,
 } from "./search/formatting.js";
-import { recencySearch } from "./search/lexical.js";
 import { isQdrantConnectionError, semanticSearch } from "./search/semantic.js";
 import { applyStaleDemotion, computeStaleness } from "./search/staleness.js";
 import {
@@ -139,7 +138,7 @@ function buildDegradationStatus(
   return {
     semanticUnavailable: true,
     reason,
-    fallbackSources: ["recency"],
+    fallbackSources: [],
   };
 }
 
@@ -243,13 +242,12 @@ async function generateQueryEmbedding(
  *   1. Build query text (caller provides via buildMemoryQuery)
  *   2. Generate dense + sparse embeddings
  *   3. Hybrid search on Qdrant (dense + sparse RRF fusion)
- *   4. Supplement with recency search (conversation-scoped, DB only)
- *   5. Merge + deduplicate results
- *   6. Classify tiers (score > 0.8 → tier 1, > 0.6 → tier 2)
- *   7. Enrich item candidates with metadata for staleness
- *   8. Compute staleness per item
- *   9. Demote very_stale tier 1 → tier 2
- *  10. Build two-layer XML injection with budget allocation
+ *   4. Deduplicate results
+ *   5. Classify tiers (score > 0.6 → tier 1, > 0.4 → tier 2)
+ *   6. Enrich item candidates with metadata for staleness
+ *   7. Compute staleness per item
+ *   8. Demote very_stale tier 1 → tier 2
+ *   9. Build two-layer XML injection with budget allocation
  */
 export async function buildMemoryRecall(
   query: string,
@@ -327,21 +325,15 @@ export async function buildMemoryRecall(
       if (isQdrantConnectionError(err)) {
         log.warn({ err }, "Qdrant unavailable — hybrid search disabled");
       } else {
-        log.warn({ err }, "Hybrid search failed, continuing with recency only");
+        log.warn({ err }, "Hybrid search failed");
       }
     }
   }
   const hybridSearchMs = Date.now() - hybridSearchStart;
 
-  // ── Step 4: Recency supplement (DB only, conversation-scoped) ───
-  const recencyLimit = 5;
-  const recencyCandidates = conversationId
-    ? recencySearch(conversationId, recencyLimit, excludeMessageIds, scopeIds)
-    : [];
-
-  // ── Step 5: Merge and deduplicate ──────────────────────────────
+  // ── Step 4: Deduplicate ────────────────────────────────────────
   const candidateMap = new Map<string, Candidate>();
-  for (const c of [...hybridCandidates, ...recencyCandidates]) {
+  for (const c of [...hybridCandidates]) {
     const existing = candidateMap.get(c.key);
     if (!existing) {
       candidateMap.set(c.key, { ...c });
@@ -356,8 +348,7 @@ export async function buildMemoryRecall(
       existing.text = c.text;
     }
     // Propagate metadata that the first source may lack (e.g. legacy
-    // Qdrant points missing conversation_id / message_id). The recency
-    // source always has these from the DB, so merging fills the gap.
+    // Qdrant points missing conversation_id / message_id).
     if (c.conversationId && !existing.conversationId) {
       existing.conversationId = c.conversationId;
     }
@@ -366,7 +357,7 @@ export async function buildMemoryRecall(
     }
   }
 
-  // ── Step 5b: Filter out current-conversation segments still in context ──
+  // ── Step 4b: Filter out current-conversation segments still in context ──
   // Segments whose source message is still in the conversation's context
   // window are redundant (already visible to the model). However, segments
   // from messages that were removed by context compaction should be kept —
@@ -443,39 +434,26 @@ export async function buildMemoryRecall(
   // Compute RRF-style final scores for the merged candidates
   const allCandidates = [...candidateMap.values()];
   for (const c of allCandidates) {
-    // Simple weighted combination — hybrid search already applies RRF fusion
-    // at the Qdrant level; here we combine the fused semantic score with recency.
-    c.finalScore = c.semantic * 0.7 + c.recency * 0.2 + c.confidence * 0.1;
+    // Multiplicative scoring: importance, confidence, and recency amplify semantic
+    // relevance but can't substitute for it. An irrelevant item (semantic ≈ 0)
+    // stays low regardless of metadata. Multiplier range: 0.4 (all zero) to 1.0.
+    const metadataMultiplier =
+      0.4 + c.importance * 0.25 + c.confidence * 0.15 + c.recency * 0.2;
+    c.finalScore = c.semantic * metadataMultiplier;
   }
   allCandidates.sort((a, b) => b.finalScore - a.finalScore);
 
-  // ── Step 6: Tier classification ─────────────────────────────────
-  // Recency-only candidates (semantic=0) can never reach the tier 2 threshold
-  // (>0.6) since their max finalScore is 0.3. Promote them directly to tier 2
-  // so recent conversation context is preserved even without semantic signal.
-  const recencyOnlyKeys = new Set(
-    allCandidates
-      .filter((c) => c.semantic === 0 && c.recency > 0)
-      .map((c) => c.key),
-  );
+  // ── Step 5: Tier classification ─────────────────────────────────
   const tiered = classifyTiers(allCandidates);
-  if (recencyOnlyKeys.size > 0) {
-    const alreadyTiered = new Set(tiered.map((c) => c.key));
-    for (const c of allCandidates) {
-      if (recencyOnlyKeys.has(c.key) && !alreadyTiered.has(c.key)) {
-        tiered.push({ ...c, tier: 2 });
-      }
-    }
-  }
 
-  // ── Step 6b: Enrich candidates with source labels ──────────────
+  // ── Step 5b: Enrich candidates with source labels ──────────────
   enrichSourceLabels(tiered);
 
-  // ── Step 7: Enrich with item metadata for staleness ─────────────
+  // ── Step 6: Enrich with item metadata for staleness ─────────────
   const itemIds = tiered.filter((c) => c.type === "item").map((c) => c.id);
   const itemMetadataMap = enrichItemMetadata(itemIds);
 
-  // ── Step 8: Compute staleness per item ──────────────────────────
+  // ── Step 7: Compute staleness per item ──────────────────────────
   const now = Date.now();
   for (const c of tiered) {
     if (c.type !== "item") continue;
@@ -492,10 +470,10 @@ export async function buildMemoryRecall(
     c.staleness = level;
   }
 
-  // ── Step 9: Demote very_stale tier 1 → tier 2 ──────────────────
+  // ── Step 8: Demote very_stale tier 1 → tier 2 ──────────────────
   const afterDemotion = applyStaleDemotion(tiered);
 
-  // ── Step 10: Budget allocation and two-layer injection ──────────
+  // ── Step 9: Budget allocation and two-layer injection ──────────
   const maxInjectTokens = Math.max(
     1,
     Math.floor(
@@ -581,7 +559,6 @@ export async function buildMemoryRecall(
     {
       query: truncate(query, 120),
       hybridHits: hybridCandidates.length,
-      recencyHits: recencyCandidates.length,
       mergedCount: allCandidates.length,
       tier1Count,
       tier2Count,
@@ -602,7 +579,6 @@ export async function buildMemoryRecall(
     provider: embeddingResult.provider,
     model: embeddingResult.model,
     semanticHits: hybridCandidates.length,
-    recencyHits: recencyCandidates.length,
     mergedCount: allCandidates.length,
     selectedCount,
     injectedTokens: estimateTextTokens(injectedText),
@@ -887,7 +863,6 @@ function emptyResult(
     provider: init.provider,
     model: init.model,
     semanticHits: 0,
-    recencyHits: 0,
     mergedCount: 0,
     selectedCount: 0,
     injectedTokens: 0,

package/src/memory/schema/calls.ts

@@ -27,6 +27,7 @@ export const callSessions = sqliteTable(
     inviteGuardianName: text("invite_guardian_name"),
     callerIdentityMode: text("caller_identity_mode"),
     callerIdentitySource: text("caller_identity_source"),
+    skipDisclosure: integer("skip_disclosure").notNull().default(0),
     initiatedFromConversationId: text("initiated_from_conversation_id"),
     startedAt: integer("started_at"),
     endedAt: integer("ended_at"),

package/src/memory/schema/contacts.ts

@@ -10,6 +10,7 @@ export const contacts = sqliteTable("contacts", {
   updatedAt: integer("updated_at").notNull(),
   role: text("role").notNull().default("contact"), // 'guardian' | 'contact'
   principalId: text("principal_id"), // internal auth principal (nullable)
+  userFile: text("user_file"), // workspace-relative path to per-user persona file
   contactType: text("contact_type").notNull().default("human"), // 'human' | 'assistant'
 });
 

package/src/memory/schema/memory-core.ts

@@ -56,6 +56,8 @@ export const memoryItems = sqliteTable(
     supersedes: text("supersedes"),
     supersededBy: text("superseded_by"),
     overrideConfidence: text("override_confidence").default("inferred"),
+    sourceType: text("source_type").notNull().default("extraction"),
+    sourceMessageRole: text("source_message_role"),
   },
   (table) => [
     index("idx_memory_items_scope_id").on(table.scopeId),

package/src/memory/search/formatting.ts

@@ -80,15 +80,6 @@ export const PREFERENCE_KINDS = new Set(["preference", "constraint"]);
 /** Kinds classified as capabilities for the <available_capabilities> section. */
 export const CAPABILITY_KINDS = new Set(["capability"]);
 
-/** Per-item token budget for tier 1 items. */
-const TIER1_PER_ITEM_TOKENS = 150;
-
-/** Per-item token budget for tier 2 items. */
-const TIER2_PER_ITEM_TOKENS = 100;
-
-/** Approximate chars-per-token for truncation (matches token-estimator). */
-const CHARS_PER_TOKEN = 4;
-
 /**
  * Build a two-layer XML injection block from tiered candidates.
  *
@@ -151,38 +142,21 @@ export function buildTwoLayerInjection(params: {
     : Infinity;
 
   // Render tier 1 items first (identity, relevant context, preferences)
-  const identityLines = renderPlainStatements(
-    identityItems,
-    TIER1_PER_ITEM_TOKENS,
-    remainingTokens,
-  );
+  const identityLines = renderPlainStatements(identityItems, remainingTokens);
   remainingTokens -= estimateTextTokens(identityLines.join("\n"));
 
-  const relevantEpisodes = renderEpisodes(
-    tier1Candidates,
-    TIER1_PER_ITEM_TOKENS,
-    remainingTokens,
-  );
+  const relevantEpisodes = renderEpisodes(tier1Candidates, remainingTokens);
   remainingTokens -= estimateTextTokens(relevantEpisodes.join("\n"));
 
-  const preferenceLines = renderPlainStatements(
-    preferences,
-    TIER1_PER_ITEM_TOKENS,
-    remainingTokens,
-  );
+  const preferenceLines = renderPlainStatements(preferences, remainingTokens);
   remainingTokens -= estimateTextTokens(preferenceLines.join("\n"));
 
-  const capabilityLines = renderPlainStatements(
-    capabilities,
-    TIER1_PER_ITEM_TOKENS,
-    remainingTokens,
-  );
+  const capabilityLines = renderPlainStatements(capabilities, remainingTokens);
   remainingTokens -= estimateTextTokens(capabilityLines.join("\n"));
 
   // Tier 2 uses remaining budget
   const possiblyRelevantEpisodes = renderEpisodesWithStaleness(
     tier2Candidates,
-    TIER2_PER_ITEM_TOKENS,
     remainingTokens,
   );
 
@@ -229,15 +203,13 @@ export function buildTwoLayerInjection(params: {
  */
 function renderPlainStatements(
   items: TieredCandidate[],
-  perItemBudgetTokens: number,
   remainingBudget: number,
 ): string[] {
   const lines: string[] = [];
   let used = 0;
   for (const item of items) {
     if (used >= remainingBudget) break;
-    const maxChars = perItemBudgetTokens * CHARS_PER_TOKEN;
-    const text = escapeXmlTags(truncate(item.text, maxChars));
+    const text = escapeXmlTags(item.text);
     const tokens = estimateTextTokens(text);
     if (used + tokens > remainingBudget) break;
     lines.push(text);
@@ -251,15 +223,13 @@ function renderPlainStatements(
  */
 function renderEpisodes(
   items: TieredCandidate[],
-  perItemBudgetTokens: number,
   remainingBudget: number,
 ): string[] {
   const lines: string[] = [];
   let used = 0;
   for (const item of items) {
     if (used >= remainingBudget) break;
-    const maxChars = perItemBudgetTokens * CHARS_PER_TOKEN;
-    const text = escapeXmlTags(truncate(item.text, maxChars));
+    const text = escapeXmlTags(item.text);
     const sourceAttr = buildSourceAttr(item);
     const line = `<episode${sourceAttr}>\n${text}\n</episode>`;
     const tokens = estimateTextTokens(line);
@@ -275,15 +245,13 @@ function renderEpisodes(
  */
 function renderEpisodesWithStaleness(
   items: TieredCandidate[],
-  perItemBudgetTokens: number,
   remainingBudget: number,
 ): string[] {
   const lines: string[] = [];
   let used = 0;
   for (const item of items) {
     if (used >= remainingBudget) break;
-    const maxChars = perItemBudgetTokens * CHARS_PER_TOKEN;
-    const text = escapeXmlTags(truncate(item.text, maxChars));
+    const text = escapeXmlTags(item.text);
     const sourceAttr = buildSourceAttr(item);
     const stalenessAttr =
       item.staleness && item.staleness !== "fresh"
@@ -347,8 +315,3 @@ function formatShortDate(epochMs: number): string {
   }
   return `${month} ${day} ${date.getFullYear()}`;
 }
-
-function truncate(text: string, max: number): string {
-  if (text.length <= max) return text;
-  return `${text.slice(0, max - 3)}...`;
-}

package/src/memory/search/staleness.ts

@@ -8,6 +8,10 @@ const BASE_LIFETIME_MS: Record<string, number> = {
   project: 14 * 86_400_000, // 2 weeks
   decision: 14 * 86_400_000, // 2 weeks
   event: 3 * 86_400_000, // 3 days
+  // Journals are experiential reflections and forward-looking notes — more
+  // durable than ephemeral events or decisions, but not as permanent as
+  // identity. 90 days mirrors "preference" lifetime.
+  journal: 90 * 86_400_000, // 3 months
   capability: Infinity,
 };
 

package/src/memory/search/tier-classifier.ts

@@ -8,9 +8,17 @@ export interface TieredCandidate extends Candidate {
   sourceLabel?: string;
 }
 
+/**
+ * Map a composite relevance score to an injection tier.
+ *
+ * Thresholds are intentionally set lower than raw-embedding ceilings because
+ * the multiplicative scoring pipeline (semantic × recency × metadata) compresses
+ * the effective score range.  Lowering the gates lets moderately-relevant items
+ * surface rather than being silently dropped.
+ */
 export function classifyTier(score: number): Tier | null {
-  if (score > 0.8) return 1;
-  if (score > 0.6) return 2;
+  if (score > 0.6) return 1;
+  if (score > 0.4) return 2;
   return null;
 }
 

package/src/memory/search/types.ts

@@ -1,5 +1,5 @@
 export type CandidateType = "segment" | "item" | "summary" | "media";
-export type CandidateSource = "semantic" | "recency";
+export type CandidateSource = "semantic";
 
 export type StalenessLevel = "fresh" | "aging" | "stale" | "very_stale";
 
@@ -39,12 +39,10 @@ export type DegradationReason =
   | "qdrant_unavailable"
   | "embedding_generation_failed";
 
-export type FallbackSource = "recency";
-
 export interface DegradationStatus {
   semanticUnavailable: boolean;
   reason: DegradationReason;
-  fallbackSources: FallbackSource[];
+  fallbackSources: string[];
 }
 
 export interface MemoryRecallResult {
@@ -55,7 +53,6 @@ export interface MemoryRecallResult {
   provider?: string;
   model?: string;
   semanticHits: number;
-  recencyHits: number;
   mergedCount: number;
   selectedCount: number;
   injectedTokens: number;

package/src/memory/task-memory-cleanup.ts

@@ -24,14 +24,14 @@ export function isConversationFailed(conversationId: string): boolean {
 }
 
 /**
- * Invalidate `assistant_inferred` memory items sourced *exclusively* from
+ * Invalidate assistant-extracted memory items sourced *exclusively* from
  * messages in the given conversation. Called when a background task or
  * schedule fails — the assistant's optimistic claims (e.g., "I booked an
  * appointment") are not trustworthy if the task didn't complete.
  *
  * The failed state is derived from durable storage (task_runs / cron_runs),
  * so any pending or future extraction jobs for this conversation are blocked
- * from creating new `assistant_inferred` items — even after daemon restarts.
+ * from creating new assistant-extracted items — even after daemon restarts.
  *
  * Items that also have sources from other conversations are left alone
  * only when those conversations come from non-failed task/schedule runs
@@ -55,7 +55,8 @@ export function invalidateAssistantInferredItemsForConversation(
     `UPDATE memory_items
         SET status = 'invalidated',
             invalid_at = ?
-      WHERE verification_state = 'assistant_inferred'
+      WHERE source_type = 'extraction'
+        AND source_message_role = 'assistant'
         AND status = 'active'
         AND id IN (
           SELECT mis.memory_item_id