@vellumai/assistant 0.3.14 → 0.3.16

package/src/daemon/date-context.ts

@@ -11,6 +11,12 @@ export interface TemporalContextOptions {
   nowMs?: number;
   /** IANA timezone (e.g. "America/New_York"). Defaults to host timezone. */
   timeZone?: string;
+  /** IANA timezone for the assistant host clock (defaults to process local timezone). */
+  hostTimeZone?: string;
+  /** IANA timezone configured in user settings (if available). */
+  configuredUserTimeZone?: string | null;
+  /** IANA timezone inferred from user profile/memory (if available). */
+  userTimeZone?: string | null;
   /** Number of future days to list (default 14, hard-capped at 14). */
   horizonDays?: number;
 }
@@ -19,6 +25,117 @@ const MAX_OUTPUT_CHARS = 1500;
 const MAX_HORIZON_ENTRIES = 14;
 
 const WEEKDAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'] as const;
+const TIMEZONE_SUBJECT_LINE_RE = /^\s*-\s*time\s*zone\s*:\s*(.+)$/i;
+const TIMEZONE_SUBJECT_COMPACT_RE = /^\s*-\s*timezone\s*:\s*(.+)$/i;
+const TIMEZONE_TOKEN_RE = /\b(?:[A-Za-z][A-Za-z0-9_+-]*(?:\/[A-Za-z0-9_+-]+)+|(?:UTC|GMT)(?:[+-]\d{1,2}(?::?\d{2})?)?)\b/gi;
+const UTC_GMT_OFFSET_TOKEN_RE = /^(?:UTC|GMT)([+-])(\d{1,2})(?::?(\d{2}))?$/i;
+
+function normalizeOffsetToken(offsetToken: string): string {
+  if (offsetToken === 'GMT' || offsetToken === 'UTC') {
+    return '+00:00';
+  }
+  const match = /^(?:GMT|UTC)([+-])(\d{1,2})(?::?(\d{2}))?$/i.exec(offsetToken);
+  if (!match) {
+    return '+00:00';
+  }
+  const [, sign, hours, minutes] = match;
+  return `${sign}${hours.padStart(2, '0')}:${(minutes ?? '00').padStart(2, '0')}`;
+}
+
+function canonicalizeUtcGmtOffsetToken(offsetToken: string): string | null {
+  if (/^(?:UTC|GMT)$/i.test(offsetToken)) {
+    return 'UTC';
+  }
+  const match = offsetToken.match(UTC_GMT_OFFSET_TOKEN_RE);
+  if (!match) {
+    return null;
+  }
+  const [, sign, hoursRaw, minutesRaw] = match;
+  const hours = Number.parseInt(hoursRaw, 10);
+  const minutes = Number.parseInt(minutesRaw ?? '0', 10);
+  if (!Number.isInteger(hours) || !Number.isInteger(minutes)) {
+    return null;
+  }
+  if (hours > 14 || minutes > 59) {
+    return null;
+  }
+  const totalMinutes = (hours * 60 + minutes) * (sign === '+' ? 1 : -1);
+  if (Math.abs(totalMinutes) > 14 * 60) {
+    return null;
+  }
+  if (totalMinutes === 0) {
+    return 'UTC';
+  }
+  const absTotalMinutes = Math.abs(totalMinutes);
+  const absHours = Math.floor(absTotalMinutes / 60);
+  const absMinutes = absTotalMinutes % 60;
+  const offsetSign = totalMinutes > 0 ? '+' : '-';
+
+  // For whole-hour offsets, prefer `Etc/GMT` for stable canonicalization.
+  if (absMinutes === 0) {
+    // `Etc/GMT` uses POSIX sign semantics: east-of-UTC offsets use a minus sign.
+    const etcSign = totalMinutes > 0 ? '-' : '+';
+    return `Etc/GMT${etcSign}${absHours}`;
+  }
+
+  // Bun/Intl accepts fixed-offset IDs in ±HH:MM format.
+  return `${offsetSign}${String(absHours).padStart(2, '0')}:${String(absMinutes).padStart(2, '0')}`;
+}
+
+function canonicalizeTimeZone(timeZone: string): string | null {
+  const trimmed = timeZone.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  const canonicalOffset = canonicalizeUtcGmtOffsetToken(trimmed);
+  if (canonicalOffset) {
+    try {
+      return new Intl.DateTimeFormat('en-US', { timeZone: canonicalOffset }).resolvedOptions().timeZone;
+    } catch {
+      return null;
+    }
+  }
+  try {
+    return new Intl.DateTimeFormat('en-US', { timeZone: trimmed }).resolvedOptions().timeZone;
+  } catch {
+    return null;
+  }
+}
+
+function extractTimeZoneCandidates(text: string): string[] {
+  const matches = (text.match(TIMEZONE_TOKEN_RE) ?? []).map((token) => token.trim()).filter((token) => token.length > 0);
+  const ianaTokens = matches.filter((token) => token.includes('/'));
+  const offsetTokens = matches.filter((token) => !token.includes('/'));
+  return [...ianaTokens, ...offsetTokens];
+}
+
+/**
+ * Extract a valid user timezone from compiled `<dynamic-user-profile>` text.
+ *
+ * Prefers explicit `timezone:` profile lines, then falls back to scanning the
+ * full profile body for valid IANA timezone identifiers.
+ */
+export function extractUserTimeZoneFromDynamicProfile(profileText: string): string | null {
+  const trimmed = profileText.trim();
+  if (trimmed.length === 0) return null;
+
+  const candidateTexts: string[] = [];
+  for (const line of trimmed.split('\n')) {
+    const match = line.match(TIMEZONE_SUBJECT_LINE_RE) ?? line.match(TIMEZONE_SUBJECT_COMPACT_RE);
+    if (match) {
+      candidateTexts.push(match[1]);
+    }
+  }
+  candidateTexts.push(trimmed);
+
+  for (const text of candidateTexts) {
+    for (const token of extractTimeZoneCandidates(text)) {
+      const canonical = canonicalizeTimeZone(token);
+      if (canonical) return canonical;
+    }
+  }
+  return null;
+}
 
 /**
  * Get the local date parts for a given instant in the specified timezone.
@@ -52,6 +169,33 @@ function formatLocalDate(date: Date, timeZone: string): string {
   return `${p.year}-${String(p.month).padStart(2, '0')}-${String(p.day).padStart(2, '0')}`;
 }
 
+/**
+ * Format a Date as local ISO 8601 with timezone offset in the given timezone.
+ */
+function formatLocalIsoWithOffset(date: Date, timeZone: string): string {
+  const fmt = new Intl.DateTimeFormat('en-US', {
+    timeZone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hourCycle: 'h23',
+    timeZoneName: 'shortOffset',
+  });
+  const parts = fmt.formatToParts(date);
+  const get = (t: string) => parts.find((p) => p.type === t)?.value ?? '';
+  const offset = normalizeOffsetToken(get('timeZoneName'));
+  const year = get('year');
+  const month = get('month');
+  const day = get('day');
+  const hour = get('hour');
+  const minute = get('minute');
+  const second = get('second');
+  return `${year}-${month}-${day}T${hour}:${minute}:${second}${offset}`;
+}
+
 /**
  * Advance a date by `days` calendar days in the given timezone.
  *
@@ -84,7 +228,30 @@ function addDays(date: Date, days: number, timeZone: string): Date {
  */
 export function buildTemporalContext(options: TemporalContextOptions = {}): string {
   const now = new Date(options.nowMs ?? Date.now());
-  const timeZone = options.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const resolvedHostTimeZone = canonicalizeTimeZone(
+    options.hostTimeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
+  ) ?? 'UTC';
+  const resolvedConfiguredUserTimeZone = options.configuredUserTimeZone
+    ? canonicalizeTimeZone(options.configuredUserTimeZone)
+    : null;
+  const resolvedUserTimeZone = options.userTimeZone
+    ? canonicalizeTimeZone(options.userTimeZone)
+    : null;
+  const resolvedTimeZone = options.timeZone
+    ? canonicalizeTimeZone(options.timeZone)
+    : null;
+  const timeZone = resolvedTimeZone
+    ?? resolvedConfiguredUserTimeZone
+    ?? resolvedUserTimeZone
+    ?? resolvedHostTimeZone;
+  const userTimeZone = resolvedConfiguredUserTimeZone ?? resolvedUserTimeZone;
+  const timeZoneSource = resolvedTimeZone
+    ? 'explicit_override'
+    : resolvedConfiguredUserTimeZone
+      ? 'user_settings'
+      : resolvedUserTimeZone
+        ? 'user_profile_memory'
+        : 'assistant_host_fallback';
   const horizonDays = Math.min(options.horizonDays ?? MAX_HORIZON_ENTRIES, MAX_HORIZON_ENTRIES);
 
   const todayParts = localDateParts(now, timeZone);
@@ -114,6 +281,12 @@ export function buildTemporalContext(options: TemporalContextOptions = {}): stri
     `<temporal_context>`,
     `Today: ${todayStr} (${todayWeekday})`,
     `Timezone: ${timeZone}`,
+    `Current local time: ${formatLocalIsoWithOffset(now, timeZone)}`,
+    `Current UTC time: ${now.toISOString()}`,
+    `Clock source: assistant host machine`,
+    `Assistant host timezone: ${resolvedHostTimeZone}`,
+    `User timezone: ${userTimeZone ?? 'unknown'}`,
+    `Timezone source: ${timeZoneSource}`,
     ``,
     `Week definitions: work week = Monday–Friday, weekend = Saturday–Sunday`,
     ``,

package/src/daemon/guardian-action-generators.ts

@@ -0,0 +1,175 @@
+import { loadConfig } from '../config/loader.js';
+import { getFailoverProvider } from '../providers/registry.js';
+import {
+  buildGuardianActionGenerationPrompt,
+  getGuardianActionFallbackMessage,
+  GUARDIAN_ACTION_COPY_MAX_TOKENS,
+  GUARDIAN_ACTION_COPY_SYSTEM_PROMPT,
+  GUARDIAN_ACTION_COPY_TIMEOUT_MS,
+  includesRequiredKeywords,
+} from '../runtime/guardian-action-message-composer.js';
+import type {
+  GuardianActionCopyGenerator,
+  GuardianFollowUpConversationGenerator,
+  GuardianFollowUpDisposition,
+  GuardianFollowUpTurnResult,
+} from '../runtime/http-types.js';
+
+/**
+ * Create the daemon-owned guardian action copy generator that resolves
+ * providers and calls `provider.sendMessage` to generate guardian action
+ * copy text. Uses `latency-optimized` model intent since these are
+ * time-sensitive voice responses.
+ *
+ * This keeps all provider awareness in the daemon lifecycle, away from
+ * the runtime composer.
+ */
+export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator {
+  return async (context, options = {}) => {
+    const config = loadConfig();
+    let provider;
+    try {
+      provider = getFailoverProvider(config.provider, config.providerOrder);
+    } catch {
+      return null;
+    }
+
+    const fallbackText = options.fallbackText?.trim() || getGuardianActionFallbackMessage(context);
+    const requiredKeywords = options.requiredKeywords?.map((kw) => kw.trim()).filter((kw) => kw.length > 0);
+    const prompt = buildGuardianActionGenerationPrompt(context, fallbackText, requiredKeywords);
+
+    const response = await provider.sendMessage(
+      [{ role: 'user', content: [{ type: 'text', text: prompt }] }],
+      [],
+      GUARDIAN_ACTION_COPY_SYSTEM_PROMPT,
+      {
+        config: {
+          max_tokens: options.maxTokens ?? GUARDIAN_ACTION_COPY_MAX_TOKENS,
+          modelIntent: 'latency-optimized',
+        },
+        signal: AbortSignal.timeout(options.timeoutMs ?? GUARDIAN_ACTION_COPY_TIMEOUT_MS),
+      },
+    );
+
+    const block = response.content.find((entry) => entry.type === 'text');
+    const text = block && 'text' in block ? block.text.trim() : '';
+    if (!text) return null;
+    const cleaned = text
+      .replace(/^["'`]+/, '')
+      .replace(/["'`]+$/, '')
+      .trim();
+    if (!cleaned) return null;
+    if (!includesRequiredKeywords(cleaned, requiredKeywords)) return null;
+    return cleaned;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Guardian follow-up conversation generator
+// ---------------------------------------------------------------------------
+
+const FOLLOWUP_CONVERSATION_TIMEOUT_MS = 8_000;
+const FOLLOWUP_CONVERSATION_MAX_TOKENS = 300;
+
+const FOLLOWUP_CONVERSATION_SYSTEM_PROMPT =
+  'You are an assistant helping route a guardian\'s reply to a post-timeout follow-up message. '
+  + 'A voice caller asked a question, but the call timed out before the guardian could answer. '
+  + 'The guardian has now replied late, and was asked whether they want to call the caller back, '
+  + 'send them a text message, or skip it. '
+  + 'Analyze the guardian\'s latest reply to determine their intent. '
+  + 'When uncertain, default to keep_pending and ask a clarifying question. '
+  + 'Always provide a natural, helpful reply along with your decision.';
+
+const FOLLOWUP_CONVERSATION_TOOL_NAME = 'followup_decision';
+
+const FOLLOWUP_CONVERSATION_TOOL_SCHEMA = {
+  name: FOLLOWUP_CONVERSATION_TOOL_NAME,
+  description:
+    'Record the guardian\'s follow-up decision and a natural reply. '
+    + 'Call this tool with the determined disposition and a reply to the guardian.',
+  input_schema: {
+    type: 'object' as const,
+    properties: {
+      disposition: {
+        type: 'string',
+        enum: ['call_back', 'message_back', 'decline', 'keep_pending'],
+        description:
+          'The guardian\'s intent: call_back to call the original caller, '
+          + 'message_back to send a text message, decline to skip the follow-up, '
+          + 'keep_pending if the intent is unclear (ask for clarification).',
+      },
+      replyText: {
+        type: 'string',
+        description: 'A natural language reply to send back to the guardian.',
+      },
+    },
+    required: ['disposition', 'replyText'],
+  },
+};
+
+const VALID_FOLLOWUP_DISPOSITIONS: ReadonlySet<string> = new Set([
+  'call_back',
+  'message_back',
+  'decline',
+  'keep_pending',
+]);
+
+/**
+ * Create the daemon-owned guardian follow-up conversation generator.
+ * Uses tool/function calling to produce structured dispositions alongside
+ * natural reply text. Follows the same pattern as
+ * createApprovalConversationGenerator().
+ */
+export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpConversationGenerator {
+  return async (context) => {
+    const config = loadConfig();
+    const provider = getFailoverProvider(config.provider, config.providerOrder);
+
+    const userPrompt = [
+      `Original question from the voice call: "${context.questionText}"`,
+      `Guardian's late answer: "${context.lateAnswerText}"`,
+      `\nGuardian's latest reply: ${context.guardianReply}`,
+    ].join('\n');
+
+    const response = await provider.sendMessage(
+      [{ role: 'user', content: [{ type: 'text', text: userPrompt }] }],
+      [FOLLOWUP_CONVERSATION_TOOL_SCHEMA],
+      FOLLOWUP_CONVERSATION_SYSTEM_PROMPT,
+      {
+        config: {
+          max_tokens: FOLLOWUP_CONVERSATION_MAX_TOKENS,
+          modelIntent: 'latency-optimized',
+        },
+        signal: AbortSignal.timeout(FOLLOWUP_CONVERSATION_TIMEOUT_MS),
+      },
+    );
+
+    // Extract the tool_use block from the response
+    const toolUseBlock = response.content.find(
+      (block) => block.type === 'tool_use' && block.name === FOLLOWUP_CONVERSATION_TOOL_NAME,
+    );
+
+    if (!toolUseBlock || toolUseBlock.type !== 'tool_use') {
+      throw new Error('Provider did not return a tool_use block for follow-up decision');
+    }
+
+    const input = toolUseBlock.input as Record<string, unknown>;
+
+    // Strict validation of the structured output
+    const disposition = input.disposition;
+    if (typeof disposition !== 'string' || !VALID_FOLLOWUP_DISPOSITIONS.has(disposition)) {
+      throw new Error(`Invalid disposition: ${String(disposition)}`);
+    }
+
+    const replyText = input.replyText;
+    if (typeof replyText !== 'string' || replyText.trim().length === 0) {
+      throw new Error('Missing or empty replyText in tool_use response');
+    }
+
+    const result: GuardianFollowUpTurnResult = {
+      disposition: disposition as GuardianFollowUpDisposition,
+      replyText: replyText.trim(),
+    };
+    return result;
+  };
+}

package/src/daemon/guardian-verification-intent.ts

@@ -0,0 +1,120 @@
+// Guardian verification intent resolution for deterministic first-turn routing.
+// Exports `resolveGuardianVerificationIntent` as the single public entry point.
+// When a direct guardian setup request is detected, the session pipeline
+// rewrites the message to force immediate entry into the guardian-verify-setup
+// skill flow, bypassing the normal agent loop's tendency to produce conceptual
+// preambles before loading the skill.
+
+export type GuardianVerificationIntentResult =
+  | { kind: 'none' }
+  | { kind: 'direct_setup'; rewrittenContent: string; channelHint?: 'sms' | 'voice' | 'telegram' };
+
+// ── Direct setup patterns ────────────────────────────────────────────────
+// These capture imperative requests to start guardian verification.
+
+const DIRECT_SETUP_PATTERNS: RegExp[] = [
+  /\b(?:help\s+me\s+)?(?:confirm|verify)\s+(?:me|myself)\s+as\s+(?:your\s+|the\s+)?guardian\b/i,
+  /\b(?:set|add)\s+(?:me|myself)\s+(?:up\s+)?as\s+(?:your\s+|the\s+)?guardian\b/i,
+  /\bverify\s+(?:me\s+as\s+)?guardian\b/i,
+  /\bset\s+(?:me\s+as\s+)?guardian\b/i,
+  /\bguardian\s+verif(?:y|ication)\s*(?:setup|set\s*up)?\b/i,
+  /\bset\s*up\s+guardian\s+verif(?:y|ication)\b/i,
+  /\b(?:help\s+me\s+)?set\s+(?:myself\s+)?(?:up\s+)?as\s+(?:your\s+)?guardian\s+(?:for|via|by|over|on|through)\s+/i,
+  /\bguardian\s+(?:for|via|by|over|on|through)\s+(?:sms|text|phone|voice|telegram|call)\b/i,
+  /\bbecome\s+(?:your\s+|the\s+)?guardian\b/i,
+  /\bregister\s+(?:me\s+)?as\s+(?:your\s+|the\s+)?guardian\b/i,
+];
+
+// ── Conceptual / security question patterns ──────────────────────────────
+// These indicate the user is asking *about* guardian verification
+// rather than requesting to start it. Return passthrough for these.
+
+const CONCEPTUAL_PATTERNS: RegExp[] = [
+  /^\s*(how|what|why|when|where|who|which)\b/i,
+  /\bwhat\s+is\s+(?:a\s+)?guardian\b/i,
+  /\bwhy\s+can'?t\s+(?:you|i)\b/i,
+  /\bhow\s+does\s+(?:guardian|verification)\s+work\b/i,
+  /\bexplain\s+(?:the\s+)?(?:guardian|verification)\b/i,
+  /\btell\s+me\s+about\s+(?:guardian|verification)\b/i,
+  /\bis\s+(?:there\s+)?(?:a\s+way|any\s+way)\s+to\b/i,
+  /\bcan\s+(?:you\s+)?(?:tell|explain|describe)\b/i,
+];
+
+// ── Channel hint extraction ──────────────────────────────────────────────
+
+const CHANNEL_HINT_PATTERNS: Array<{ pattern: RegExp; channel: 'sms' | 'voice' | 'telegram' }> = [
+  { pattern: /\b(?:sms|text\s*(?:message)?)\b/i, channel: 'sms' },
+  { pattern: /\b(?:voice|call|phone\s*call|by\s+phone)\b/i, channel: 'voice' },
+  { pattern: /\btelegram\b/i, channel: 'telegram' },
+];
+
+/** Common polite/filler words stripped before checking intent-only status. */
+const FILLER_PATTERN =
+  /\b(please|pls|plz|can\s+you|could\s+you|would\s+you|now|right\s+now|thanks|thank\s+you|thx|ty|for\s+me|ok(ay)?|hey|hi|hello|just|i\s+want\s+to|i'd\s+like\s+to|i\s+need\s+to|let's|let\s+me)\b/gi;
+
+// ── Internal helpers ─────────────────────────────────────────────────────
+
+function isConceptualQuestion(text: string): boolean {
+  const cleaned = text.replace(/^\s*(hey|hi|hello|please|pls|plz)[,\s]+/i, '');
+  return CONCEPTUAL_PATTERNS.some((p) => p.test(cleaned));
+}
+
+function isDirectSetupIntent(text: string): boolean {
+  return DIRECT_SETUP_PATTERNS.some((p) => p.test(text));
+}
+
+function extractChannelHint(text: string): 'sms' | 'voice' | 'telegram' | undefined {
+  for (const { pattern, channel } of CHANNEL_HINT_PATTERNS) {
+    if (pattern.test(text)) return channel;
+  }
+  return undefined;
+}
+
+// ── Structured intent resolver ───────────────────────────────────────────
+
+/**
+ * Resolves guardian verification intent from user text.
+ *
+ * Pipeline:
+ * 1. Skip slash commands entirely
+ * 2. Conceptual question gate -- questions return `none`
+ * 3. Detect direct setup patterns
+ * 4. On match, build a deterministic model instruction to load guardian-verify-setup
+ */
+export function resolveGuardianVerificationIntent(text: string): GuardianVerificationIntentResult {
+  const trimmed = text.trim();
+
+  // Never intercept slash commands
+  if (trimmed.startsWith('/')) {
+    return { kind: 'none' };
+  }
+
+  // Conceptual questions pass through to normal agent processing
+  if (isConceptualQuestion(trimmed)) {
+    return { kind: 'none' };
+  }
+
+  // Strip fillers for pattern matching but keep original for context
+  const withoutFillers = trimmed.replace(FILLER_PATTERN, '').replace(/\s{2,}/g, ' ').trim();
+
+  if (!isDirectSetupIntent(withoutFillers)) {
+    return { kind: 'none' };
+  }
+
+  const channelHint = extractChannelHint(trimmed);
+
+  // Build the rewritten content that deterministically loads the skill
+  const lines = [
+    'The user wants to verify themselves as the trusted guardian.',
+    'Please invoke the "Guardian Verify Setup" skill (ID: guardian-verify-setup) immediately using skill_load.',
+  ];
+  if (channelHint) {
+    lines.push(`The user specified the ${channelHint} channel. Pass this context when starting the verification flow.`);
+  }
+
+  return {
+    kind: 'direct_setup',
+    rewrittenContent: lines.join('\n'),
+    channelHint,
+  };
+}

package/src/daemon/handlers/apps.ts

@@ -6,7 +6,6 @@ import { join } from 'node:path';
 import { v4 as uuid } from 'uuid';
 
 import { packageApp } from '../../bundler/app-bundler.js';
-import { getRuntimeHttpPort } from '../../config/env.js';
 import { defaultGallery } from '../../gallery/default-gallery.js';
 import { getAppDiff, getAppFileAtVersion, getAppHistory, restoreAppVersion } from '../../memory/app-git-service.js';
 import { createApp, createAppRecord, deleteAppRecord, getApp, getAppPreview, listApps, queryAppRecords, updateApp,updateAppRecord } from '../../memory/app-store.js';
@@ -368,8 +367,7 @@ export async function handleShareAppCloud(
     const bundleData = readFileSync(result.bundlePath);
     const { shareToken } = createSharedAppLink(bundleData, result.manifest);
 
-    const port = getRuntimeHttpPort() ?? 7821;
-    const shareUrl = `http://localhost:${port}/v1/apps/shared/${shareToken}`;
+    const shareUrl = `/v1/apps/shared/${shareToken}`;
 
     ctx.send(socket, {
       type: 'share_app_cloud_response',

package/src/daemon/handlers/config-channels.ts

@@ -1,22 +1,22 @@
 import * as net from 'node:net';
 
+import type { ChannelId } from '../../channels/types.js';
 import * as externalConversationStore from '../../memory/external-conversation-store.js';
 import {
   createVerificationChallenge,
+  findActiveSession,
   getGuardianBinding,
   getPendingChallenge,
   revokeBinding as revokeGuardianBinding,
   revokePendingChallenges,
-  findActiveSession,
 } from '../../runtime/channel-guardian-service.js';
 import { type ChannelReadinessService, createReadinessService } from '../../runtime/channel-readiness-service.js';
 import {
-  startOutbound,
-  resendOutbound,
   cancelOutbound,
+  resendOutbound,
+  startOutbound,
 } from '../../runtime/guardian-outbound-actions.js';
 import { normalizeAssistantId } from '../../util/platform.js';
-import type { ChannelId } from '../../channels/types.js';
 import type {
   ChannelReadinessRequest,
   GuardianVerificationRequest,
@@ -34,10 +34,10 @@ export type GuardianVerificationResult = Omit<GuardianVerificationResponse, 'typ
 // ---------------------------------------------------------------------------
 
 export {
+  DESTINATION_RATE_WINDOW_MS,
+  MAX_SENDS_PER_DESTINATION_WINDOW,
   MAX_SENDS_PER_SESSION,
   RESEND_COOLDOWN_MS,
-  MAX_SENDS_PER_DESTINATION_WINDOW,
-  DESTINATION_RATE_WINDOW_MS,
 } from '../../runtime/guardian-outbound-actions.js';
 
 // ---------------------------------------------------------------------------
@@ -182,10 +182,10 @@ export function handleGuardianVerification(
         channel,
       });
     } else if (msg.action === 'start_outbound') {
-      const result = startOutbound({ channel, assistantId, destination: msg.destination, rebind: msg.rebind });
+      const result = startOutbound({ channel, assistantId, destination: msg.destination, rebind: msg.rebind, originConversationId: msg.originConversationId });
       ctx.send(socket, { type: 'guardian_verification_response', ...result });
     } else if (msg.action === 'resend_outbound') {
-      const result = resendOutbound({ channel, assistantId });
+      const result = resendOutbound({ channel, assistantId, originConversationId: msg.originConversationId });
       ctx.send(socket, { type: 'guardian_verification_response', ...result });
     } else if (msg.action === 'cancel_outbound') {
       const result = cancelOutbound({ channel, assistantId });

package/src/daemon/handlers/config-heartbeat.ts

@@ -85,7 +85,7 @@ export function handleHeartbeatConfig(
         activeHoursEnd: null,
         nextRunAt: null,
         success: false,
-        error: `Unknown action: ${String((msg as unknown as Record<string, unknown>).action)}`,
+        error: `Unknown action: ${String(msg.action)}`,
       });
     }
   } catch (err) {