@vellumai/assistant 0.4.44 → 0.4.45

package/src/config/bundled-skills/messaging/tools/gmail-mime-helpers.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared MIME type guessing for Gmail attachment support.
+ */
+
+import { extname } from "node:path";
+
+export const MIME_MAP: Record<string, string> = {
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".tar": "application/x-tar",
+  ".doc": "application/msword",
+  ".docx":
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx":
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".wav": "audio/wav",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".csv": "text/csv",
+};
+
+export function guessMimeType(filePath: string): string {
+  return (
+    MIME_MAP[extname(filePath).toLowerCase()] ?? "application/octet-stream"
+  );
+}

package/src/config/bundled-skills/messaging/tools/messaging-send.ts

@@ -1,9 +1,28 @@
-import { createDraft } from "../../../../messaging/providers/gmail/client.js";
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+
+import {
+  batchGetMessages,
+  createDraft,
+  createDraftRaw,
+  getProfile,
+  listMessages,
+} from "../../../../messaging/providers/gmail/client.js";
+import { buildMultipartMime } from "../../../../messaging/providers/gmail/mime-builder.js";
 import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
-import { err, ok, resolveProvider, withProviderToken } from "./shared.js";
+import { guessMimeType } from "./gmail-mime-helpers.js";
+import {
+  err,
+  extractEmail,
+  extractHeader,
+  ok,
+  parseAddressList,
+  resolveProvider,
+  withProviderToken,
+} from "./shared.js";
 
 export async function run(
   input: Record<string, unknown>,
@@ -14,6 +33,8 @@ export async function run(
   const text = input.text as string;
   const subject = input.subject as string | undefined;
   const inReplyTo = input.in_reply_to as string | undefined;
+  const attachmentPaths = input.attachment_paths as string[] | undefined;
+  const threadId = input.thread_id as string | undefined;
 
   if (!conversationId) {
     return err("conversation_id is required.");
@@ -25,15 +46,155 @@ export async function run(
   try {
     const provider = resolveProvider(platform);
 
+    // Non-Gmail platforms: reject attachment_paths
+    if (provider.id !== "gmail" && attachmentPaths?.length) {
+      return err("Attachments are only supported on Gmail.");
+    }
+
     // Gmail: create a draft instead of sending directly
     if (provider.id === "gmail") {
       return withProviderToken(provider, async (token) => {
+        // Reply mode: thread_id provided — create a threaded draft with reply-all recipients
+        if (threadId) {
+          // Fetch thread messages to extract recipients and threading headers
+          const list = await listMessages(token, `thread:${threadId}`, 10);
+          if (!list.messages?.length) {
+            return err("No messages found in this thread.");
+          }
+
+          const messages = await batchGetMessages(
+            token,
+            list.messages.map((m) => m.id),
+            "metadata",
+            ["From", "To", "Cc", "Message-ID", "Subject"],
+          );
+
+          // Use the latest message for threading and recipient extraction
+          const latest = messages[messages.length - 1];
+          const latestHeaders = latest.payload?.headers ?? [];
+
+          const messageIdHeader = extractHeader(latestHeaders, "Message-ID");
+          let replySubject = extractHeader(latestHeaders, "Subject");
+          if (replySubject && !replySubject.startsWith("Re:")) {
+            replySubject = `Re: ${replySubject}`;
+          }
+
+          // Build reply-all recipient list, excluding the user's own email
+          const profile = await getProfile(token);
+          const userEmail = profile.emailAddress.toLowerCase();
+
+          const allRecipients = new Set<string>();
+          const allCc = new Set<string>();
+
+          // From the latest message: From goes to To, original To/Cc go to Cc
+          const fromAddr = extractHeader(latestHeaders, "From");
+          const toAddrs = extractHeader(latestHeaders, "To");
+          const ccAddrs = extractHeader(latestHeaders, "Cc");
+
+          if (fromAddr) allRecipients.add(fromAddr);
+          for (const addr of parseAddressList(toAddrs)) {
+            allRecipients.add(addr);
+          }
+          for (const addr of parseAddressList(ccAddrs)) {
+            allCc.add(addr);
+          }
+
+          // Remove user's own email from recipients using exact email comparison
+          const filterSelf = (addr: string) => extractEmail(addr) !== userEmail;
+          const toList = [...allRecipients].filter(filterSelf);
+          const ccList = [...allCc].filter(filterSelf);
+
+          if (toList.length === 0) {
+            return err("Could not determine reply recipients from thread.");
+          }
+
+          // With attachments: build multipart MIME for threaded reply
+          if (attachmentPaths?.length) {
+            const attachments = await Promise.all(
+              attachmentPaths.map(async (filePath) => {
+                const data = await readFile(filePath);
+                const filename = basename(filePath);
+                const mimeType = guessMimeType(filePath);
+                return { filename, mimeType, data };
+              }),
+            );
+
+            const raw = buildMultipartMime({
+              to: toList.join(", "),
+              subject: replySubject,
+              body: text,
+              inReplyTo: messageIdHeader || undefined,
+              cc: ccList.length > 0 ? ccList.join(", ") : undefined,
+              attachments,
+            });
+            const draft = await createDraftRaw(token, raw, threadId);
+
+            const filenames = attachments.map((a) => a.filename).join(", ");
+            const recipientSummary =
+              ccList.length > 0
+                ? `To: ${toList.join(", ")}; Cc: ${ccList.join(", ")}`
+                : `To: ${toList.join(", ")}`;
+            return ok(
+              `Gmail draft created with ${attachments.length} attachment(s): ${filenames} (Draft ID: ${draft.id}). ${recipientSummary}. Review in Gmail Drafts, then tell me to send it or send it yourself.`,
+            );
+          }
+
+          const draft = await createDraft(
+            token,
+            toList.join(", "),
+            replySubject,
+            text,
+            messageIdHeader || undefined,
+            ccList.length > 0 ? ccList.join(", ") : undefined,
+            undefined,
+            threadId,
+          );
+
+          const recipientSummary =
+            ccList.length > 0
+              ? `To: ${toList.join(", ")}; Cc: ${ccList.join(", ")}`
+              : `To: ${toList.join(", ")}`;
+          return ok(
+            `Gmail draft created (ID: ${draft.id}). ${recipientSummary}. Review in Gmail Drafts, then tell me to send it or send it yourself.`,
+          );
+        }
+
+        // With attachments: build multipart MIME and use createDraftRaw
+        if (attachmentPaths?.length) {
+          const attachments = await Promise.all(
+            attachmentPaths.map(async (filePath) => {
+              const data = await readFile(filePath);
+              const filename = basename(filePath);
+              const mimeType = guessMimeType(filePath);
+              return { filename, mimeType, data };
+            }),
+          );
+
+          const raw = buildMultipartMime({
+            to: conversationId,
+            subject: subject ?? "",
+            body: text,
+            inReplyTo,
+            attachments,
+          });
+          const draft = await createDraftRaw(token, raw, threadId);
+
+          const filenames = attachments.map((a) => a.filename).join(", ");
+          return ok(
+            `Gmail draft created with ${attachments.length} attachment(s): ${filenames} (Draft ID: ${draft.id}). Review in Gmail Drafts, then tell me to send it or send it yourself.`,
+          );
+        }
+
+        // Without attachments: use standard createDraft
         const draft = await createDraft(
           token,
           conversationId,
           subject ?? "",
           text,
           inReplyTo,
+          undefined,
+          undefined,
+          threadId,
         );
         return ok(
           `Gmail draft created (ID: ${draft.id}). Review it in your Gmail Drafts, then tell me to send it or send it yourself from Gmail.`,
@@ -41,10 +202,12 @@ export async function run(
       });
     }
 
+    // Non-Gmail platforms
     return withProviderToken(provider, async (token) => {
       const result = await provider.sendMessage(token, conversationId, text, {
         subject,
         inReplyTo,
+        threadId,
         assistantId: context.assistantId,
       });
 

package/src/config/bundled-skills/messaging/tools/messaging-sender-digest.ts

@@ -2,7 +2,6 @@ import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
-import { storeScanResult } from "./scan-result-store.js";
 import { err, ok, resolveProvider, withProviderToken } from "./shared.js";
 
 export async function run(
@@ -55,24 +54,13 @@ export async function run(
         search_query: s.searchQuery,
       }));
 
-      // Store message IDs server-side to keep them out of LLM context
-      const scanId = storeScanResult(
-        result.senders.map((s) => ({
-          id: s.id,
-          messageIds: s.messageIds,
-          newestMessageId: s.newestMessageId,
-          newestUnsubscribableMessageId: null,
-        })),
-      );
-
       return ok(
         JSON.stringify({
-          scan_id: scanId,
           senders,
           total_scanned: result.totalScanned,
           query_used: result.queryUsed,
           ...(result.truncated ? { truncated: true } : {}),
-          note: `message_count reflects emails found per sender within the ${result.totalScanned} messages scanned. Use scan_id with the archive tool to archive messages (pass scan_id + sender_ids instead of message_ids).`,
+          note: `message_count reflects emails found per sender within the ${result.totalScanned} messages scanned. Use messaging_archive_by_sender with the sender's search_query to archive their messages.`,
         }),
       );
     });

package/src/config/bundled-skills/messaging/tools/shared.ts

@@ -2,11 +2,6 @@
  * Shared utilities for messaging skill tools.
  */
 
-import {
-  request as httpsRequest,
-  type RequestOptions as HttpsRequestOptions,
-} from "node:https";
-
 import type { MessagingProvider } from "../../../../messaging/provider.js";
 import {
   getConnectedProviders,
@@ -24,6 +19,87 @@ export function err(message: string): ToolExecutionResult {
   return { content: message, isError: true };
 }
 
+// ── RFC 5322 address helpers ──────────────────────────────────────────────────
+
+export function extractHeader(
+  headers: Array<{ name: string; value: string }> | undefined,
+  name: string,
+): string {
+  return (
+    headers?.find((h) => h.name.toLowerCase() === name.toLowerCase())?.value ??
+    ""
+  );
+}
+
+/**
+ * RFC 5322-aware address list parser. Splits a header value like
+ * `"Doe, Jane" <jane@example.com>, bob@example.com` into individual
+ * addresses without breaking on commas inside quoted display names.
+ */
+export function parseAddressList(header: string): string[] {
+  const addresses: string[] = [];
+  let current = "";
+  let inQuotes = false;
+  let inAngle = false;
+
+  for (let i = 0; i < header.length; i++) {
+    const ch = header[i];
+
+    if (ch === '"' && !inAngle) {
+      inQuotes = !inQuotes;
+      current += ch;
+    } else if (ch === "<" && !inQuotes) {
+      inAngle = true;
+      current += ch;
+    } else if (ch === ">" && !inQuotes) {
+      inAngle = false;
+      current += ch;
+    } else if (ch === "," && !inQuotes && !inAngle) {
+      const trimmed = current.trim();
+      if (trimmed) addresses.push(trimmed);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+
+  const trimmed = current.trim();
+  if (trimmed) addresses.push(trimmed);
+
+  return addresses;
+}
+
+/**
+ * Extracts the bare email from an address that may be in any of these forms:
+ *   - `user@example.com`
+ *   - `<user@example.com>`
+ *   - `"Display Name" <user@example.com>`
+ *   - `Display Name <user@example.com>`
+ *   - `"Team <Ops>" <user@example.com>`
+ *   - `user@example.com (team <ops>)`
+ *
+ * Extracts all angle-bracketed segments and picks the last one containing `@`,
+ * preferring the actual mailbox over display-name fragments like
+ * `"Acme <support@acme.com>" <owner@example.com>`. If no segment contains `@`,
+ * strips angle-bracketed portions and parenthetical comments, returning the
+ * remaining text. This handles display names with angle brackets and trailing
+ * RFC 5322 comments.
+ */
+export function extractEmail(address: string): string {
+  // Strip parenthetical comments first to avoid matching addresses inside them
+  const cleaned = address.replace(/\(.*?\)/g, "");
+  const segments = [...cleaned.matchAll(/<([^>]+)>/g)].map((m) => m[1]);
+  if (segments.length > 0) {
+    const emailSegment = [...segments].reverse().find((s) => s.includes("@"));
+    if (emailSegment) return emailSegment.trim().toLowerCase();
+  }
+  return address
+    .replace(/<[^>]+>/g, "")
+    .replace(/\(.*?\)/g, "")
+    .trim()
+    .toLowerCase();
+}
+
 /**
  * Resolve the messaging provider from user input.
  * If platform is specified, look it up directly.
@@ -63,32 +139,3 @@ export async function withProviderToken<T>(
   }
   return withValidToken(provider.credentialService, fn);
 }
-
-/** Make an HTTPS request pinned to a specific resolved IP to prevent DNS rebinding. */
-export function pinnedHttpsRequest(
-  target: URL,
-  resolvedAddress: string,
-  options?: {
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string;
-  },
-): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const reqOpts: HttpsRequestOptions = {
-      method: options?.method ?? "GET",
-      hostname: resolvedAddress,
-      port: target.port ? Number(target.port) : undefined,
-      path: `${target.pathname}${target.search}`,
-      headers: { host: target.host, ...options?.headers },
-      servername: target.hostname,
-    };
-    const req = httpsRequest(reqOpts, (res) => {
-      res.resume();
-      resolve(res.statusCode ?? 0);
-    });
-    req.once("error", reject);
-    if (options?.body) req.write(options.body);
-    req.end();
-  });
-}

package/src/config/bundled-skills/notifications/SKILL.md

@@ -2,7 +2,11 @@
 name: notifications
 description: Send notifications through the unified notification router
 compatibility: "Designed for Vellum personal assistants"
-metadata: {"emoji":"🔔","vellum":{"display-name":"Notifications","user-invocable":true}}
+metadata:
+  emoji: "🔔"
+  vellum:
+    display-name: "Notifications"
+    user-invocable: true
 ---
 
 Use `send_notification` for user-facing alerts and notifications. This tool routes through the unified notification pipeline, which handles channel selection, delivery, deduplication, and audit logging.

package/src/config/bundled-skills/orchestration/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: orchestration
+description: Decompose complex tasks into parallel specialist subtasks
+compatibility: "Designed for Vellum personal assistants"
+metadata:
+  emoji: "\U0001F500"
+  vellum:
+    display-name: "Orchestration"
+    user-invocable: true
+---
+
+Use `swarm_delegate` when facing complex multi-part tasks that benefit from parallel execution. The tool decomposes an objective into independent specialist subtasks, runs them concurrently, and synthesises the results.
+
+## When to use
+
+- The request involves **multiple independent work streams** (e.g. research + coding + review).
+- Tasks can run in parallel without sequential dependencies.
+- The combined work would take significantly longer if done serially.
+
+## When NOT to use
+
+- Simple single-step requests — just do them directly.
+- Tasks that are inherently sequential (each step depends on the previous result).
+- Requests where the user is asking for a quick answer, not a deep workflow.
+
+## Tips
+
+- Provide a clear, specific `objective`. The planner uses it to decompose the work.
+- Pass relevant `context` about the codebase or project when available.
+- The `max_workers` parameter caps concurrency (1-6); the default comes from config.

package/src/config/bundled-skills/orchestration/TOOLS.json

@@ -0,0 +1,35 @@
+{
+  "version": 1,
+  "tools": [
+    {
+      "name": "swarm_delegate",
+      "description": "Decompose a complex task into parallel specialist subtasks and execute them concurrently. Use this for multi-part tasks that benefit from parallel research, coding, and review.",
+      "category": "orchestration",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "objective": {
+            "type": "string",
+            "description": "The complex task to decompose and execute in parallel"
+          },
+          "context": {
+            "type": "string",
+            "description": "Optional additional context about the task or codebase"
+          },
+          "max_workers": {
+            "type": "number",
+            "description": "Maximum concurrent workers (1-6, default from config)"
+          },
+          "reason": {
+            "type": "string",
+            "description": "Brief non-technical explanation of what you are doing and why, shown to the user as a status update. Use simple language a non-technical person would understand."
+          }
+        },
+        "required": ["objective"]
+      },
+      "executor": "tools/swarm-delegate.ts",
+      "execution_target": "host"
+    }
+  ]
+}

package/src/config/bundled-skills/{reminder/tools/reminder-create.ts → orchestration/tools/swarm-delegate.ts}

@@ -1,4 +1,4 @@
-import { executeReminderCreate } from "../../../../tools/reminder/reminder.js";
+import { swarmDelegateTool } from "../../../../tools/swarm/delegate.js";
 import type {
   ToolContext,
   ToolExecutionResult,
@@ -6,7 +6,7 @@ import type {
 
 export async function run(
   input: Record<string, unknown>,
-  _context: ToolContext,
+  context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  return executeReminderCreate(input);
+  return swarmDelegateTool.execute(input, context);
 }

package/src/config/bundled-skills/phone-calls/SKILL.md

@@ -2,7 +2,15 @@
 name: phone-calls
 description: Set up Twilio for AI-powered voice calls — both outgoing calls on behalf of the user and incoming calls where the assistant answers as a receptionist
 compatibility: "Designed for Vellum personal assistants"
-metadata: {"emoji":"📞","vellum":{"display-name":"Phone Calls","user-invocable":true,"includes":["twilio-setup", "public-ingress","elevenlabs-voice"]}}
+metadata:
+  emoji: "📞"
+  vellum:
+    display-name: "Phone Calls"
+    user-invocable: true
+    includes:
+      - "twilio-setup"
+      - "public-ingress"
+      - "elevenlabs-voice"
 ---
 
 You are helping the user set up and manage phone calls via Twilio. This skill covers enabling the calls feature, placing outbound calls, receiving inbound calls, and interacting with live calls. Twilio credential storage, phone number provisioning, and public ingress are handled by the **twilio-setup** skill.

package/src/config/bundled-skills/playbooks/SKILL.md

@@ -2,7 +2,10 @@
 name: playbooks
 description: Trigger-action automation rules for handling incoming messages
 compatibility: "Designed for Vellum personal assistants"
-metadata: {"emoji":"📖","vellum":{"display-name":"Playbooks"}}
+metadata:
+  emoji: "📖"
+  vellum:
+    display-name: "Playbooks"
 ---
 
 Playbooks are trigger-action automation rules that tell the assistant how to handle incoming messages matching a pattern.

package/src/config/bundled-skills/schedule/SKILL.md

@@ -1,11 +1,14 @@
 ---
 name: schedule
-description: Recurring automation that dispatches messages on a cron or RRULE schedule
+description: Recurring and one-shot scheduling — cron, RRULE, or single fire-at time
 compatibility: "Designed for Vellum personal assistants"
-metadata: {"emoji":"📅","vellum":{"display-name":"Schedule"}}
+metadata:
+  emoji: "📅"
+  vellum:
+    display-name: "Schedule"
 ---
 
-Manage recurring scheduled automations. Each schedule has an expression (cron or RRULE) that defines when it fires, and a message that gets dispatched to the assistant at trigger time.
+Manage scheduled automations. Schedules can be **recurring** (cron or RRULE expression) or **one-shot** (a single `fire_at` timestamp). Both recurring and one-shot schedules support two modes: **execute** (run a message through the assistant) and **notify** (send a notification to the user).
 
 ## Schedule Syntax
 
@@ -62,19 +65,78 @@ Exclusions (EXDATE, EXRULE) always take precedence over inclusions (RRULE, RDATE
 - `DTSTART:20250101T090000Z\nRRULE:FREQ=MONTHLY;BYMONTHDAY=1\nRDATE:20250704T090000Z` — 1st of each month plus July 4th
 - `DTSTART:20250101T090000Z\nRRULE:FREQ=WEEKLY;BYDAY=TU\nRRULE:FREQ=WEEKLY;BYDAY=TH` — union of Tuesdays and Thursdays
 
+## One-Shot Schedules (Reminders)
+
+To create a one-time schedule that fires once and is done, pass `fire_at` (an ISO 8601 timestamp) instead of an `expression`. This replaces the old reminder concept — "remind me at 3pm" becomes a one-shot schedule with `fire_at`.
+
+One-shot schedules:
+- Fire once at the specified time, then are marked as `fired` and disabled.
+- Support both `execute` and `notify` modes (see below).
+- Can be cancelled before they fire.
+
+Examples:
+- "remind me at 3pm" → `schedule_create` with `fire_at: "2025-03-15T15:00:00-05:00"`, `mode: "notify"`
+- "at 5pm, check my email and summarize it" → `schedule_create` with `fire_at`, `mode: "execute"`
+
+## Mode
+
+The `mode` parameter controls what happens when a schedule fires:
+
+- **execute** (default) — sends the schedule's message to a background assistant conversation for autonomous handling. The assistant processes the message as if the user sent it.
+- **notify** — sends a notification to the user via the notification pipeline. No assistant processing occurs.
+
+Use `notify` for simple reminders ("remind me to take medicine at 9am") and `execute` for tasks that need assistant action ("check my calendar at 8am and send me a digest").
+
+## Routing (notify mode)
+
+Control how notify-mode schedules are delivered at trigger time with `routing_intent`:
+
+- **single_channel** — deliver to one best channel
+- **multi_channel** — deliver to a subset of channels
+- **all_channels** (default) — deliver to every available channel
+
+Optionally pass `routing_hints` (a JSON object) to influence routing decisions (e.g. preferred channels, exclusions).
+
+### Routing Defaults
+
+- **Default to `all_channels`** for most notifications. Users usually want to be notified wherever they are.
+- **Use `single_channel`** only when the user explicitly specifies a single channel (e.g. "remind me on Telegram").
+- **Check `user_message_channel`** from the turn context. If the user is currently active on a specific channel, include it as a routing hint:
+  ```
+  routing_hints: { preferred_channels: ["vellum"] }
+  routing_intent: "all_channels"
+  ```
+
 ## Tool Input
 
-Use `syntax` + `expression` to specify the schedule type explicitly, or just `expression` to auto-detect.
+Use `syntax` + `expression` to specify the schedule type explicitly, or just `expression` to auto-detect. For one-shot schedules, use `fire_at` instead of `expression`.
 
 ## Lifecycle
 
-1. Create a schedule with a name, expression, and message.
-2. At each trigger time, the message is dispatched to the assistant as if the user sent it.
-3. Schedules can be enabled/disabled, updated, or deleted.
+1. Create a schedule with a name and either an expression (recurring) or fire_at (one-shot), plus a message.
+2. At each trigger time, the message is dispatched to the assistant (execute mode) or a notification is sent (notify mode).
+3. Schedules can be enabled/disabled, updated, or deleted. One-shot schedules are automatically disabled after firing.
 
 ## Tips
 
-- Only use `schedule_create` when the user explicitly wants recurring automation (e.g. "every day at 9am", "weekly on Mondays"). For one-time tasks, use the task list instead.
+- Use `schedule_create` for both recurring automation ("every day at 9am") and one-time reminders ("remind me at 3pm").
+- For task tracking ("add to my tasks", "add to my queue"), use task_list_add instead.
+- `fire_at` must be a strict ISO 8601 timestamp with timezone offset or Z (e.g. `2025-03-15T09:00:00-05:00`).
+
+### Anchored & Ambiguous Relative Time
+
+Phrases like "at the 45 minute mark", "at the top of the hour", "at noon", or "20 minutes in" are **clock-position or anchored relative time** expressions. Do NOT treat them as offsets from now.
+
+**Resolution rules (in priority order):**
+
+1. **Session-anchored expressions** — if the user mentioned a start time earlier in conversation ("I got here at 9", "meeting started at 2:10"), interpret offset-style phrases ("the 45 minute mark", "20 minutes in") as `start_time + offset`.
+
+2. **Clock-position expressions** — when no start time is in context, map directly to a wall-clock time:
+   - "top of the hour" → next :00
+   - "the X minute mark" → current hour's :XX; if already past, advance one hour
+   - "noon" / "midnight" → 12:00 PM or 12:00 AM today; if past, tomorrow
+
+3. **Ask only if truly ambiguous** — if neither rule resolves, ask for clarification. Never silently default to "from now."
 - Timezones default to the system timezone if omitted. Use IANA timezone identifiers (e.g. "America/Los_Angeles").
 - Prefer RRULE for complex patterns that cron cannot express (e.g. "every other Tuesday", "last weekday of the month").
 
@@ -85,7 +147,6 @@ Before confirming a schedule to the user, you MUST verify that you have the capa
 When `schedule_create` returns, it includes an integration status summary. Cross-reference the scheduled task's requirements against the available integrations:
 
 - If the task involves **email** (reading, sending, OTP verification): an email integration must be connected (check the "email" category)
-- If the task involves **tweeting or reading Twitter**: Twitter must be connected
 - If the task involves **sending SMS or making calls**: SMS/Twilio must be connected
 - If the task involves **web browsing or form-filling**: browser automation must be available (check client type)
 - If the task involves a **multi-step workflow** (e.g., book appointment → read confirmation email), trace the full dependency chain