@vellumai/assistant 0.8.0 → 0.8.1

package/src/memory/context-search/agent-runner.ts

@@ -27,13 +27,13 @@ import {
 import {
   type DeterministicRecallSearchOptions,
   type DeterministicRecallSearchResult,
-  isAutoInjectedPkbContextEvidence,
   runDeterministicRecallSearch,
 } from "./search.js";
 import {
   extractWorkspacePathLiterals,
   inspectWorkspacePaths,
   isSafeWorkspaceRelativePath,
+  normalizeWorkspacePathLiteral,
 } from "./sources/workspace.js";
 import type {
   RecallAnswer,
@@ -214,19 +214,6 @@ const FINISH_NEGATIVE_PATTERNS = [
   /\bno text\b/i,
 ];
 
-const PKB_RELATIVE_PATH_PREFIXES = [
-  "archive/",
-  "dpo/",
-  "essentials.md",
-  "INDEX.md",
-  "intimate/",
-  "people/",
-  "preferences/",
-  "procedures/",
-  "schedule/",
-  "us-arcs/",
-];
-
 export async function runAgenticRecall(
   input: RecallInput,
   context: RecallSearchContext,
@@ -429,7 +416,7 @@ export async function runAgenticRecall(
  * Redact secrets from workspace-sourced evidence excerpts before they are
  * serialised into a prompt that will be sent to an external LLM provider.
  *
- * Memory, PKB, and conversation evidence is already controlled content —
+ * Memory and conversation evidence is already controlled content —
  * only workspace files can contain arbitrary secrets (API keys, tokens, etc.)
  * written by the user or by tools. This runs the same pattern-based scanner
  * used for shell command summaries and approval prompts, replacing any
@@ -499,7 +486,7 @@ async function runSeedRecallSearch(
       context,
       searchOptions,
     );
-    evidence = mergeEvidence(expansionResult.evidence, evidence);
+    evidence = mergeEvidence(evidence, expansionResult.evidence);
   }
 
   return withFallbackEvidence(baseResult, evidence);
@@ -694,6 +681,13 @@ function finishRecallFromToolUse(
   }
 
   const citedEvidence = selectCitedEvidence(promptEvidence, finish.citationIds);
+  if (citedEvidence.length === 0) {
+    return {
+      ok: false,
+      reason: "citation_validation_failed",
+      detail: "finish_recall returned no resolvable citations",
+    };
+  }
   debug.finish = {
     confidence: finish.confidence,
     citationIds: finish.citationIds,
@@ -960,14 +954,16 @@ async function executeInspectWorkspacePaths(
 }> {
   const reason = readSearchReason(payload.reason);
   const requestedPaths = readInspectPaths(payload.paths);
-  const allowedPaths = collectInspectableWorkspacePaths(input.query, evidence);
+  const workspaceSourceEnabled = input.sources.includes("workspace");
+  const allowedPaths = workspaceSourceEnabled
+    ? collectInspectableWorkspacePaths(input.query, evidence)
+    : new Set<string>();
   const acceptedPaths: string[] = [];
   const rejectedPaths: string[] = [];
   for (const requestedPath of requestedPaths) {
-    const acceptedPath = normalizeRequestedWorkspaceInspectionPath(
-      requestedPath,
-      allowedPaths,
-    );
+    const acceptedPath = workspaceSourceEnabled
+      ? normalizeRequestedWorkspaceInspectionPath(requestedPath, allowedPaths)
+      : null;
     if (acceptedPath) {
       acceptedPaths.push(acceptedPath);
     } else {
@@ -994,6 +990,7 @@ async function executeInspectWorkspacePaths(
       ],
       debug: {
         ...debug,
+        evidenceCount: 1,
         errors: [
           {
             path: "inspect_workspace_paths",
@@ -1006,8 +1003,9 @@ async function executeInspectWorkspacePaths(
 
   const errors = rejectedPaths.map((path) => ({
     path,
-    reason:
-      "path was not a safe relative workspace file surfaced by the query or prior evidence",
+    reason: workspaceSourceEnabled
+      ? "path was not a safe relative workspace file surfaced by the query or prior evidence"
+      : "workspace source is disabled for this recall request",
   }));
 
   let inspectionEvidence: RecallEvidence[] = [];
@@ -1049,7 +1047,7 @@ async function runAutomaticWorkspaceInspection(
   evidence: RecallEvidence[];
   debug?: AgenticRecallInspectDebug;
 }> {
-  if (!input.sources.includes("workspace") && !input.sources.includes("pkb")) {
+  if (!input.sources.includes("workspace")) {
     return { evidence: [] };
   }
 
@@ -1113,7 +1111,7 @@ function collectAutomaticWorkspaceInspectionPaths(
   for (const item of evidence) {
     collectEvidenceWorkspacePaths(item).forEach((path) => paths.add(path));
   }
-  return [...paths].filter(isSafeWorkspaceRelativePath).slice(0, 3);
+  return [...paths].slice(0, 3);
 }
 
 function collectInspectableWorkspacePaths(
@@ -1128,62 +1126,33 @@ function collectInspectableWorkspacePaths(
 }
 
 function collectEvidenceWorkspacePaths(item: RecallEvidence): string[] {
-  if (isAutoInjectedPkbContextEvidence(item)) {
-    return [];
-  }
-
-  const rawPaths = new Set<string>();
+  const paths = new Set<string>();
   const metadataPath = item.metadata?.path;
-  if (typeof metadataPath === "string") {
-    rawPaths.add(metadataPath);
+  if (
+    typeof metadataPath === "string" &&
+    isSafeWorkspaceRelativePath(metadataPath)
+  ) {
+    paths.add(metadataPath);
   }
   for (const text of [item.locator, item.title, item.excerpt]) {
     for (const path of extractWorkspacePathLiterals(text)) {
-      rawPaths.add(path);
-    }
-  }
-
-  const paths: string[] = [];
-  for (const rawPath of rawPaths) {
-    for (const path of normalizeEvidenceWorkspacePath(rawPath, item.source)) {
       if (isSafeWorkspaceRelativePath(path)) {
-        paths.push(path);
+        paths.add(path);
       }
     }
   }
-  return [...new Set(paths)];
+  return [...paths];
 }
 
 function normalizeRequestedWorkspaceInspectionPath(
   requestedPath: string,
   allowedPaths: ReadonlySet<string>,
 ): string | null {
-  const pkbPrefixedPath = `pkb/${requestedPath}`;
-  if (!requestedPath.startsWith("pkb/") && allowedPaths.has(pkbPrefixedPath)) {
-    return pkbPrefixedPath;
-  }
-
-  if (allowedPaths.has(requestedPath)) {
-    return requestedPath;
-  }
-
-  return null;
-}
-
-function normalizeEvidenceWorkspacePath(
-  path: string,
-  source: RecallSource,
-): string[] {
-  if (path.startsWith("pkb/")) {
-    return [path];
-  }
-  if (
-    source === "pkb" ||
-    PKB_RELATIVE_PATH_PREFIXES.some((prefix) => path.startsWith(prefix))
-  ) {
-    return [`pkb/${path}`];
+  const normalized = normalizeWorkspacePathLiteral(requestedPath);
+  if (!normalized) {
+    return null;
   }
-  return [path];
+  return allowedPaths.has(normalized) ? normalized : null;
 }
 
 function makeWorkspaceInspectionErrorEvidence(options: {
@@ -1240,24 +1209,7 @@ function mergeEvidence(
     merged.push(item);
   }
 
-  return demoteAutoInjectedContextEvidence(merged);
-}
-
-function demoteAutoInjectedContextEvidence(
-  evidence: readonly RecallEvidence[],
-): RecallEvidence[] {
-  const regularEvidence: RecallEvidence[] = [];
-  const autoInjectedContextEvidence: RecallEvidence[] = [];
-
-  for (const item of evidence) {
-    if (isAutoInjectedPkbContextEvidence(item)) {
-      autoInjectedContextEvidence.push(item);
-    } else {
-      regularEvidence.push(item);
-    }
-  }
-
-  return [...regularEvidence, ...autoInjectedContextEvidence];
+  return merged;
 }
 
 function toRecallInput(input: NormalizedRecallInput): RecallInput {
@@ -1284,7 +1236,7 @@ function withFallbackEvidence(
   result: DeterministicRecallSearchResult,
   evidence: readonly RecallEvidence[],
 ): DeterministicRecallSearchResult {
-  const orderedEvidence = demoteAutoInjectedContextEvidence(evidence);
+  const orderedEvidence = dedupeEvidenceByContent(evidence);
   const evidenceCountBySource = new Map<RecallSource, number>();
   for (const item of orderedEvidence) {
     evidenceCountBySource.set(
@@ -1303,6 +1255,29 @@ function withFallbackEvidence(
   };
 }
 
+function dedupeEvidenceByContent(
+  evidence: readonly RecallEvidence[],
+): RecallEvidence[] {
+  const seenIds = new Set<string>();
+  const seenContent = new Set<string>();
+  const deduped: RecallEvidence[] = [];
+
+  for (const item of evidence) {
+    if (seenIds.has(item.id)) {
+      continue;
+    }
+    const contentKey = `${item.source}\0${item.locator}\0${item.excerpt}`;
+    if (seenContent.has(contentKey)) {
+      continue;
+    }
+    seenIds.add(item.id);
+    seenContent.add(contentKey);
+    deduped.push(item);
+  }
+
+  return deduped;
+}
+
 function deterministicFallback(
   result: DeterministicRecallSearchResult,
   debug: AgenticRecallDebug,

package/src/memory/context-search/limits.ts

@@ -2,7 +2,6 @@ import type { RecallDepth, RecallInput, RecallSource } from "./types.js";
 
 export const ALL_RECALL_SOURCES: readonly RecallSource[] = [
   "memory",
-  "pkb",
   "conversations",
   "workspace",
 ] as const;
@@ -81,9 +80,7 @@ export function normalizeRecallMaxResults(
   );
 }
 
-function normalizeRecallDepth(
-  depth: RecallDepth | undefined,
-): RecallDepth {
+function normalizeRecallDepth(depth: RecallDepth | undefined): RecallDepth {
   if (depth === undefined) {
     return DEFAULT_RECALL_DEPTH;
   }

package/src/memory/context-search/search.ts

@@ -1,3 +1,4 @@
+import { isAbortReason } from "../../util/abort-reasons.js";
 import {
   ALL_RECALL_SOURCES,
   type NormalizedRecallInput,
@@ -30,23 +31,12 @@ export interface DeterministicRecallSearchResult extends RecallSearchResult {
 
 export interface DeterministicRecallSearchOptions {
   adapters?: readonly RecallSourceAdapter[];
-  readPkbContextEvidence?: (
-    context: RecallSearchContext,
-  ) => Promise<readonly RecallEvidence[]> | readonly RecallEvidence[];
 }
 
 const SOURCE_PRIORITY = new Map<RecallSource, number>(
   ALL_RECALL_SOURCES.map((source, index) => [source, index]),
 );
 
-const AUTO_INJECTED_PKB_CONTEXT_EVIDENCE_IDS = new Set([
-  "pkb:auto-inject",
-  "pkb:NOW.md",
-]);
-const AUTO_INJECTED_PKB_CONTEXT_TEXT_CAP = Math.floor(
-  RECALL_EVIDENCE_TEXT_CAP_PER_SOURCE / 2,
-);
-
 export async function runDeterministicRecallSearch(
   input: RecallInput,
   context: RecallSearchContext,
@@ -64,18 +54,6 @@ export async function runDeterministicRecallSearch(
   );
   const errorsBySource = new Map<RecallSource, string>();
 
-  if (normalizedInput.sources.includes("pkb")) {
-    try {
-      const contextEvidence = await readPkbContextEvidenceForSearch(
-        context,
-        options,
-      );
-      appendEvidence(evidenceBySource, "pkb", contextEvidence);
-    } catch (err) {
-      errorsBySource.set("pkb", errorToMessage(err));
-    }
-  }
-
   const selectedAdapters = normalizedInput.sources.flatMap((source) => {
     const adapter = adapterBySource.get(source);
     return adapter ? [adapter] : [];
@@ -88,17 +66,20 @@ export async function runDeterministicRecallSearch(
     ),
   );
 
-  adapterResults.forEach((settledResult, index) => {
+  for (const [index, settledResult] of adapterResults.entries()) {
     const source = selectedAdapters[index]?.source;
-    if (!source) return;
+    if (!source) continue;
 
     if (settledResult.status === "fulfilled") {
       appendEvidence(evidenceBySource, source, settledResult.value.evidence);
-      return;
+      continue;
     }
 
+    if (isAbortLikeError(settledResult.reason)) {
+      throw settledResult.reason;
+    }
     errorsBySource.set(source, errorToMessage(settledResult.reason));
-  });
+  }
 
   const evidence = capEvidence(
     dedupeEvidence(sortEvidence([...evidenceBySource.values()].flat())),
@@ -142,10 +123,6 @@ async function loadDefaultRecallSourceAdapter(
       const { searchMemorySource } = await import("./sources/memory.js");
       return { source, search: searchMemorySource };
     }
-    case "pkb": {
-      const { searchPkbSource } = await import("./sources/pkb.js");
-      return { source, search: searchPkbSource };
-    }
     case "conversations": {
       const { searchConversationSource } =
         await import("./sources/conversations.js");
@@ -156,21 +133,6 @@ async function loadDefaultRecallSourceAdapter(
       return { source, search: searchWorkspaceSource };
     }
   }
-
-  const exhaustiveSource: never = source;
-  throw new Error(`Unknown recall source: ${String(exhaustiveSource)}`);
-}
-
-async function readPkbContextEvidenceForSearch(
-  context: RecallSearchContext,
-  options: DeterministicRecallSearchOptions,
-): Promise<readonly RecallEvidence[]> {
-  if (options.readPkbContextEvidence) {
-    return options.readPkbContextEvidence(context);
-  }
-
-  const { readPkbContextEvidence } = await import("./sources/pkb.js");
-  return readPkbContextEvidence(context);
 }
 
 function appendEvidence(
@@ -221,7 +183,7 @@ function retrievalRankBoost(item: RecallEvidence): number {
   if (retrieval === "path") return 0.45;
   if (retrieval === "structured-json") return 0.4;
   if (retrieval === "section") return 0.35;
-  if (retrieval === "lexical") return item.source === "pkb" ? 1.5 : 0.25;
+  if (retrieval === "lexical") return 0.25;
   return 0;
 }
 
@@ -253,17 +215,11 @@ function capEvidence(
   evidence: readonly RecallEvidence[],
   maxResults: number,
 ): RecallEvidence[] {
-  const autoInjectedContextEvidence = evidence.filter(
-    isAutoInjectedPkbContextEvidence,
-  );
-  const regularEvidence = evidence.filter(
-    (item) => !isAutoInjectedPkbContextEvidence(item),
-  );
   const capped: RecallEvidence[] = [];
   const textSizeBySource = new Map<RecallSource, number>();
   let totalTextSize = 0;
 
-  for (const item of regularEvidence) {
+  for (const item of evidence) {
     if (capped.length >= maxResults) {
       break;
     }
@@ -277,79 +233,21 @@ function capEvidence(
     if (appended.totalRemaining <= 0) break;
   }
 
-  for (let index = 0; index < autoInjectedContextEvidence.length; index += 1) {
-    if (capped.length >= maxResults) {
-      break;
-    }
-
-    const item = autoInjectedContextEvidence[index];
-    if (!item) continue;
-
-    const autoInjectedRemaining = autoInjectedContextEvidence.length - index;
-    const reservedTextBudget = getReservedAutoInjectedTextBudget(item, {
-      textSizeBySource,
-      totalTextSize,
-      autoInjectedRemaining,
-    });
-    const appended = appendCappedEvidence(item, {
-      capped,
-      textSizeBySource,
-      totalTextSize,
-      textBudget: reservedTextBudget,
-    });
-    totalTextSize = appended.totalTextSize;
-    if (appended.totalRemaining <= 0) {
-      break;
-    }
-  }
-
   return capped;
 }
 
-export function isAutoInjectedPkbContextEvidence(
-  item: RecallEvidence,
-): boolean {
-  return (
-    item.source === "pkb" && AUTO_INJECTED_PKB_CONTEXT_EVIDENCE_IDS.has(item.id)
-  );
-}
-
-function getReservedAutoInjectedTextBudget(
-  item: RecallEvidence,
-  state: {
-    textSizeBySource: Map<RecallSource, number>;
-    totalTextSize: number;
-    autoInjectedRemaining: number;
-  },
-): number {
-  const sourceTextSize = state.textSizeBySource.get(item.source) ?? 0;
-  const autoInjectedSourceCap =
-    item.source === "pkb"
-      ? AUTO_INJECTED_PKB_CONTEXT_TEXT_CAP
-      : RECALL_EVIDENCE_TEXT_CAP_PER_SOURCE;
-  const sourceRemaining = autoInjectedSourceCap - sourceTextSize;
-  const totalRemaining = RECALL_TOTAL_EVIDENCE_TEXT_CAP - state.totalTextSize;
-  const remaining = Math.min(sourceRemaining, totalRemaining);
-  return Math.max(1, Math.floor(remaining / state.autoInjectedRemaining));
-}
-
 function appendCappedEvidence(
   item: RecallEvidence,
   state: {
     capped: RecallEvidence[];
     textSizeBySource: Map<RecallSource, number>;
     totalTextSize: number;
-    textBudget?: number;
   },
 ): { totalTextSize: number; totalRemaining: number } {
   const sourceTextSize = state.textSizeBySource.get(item.source) ?? 0;
   const sourceRemaining = RECALL_EVIDENCE_TEXT_CAP_PER_SOURCE - sourceTextSize;
   const totalRemaining = RECALL_TOTAL_EVIDENCE_TEXT_CAP - state.totalTextSize;
-  const remaining = Math.min(
-    sourceRemaining,
-    totalRemaining,
-    state.textBudget ?? Number.MAX_SAFE_INTEGER,
-  );
+  const remaining = Math.min(sourceRemaining, totalRemaining);
   if (remaining <= 0) {
     return { totalTextSize: state.totalTextSize, totalRemaining };
   }
@@ -385,3 +283,15 @@ function errorToMessage(err: unknown): string {
   }
   return String(err);
 }
+
+function isAbortLikeError(err: unknown): boolean {
+  if (err instanceof Error && err.name === "AbortError") return true;
+  if (
+    typeof DOMException !== "undefined" &&
+    err instanceof DOMException &&
+    err.name === "AbortError"
+  ) {
+    return true;
+  }
+  return isAbortReason(err);
+}

package/src/memory/context-search/sources/conversations.ts

@@ -7,6 +7,7 @@ import { rawAll } from "../../raw-query.js";
 import type { RecallSearchContext, RecallSearchResult } from "../types.js";
 
 const SUBAGENT_SOURCE = "subagent";
+const NOTIFICATION_SOURCE = "notification";
 
 interface ConversationEvidenceRow {
   message_id: string;
@@ -88,7 +89,10 @@ export async function searchConversationSource(
 
   for (const ftsMatch of ftsMatches) {
     try {
-      rows = mergeConversationRows(rows, searchWithFts(ftsMatch, queryLimit));
+      rows = mergeConversationRows(
+        rows,
+        searchWithFts(ftsMatch, queryLimit, context.conversationId),
+      );
     } catch {
       // Try the next, broader query shape.
     }
@@ -97,7 +101,7 @@ export async function searchConversationSource(
   }
 
   if (rows.length === 0) {
-    rows = searchWithLike(trimmedQuery, queryLimit);
+    rows = searchWithLike(trimmedQuery, queryLimit, context.conversationId);
   }
 
   const sortedRows = rows
@@ -128,6 +132,7 @@ export async function searchConversationSource(
 function searchWithFts(
   ftsMatch: string,
   limit: number,
+  excludedConversationId: string,
 ): ConversationEvidenceRow[] {
   return rawAll<ConversationEvidenceRow>(
     `
@@ -142,14 +147,17 @@ function searchWithFts(
     JOIN messages m ON m.id = messages_fts.message_id
     JOIN conversations c ON c.id = m.conversation_id
     WHERE messages_fts MATCH ?
-      AND (c.conversation_type IS NULL OR c.conversation_type != 'private')
-      AND (c.source IS NULL OR c.source NOT IN (?, ?))
+      AND (c.source IS NULL OR c.source NOT IN (?, ?, ?))
+      AND c.id != ?
+      AND c.conversation_type != 'private'
     ORDER BY bm25(messages_fts), m.created_at DESC
     LIMIT ?
     `,
     ftsMatch,
     SUBAGENT_SOURCE,
     AUTO_ANALYSIS_SOURCE,
+    NOTIFICATION_SOURCE,
+    excludedConversationId,
     limit,
   );
 }
@@ -157,6 +165,7 @@ function searchWithFts(
 function searchWithLike(
   query: string,
   limit: number,
+  excludedConversationId: string,
 ): ConversationEvidenceRow[] {
   return rawAll<ConversationEvidenceRow>(
     `
@@ -170,14 +179,17 @@ function searchWithLike(
     FROM messages m
     JOIN conversations c ON c.id = m.conversation_id
     WHERE m.content LIKE ? ESCAPE '\\'
-      AND (c.conversation_type IS NULL OR c.conversation_type != 'private')
-      AND (c.source IS NULL OR c.source NOT IN (?, ?))
+      AND (c.source IS NULL OR c.source NOT IN (?, ?, ?))
+      AND c.id != ?
+      AND c.conversation_type != 'private'
     ORDER BY m.created_at DESC
     LIMIT ?
     `,
     buildLikePattern(query),
     SUBAGENT_SOURCE,
     AUTO_ANALYSIS_SOURCE,
+    NOTIFICATION_SOURCE,
+    excludedConversationId,
     limit,
   );
 }