vellum 0.2.2 → 0.2.8

package/src/daemon/ipc-contract.ts

@@ -212,6 +212,8 @@ export interface RideShotgunStart {
   intervalSeconds: number;
   mode?: 'observe' | 'learn';
   targetDomain?: string;
+  /** Domain to auto-navigate (may differ from targetDomain, e.g. open.spotify.com vs spotify.com). */
+  navigateDomain?: string;
   autoNavigate?: boolean;
 }
 
@@ -470,6 +472,18 @@ export interface SlackWebhookConfigRequest {
   webhookUrl?: string;
 }
 
+export interface TwilioWebhookConfigRequest {
+  type: 'twilio_webhook_config';
+  action: 'get' | 'set';
+  webhookBaseUrl?: string;
+}
+
+export interface IngressConfigRequest {
+  type: 'ingress_config';
+  action: 'get' | 'set';
+  publicBaseUrl?: string;
+}
+
 export interface VercelApiConfigRequest {
   type: 'vercel_api_config';
   action: 'get' | 'set' | 'delete';
@@ -933,6 +947,8 @@ export type ClientMessage =
   | ShareAppCloudRequest
   | ShareToSlackRequest
   | SlackWebhookConfigRequest
+  | TwilioWebhookConfigRequest
+  | IngressConfigRequest
   | VercelApiConfigRequest
   | TwitterIntegrationConfigRequest
   | TwitterAuthStartRequest
@@ -1041,6 +1057,12 @@ export interface ToolUseStart {
 export interface ToolOutputChunk {
   type: 'tool_output_chunk';
   chunk: string;
+  sessionId?: string;
+  subType?: 'tool_start' | 'tool_complete' | 'status';
+  subToolName?: string;
+  subToolInput?: string;
+  subToolIsError?: boolean;
+  subToolId?: string;
 }
 
 export interface ToolInputDelta {
@@ -1675,6 +1697,20 @@ export interface SlackWebhookConfigResponse {
   error?: string;
 }
 
+export interface TwilioWebhookConfigResponse {
+  type: 'twilio_webhook_config_response';
+  webhookBaseUrl: string;
+  success: boolean;
+  error?: string;
+}
+
+export interface IngressConfigResponse {
+  type: 'ingress_config_response';
+  publicBaseUrl: string;
+  success: boolean;
+  error?: string;
+}
+
 export interface OpenUrl {
   type: 'open_url';
   url: string;
@@ -1993,7 +2029,7 @@ export interface WorkItemDeleteResponse {
   success: boolean;
 }
 
-export type WorkItemRunTaskErrorCode = 'not_found' | 'already_running' | 'invalid_status' | 'no_task';
+export type WorkItemRunTaskErrorCode = 'not_found' | 'already_running' | 'invalid_status' | 'no_task' | 'permission_required';
 
 export interface WorkItemRunTaskResponse {
   type: 'work_item_run_task_response';
@@ -2158,6 +2194,8 @@ export type ServerMessage =
   | GalleryInstallResponse
   | ShareToSlackResponse
   | SlackWebhookConfigResponse
+  | TwilioWebhookConfigResponse
+  | IngressConfigResponse
   | VercelApiConfigResponse
   | TwitterIntegrationConfigResponse
   | TwitterAuthResult

package/src/daemon/ride-shotgun-handler.ts

@@ -161,6 +161,7 @@ export async function handleRideShotgunStart(
               }
             });
           } else if (msg.autoNavigate && targetDomain) {
+            const navDomain = msg.navigateDomain ?? targetDomain;
             const abortSignal = { aborted: false };
             const checkInterval = setInterval(() => {
               if (session.status !== 'active') {
@@ -168,7 +169,7 @@ export async function handleRideShotgunStart(
                 clearInterval(checkInterval);
               }
             }, 1000);
-            autoNavigate(targetDomain, abortSignal).then(visited => {
+            autoNavigate(navDomain, abortSignal).then(visited => {
               clearInterval(checkInterval);
               log.info({ watchId, visitedPages: visited.length }, 'Generic auto-navigation finished');
               if (session.status === 'active') {

package/src/daemon/session-agent-loop.ts

@@ -350,9 +350,44 @@ export async function runAgentLoopImpl(
           currentTurnToolNames.push(event.name);
           onEvent({ type: 'tool_use_start', toolName: event.name, input: event.input, sessionId: ctx.conversationId });
           break;
-        case 'tool_output_chunk':
-          onEvent({ type: 'tool_output_chunk', chunk: event.chunk });
+        case 'tool_output_chunk': {
+          // Try to parse structured progress fields from the chunk.
+          // Cheap pre-check: only attempt JSON.parse when the chunk looks like an object.
+          let structured: { subType?: 'tool_start' | 'tool_complete' | 'status'; subToolName?: string; subToolInput?: string; subToolIsError?: boolean; subToolId?: string } | undefined;
+          const trimmed = event.chunk.trimStart();
+          if (trimmed.length > 0 && trimmed.length < 4096 && trimmed[0] === '{') {
+            try {
+              const parsed = JSON.parse(event.chunk);
+              const VALID_SUB_TYPES = new Set(['tool_start', 'tool_complete', 'status']);
+              if (parsed && typeof parsed === 'object' && typeof parsed.subType === 'string' && VALID_SUB_TYPES.has(parsed.subType)) {
+                structured = {
+                  subType: parsed.subType as 'tool_start' | 'tool_complete' | 'status',
+                  subToolName: typeof parsed.subToolName === 'string' ? parsed.subToolName : undefined,
+                  subToolInput: typeof parsed.subToolInput === 'string' ? parsed.subToolInput : undefined,
+                  subToolIsError: typeof parsed.subToolIsError === 'boolean' ? parsed.subToolIsError : undefined,
+                  subToolId: typeof parsed.subToolId === 'string' ? parsed.subToolId : undefined,
+                };
+              }
+            } catch {
+              // Not valid JSON — pass through as plain chunk
+            }
+          }
+          if (structured) {
+            onEvent({
+              type: 'tool_output_chunk',
+              chunk: event.chunk,
+              sessionId: ctx.conversationId,
+              subType: structured.subType,
+              subToolName: structured.subToolName,
+              subToolInput: structured.subToolInput,
+              subToolIsError: structured.subToolIsError,
+              subToolId: structured.subToolId,
+            });
+          } else {
+            onEvent({ type: 'tool_output_chunk', chunk: event.chunk, sessionId: ctx.conversationId });
+          }
           break;
+        }
         case 'input_json_delta':
           onEvent({ type: 'tool_input_delta', toolName: event.toolName, content: event.accumulatedJson, sessionId: ctx.conversationId });
           break;

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

@@ -1,8 +1,8 @@
 /**
  * Conflict-gate logic extracted from Session.
  *
- * Decides whether to ask the user about a pending memory conflict (relevant gate),
- * inject a soft instruction (irrelevant gate), or skip entirely.
+ * Decides whether to ask the user about a pending memory conflict (relevant gate)
+ * or skip entirely.
  */
 
 import {
@@ -12,6 +12,11 @@ import {
 } from '../memory/conflict-store.js';
 import type { PendingConflictDetail } from '../memory/conflict-store.js';
 import { resolveConflictClarification } from '../memory/clarification-resolver.js';
+import {
+  computeConflictRelevance,
+  looksLikeClarificationReply,
+  shouldAttemptConflictResolution,
+} from '../memory/conflict-intent.js';
 
 export interface ConflictGateDecision {
   question: string;
@@ -39,14 +44,14 @@ export class ConflictGate {
     const threshold = conflictConfig.relevanceThreshold;
     const cooldownTurns = Math.max(1, conflictConfig.reaskCooldownTurns);
     const pendingBeforeResolve = listPendingConflictDetails(scopeId, 50);
+    const clarificationReply = looksLikeClarificationReply(userMessage);
     const candidatesBeforeResolve = pendingBeforeResolve.filter((conflict) => {
       const relevance = computeConflictRelevance(userMessage, conflict);
-      if (relevance >= threshold) return true;
-      // Only try to resolve recently-asked conflicts when the user message
-      // looks like a short clarification reply (e.g. "keep the new one"),
-      // not a full unrelated question that happens to contain cue words.
-      return this.wasRecentlyAsked(conflict.id, cooldownTurns)
-        && looksLikeClarificationReply(userMessage);
+      return shouldAttemptConflictResolution({
+        clarificationReply,
+        relevance,
+        wasRecentlyAsked: this.wasRecentlyAsked(conflict.id, cooldownTurns),
+      });
     });
     await this.resolvePendingConflicts(
       userMessage,
@@ -61,18 +66,16 @@ export class ConflictGate {
       conflict,
       relevance: computeConflictRelevance(userMessage, conflict),
     }));
-    const relevant = scored.filter((entry) => entry.relevance >= threshold);
-    const irrelevant = scored.filter((entry) => entry.relevance < threshold);
-    const ordered = [...relevant, ...irrelevant];
-
-    const askable = ordered.find((entry) => this.shouldAsk(entry.conflict.id, cooldownTurns));
+    const askable = scored
+      .filter((entry) => entry.relevance >= threshold)
+      .find((entry) => this.shouldAsk(entry.conflict.id, cooldownTurns));
     if (!askable) return null;
 
     this.lastAskedTurn.set(askable.conflict.id, this.turnCounter);
     markConflictAsked(askable.conflict.id);
     return {
       question: askable.conflict.clarificationQuestion ?? buildFallbackConflictQuestion(askable.conflict),
-      relevant: askable.relevance >= threshold,
+      relevant: true,
     };
   }
 
@@ -122,98 +125,4 @@ export function buildFallbackConflictQuestion(conflict: PendingConflictDetail):
     'Which one should I keep?',
   ].join('\n');
 }
-
-export function computeConflictRelevance(
-  userMessage: string,
-  conflict: Pick<PendingConflictDetail, 'existingStatement' | 'candidateStatement'>,
-): number {
-  const queryTokens = tokenizeForConflictRelevance(userMessage);
-  if (queryTokens.size === 0) return 0;
-  const existingTokens = tokenizeForConflictRelevance(conflict.existingStatement);
-  const candidateTokens = tokenizeForConflictRelevance(conflict.candidateStatement);
-  return Math.max(
-    overlapRatio(queryTokens, existingTokens),
-    overlapRatio(queryTokens, candidateTokens),
-  );
-}
-
-function tokenizeForConflictRelevance(input: string): Set<string> {
-  const tokens = input
-    .toLowerCase()
-    .split(/[^a-z0-9]+/g)
-    .map((token) => token.trim())
-    .filter((token) => token.length >= 4);
-  return new Set(tokens);
-}
-
-function overlapRatio(left: Set<string>, right: Set<string>): number {
-  if (left.size === 0 || right.size === 0) return 0;
-  let overlap = 0;
-  for (const token of left) {
-    if (right.has(token)) overlap += 1;
-  }
-  return overlap / Math.max(left.size, right.size);
-}
-
-// Action verbs that signal the user is making a deliberate choice.
-const ACTION_CUES = new Set([
-  'keep', 'use', 'prefer', 'go', 'pick', 'choose', 'take', 'want', 'select',
-]);
-
-// Directional/merge cue words mirrored from clarification-resolver.ts heuristics.
-const DIRECTIONAL_CUES = new Set([
-  'existing', 'old', 'previous', 'first', 'earlier', 'original',
-  'candidate', 'new', 'latest', 'second', 'updated', 'instead', 'replace',
-  'both', 'merge', 'combine', 'together', 'either', 'mix',
-  'option', 'former', 'latter',
-]);
-
-const MAX_REPLY_WORD_COUNT = 12;
-
-// Direction-only matches (no action verb) must be very short to avoid
-// false positives from unrelated statements that happen to contain
-// common words like "new", "old", "option", etc.
-const MAX_DIRECTION_ONLY_WORD_COUNT = 4;
-
-// Messages starting with a question word are unlikely to be clarification
-// replies even when they lack a trailing question mark.
-const QUESTION_WORD_PREFIXES = new Set([
-  'what', 'how', 'why', 'where', 'when', 'which', 'who', 'whom', 'whose',
-]);
-
-/**
- * Determines whether a user message looks like a deliberate reply to a
- * recently asked conflict clarification (e.g. "keep the new one", "both",
- * "option B", "new one"). Requires at least one action or directional cue,
- * and the message must be short. Questions and longer statements are excluded
- * to prevent accidental resolution from unrelated messages.
- *
- * When only directional cues are present (no action verb), the message must
- * be very short (<= 4 words) to avoid false positives from unrelated messages
- * like "What's new in Bun" or "try the old approach".
- */
-export function looksLikeClarificationReply(userMessage: string): boolean {
-  const trimmed = userMessage.trim();
-  if (trimmed.endsWith('?')) return false;
-
-  const words = trimmed.toLowerCase().split(/\s+/).filter(Boolean);
-  if (words.length === 0 || words.length > MAX_REPLY_WORD_COUNT) return false;
-
-  const normalized = words.map((w) => w.replace(/[^a-z]/g, ''));
-
-  // Reject messages that start with a question word (even without '?').
-  // Match exact question words or contractions (e.g. "what's", "where's"),
-  // but not words that merely share a prefix (e.g. "whichever", "however").
-  const firstWord = words[0];
-  const firstNorm = normalized[0];
-  for (const qw of QUESTION_WORD_PREFIXES) {
-    if (firstNorm === qw || (firstWord.startsWith(qw) && "'\u2018\u2019".includes(firstWord[qw.length]))) return false;
-  }
-
-  const hasAction = normalized.some((w) => ACTION_CUES.has(w));
-  const hasDirection = normalized.some((w) => DIRECTIONAL_CUES.has(w));
-
-  if (hasAction) return true;
-  if (hasDirection) return words.length <= MAX_DIRECTION_ONLY_WORD_COUNT;
-  return false;
-}
+export { computeConflictRelevance, looksLikeClarificationReply };

package/src/daemon/session-tool-setup.ts

@@ -14,6 +14,9 @@ import type { PermissionPrompter } from '../permissions/prompter.js';
 import type { SecretPrompter } from '../permissions/secret-prompter.js';
 import { addRule, findHighestPriorityRule } from '../permissions/trust-store.js';
 import { generateAllowlistOptions, generateScopeOptions, normalizeWebFetchUrl } from '../permissions/checker.js';
+import { getLogger } from '../util/logger.js';
+
+const log = getLogger('session-tool-setup');
 import { getAllToolDefinitions } from '../tools/registry.js';
 import { allUiSurfaceTools } from '../tools/ui-surface/definitions.js';
 import { coreAppProxyTools } from '../tools/apps/definitions.js';
@@ -248,10 +251,12 @@ export function createToolExecutor(
           req.principal,
         );
         if ((response.decision === 'always_allow' || response.decision === 'always_allow_high_risk') && response.selectedPattern && response.selectedScope) {
+          log.info({ toolName: 'cc:' + req.toolName, pattern: response.selectedPattern, scope: response.selectedScope, highRisk: response.decision === 'always_allow_high_risk' }, 'Persisting always-allow trust rule');
           addRule('cc:' + req.toolName, response.selectedPattern, response.selectedScope, 'allow', 100,
             response.decision === 'always_allow_high_risk' ? { allowHighRisk: true } : undefined);
         }
         if (response.decision === 'always_deny' && response.selectedPattern && response.selectedScope) {
+          log.info({ toolName: 'cc:' + req.toolName, pattern: response.selectedPattern, scope: response.selectedScope }, 'Persisting always-deny trust rule');
           addRule('cc:' + req.toolName, response.selectedPattern, response.selectedScope, 'deny');
         }
         return {
@@ -440,10 +445,12 @@ export function createProxyApprovalCallback(
 
     // Persist trust rule if the user chose "always allow" or "always deny"
     if ((response.decision === 'always_allow' || response.decision === 'always_allow_high_risk') && response.selectedPattern && response.selectedScope) {
+      log.info({ toolName, pattern: response.selectedPattern, scope: response.selectedScope, highRisk: response.decision === 'always_allow_high_risk' }, 'Persisting always-allow trust rule (proxy)');
       addRule(toolName, response.selectedPattern, response.selectedScope, 'allow', 100,
         response.decision === 'always_allow_high_risk' ? { allowHighRisk: true } : undefined);
     }
     if (response.decision === 'always_deny' && response.selectedPattern && response.selectedScope) {
+      log.info({ toolName, pattern: response.selectedPattern, scope: response.selectedScope }, 'Persisting always-deny trust rule (proxy)');
       addRule(toolName, response.selectedPattern, response.selectedScope, 'deny');
     }
 

package/src/inbound/public-ingress-urls.ts

@@ -0,0 +1,106 @@
+/**
+ * Centralized URL builders for all public-facing ingress endpoints.
+ *
+ * Resolves the canonical public base URL via a fallback chain:
+ *   ingress.publicBaseUrl → calls.webhookBaseUrl → env TWILIO_WEBHOOK_BASE_URL
+ *
+ * Supersedes the per-domain URL helpers in calls/twilio-webhook-urls.ts.
+ */
+
+import { getLogger } from '../util/logger.js';
+
+const log = getLogger('public-ingress-urls');
+
+export interface IngressConfig {
+  ingress?: { publicBaseUrl?: string };
+  calls?: { webhookBaseUrl?: string };
+}
+
+/**
+ * Trim whitespace and strip trailing slashes from a URL string.
+ */
+function normalizeUrl(url: string): string {
+  return url.trim().replace(/\/+$/, '');
+}
+
+/**
+ * Resolve the canonical public base URL with a three-level fallback chain:
+ *   1. ingress.publicBaseUrl (preferred)
+ *   2. calls.webhookBaseUrl (backward compat)
+ *   3. TWILIO_WEBHOOK_BASE_URL env var (legacy, deprecated)
+ *
+ * Throws if no source provides a non-empty value.
+ */
+export function getPublicBaseUrl(config: IngressConfig): string {
+  const ingressValue = config.ingress?.publicBaseUrl;
+  if (ingressValue) {
+    const normalized = normalizeUrl(ingressValue);
+    if (normalized) return normalized;
+  }
+
+  const callsValue = config.calls?.webhookBaseUrl;
+  if (callsValue) {
+    const normalized = normalizeUrl(callsValue);
+    if (normalized) {
+      log.warn(
+        'Using calls.webhookBaseUrl as public base URL — set ingress.publicBaseUrl instead.',
+      );
+      return normalized;
+    }
+  }
+
+  const envValue = process.env.TWILIO_WEBHOOK_BASE_URL;
+  if (envValue) {
+    log.warn(
+      'TWILIO_WEBHOOK_BASE_URL env var is deprecated — set ingress.publicBaseUrl in config instead.',
+    );
+    const normalized = normalizeUrl(envValue);
+    if (normalized) return normalized;
+  }
+
+  throw new Error(
+    'No public base URL configured. Set ingress.publicBaseUrl in config, calls.webhookBaseUrl, or TWILIO_WEBHOOK_BASE_URL env var.',
+  );
+}
+
+/**
+ * Build the Twilio voice webhook URL for a given call session.
+ */
+export function getTwilioVoiceWebhookUrl(config: IngressConfig, callSessionId: string): string {
+  const base = getPublicBaseUrl(config);
+  return `${base}/webhooks/twilio/voice?callSessionId=${callSessionId}`;
+}
+
+/**
+ * Build the Twilio status callback URL.
+ */
+export function getTwilioStatusCallbackUrl(config: IngressConfig): string {
+  const base = getPublicBaseUrl(config);
+  return `${base}/webhooks/twilio/status`;
+}
+
+/**
+ * Build the Twilio connect-action callback URL.
+ */
+export function getTwilioConnectActionUrl(config: IngressConfig): string {
+  const base = getPublicBaseUrl(config);
+  return `${base}/webhooks/twilio/connect-action`;
+}
+
+/**
+ * Build the Twilio ConversationRelay WebSocket URL.
+ * Converts http:// → ws:// and https:// → wss://.
+ */
+export function getTwilioRelayUrl(config: IngressConfig): string {
+  const base = getPublicBaseUrl(config);
+  const wsBase = base.replace(/^http(s?)/, 'ws$1');
+  return `${wsBase}/webhooks/twilio/relay`;
+}
+
+/**
+ * Build the OAuth callback URL.
+ */
+export function getOAuthCallbackUrl(config: IngressConfig): string {
+  const base = getPublicBaseUrl(config);
+  return `${base}/webhooks/oauth/callback`;
+}

package/src/memory/attachments-store.ts

@@ -197,7 +197,6 @@ export function uploadAttachment(
 
   const record = {
     id: uuid(),
-    assistantId: 'self',
     originalFilename: filename,
     mimeType,
     sizeBytes,

package/src/memory/channel-delivery-store.ts

@@ -82,7 +82,6 @@ export function recordInbound(
     tx.insert(channelInboundEvents)
       .values({
         id: eventId,
-        assistantId: 'self',
         sourceChannel,
         externalChatId,
         externalMessageId,

package/src/memory/conflict-intent.ts

@@ -0,0 +1,114 @@
+/**
+ * Shared conflict intent helpers used by both interactive conflict gating and
+ * background conflict resolution jobs.
+ */
+
+export interface ConflictStatementPair {
+  existingStatement: string;
+  candidateStatement: string;
+}
+
+export function computeConflictRelevance(
+  userMessage: string,
+  conflict: ConflictStatementPair,
+): number {
+  const queryTokens = tokenizeForConflictRelevance(userMessage);
+  if (queryTokens.size === 0) return 0;
+  const existingTokens = tokenizeForConflictRelevance(conflict.existingStatement);
+  const candidateTokens = tokenizeForConflictRelevance(conflict.candidateStatement);
+  return Math.max(
+    overlapRatio(queryTokens, existingTokens),
+    overlapRatio(queryTokens, candidateTokens),
+  );
+}
+
+function tokenizeForConflictRelevance(input: string): Set<string> {
+  const tokens = input
+    .toLowerCase()
+    .split(/[^a-z0-9]+/g)
+    .map((token) => token.trim())
+    .filter((token) => token.length >= 4);
+  return new Set(tokens);
+}
+
+function overlapRatio(left: Set<string>, right: Set<string>): number {
+  if (left.size === 0 || right.size === 0) return 0;
+  let overlap = 0;
+  for (const token of left) {
+    if (right.has(token)) overlap += 1;
+  }
+  return overlap / Math.max(left.size, right.size);
+}
+
+// Action verbs that signal the user is making a deliberate choice.
+const ACTION_CUES = new Set([
+  'keep', 'use', 'prefer', 'go', 'pick', 'choose', 'take', 'want', 'select',
+]);
+
+// Directional/merge cue words mirrored from clarification-resolver.ts heuristics.
+const DIRECTIONAL_CUES = new Set([
+  'existing', 'old', 'previous', 'first', 'earlier', 'original',
+  'candidate', 'new', 'latest', 'second', 'updated', 'instead', 'replace',
+  'both', 'merge', 'combine', 'together', 'either', 'mix',
+  'option', 'former', 'latter',
+]);
+
+const MAX_REPLY_WORD_COUNT = 12;
+
+// Direction-only matches (no action verb) must be very short to avoid
+// false positives from unrelated statements that happen to contain
+// common words like "new", "old", "option", etc.
+const MAX_DIRECTION_ONLY_WORD_COUNT = 4;
+
+// Messages starting with a question word are unlikely to be clarification
+// replies even when they lack a trailing question mark.
+const QUESTION_WORD_PREFIXES = new Set([
+  'what', 'how', 'why', 'where', 'when', 'which', 'who', 'whom', 'whose',
+]);
+
+/**
+ * Determines whether a user message looks like a deliberate clarification
+ * reply (e.g. "keep the new one", "both", "option B").
+ */
+export function looksLikeClarificationReply(userMessage: string): boolean {
+  const trimmed = userMessage.trim();
+  if (trimmed.endsWith('?')) return false;
+
+  const words = trimmed.toLowerCase().split(/\s+/).filter(Boolean);
+  if (words.length === 0 || words.length > MAX_REPLY_WORD_COUNT) return false;
+
+  const normalized = words.map((w) => w.replace(/[^a-z]/g, ''));
+
+  // Reject messages that start with a question word (even without '?').
+  // Match exact question words or contractions (e.g. "what's", "where's"),
+  // but not words that merely share a prefix (e.g. "whichever", "however").
+  const firstWord = words[0];
+  const firstNorm = normalized[0];
+  for (const qw of QUESTION_WORD_PREFIXES) {
+    if (firstNorm === qw || (firstWord.startsWith(qw) && "'\u2018\u2019".includes(firstWord[qw.length]))) return false;
+  }
+
+  const hasAction = normalized.some((w) => ACTION_CUES.has(w));
+  const hasDirection = normalized.some((w) => DIRECTIONAL_CUES.has(w));
+
+  if (hasAction) return true;
+  if (hasDirection) return words.length <= MAX_DIRECTION_ONLY_WORD_COUNT;
+  return false;
+}
+
+/**
+ * Conflict resolution should require explicit clarification intent and either:
+ * - non-zero topical overlap with the conflict statements, or
+ * - a very recent explicit ask from the assistant.
+ */
+export function shouldAttemptConflictResolution(
+  input: {
+    clarificationReply: boolean;
+    relevance: number;
+    wasRecentlyAsked: boolean;
+  },
+): boolean {
+  if (!input.clarificationReply) return false;
+  if (input.relevance > 0) return true;
+  return input.wasRecentlyAsked;
+}

package/src/memory/conversation-key-store.ts

@@ -96,7 +96,6 @@ export function getOrCreateConversation(
     tx.insert(conversationKeys)
       .values({
         id: uuid(),
-        assistantId: 'self',
         conversationKey,
         conversationId,
         createdAt: now,