@vellumai/assistant 0.4.48 → 0.4.50

package/src/daemon/session-conflict-gate.ts

@@ -1,167 +0,0 @@
-/**
- * Conflict-gate logic extracted from Session.
- *
- * Handles pending memory conflicts internally: dismisses non-user-evidenced
- * and non-actionable conflicts, and attempts resolution when the user's reply
- * looks like an explicit clarification with topical relevance. Never produces
- * user-facing clarification text.
- */
-
-import { resolveConflictClarification } from "../memory/clarification-resolver.js";
-import {
-  areStatementsCoherent,
-  computeConflictRelevance,
-  looksLikeClarificationReply,
-  shouldAttemptConflictResolution,
-} from "../memory/conflict-intent.js";
-import {
-  isConflictKindPairEligible,
-  isConflictUserEvidenced,
-  isStatementConflictEligible,
-} from "../memory/conflict-policy.js";
-import type { PendingConflictDetail } from "../memory/conflict-store.js";
-import {
-  applyConflictResolution,
-  listPendingConflictDetails,
-  resolveConflict,
-} from "../memory/conflict-store.js";
-
-export class ConflictGate {
-  async evaluate(
-    userMessage: string,
-    conflictConfig: {
-      enabled: boolean;
-      gateMode: string;
-      relevanceThreshold: number;
-      resolverLlmTimeoutMs: number;
-      conflictableKinds: readonly string[];
-    },
-    scopeId = "default",
-  ): Promise<void> {
-    if (!conflictConfig.enabled || conflictConfig.gateMode !== "soft") return;
-
-    const pendingBeforeResolve = listPendingConflictDetails(scopeId, 50);
-
-    // Dismiss non-actionable conflicts (kind/statement policy, incoherent pair,
-    // or assistant-inferred-only provenance with no user evidence)
-    const dismissedIds = new Set<string>();
-    for (const conflict of pendingBeforeResolve) {
-      const dismissReason = this.getDismissReason(
-        conflict,
-        conflictConfig.conflictableKinds,
-      );
-      if (dismissReason) {
-        resolveConflict(conflict.id, {
-          status: "dismissed",
-          resolutionNote: dismissReason,
-        });
-        dismissedIds.add(conflict.id);
-      }
-    }
-
-    const actionablePending = pendingBeforeResolve.filter(
-      (c) => !dismissedIds.has(c.id),
-    );
-
-    // Attempt resolution only for explicit clarification-like replies with
-    // topical relevance to the conflict statements
-    const clarificationReply = looksLikeClarificationReply(userMessage);
-    const candidatesBeforeResolve = actionablePending.filter((conflict) => {
-      const relevance = computeConflictRelevance(userMessage, conflict);
-      return shouldAttemptConflictResolution({
-        clarificationReply,
-        relevance,
-      });
-    });
-    await this.resolvePendingConflicts(
-      userMessage,
-      conflictConfig.resolverLlmTimeoutMs,
-      candidatesBeforeResolve,
-    );
-  }
-
-  private async resolvePendingConflicts(
-    userMessage: string,
-    resolverTimeoutMs: number,
-    pendingConflicts: PendingConflictDetail[],
-  ): Promise<void> {
-    for (const conflict of pendingConflicts) {
-      const resolution = await resolveConflictClarification(
-        {
-          existingStatement: conflict.existingStatement,
-          candidateStatement: conflict.candidateStatement,
-          userMessage,
-        },
-        { timeoutMs: resolverTimeoutMs },
-      );
-      if (resolution.resolution === "still_unclear") continue;
-
-      applyConflictResolution({
-        conflictId: conflict.id,
-        resolution: resolution.resolution,
-        mergedStatement:
-          resolution.resolution === "merge"
-            ? resolution.resolvedStatement
-            : null,
-        resolutionNote: resolution.explanation,
-      });
-    }
-  }
-
-  /**
-   * Returns a dismissal reason if the conflict should be dismissed, or null if actionable.
-   */
-  private getDismissReason(
-    conflict: PendingConflictDetail,
-    conflictableKinds: readonly string[],
-  ): string | null {
-    if (
-      !isConflictKindPairEligible(
-        conflict.existingKind,
-        conflict.candidateKind,
-        { conflictableKinds },
-      )
-    ) {
-      return "Dismissed by conflict policy (kind not eligible).";
-    }
-    if (
-      !isStatementConflictEligible(
-        conflict.existingKind,
-        conflict.existingStatement,
-        { conflictableKinds },
-      )
-    ) {
-      return "Dismissed by conflict policy (transient/non-durable).";
-    }
-    if (
-      !isStatementConflictEligible(
-        conflict.candidateKind,
-        conflict.candidateStatement,
-        { conflictableKinds },
-      )
-    ) {
-      return "Dismissed by conflict policy (transient/non-durable).";
-    }
-    // Dismiss incoherent conflicts where the two statements have zero topical overlap
-    if (
-      !areStatementsCoherent(
-        conflict.existingStatement,
-        conflict.candidateStatement,
-      )
-    ) {
-      return "Dismissed by conflict policy (incoherent — zero statement overlap).";
-    }
-    // Dismiss conflicts where neither side has user-evidenced provenance
-    if (
-      !isConflictUserEvidenced(
-        conflict.existingVerificationState,
-        conflict.candidateVerificationState,
-      )
-    ) {
-      return "Dismissed by conflict policy (no user-evidenced provenance).";
-    }
-    return null;
-  }
-}
-
-export { computeConflictRelevance, looksLikeClarificationReply };

package/src/daemon/session-dynamic-profile.ts

@@ -1,77 +0,0 @@
-/**
- * Dynamic-profile injection and stripping helpers extracted from Session.
- *
- * These are pure functions with no state — they wrap profile text into user
- * messages at runtime and strip it back out before persistence.
- */
-
-import type { Message } from "../providers/types.js";
-
-export function injectDynamicProfileIntoUserMessage(
-  message: Message,
-  profileText: string,
-): Message {
-  const trimmedProfile = profileText.trim();
-  if (trimmedProfile.length === 0) return message;
-  const block = [
-    "<dynamic-profile-context>",
-    trimmedProfile,
-    "</dynamic-profile-context>",
-  ].join("\n");
-  return {
-    ...message,
-    content: [...message.content, { type: "text", text: `\n\n${block}` }],
-  };
-}
-
-export function stripDynamicProfileMessages(
-  messages: Message[],
-  profileText: string,
-): Message[] {
-  const trimmedProfile = profileText.trim();
-  if (trimmedProfile.length === 0) return messages;
-  const injectedBlock = `\n\n<dynamic-profile-context>\n${trimmedProfile}\n</dynamic-profile-context>`;
-  // Find the last user message that actually contains the injected profile block.
-  // We can't just target the last user message by role — tool_result messages also
-  // have role 'user', so after tool use the last user message won't be the one
-  // we injected the profile into.
-  let lastUserIdx = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (
-      messages[i].role === "user" &&
-      messages[i].content.some(
-        (b) => b.type === "text" && b.text.includes(injectedBlock),
-      )
-    ) {
-      lastUserIdx = i;
-      break;
-    }
-  }
-  if (lastUserIdx === -1) return messages;
-  const message = messages[lastUserIdx];
-  let changed = false;
-  const nextContent = message.content
-    .map((block) => {
-      if (block.type !== "text") return block;
-      const nextText = block.text.split(injectedBlock).join("");
-      if (nextText === block.text) return block;
-      changed = true;
-      const stripped = nextText.replace(/\n{3,}/g, "\n\n").trimEnd();
-      return stripped.length > 0 ? { ...block, text: stripped } : null;
-    })
-    .filter((block): block is NonNullable<typeof block> => block != null);
-  if (!changed) return messages;
-  // If stripping removed all content blocks, drop the message entirely
-  // to avoid sending an empty content array to the provider.
-  if (nextContent.length === 0) {
-    return [
-      ...messages.slice(0, lastUserIdx),
-      ...messages.slice(lastUserIdx + 1),
-    ];
-  }
-  return [
-    ...messages.slice(0, lastUserIdx),
-    { ...message, content: nextContent },
-    ...messages.slice(lastUserIdx + 1),
-  ];
-}

package/src/memory/clarification-resolver.ts

@@ -1,417 +0,0 @@
-import {
-  createTimeout,
-  extractToolUse,
-  getConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import type { ModelIntent } from "../providers/types.js";
-import { truncate } from "../util/truncate.js";
-
-const DEFAULT_RESOLVER_MODEL_INTENT: ModelIntent = "latency-optimized";
-const DEFAULT_RESOLVER_TIMEOUT_MS = 12_000;
-
-const DIRECTIONAL_EXISTING_CUES = [
-  "existing",
-  "old",
-  "previous",
-  "first",
-  "earlier",
-  "original",
-];
-const DIRECTIONAL_CANDIDATE_CUES = [
-  "candidate",
-  "new",
-  "latest",
-  "second",
-  "updated",
-  "instead",
-  "replace",
-];
-const MERGE_CUES = [
-  "both",
-  "merge",
-  "combine",
-  "together",
-  "depends",
-  "either",
-  "mix",
-];
-
-const STOP_WORDS = new Set([
-  "about",
-  "after",
-  "again",
-  "also",
-  "because",
-  "been",
-  "before",
-  "being",
-  "between",
-  "could",
-  "doing",
-  "from",
-  "have",
-  "into",
-  "just",
-  "more",
-  "most",
-  "only",
-  "over",
-  "same",
-  "should",
-  "some",
-  "than",
-  "that",
-  "their",
-  "there",
-  "these",
-  "they",
-  "this",
-  "those",
-  "were",
-  "what",
-  "when",
-  "where",
-  "which",
-  "while",
-  "with",
-  "would",
-  "your",
-]);
-
-export type ClarificationResolution =
-  | "keep_existing"
-  | "keep_candidate"
-  | "merge"
-  | "still_unclear";
-
-export type ClarificationStrategy =
-  | "heuristic"
-  | "llm"
-  | "llm_timeout"
-  | "llm_error"
-  | "no_llm_key";
-
-export interface ClarificationResolverInput {
-  existingStatement: string;
-  candidateStatement: string;
-  userMessage: string;
-}
-
-export interface ClarificationResolverOptions {
-  apiKey?: string;
-  model?: string;
-  modelIntent?: ModelIntent;
-  timeoutMs?: number;
-}
-
-export interface ClarificationResolverResult {
-  resolution: ClarificationResolution;
-  strategy: ClarificationStrategy;
-  resolvedStatement: string | null;
-  explanation: string;
-}
-
-export async function resolveConflictClarification(
-  input: ClarificationResolverInput,
-  options?: ClarificationResolverOptions,
-): Promise<ClarificationResolverResult> {
-  const heuristicResult = resolveWithHeuristics(input);
-  if (heuristicResult) return heuristicResult;
-
-  const provider = getConfiguredProvider();
-  if (!provider) {
-    return {
-      resolution: "still_unclear",
-      strategy: "no_llm_key",
-      resolvedStatement: null,
-      explanation:
-        "Configured provider unavailable for clarification fallback.",
-    };
-  }
-
-  try {
-    return await resolveWithLlm(input, {
-      model: options?.model,
-      modelIntent: options?.modelIntent ?? DEFAULT_RESOLVER_MODEL_INTENT,
-      timeoutMs: options?.timeoutMs ?? DEFAULT_RESOLVER_TIMEOUT_MS,
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message === "clarification_resolver_timeout") {
-      return {
-        resolution: "still_unclear",
-        strategy: "llm_timeout",
-        resolvedStatement: null,
-        explanation: "Clarification resolver timed out.",
-      };
-    }
-    return {
-      resolution: "still_unclear",
-      strategy: "llm_error",
-      resolvedStatement: null,
-      explanation: `Clarification resolver failed: ${truncate(
-        message,
-        300,
-        "",
-      )}`,
-    };
-  }
-}
-
-function resolveWithHeuristics(
-  input: ClarificationResolverInput,
-): ClarificationResolverResult | null {
-  const normalizedMessage = normalize(input.userMessage);
-  if (!normalizedMessage) return null;
-
-  const lowerMessage = normalizedMessage.toLowerCase();
-
-  const hasExistingCue = containsAnyCue(
-    lowerMessage,
-    DIRECTIONAL_EXISTING_CUES,
-  );
-  const hasCandidateCue = containsAnyCue(
-    lowerMessage,
-    DIRECTIONAL_CANDIDATE_CUES,
-  );
-  const hasMergeCue = containsAnyCue(lowerMessage, MERGE_CUES);
-
-  // When multiple cue categories match, delegate to LLM to avoid misclassification
-  const matchCount = [hasExistingCue, hasCandidateCue, hasMergeCue].filter(
-    Boolean,
-  ).length;
-  if (matchCount > 1) return null;
-
-  if (hasMergeCue) {
-    return {
-      resolution: "merge",
-      strategy: "heuristic",
-      resolvedStatement: buildMergedStatement(input),
-      explanation: "User response includes merge cues.",
-    };
-  }
-
-  if (hasExistingCue) {
-    return {
-      resolution: "keep_existing",
-      strategy: "heuristic",
-      resolvedStatement: null,
-      explanation: "User response explicitly points to existing/old statement.",
-    };
-  }
-
-  if (hasCandidateCue) {
-    return {
-      resolution: "keep_candidate",
-      strategy: "heuristic",
-      resolvedStatement: null,
-      explanation:
-        "User response explicitly points to candidate/new statement.",
-    };
-  }
-
-  const messageTokens = tokenize(normalizedMessage);
-  const existingOverlap = overlapScore(
-    messageTokens,
-    tokenize(input.existingStatement),
-  );
-  const candidateOverlap = overlapScore(
-    messageTokens,
-    tokenize(input.candidateStatement),
-  );
-
-  if (existingOverlap >= 2 && existingOverlap >= candidateOverlap + 1) {
-    return {
-      resolution: "keep_existing",
-      strategy: "heuristic",
-      resolvedStatement: null,
-      explanation:
-        "User response overlaps more with existing statement details.",
-    };
-  }
-
-  if (candidateOverlap >= 2 && candidateOverlap >= existingOverlap + 1) {
-    return {
-      resolution: "keep_candidate",
-      strategy: "heuristic",
-      resolvedStatement: null,
-      explanation:
-        "User response overlaps more with candidate statement details.",
-    };
-  }
-
-  if (existingOverlap > 0 && candidateOverlap > 0) {
-    return {
-      resolution: "merge",
-      strategy: "heuristic",
-      resolvedStatement: buildMergedStatement(input),
-      explanation: "User response overlaps with both statements.",
-    };
-  }
-
-  return null;
-}
-
-async function resolveWithLlm(
-  input: ClarificationResolverInput,
-  options: { model?: string; modelIntent: ModelIntent; timeoutMs: number },
-): Promise<ClarificationResolverResult> {
-  const provider = getConfiguredProvider()!;
-  const userPrompt = [
-    "You are resolving a memory clarification response.",
-    "",
-    `Existing statement: ${input.existingStatement}`,
-    `Candidate statement: ${input.candidateStatement}`,
-    `User clarification: ${input.userMessage}`,
-  ].join("\n");
-
-  const { signal, cleanup } = createTimeout(options.timeoutMs);
-
-  try {
-    const response = await provider.sendMessage(
-      [userMessage(userPrompt)],
-      [
-        {
-          name: "resolve_conflict_clarification",
-          description:
-            "Resolve a pending memory contradiction using user clarification.",
-          input_schema: {
-            type: "object" as const,
-            properties: {
-              resolution: {
-                type: "string",
-                enum: [
-                  "keep_existing",
-                  "keep_candidate",
-                  "merge",
-                  "still_unclear",
-                ],
-              },
-              resolved_statement: {
-                type: "string",
-                description: "Required only when resolution is merge.",
-              },
-              explanation: {
-                type: "string",
-                description: "One short rationale for the classification.",
-              },
-            },
-            required: ["resolution", "explanation"],
-          },
-        },
-      ],
-      [
-        "Classify the user clarification for conflicting memory statements.",
-        "Return exactly one resolution:",
-        "- keep_existing",
-        "- keep_candidate",
-        "- merge",
-        "- still_unclear",
-      ].join("\n"),
-      {
-        config: {
-          ...(options.model
-            ? { model: options.model }
-            : { modelIntent: options.modelIntent }),
-          max_tokens: 256,
-          tool_choice: {
-            type: "tool" as const,
-            name: "resolve_conflict_clarification",
-          },
-        },
-        signal,
-      },
-    );
-    cleanup();
-
-    const toolBlock = extractToolUse(response);
-    if (!toolBlock) {
-      throw new Error("No tool_use block in clarification resolver response.");
-    }
-
-    const parsed = toolBlock.input as {
-      resolution?: string;
-      resolved_statement?: string;
-      explanation?: string;
-    };
-
-    if (!isResolution(parsed.resolution)) {
-      throw new Error(
-        `Invalid clarification resolution: ${String(parsed.resolution)}`,
-      );
-    }
-
-    const resolvedStatement =
-      parsed.resolution === "merge"
-        ? normalize(parsed.resolved_statement ?? buildMergedStatement(input)) ||
-          buildMergedStatement(input)
-        : null;
-
-    return {
-      resolution: parsed.resolution,
-      strategy: "llm",
-      resolvedStatement,
-      explanation: truncate(
-        normalize(parsed.explanation ?? "Resolved via LLM fallback."),
-        500,
-        "",
-      ),
-    };
-  } catch (err) {
-    cleanup();
-    if (signal.aborted) {
-      throw new Error("clarification_resolver_timeout");
-    }
-    throw err;
-  }
-}
-
-function isResolution(
-  value: string | undefined,
-): value is ClarificationResolution {
-  return (
-    value === "keep_existing" ||
-    value === "keep_candidate" ||
-    value === "merge" ||
-    value === "still_unclear"
-  );
-}
-
-function containsAnyCue(input: string, cues: readonly string[]): boolean {
-  return cues.some((cue) => new RegExp(`\\b${cue}\\b`).test(input));
-}
-
-function overlapScore(left: Set<string>, right: Set<string>): number {
-  let score = 0;
-  for (const token of left) {
-    if (right.has(token)) score += 1;
-  }
-  return score;
-}
-
-function tokenize(input: string): Set<string> {
-  const words = input
-    .toLowerCase()
-    .split(/[^a-z0-9]+/g)
-    .map((word) => word.trim())
-    .filter((word) => word.length >= 4 && !STOP_WORDS.has(word));
-  return new Set(words);
-}
-
-function normalize(input: string): string {
-  return input.replace(/\s+/g, " ").trim();
-}
-
-function buildMergedStatement(input: ClarificationResolverInput): string {
-  const normalizedUserMessage = normalize(input.userMessage);
-  if (
-    normalizedUserMessage.length >= 8 &&
-    normalizedUserMessage.length <= 320
-  ) {
-    return normalizedUserMessage;
-  }
-  const existing = truncate(normalize(input.existingStatement), 140, "");
-  const candidate = truncate(normalize(input.candidateStatement), 140, "");
-  return truncate(`Merged clarification: ${existing}; ${candidate}`, 320, "");
-}