@vellumai/assistant 0.4.49 → 0.4.51

package/src/config/schemas/memory-processing.ts

@@ -1,28 +1,5 @@
 import { z } from "zod";
 
-const VALID_MEMORY_ITEM_KINDS = [
-  "preference",
-  "profile",
-  "project",
-  "decision",
-  "todo",
-  "fact",
-  "constraint",
-  "relationship",
-  "event",
-  "opinion",
-  "instruction",
-  "style",
-] as const;
-
-const DEFAULT_CONFLICTABLE_KINDS = [
-  "preference",
-  "profile",
-  "constraint",
-  "instruction",
-  "style",
-] as const;
-
 export const MemoryExtractionConfigSchema = z.object({
   useLLM: z
     .boolean({ error: "memory.extraction.useLLM must be a boolean" })
@@ -50,166 +27,9 @@ export const MemorySummarizationConfigSchema = z.object({
     .default("latency-optimized"),
 });
 
-export const MemoryEntityConfigSchema = z.object({
-  enabled: z
-    .boolean({ error: "memory.entity.enabled must be a boolean" })
-    .default(true),
-  modelIntent: z
-    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-      error: "memory.entity.modelIntent must be a valid model intent",
-    })
-    .default("latency-optimized"),
-  extractRelations: z
-    .object({
-      enabled: z
-        .boolean({
-          error: "memory.entity.extractRelations.enabled must be a boolean",
-        })
-        .default(true),
-      backfillBatchSize: z
-        .number({
-          error:
-            "memory.entity.extractRelations.backfillBatchSize must be a number",
-        })
-        .int(
-          "memory.entity.extractRelations.backfillBatchSize must be an integer",
-        )
-        .positive(
-          "memory.entity.extractRelations.backfillBatchSize must be a positive integer",
-        )
-        .default(200),
-    })
-    .default({ enabled: true, backfillBatchSize: 200 }),
-  relationRetrieval: z
-    .object({
-      enabled: z
-        .boolean({
-          error: "memory.entity.relationRetrieval.enabled must be a boolean",
-        })
-        .default(true),
-      maxSeedEntities: z
-        .number({
-          error:
-            "memory.entity.relationRetrieval.maxSeedEntities must be a number",
-        })
-        .int(
-          "memory.entity.relationRetrieval.maxSeedEntities must be an integer",
-        )
-        .positive(
-          "memory.entity.relationRetrieval.maxSeedEntities must be a positive integer",
-        )
-        .default(8),
-      maxNeighborEntities: z
-        .number({
-          error:
-            "memory.entity.relationRetrieval.maxNeighborEntities must be a number",
-        })
-        .int(
-          "memory.entity.relationRetrieval.maxNeighborEntities must be an integer",
-        )
-        .positive(
-          "memory.entity.relationRetrieval.maxNeighborEntities must be a positive integer",
-        )
-        .default(20),
-      maxEdges: z
-        .number({
-          error: "memory.entity.relationRetrieval.maxEdges must be a number",
-        })
-        .int("memory.entity.relationRetrieval.maxEdges must be an integer")
-        .positive(
-          "memory.entity.relationRetrieval.maxEdges must be a positive integer",
-        )
-        .default(40),
-      neighborScoreMultiplier: z
-        .number({
-          error:
-            "memory.entity.relationRetrieval.neighborScoreMultiplier must be a number",
-        })
-        .gt(
-          0,
-          "memory.entity.relationRetrieval.neighborScoreMultiplier must be > 0",
-        )
-        .lte(
-          1,
-          "memory.entity.relationRetrieval.neighborScoreMultiplier must be <= 1",
-        )
-        .default(0.7),
-      maxDepth: z
-        .number({
-          error: "memory.entity.relationRetrieval.maxDepth must be a number",
-        })
-        .int("memory.entity.relationRetrieval.maxDepth must be an integer")
-        .positive(
-          "memory.entity.relationRetrieval.maxDepth must be a positive integer",
-        )
-        .default(3),
-      depthDecay: z
-        .boolean({
-          error: "memory.entity.relationRetrieval.depthDecay must be a boolean",
-        })
-        .default(true),
-    })
-    .default({
-      enabled: true,
-      maxSeedEntities: 8,
-      maxNeighborEntities: 20,
-      maxEdges: 40,
-      neighborScoreMultiplier: 0.7,
-      maxDepth: 3,
-      depthDecay: true,
-    }),
-});
-
-export const MemoryConflictsConfigSchema = z.object({
-  enabled: z
-    .boolean({ error: "memory.conflicts.enabled must be a boolean" })
-    .default(true),
-  gateMode: z
-    .enum(["soft"], { error: 'memory.conflicts.gateMode must be "soft"' })
-    .default("soft"),
-  resolverLlmTimeoutMs: z
-    .number({ error: "memory.conflicts.resolverLlmTimeoutMs must be a number" })
-    .int("memory.conflicts.resolverLlmTimeoutMs must be an integer")
-    .positive(
-      "memory.conflicts.resolverLlmTimeoutMs must be a positive integer",
-    )
-    .default(12000),
-  relevanceThreshold: z
-    .number({ error: "memory.conflicts.relevanceThreshold must be a number" })
-    .min(0, "memory.conflicts.relevanceThreshold must be >= 0")
-    .max(1, "memory.conflicts.relevanceThreshold must be <= 1")
-    .default(0.3),
-  conflictableKinds: z
-    .array(
-      z.enum(VALID_MEMORY_ITEM_KINDS, {
-        error: `memory.conflicts.conflictableKinds entries must be one of: ${VALID_MEMORY_ITEM_KINDS.join(
-          ", ",
-        )}`,
-      }),
-    )
-    .nonempty({
-      message: "memory.conflicts.conflictableKinds must not be empty",
-    })
-    .default([...DEFAULT_CONFLICTABLE_KINDS]),
-});
-
-export const MemoryProfileConfigSchema = z.object({
-  enabled: z
-    .boolean({ error: "memory.profile.enabled must be a boolean" })
-    .default(true),
-  maxInjectTokens: z
-    .number({ error: "memory.profile.maxInjectTokens must be a number" })
-    .int("memory.profile.maxInjectTokens must be an integer")
-    .positive("memory.profile.maxInjectTokens must be a positive integer")
-    .default(800),
-});
-
 export type MemoryExtractionConfig = z.infer<
   typeof MemoryExtractionConfigSchema
 >;
 export type MemorySummarizationConfig = z.infer<
   typeof MemorySummarizationConfigSchema
 >;
-export type MemoryEntityConfig = z.infer<typeof MemoryEntityConfigSchema>;
-export type MemoryConflictsConfig = z.infer<typeof MemoryConflictsConfigSchema>;
-export type MemoryProfileConfig = z.infer<typeof MemoryProfileConfigSchema>;

package/src/config/schemas/memory-retrieval.ts

@@ -1,22 +1,5 @@
 import { z } from "zod";
 
-export const MemoryRerankingConfigSchema = z.object({
-  enabled: z
-    .boolean({ error: "memory.retrieval.reranking.enabled must be a boolean" })
-    .default(false),
-  modelIntent: z
-    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-      error:
-        "memory.retrieval.reranking.modelIntent must be a valid model intent",
-    })
-    .default("latency-optimized"),
-  topK: z
-    .number({ error: "memory.retrieval.reranking.topK must be a number" })
-    .int("memory.retrieval.reranking.topK must be an integer")
-    .positive("memory.retrieval.reranking.topK must be a positive integer")
-    .default(20),
-});
-
 export const MemoryDynamicBudgetConfigSchema = z.object({
   enabled: z
     .boolean({
@@ -55,49 +38,6 @@ export const MemoryDynamicBudgetConfigSchema = z.object({
     .default(10000),
 });
 
-export const MemoryEarlyTerminationConfigSchema = z.object({
-  enabled: z
-    .boolean({
-      error: "memory.retrieval.earlyTermination.enabled must be a boolean",
-    })
-    .default(true),
-  minCandidates: z
-    .number({
-      error: "memory.retrieval.earlyTermination.minCandidates must be a number",
-    })
-    .int("memory.retrieval.earlyTermination.minCandidates must be an integer")
-    .positive(
-      "memory.retrieval.earlyTermination.minCandidates must be a positive integer",
-    )
-    .default(20),
-  minHighConfidence: z
-    .number({
-      error:
-        "memory.retrieval.earlyTermination.minHighConfidence must be a number",
-    })
-    .int(
-      "memory.retrieval.earlyTermination.minHighConfidence must be an integer",
-    )
-    .positive(
-      "memory.retrieval.earlyTermination.minHighConfidence must be a positive integer",
-    )
-    .default(10),
-  confidenceThreshold: z
-    .number({
-      error:
-        "memory.retrieval.earlyTermination.confidenceThreshold must be a number",
-    })
-    .min(
-      0,
-      "memory.retrieval.earlyTermination.confidenceThreshold must be >= 0",
-    )
-    .max(
-      1,
-      "memory.retrieval.earlyTermination.confidenceThreshold must be <= 1",
-    )
-    .default(0.7),
-});
-
 /**
  * Per-kind freshness windows (in days). Items older than their window
  * (based on lastSeenAt) are down-ranked unless recently reinforced.
@@ -109,12 +49,13 @@ const MemoryFreshnessConfigSchema = z.object({
     .default(true),
   maxAgeDays: z
     .object({
-      fact: z
+      identity: z
         .number({
-          error: "memory.retrieval.freshness.maxAgeDays.fact must be a number",
+          error:
+            "memory.retrieval.freshness.maxAgeDays.identity must be a number",
         })
         .nonnegative(
-          "memory.retrieval.freshness.maxAgeDays.fact must be non-negative",
+          "memory.retrieval.freshness.maxAgeDays.identity must be non-negative",
         )
         .default(0),
       preference: z
@@ -126,34 +67,50 @@ const MemoryFreshnessConfigSchema = z.object({
           "memory.retrieval.freshness.maxAgeDays.preference must be non-negative",
         )
         .default(0),
-      behavior: z
+      project: z
         .number({
           error:
-            "memory.retrieval.freshness.maxAgeDays.behavior must be a number",
+            "memory.retrieval.freshness.maxAgeDays.project must be a number",
         })
         .nonnegative(
-          "memory.retrieval.freshness.maxAgeDays.behavior must be non-negative",
+          "memory.retrieval.freshness.maxAgeDays.project must be non-negative",
         )
-        .default(90),
-      event: z
+        .default(30),
+      decision: z
         .number({
-          error: "memory.retrieval.freshness.maxAgeDays.event must be a number",
+          error:
+            "memory.retrieval.freshness.maxAgeDays.decision must be a number",
         })
         .nonnegative(
-          "memory.retrieval.freshness.maxAgeDays.event must be non-negative",
+          "memory.retrieval.freshness.maxAgeDays.decision must be non-negative",
         )
         .default(30),
-      opinion: z
+      constraint: z
         .number({
           error:
-            "memory.retrieval.freshness.maxAgeDays.opinion must be a number",
+            "memory.retrieval.freshness.maxAgeDays.constraint must be a number",
+        })
+        .nonnegative(
+          "memory.retrieval.freshness.maxAgeDays.constraint must be non-negative",
+        )
+        .default(90),
+      event: z
+        .number({
+          error: "memory.retrieval.freshness.maxAgeDays.event must be a number",
         })
         .nonnegative(
-          "memory.retrieval.freshness.maxAgeDays.opinion must be non-negative",
+          "memory.retrieval.freshness.maxAgeDays.event must be non-negative",
         )
-        .default(60),
+        .default(30),
     })
-    .default({ fact: 0, preference: 0, behavior: 90, event: 30, opinion: 60 }),
+    .default({
+      identity: 0,
+      preference: 0,
+      project: 30,
+      decision: 30,
+      constraint: 90,
+      event: 30,
+    }),
   staleDecay: z
     .number({ error: "memory.retrieval.freshness.staleDecay must be a number" })
     .min(0, "memory.retrieval.freshness.staleDecay must be >= 0")
@@ -171,36 +128,11 @@ const MemoryFreshnessConfigSchema = z.object({
 });
 
 export const MemoryRetrievalConfigSchema = z.object({
-  lexicalTopK: z
-    .number({ error: "memory.retrieval.lexicalTopK must be a number" })
-    .int("memory.retrieval.lexicalTopK must be an integer")
-    .positive("memory.retrieval.lexicalTopK must be a positive integer")
-    .default(80),
-  semanticTopK: z
-    .number({ error: "memory.retrieval.semanticTopK must be a number" })
-    .int("memory.retrieval.semanticTopK must be an integer")
-    .positive("memory.retrieval.semanticTopK must be a positive integer")
-    .default(40),
   maxInjectTokens: z
     .number({ error: "memory.retrieval.maxInjectTokens must be a number" })
     .int("memory.retrieval.maxInjectTokens must be an integer")
     .positive("memory.retrieval.maxInjectTokens must be a positive integer")
     .default(10000),
-  injectionFormat: z
-    .enum(["markdown", "structured_v1"], {
-      error:
-        'memory.retrieval.injectionFormat must be "markdown" or "structured_v1"',
-    })
-    .default("markdown"),
-  injectionStrategy: z
-    .enum(["prepend_user_block", "separate_context_message"], {
-      error:
-        'memory.retrieval.injectionStrategy must be "prepend_user_block" or "separate_context_message"',
-    })
-    .default("prepend_user_block"),
-  reranking: MemoryRerankingConfigSchema.default(
-    MemoryRerankingConfigSchema.parse({}),
-  ),
   freshness: MemoryFreshnessConfigSchema.default(
     MemoryFreshnessConfigSchema.parse({}),
   ),
@@ -213,10 +145,6 @@ export const MemoryRetrievalConfigSchema = z.object({
   dynamicBudget: MemoryDynamicBudgetConfigSchema.default(
     MemoryDynamicBudgetConfigSchema.parse({}),
   ),
-  earlyTermination: MemoryEarlyTerminationConfigSchema.default(
-    MemoryEarlyTerminationConfigSchema.parse({}),
-  ),
 });
 
-export type MemoryRerankingConfig = z.infer<typeof MemoryRerankingConfigSchema>;
 export type MemoryRetrievalConfig = z.infer<typeof MemoryRetrievalConfigSchema>;

package/src/config/schemas/memory.ts

@@ -6,10 +6,7 @@ import {
   MemoryRetentionConfigSchema,
 } from "./memory-lifecycle.js";
 import {
-  MemoryConflictsConfigSchema,
-  MemoryEntityConfigSchema,
   MemoryExtractionConfigSchema,
-  MemoryProfileConfigSchema,
   MemorySummarizationConfigSchema,
 } from "./memory-processing.js";
 import { MemoryRetrievalConfigSchema } from "./memory-retrieval.js";
@@ -46,13 +43,6 @@ export const MemoryConfigSchema = z.object({
   summarization: MemorySummarizationConfigSchema.default(
     MemorySummarizationConfigSchema.parse({}),
   ),
-  entity: MemoryEntityConfigSchema.default(MemoryEntityConfigSchema.parse({})),
-  conflicts: MemoryConflictsConfigSchema.default(
-    MemoryConflictsConfigSchema.parse({}),
-  ),
-  profile: MemoryProfileConfigSchema.default(
-    MemoryProfileConfigSchema.parse({}),
-  ),
 });
 
 export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;

package/src/config/types.ts

@@ -12,13 +12,9 @@ export type {
   IngressConfig,
   LogFileConfig,
   MemoryConfig,
-  MemoryConflictsConfig,
   MemoryEmbeddingsConfig,
-  MemoryEntityConfig,
   MemoryExtractionConfig,
   MemoryJobsConfig,
-  MemoryProfileConfig,
-  MemoryRerankingConfig,
   MemoryRetentionConfig,
   MemoryRetrievalConfig,
   MemorySegmentationConfig,

package/src/contacts/contact-store.ts

@@ -140,6 +140,10 @@ export function upsertContact(params: {
   contactType?: ContactType;
   principalId?: string | null;
   channels?: SyncChannelData[];
+  /** When true, conflicting channels on other contacts are reassigned to this
+   *  contact instead of being skipped. Used by invite redemption to bind a
+   *  redeemer's existing channel identity to the invite's target contact. */
+  reassignConflictingChannels?: boolean;
 }): ContactWithChannels & { created: boolean } {
   const db = getDb();
   const now = Date.now();
@@ -171,7 +175,12 @@ export function upsertContact(params: {
         .run();
 
       if (params.channels) {
-        syncChannels(contactId, params.channels, now);
+        syncChannels(
+          contactId,
+          params.channels,
+          now,
+          params.reassignConflictingChannels,
+        );
       }
 
       emitContactChange();
@@ -253,6 +262,7 @@ function syncChannels(
   contactId: string,
   channels: SyncChannelData[],
   now: number,
+  reassignConflicting?: boolean,
 ): void {
   const db = getDb();
 
@@ -312,7 +322,34 @@ function syncChannels(
       .get();
 
     if (conflicting) {
-      // Channel belongs to another contact -- skip to avoid unique constraint violation.
+      if (reassignConflicting) {
+        // Reassign the channel to the target contact. Used by invite redemption
+        // to bind a redeemer's existing channel identity to the invite's target.
+        const reassignSet: Record<string, unknown> = {
+          contactId,
+          updatedAt: now,
+        };
+        if (ch.externalUserId !== undefined)
+          reassignSet.externalUserId = ch.externalUserId;
+        if (ch.externalChatId !== undefined)
+          reassignSet.externalChatId = ch.externalChatId;
+        if (ch.status !== undefined) reassignSet.status = ch.status;
+        if (ch.policy !== undefined) reassignSet.policy = ch.policy;
+        if (ch.verifiedAt !== undefined) reassignSet.verifiedAt = ch.verifiedAt;
+        if (ch.verifiedVia !== undefined)
+          reassignSet.verifiedVia = ch.verifiedVia;
+        if (ch.inviteId !== undefined) reassignSet.inviteId = ch.inviteId;
+        if (ch.revokedReason !== undefined)
+          reassignSet.revokedReason = ch.revokedReason;
+        if (ch.blockedReason !== undefined)
+          reassignSet.blockedReason = ch.blockedReason;
+
+        db.update(contactChannels)
+          .set(reassignSet)
+          .where(eq(contactChannels.id, conflicting.id))
+          .run();
+      }
+      // When not reassigning, skip to avoid unique constraint violation.
       // The caller should use contact_merge to combine the two contacts.
       continue;
     }

package/src/contacts/contacts-write.ts

@@ -24,6 +24,7 @@ import {
 import type {
   ChannelPolicy,
   ChannelStatus,
+  ContactRole,
   ContactWriteResult,
 } from "./types.js";
 
@@ -146,6 +147,8 @@ export function upsertContactChannel(params: {
   createdBySessionId?: string;
   verifiedAt?: number;
   verifiedVia?: string;
+  role?: ContactRole;
+  contactId?: string;
 }): ContactWriteResult | null {
   let address: string;
 
@@ -173,7 +176,9 @@ export function upsertContactChannel(params: {
     : null;
 
   upsertContact({
+    id: params.contactId,
     displayName,
+    role: params.role,
     channels: [
       {
         type: params.sourceChannel,
@@ -189,6 +194,10 @@ export function upsertContactChannel(params: {
         verifiedVia: params.verifiedVia ?? undefined,
       },
     ],
+    // When a specific contactId is provided, reassign conflicting channels from
+    // other contacts. This enables invite redemption to bind a redeemer's
+    // existing channel identity to the invite's target contact.
+    reassignConflictingChannels: !!params.contactId,
   });
 
   const contactResult = findContactChannel({

package/src/context/window-manager.ts

@@ -671,7 +671,10 @@ function countPersistedMessages(messages: Message[]): number {
 function isToolResultOnly(message: Message): boolean {
   return (
     message.content.length > 0 &&
-    message.content.every((block) => block.type === "tool_result")
+    message.content.every(
+      (block) =>
+        block.type === "tool_result" || block.type === "web_search_tool_result",
+    )
   );
 }
 

package/src/daemon/config-watcher.ts

@@ -3,7 +3,13 @@
  * Watches workspace files (config, prompts), protected directory
  * (trust rules, secret allowlist), and skills directories for changes.
  */
-import { existsSync, type FSWatcher, readdirSync, watch } from "node:fs";
+import {
+  existsSync,
+  type FSWatcher,
+  mkdirSync,
+  readdirSync,
+  watch,
+} from "node:fs";
 import { join } from "node:path";
 
 import { getConfig, invalidateConfigCache } from "../config/loader.js";
@@ -14,6 +20,8 @@ import {
   resetAllowlist,
   validateAllowlistFile,
 } from "../security/secret-allowlist.js";
+import { handleConfirmationSignal } from "../signals/confirm.js";
+import { handleMcpReloadSignal } from "../signals/mcp-reload.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -107,8 +115,17 @@ export class ConfigWatcher {
       "config.json": () => {
         if (this.suppressReload) return;
         try {
+          const prevConfig = getConfig();
+          const prevMcpFingerprint = JSON.stringify(prevConfig.mcp ?? {});
           const changed = this.refreshConfigFromSources();
-          if (changed) onSessionEvict();
+          if (changed) {
+            onSessionEvict();
+            const newConfig = getConfig();
+            const newMcpFingerprint = JSON.stringify(newConfig.mcp ?? {});
+            if (newMcpFingerprint !== prevMcpFingerprint) {
+              handleMcpReloadSignal();
+            }
+          }
         } catch (err) {
           log.error(
             { err, configPath: join(workspaceDir, "config.json") },
@@ -185,6 +202,7 @@ export class ConfigWatcher {
       );
     }
 
+    this.startSignalsWatcher();
     this.startSkillsWatchers(onSessionEvict);
   }
 
@@ -196,6 +214,41 @@ export class ConfigWatcher {
     this.watchers = [];
   }
 
+  private startSignalsWatcher(): void {
+    const signalsDir = join(getWorkspaceDir(), "signals");
+    try {
+      if (!existsSync(signalsDir)) {
+        mkdirSync(signalsDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    const signalHandlers: Record<string, () => void> = {
+      "mcp-reload": handleMcpReloadSignal,
+      confirm: handleConfirmationSignal,
+    };
+
+    try {
+      const watcher = watch(signalsDir, (_eventType, filename) => {
+        if (!filename) return;
+        const file = String(filename);
+        if (!signalHandlers[file]) return;
+        this.debounceTimers.schedule(`signal:${file}`, () => {
+          log.info({ file }, "Signal file detected");
+          signalHandlers[file]();
+        });
+      });
+      this.watchers.push(watcher);
+      log.info({ dir: signalsDir }, "Watching signals directory");
+    } catch (err) {
+      log.warn(
+        { err, dir: signalsDir },
+        "Failed to watch signals directory. Signal-based reload will be unavailable.",
+      );
+    }
+  }
+
   private startSkillsWatchers(onSessionEvict: () => void): void {
     const skillsDir = getWorkspaceSkillsDir();
     if (!existsSync(skillsDir)) return;

package/src/daemon/daemon-control.ts

@@ -143,7 +143,7 @@ function healthCheckHost(host: string): string {
 /** Hit the daemon's HTTP /healthz endpoint. Returns true if it responds
  *  with HTTP 200 within the timeout — false on connection refused, timeout,
  *  or any other error. */
-async function isHttpHealthy(): Promise<boolean> {
+export async function isHttpHealthy(): Promise<boolean> {
   const host = healthCheckHost(getRuntimeHttpHost());
   const port = getRuntimeHttpPort();
   try {