@vellumai/assistant 0.4.26 → 0.4.30

package/src/daemon/dictation-text-processing.ts

@@ -5,11 +5,14 @@
  * - applyDictionary: post-LLM, dictation + command modes (including fallback paths)
  */
 
-import type { DictationDictionaryEntry,DictationSnippet } from './dictation-profile-store.js';
+import type {
+  DictationDictionaryEntry,
+  DictationSnippet,
+} from "./dictation-profile-store.js";
 
 /** Escape a string for safe use inside a RegExp. */
 function escapeRegExp(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 /**
@@ -20,13 +23,16 @@ function escapeRegExp(s: string): string {
  * for whitespace, punctuation, or string boundaries so matches work in contexts like
  * "C++," or "(C++)".
  */
-function wrapWordBoundary(escapedPattern: string, originalTrigger: string): string {
+function wrapWordBoundary(
+  escapedPattern: string,
+  originalTrigger: string,
+): string {
   const startsWithWord = /^\w/.test(originalTrigger);
   const endsWithWord = /\w$/.test(originalTrigger);
 
   // For non-word boundaries, allow whitespace, common punctuation, or string edges
-  const prefix = startsWithWord ? '\\b' : '(?<=[\\s,;:!?.()\\[\\]{}"\']|^)';
-  const suffix = endsWithWord ? '\\b' : '(?=[\\s,;:!?.()\\[\\]{}"\']|$)';
+  const prefix = startsWithWord ? "\\b" : "(?<=[\\s,;:!?.()\\[\\]{}\"']|^)";
+  const suffix = endsWithWord ? "\\b" : "(?=[\\s,;:!?.()\\[\\]{}\"']|$)";
 
   return `${prefix}${escapedPattern}${suffix}`;
 }
@@ -39,18 +45,25 @@ function wrapWordBoundary(escapedPattern: string, originalTrigger: string): stri
  * - Case-insensitive whole-word matching
  * - Single-pass: expansions are never re-scanned for further triggers
  */
-export function expandSnippets(text: string, snippets: DictationSnippet[] | undefined): string {
+export function expandSnippets(
+  text: string,
+  snippets: DictationSnippet[] | undefined,
+): string {
   if (!snippets || snippets.length === 0 || !text) return text;
 
   const enabled = snippets.filter((s) => s.enabled !== false);
   if (enabled.length === 0) return text;
 
   // Sort by trigger length descending so longest match wins
-  const sorted = [...enabled].sort((a, b) => b.trigger.length - a.trigger.length);
+  const sorted = [...enabled].sort(
+    (a, b) => b.trigger.length - a.trigger.length,
+  );
 
   // Build a single alternation pattern for single-pass replacement
-  const alternatives = sorted.map((s) => wrapWordBoundary(escapeRegExp(s.trigger), s.trigger));
-  const pattern = new RegExp(`(?:${alternatives.join('|')})`, 'gi');
+  const alternatives = sorted.map((s) =>
+    wrapWordBoundary(escapeRegExp(s.trigger), s.trigger),
+  );
+  const pattern = new RegExp(`(?:${alternatives.join("|")})`, "gi");
 
   // Build a lookup map (lowercase trigger → expansion)
   const expansionMap = new Map<string, string>();
@@ -74,11 +87,16 @@ export function expandSnippets(text: string, snippets: DictationSnippet[] | unde
  * - Respects wholeWord (default true) and caseSensitive (default false) per entry
  * - Single-pass: replacements are never re-scanned
  */
-export function applyDictionary(text: string, dictionary: DictationDictionaryEntry[] | undefined): string {
+export function applyDictionary(
+  text: string,
+  dictionary: DictationDictionaryEntry[] | undefined,
+): string {
   if (!dictionary || dictionary.length === 0 || !text) return text;
 
   // Sort by spoken length descending
-  const sorted = [...dictionary].sort((a, b) => b.spoken.length - a.spoken.length);
+  const sorted = [...dictionary].sort(
+    (a, b) => b.spoken.length - a.spoken.length,
+  );
 
   // Build a single pattern with named-group-free alternation for single-pass replacement
   // Each entry may have different flags, so we group entries by their flag combination
@@ -99,7 +117,10 @@ export function applyDictionary(text: string, dictionary: DictationDictionaryEnt
   });
 
   // Build single alternation (case-insensitive to catch all potential matches)
-  const combined = new RegExp(entries.map((e) => `(${e.pattern})`).join('|'), 'gi');
+  const combined = new RegExp(
+    entries.map((e) => `(${e.pattern})`).join("|"),
+    "gi",
+  );
 
   return text.replace(combined, (match, ...groups) => {
     // Find which group matched

package/src/daemon/doordash-steps.ts

@@ -5,13 +5,17 @@
  * remains clean and extensible.
  */
 
-import { isPlainObject } from '../util/object.js';
-import type { CardSurfaceData } from './ipc-contract.js';
-import type { ToolSetupContext } from './session-tool-setup.js';
-
-interface DoordashStep { label: string; status: string; detail?: string }
+import { isPlainObject } from "../util/object.js";
+import type { CardSurfaceData } from "./ipc-contract.js";
+import type { ToolSetupContext } from "./session-tool-setup.js";
+
+interface DoordashStep {
+  label: string;
+  status: string;
+  detail?: string;
+}
 
-const SURFACE_ID = 'doordash-progress';
+const SURFACE_ID = "doordash-progress";
 
 /**
  * Map a `doordash <subcommand>` (or `vellum doordash <subcommand>`) to the
@@ -20,40 +24,62 @@ const SURFACE_ID = 'doordash-progress';
 function doordashCommandToStep(cmd: string): string | undefined {
   // Match both standalone `doordash` and legacy `vellum doordash` prefixes
   const dd = /(?:vellum )?doordash /;
-  if (new RegExp(dd.source + 'status\\b').test(cmd) || new RegExp(dd.source + 'refresh\\b').test(cmd) || new RegExp(dd.source + 'login\\b').test(cmd)) return 'Check session';
-  if (new RegExp(dd.source + 'search\\b').test(cmd) || new RegExp(dd.source + 'search-items\\b').test(cmd)) return 'Search restaurants';
-  if (new RegExp(dd.source + 'menu\\b').test(cmd) || new RegExp(dd.source + 'item\\b').test(cmd) || new RegExp(dd.source + 'store-search\\b').test(cmd)) return 'Browse menu';
-  if (new RegExp(dd.source + 'cart\\b').test(cmd)) return 'Add to cart';
-  if (new RegExp(dd.source + 'checkout\\b').test(cmd) || new RegExp(dd.source + 'payment-methods\\b').test(cmd)) return 'Add to cart';
-  if (new RegExp(dd.source + 'order\\b').test(cmd)) return 'Place order';
+  if (
+    new RegExp(dd.source + "status\\b").test(cmd) ||
+    new RegExp(dd.source + "refresh\\b").test(cmd) ||
+    new RegExp(dd.source + "login\\b").test(cmd)
+  )
+    return "Check session";
+  if (
+    new RegExp(dd.source + "search\\b").test(cmd) ||
+    new RegExp(dd.source + "search-items\\b").test(cmd)
+  )
+    return "Search restaurants";
+  if (
+    new RegExp(dd.source + "menu\\b").test(cmd) ||
+    new RegExp(dd.source + "item\\b").test(cmd) ||
+    new RegExp(dd.source + "store-search\\b").test(cmd)
+  )
+    return "Browse menu";
+  if (new RegExp(dd.source + "cart\\b").test(cmd)) return "Add to cart";
+  if (
+    new RegExp(dd.source + "checkout\\b").test(cmd) ||
+    new RegExp(dd.source + "payment-methods\\b").test(cmd)
+  )
+    return "Add to cart";
+  if (new RegExp(dd.source + "order\\b").test(cmd)) return "Place order";
   return undefined;
 }
 
 /**
  * Given a completed DoorDash CLI command, return updated steps array or null if no change.
  */
-function updateDoordashSteps(cmd: string, steps: DoordashStep[], isError: boolean): DoordashStep[] | undefined {
+function updateDoordashSteps(
+  cmd: string,
+  steps: DoordashStep[],
+  isError: boolean,
+): DoordashStep[] | undefined {
   const stepLabel = doordashCommandToStep(cmd);
   if (!stepLabel) return undefined;
 
-  const stepIndex = steps.findIndex(s => s.label === stepLabel);
+  const stepIndex = steps.findIndex((s) => s.label === stepLabel);
   if (stepIndex < 0) return undefined;
 
   const updated = steps.map((s, i) => {
     if (i < stepIndex) {
       // Steps before current should be completed
-      return s.status === 'completed' ? s : { ...s, status: 'completed' };
+      return s.status === "completed" ? s : { ...s, status: "completed" };
     }
     if (i === stepIndex) {
       if (isError) {
         // If the command failed, mark as in_progress still (will retry)
-        return { ...s, status: 'in_progress' };
+        return { ...s, status: "in_progress" };
       }
-      return { ...s, status: 'completed' };
+      return { ...s, status: "completed" };
     }
     if (i === stepIndex + 1 && !isError) {
       // Next step becomes waiting (user may need to respond before it starts)
-      return { ...s, status: 'waiting' };
+      return { ...s, status: "waiting" };
     }
     return s;
   });
@@ -65,21 +91,28 @@ function updateDoordashSteps(cmd: string, steps: DoordashStep[], isError: boolea
 
 function getStoredSteps(ctx: ToolSetupContext): DoordashStep[] | null {
   const stored = ctx.surfaceState.get(SURFACE_ID);
-  if (!stored || stored.surfaceType !== 'card') return null;
+  if (!stored || stored.surfaceType !== "card") return null;
   const card = stored.data as CardSurfaceData;
-  if (card.template !== 'task_progress' || !isPlainObject(card.templateData)) return null;
+  if (card.template !== "task_progress" || !isPlainObject(card.templateData))
+    return null;
   const steps = (card.templateData as Record<string, unknown>).steps;
-  return Array.isArray(steps) ? steps as DoordashStep[] : null;
+  return Array.isArray(steps) ? (steps as DoordashStep[]) : null;
 }
 
-function pushStepsUpdate(ctx: ToolSetupContext, updatedSteps: DoordashStep[]): void {
+function pushStepsUpdate(
+  ctx: ToolSetupContext,
+  updatedSteps: DoordashStep[],
+): void {
   const stored = ctx.surfaceState.get(SURFACE_ID)!;
   const card = stored.data as CardSurfaceData;
-  const updatedTemplateData = { ...card.templateData as Record<string, unknown>, steps: updatedSteps };
+  const updatedTemplateData = {
+    ...(card.templateData as Record<string, unknown>),
+    steps: updatedSteps,
+  };
   const updatedData = { ...card, templateData: updatedTemplateData };
   stored.data = updatedData as CardSurfaceData;
   ctx.sendToClient({
-    type: 'ui_surface_update',
+    type: "ui_surface_update",
     sessionId: ctx.conversationId,
     surfaceId: SURFACE_ID,
     data: updatedData,
@@ -92,8 +125,11 @@ function pushStepsUpdate(ctx: ToolSetupContext, updatedSteps: DoordashStep[]): v
  * Returns true if the given tool invocation is a DoorDash CLI command
  * that should be tracked.
  */
-export function isDoordashCommand(name: string, input: Record<string, unknown>): boolean {
-  if (name !== 'bash' && name !== 'host_bash') return false;
+export function isDoordashCommand(
+  name: string,
+  input: Record<string, unknown>,
+): boolean {
+  if (name !== "bash" && name !== "host_bash") return false;
   const cmd = input.command as string | undefined;
   return !!cmd && doordashCommandToStep(cmd) !== undefined;
 }
@@ -102,7 +138,10 @@ export function isDoordashCommand(name: string, input: Record<string, unknown>):
  * Pre-execution hook: mark the matching DoorDash step as in_progress
  * before the command runs.
  */
-export function markDoordashStepInProgress(ctx: ToolSetupContext, input: Record<string, unknown>): void {
+export function markDoordashStepInProgress(
+  ctx: ToolSetupContext,
+  input: Record<string, unknown>,
+): void {
   const cmd = input.command as string | undefined;
   const stepLabel = cmd ? doordashCommandToStep(cmd) : null;
   if (!stepLabel) return;
@@ -110,11 +149,11 @@ export function markDoordashStepInProgress(ctx: ToolSetupContext, input: Record<
   const steps = getStoredSteps(ctx);
   if (!steps) return;
 
-  const stepIndex = steps.findIndex(s => s.label === stepLabel);
-  if (stepIndex < 0 || steps[stepIndex].status === 'in_progress') return;
+  const stepIndex = steps.findIndex((s) => s.label === stepLabel);
+  if (stepIndex < 0 || steps[stepIndex].status === "in_progress") return;
 
   const updatedSteps = steps.map((s, i) =>
-    i === stepIndex ? { ...s, status: 'in_progress' } : s
+    i === stepIndex ? { ...s, status: "in_progress" } : s,
   );
   pushStepsUpdate(ctx, updatedSteps);
 }
@@ -123,44 +162,48 @@ export function markDoordashStepInProgress(ctx: ToolSetupContext, input: Record<
  * Post-execution hook: auto-emit the task_progress card on first
  * DoorDash CLI command, then update step statuses based on the result.
  */
-export function updateDoordashProgress(ctx: ToolSetupContext, input: Record<string, unknown>, isError: boolean): void {
+export function updateDoordashProgress(
+  ctx: ToolSetupContext,
+  input: Record<string, unknown>,
+  isError: boolean,
+): void {
   const cmd = input.command as string | undefined;
   if (!cmd || !doordashCommandToStep(cmd)) return;
 
   if (!ctx.surfaceState.has(SURFACE_ID)) {
     // First DoorDash command — auto-emit the task_progress card
     const data = {
-      title: 'Ordering from DoorDash',
-      body: '',
-      template: 'task_progress' as const,
+      title: "Ordering from DoorDash",
+      body: "",
+      template: "task_progress" as const,
       templateData: {
-        title: 'Ordering from DoorDash',
-        status: 'in_progress',
+        title: "Ordering from DoorDash",
+        status: "in_progress",
         steps: [
-          { label: 'Check session', status: 'in_progress' },
-          { label: 'Search restaurants', status: 'pending' },
-          { label: 'Browse menu', status: 'pending' },
-          { label: 'Add to cart', status: 'pending' },
-          { label: 'Place order', status: 'pending' },
+          { label: "Check session", status: "in_progress" },
+          { label: "Search restaurants", status: "pending" },
+          { label: "Browse menu", status: "pending" },
+          { label: "Add to cart", status: "pending" },
+          { label: "Place order", status: "pending" },
         ],
       },
     } satisfies CardSurfaceData;
-    ctx.surfaceState.set(SURFACE_ID, { surfaceType: 'card', data });
+    ctx.surfaceState.set(SURFACE_ID, { surfaceType: "card", data });
     ctx.sendToClient({
-      type: 'ui_surface_show',
+      type: "ui_surface_show",
       sessionId: ctx.conversationId,
       surfaceId: SURFACE_ID,
-      surfaceType: 'card',
-      title: 'Ordering from DoorDash',
+      surfaceType: "card",
+      title: "Ordering from DoorDash",
       data,
-      display: 'inline',
+      display: "inline",
     });
     ctx.currentTurnSurfaces.push({
       surfaceId: SURFACE_ID,
-      surfaceType: 'card',
-      title: 'Ordering from DoorDash',
+      surfaceType: "card",
+      title: "Ordering from DoorDash",
       data,
-      display: 'inline',
+      display: "inline",
     });
   }
 

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

@@ -1,5 +1,5 @@
-import { loadConfig } from '../config/loader.js';
-import { getFailoverProvider } from '../providers/registry.js';
+import { loadConfig } from "../config/loader.js";
+import { getFailoverProvider } from "../providers/registry.js";
 import {
   buildGuardianActionGenerationPrompt,
   getGuardianActionFallbackMessage,
@@ -7,13 +7,13 @@ import {
   GUARDIAN_ACTION_COPY_SYSTEM_PROMPT,
   GUARDIAN_ACTION_COPY_TIMEOUT_MS,
   includesRequiredKeywords,
-} from '../runtime/guardian-action-message-composer.js';
+} from "../runtime/guardian-action-message-composer.js";
 import type {
   GuardianActionCopyGenerator,
   GuardianFollowUpConversationGenerator,
   GuardianFollowUpDisposition,
   GuardianFollowUpTurnResult,
-} from '../runtime/http-types.js';
+} from "../runtime/http-types.js";
 
 /**
  * Create the daemon-owned guardian action copy generator that resolves
@@ -34,29 +34,38 @@ export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator
       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 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 }] }],
+      [{ 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',
+          modelIntent: "latency-optimized",
         },
-        signal: AbortSignal.timeout(options.timeoutMs ?? GUARDIAN_ACTION_COPY_TIMEOUT_MS),
+        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() : '';
+    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(/["'`]+$/, '')
+      .replace(/^["'`]+/, "")
+      .replace(/["'`]+$/, "")
       .trim();
     if (!cleaned) return null;
     if (!includesRequiredKeywords(cleaned, requiredKeywords)) return null;
@@ -72,46 +81,46 @@ 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.';
+  "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_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.',
+    "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,
+    type: "object" as const,
     properties: {
       disposition: {
-        type: 'string',
-        enum: ['call_back', 'message_back', 'decline', 'keep_pending'],
+        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).',
+          "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.',
+        type: "string",
+        description: "A natural language reply to send back to the guardian.",
       },
     },
-    required: ['disposition', 'replyText'],
+    required: ["disposition", "replyText"],
   },
 };
 
 const VALID_FOLLOWUP_DISPOSITIONS: ReadonlySet<string> = new Set([
-  'call_back',
-  'message_back',
-  'decline',
-  'keep_pending',
+  "call_back",
+  "message_back",
+  "decline",
+  "keep_pending",
 ]);
 
 /**
@@ -129,16 +138,16 @@ export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpC
       `Original question from the voice call: "${context.questionText}"`,
       `Guardian's late answer: "${context.lateAnswerText}"`,
       `\nGuardian's latest reply: ${context.guardianReply}`,
-    ].join('\n');
+    ].join("\n");
 
     const response = await provider.sendMessage(
-      [{ role: 'user', content: [{ type: 'text', text: userPrompt }] }],
+      [{ 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',
+          modelIntent: "latency-optimized",
         },
         signal: AbortSignal.timeout(FOLLOWUP_CONVERSATION_TIMEOUT_MS),
       },
@@ -146,24 +155,31 @@ export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpC
 
     // Extract the tool_use block from the response
     const toolUseBlock = response.content.find(
-      (block) => block.type === 'tool_use' && block.name === FOLLOWUP_CONVERSATION_TOOL_NAME,
+      (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');
+    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)) {
+    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');
+    if (typeof replyText !== "string" || replyText.trim().length === 0) {
+      throw new Error("Missing or empty replyText in tool_use response");
     }
 
     const result: GuardianFollowUpTurnResult = {

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

@@ -6,8 +6,12 @@
 // preambles before loading the skill.
 
 export type GuardianVerificationIntentResult =
-  | { kind: 'none' }
-  | { kind: 'direct_setup'; rewrittenContent: string; channelHint?: 'sms' | 'voice' | 'telegram' };
+  | { kind: "none" }
+  | {
+      kind: "direct_setup";
+      rewrittenContent: string;
+      channelHint?: "voice" | "telegram" | "slack";
+    };
 
 // ── Direct setup patterns ────────────────────────────────────────────────
 // These capture imperative requests to start guardian verification.
@@ -20,7 +24,7 @@ const DIRECT_SETUP_PATTERNS: RegExp[] = [
   /\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,
+  /\bguardian\s+(?:for|via|by|over|on|through)\s+(?:sms|text|phone|voice|telegram|slack|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,
 ];
@@ -42,10 +46,13 @@ const CONCEPTUAL_PATTERNS: RegExp[] = [
 
 // ── 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' },
+const CHANNEL_HINT_PATTERNS: Array<{
+  pattern: RegExp;
+  channel: "voice" | "telegram" | "slack";
+}> = [
+  { pattern: /\b(?:voice|call|phone\s*call|by\s+phone)\b/i, channel: "voice" },
+  { pattern: /\btelegram\b/i, channel: "telegram" },
+  { pattern: /\bslack\b/i, channel: "slack" },
 ];
 
 /** Common polite/filler words stripped before checking intent-only status. */
@@ -55,7 +62,7 @@ const FILLER_PATTERN =
 // ── Internal helpers ─────────────────────────────────────────────────────
 
 function isConceptualQuestion(text: string): boolean {
-  const cleaned = text.replace(/^\s*(hey|hi|hello|please|pls|plz)[,\s]+/i, '');
+  const cleaned = text.replace(/^\s*(hey|hi|hello|please|pls|plz)[,\s]+/i, "");
   return CONCEPTUAL_PATTERNS.some((p) => p.test(cleaned));
 }
 
@@ -63,7 +70,9 @@ function isDirectSetupIntent(text: string): boolean {
   return DIRECT_SETUP_PATTERNS.some((p) => p.test(text));
 }
 
-function extractChannelHint(text: string): 'sms' | 'voice' | 'telegram' | undefined {
+function extractChannelHint(
+  text: string,
+): "voice" | "telegram" | "slack" | undefined {
   for (const { pattern, channel } of CHANNEL_HINT_PATTERNS) {
     if (pattern.test(text)) return channel;
   }
@@ -81,40 +90,47 @@ function extractChannelHint(text: string): 'sms' | 'voice' | 'telegram' | undefi
  * 3. Detect direct setup patterns
  * 4. On match, build a deterministic model instruction to load guardian-verify-setup
  */
-export function resolveGuardianVerificationIntent(text: string): GuardianVerificationIntentResult {
+export function resolveGuardianVerificationIntent(
+  text: string,
+): GuardianVerificationIntentResult {
   const trimmed = text.trim();
 
   // Never intercept slash commands
-  if (trimmed.startsWith('/')) {
-    return { kind: 'none' };
+  if (trimmed.startsWith("/")) {
+    return { kind: "none" };
   }
 
   // Conceptual questions pass through to normal agent processing
   if (isConceptualQuestion(trimmed)) {
-    return { kind: 'none' };
+    return { kind: "none" };
   }
 
   // Strip fillers for pattern matching but keep original for context
-  const withoutFillers = trimmed.replace(FILLER_PATTERN, '').replace(/\s{2,}/g, ' ').trim();
+  const withoutFillers = trimmed
+    .replace(FILLER_PATTERN, "")
+    .replace(/\s{2,}/g, " ")
+    .trim();
 
   if (!isDirectSetupIntent(withoutFillers)) {
-    return { kind: 'none' };
+    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.',
+    "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.`);
+    lines.push(
+      `The user specified the ${channelHint} channel. Pass this context when starting the verification flow.`,
+    );
   }
 
   return {
-    kind: 'direct_setup',
-    rewrittenContent: lines.join('\n'),
+    kind: "direct_setup",
+    rewrittenContent: lines.join("\n"),
     channelHint,
   };
 }