@vellumai/assistant 0.6.4 → 0.6.6

package/src/config/bundled-skills/messaging/tools/__tests__/messaging-feed-events.test.ts

@@ -0,0 +1,207 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { EmitFeedEventParams } from "../../../../../home/emit-feed-event.js";
+
+// Capture all emitFeedEvent calls
+const emittedEvents: EmitFeedEventParams[] = [];
+
+mock.module("../../../../../home/emit-feed-event.js", () => ({
+  emitFeedEvent: async (params: EmitFeedEventParams) => {
+    emittedEvents.push(params);
+    return {
+      id: `emit:${params.source}:${params.dedupKey ?? "random"}`,
+      type: "action",
+      source: params.source,
+      title: params.title,
+      summary: params.summary,
+      priority: 50,
+      status: "new",
+      author: "assistant",
+      timestamp: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+    };
+  },
+}));
+
+// Stub messaging provider dependencies
+const mockCreateDraft = mock(async () => ({ id: "draft-123" }));
+const mockCreateDraftRaw = mock(async () => ({ id: "draft-raw-456" }));
+const mockGetThread = mock(async () => ({
+  messages: [
+    {
+      payload: {
+        headers: [
+          { name: "From", value: "sender@example.com" },
+          { name: "To", value: "user@example.com" },
+          { name: "Subject", value: "Test Subject" },
+          { name: "Message-ID", value: "<msg-1@example.com>" },
+        ],
+      },
+    },
+  ],
+}));
+const mockGetProfile = mock(async () => ({
+  emailAddress: "user@example.com",
+}));
+
+mock.module("../../../../../messaging/providers/gmail/client.js", () => ({
+  createDraft: mockCreateDraft,
+  createDraftRaw: mockCreateDraftRaw,
+  getThread: mockGetThread,
+  getProfile: mockGetProfile,
+}));
+
+mock.module("../../../../../messaging/providers/gmail/mime-builder.js", () => ({
+  buildMultipartMime: () => "mock-raw-mime",
+}));
+
+const mockSendMessage = mock(async () => ({
+  id: "msg-sent-789",
+  threadId: "thread-1",
+}));
+const mockArchiveByQuery = mock(async () => ({
+  archived: 3,
+  truncated: false,
+}));
+
+mock.module("../shared.js", () => ({
+  resolveProvider: async (platform?: string) => ({
+    id: platform === "slack" ? "slack" : "gmail",
+    displayName: platform === "slack" ? "Slack" : "Gmail",
+    sendMessage: mockSendMessage,
+    archiveByQuery: mockArchiveByQuery,
+  }),
+  getProviderConnection: async () => ({ token: "mock-token" }),
+  ok: (msg: string) => ({ status: "ok", output: msg }),
+  err: (msg: string) => ({ status: "error", output: msg }),
+  extractEmail: (addr: string) => addr.replace(/.*<(.+)>/, "$1").toLowerCase(),
+  extractHeader: (
+    headers: Array<{ name: string; value: string }>,
+    name: string,
+  ) => headers.find((h: { name: string }) => h.name === name)?.value ?? null,
+  parseAddressList: (addrs: string | null) =>
+    addrs ? addrs.split(",").map((a: string) => a.trim()) : [],
+}));
+
+// Stub gmail-mime-helpers
+mock.module("../gmail-mime-helpers.js", () => ({
+  guessMimeType: () => "application/octet-stream",
+}));
+
+// Stub conversation dependencies used by messaging-send cross-post
+mock.module("../../../../../memory/conversation-crud.js", () => ({
+  addMessage: async () => ({ id: "msg-1" }),
+  getConversation: () => null,
+}));
+mock.module("../../../../../memory/conversation-disk-view.js", () => ({
+  syncMessageToDisk: () => {},
+}));
+mock.module("../../../../../memory/external-conversation-store.js", () => ({
+  getBindingByChannelChat: () => null,
+}));
+
+const { run: runSend } = await import("../messaging-send.js");
+const { run: runArchive } = await import("../messaging-archive-by-sender.js");
+
+const baseContext = {
+  workingDir: "/tmp/test",
+  conversationId: "conv-xyz",
+  assistantId: "assistant-1",
+  triggeredBySurfaceAction: true,
+  batchAuthorizedByTask: false,
+  approvedViaPrompt: false,
+  trustClass: "guardian" as const,
+};
+
+beforeEach(() => {
+  emittedEvents.length = 0;
+  mockCreateDraft.mockClear();
+  mockCreateDraftRaw.mockClear();
+  mockSendMessage.mockClear();
+  mockArchiveByQuery.mockClear();
+});
+
+afterEach(() => {
+  emittedEvents.length = 0;
+});
+
+describe("messaging-send feed events", () => {
+  test("Gmail draft creation emits with source 'gmail' and dedup by draft ID", async () => {
+    await runSend(
+      {
+        platform: "gmail",
+        conversation_id: "recipient@example.com",
+        text: "Hello there",
+        subject: "Test",
+      },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("gmail");
+    expect(emittedEvents[0].title).toBe("Email Draft Created");
+    expect(emittedEvents[0].dedupKey).toBe("email-draft:draft-123");
+  });
+
+  test("Slack sends emit with source 'slack'", async () => {
+    await runSend(
+      {
+        platform: "slack",
+        conversation_id: "#general",
+        text: "Hello Slack",
+      },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("slack");
+    expect(emittedEvents[0].title).toBe("Slack Message Sent");
+    expect(emittedEvents[0].dedupKey).toBe("message-sent:msg-sent-789");
+  });
+
+  test("Non-Gmail, non-Slack sends emit with source 'gmail' as fallback", async () => {
+    await runSend(
+      {
+        platform: "other-email",
+        conversation_id: "user@example.com",
+        text: "Hello",
+      },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("gmail");
+    // Mock resolveProvider returns id:"gmail" for non-slack platforms,
+    // so this goes through the Gmail draft path
+    expect(emittedEvents[0].title).toBe("Email Draft Created");
+    expect(emittedEvents[0].summary).toBe("Created an email draft.");
+  });
+});
+
+describe("messaging-archive feed events", () => {
+  test("Archive emits only when result.archived > 0", async () => {
+    await runArchive(
+      { platform: "gmail", query: "from:sender@example.com" },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("gmail");
+    expect(emittedEvents[0].title).toBe("Messages Archived");
+    expect(emittedEvents[0].summary).toContain("Archived 3 message(s)");
+  });
+
+  test("Zero-match archives do NOT emit", async () => {
+    mockArchiveByQuery.mockResolvedValueOnce({
+      archived: 0,
+      truncated: false,
+    });
+
+    await runArchive(
+      { platform: "gmail", query: "from:nobody@example.com" },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(0);
+  });
+});

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

@@ -1,14 +1,25 @@
+import { emitFeedEvent } from "../../../../home/emit-feed-event.js";
 import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
+import { getLogger } from "../../../../util/logger.js";
 import { err, getProviderConnection, ok, resolveProvider } from "./shared.js";
 
+const log = getLogger("messaging-archive-by-sender");
+
 export async function run(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  if (!context.triggeredBySurfaceAction && !context.batchAuthorizedByTask) {
+  const userApproved =
+    input.user_approved === true && context.trustClass === "guardian";
+  if (
+    !context.triggeredBySurfaceAction &&
+    !context.batchAuthorizedByTask &&
+    !context.approvedViaPrompt &&
+    !userApproved
+  ) {
     return err(
       "This tool requires either a surface action or a scheduled task run with this tool in required_tools. Present results in a selection table with action buttons and wait for the user to click before proceeding.",
     );
@@ -39,6 +50,14 @@ export async function run(
     }
 
     const summary = `Archived ${result.archived} message(s) matching query: ${query}`;
+    void emitFeedEvent({
+      source: "gmail",
+      title: "Messages Archived",
+      summary,
+      dedupKey: `email-archive:${Date.now()}`,
+    }).catch((err) => {
+      log.warn({ err }, "Failed to emit email archive feed event");
+    });
     if (result.truncated) {
       return ok(
         `${summary}\n\nNote: this operation was capped at 5000 messages. Additional messages matching the query may remain in the inbox. Run the command again to archive more.`,

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

@@ -1,9 +1,23 @@
+import type { Message } from "../../../../messaging/provider-types.js";
+import { wrapUntrustedContent } from "../../../../security/untrusted-content.js";
 import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
 import { err, getProviderConnection, ok, resolveProvider } from "./shared.js";
 
+function wrapMessageContent(msg: Message): Message {
+  const source =
+    msg.platform === "gmail" || msg.platform === "outlook" ? "email" : "slack";
+  return {
+    ...msg,
+    text: wrapUntrustedContent(msg.text, {
+      source,
+      sourceDetail: msg.sender.email ?? msg.sender.name,
+    }),
+  };
+}
+
 export async function run(
   input: Record<string, unknown>,
   _context: ToolContext,
@@ -32,7 +46,7 @@ export async function run(
     } else {
       messages = await provider.getHistory(conn, conversationId, { limit });
     }
-    return ok(JSON.stringify(messages, null, 2));
+    return ok(JSON.stringify(messages.map(wrapMessageContent), null, 2));
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
   }

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

@@ -1,9 +1,23 @@
+import type { Message } from "../../../../messaging/provider-types.js";
+import { wrapUntrustedContent } from "../../../../security/untrusted-content.js";
 import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
 import { err, getProviderConnection, ok, resolveProvider } from "./shared.js";
 
+function wrapMessageContent(msg: Message): Message {
+  const source =
+    msg.platform === "gmail" || msg.platform === "outlook" ? "email" : "slack";
+  return {
+    ...msg,
+    text: wrapUntrustedContent(msg.text, {
+      source,
+      sourceDetail: msg.sender.email ?? msg.sender.name,
+    }),
+  };
+}
+
 export async function run(
   input: Record<string, unknown>,
   _context: ToolContext,
@@ -21,7 +35,13 @@ export async function run(
     const account = input.account as string | undefined;
     const conn = await getProviderConnection(provider, account);
     const result = await provider.search(conn, query, { count: maxResults });
-    return ok(JSON.stringify(result, null, 2));
+    return ok(
+      JSON.stringify(
+        { ...result, messages: result.messages.map(wrapMessageContent) },
+        null,
+        2,
+      ),
+    );
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
   }

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

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
 
+import { emitFeedEvent } from "../../../../home/emit-feed-event.js";
 import {
   addMessage,
   getConversation,
@@ -8,11 +9,10 @@ import {
 import { syncMessageToDisk } from "../../../../memory/conversation-disk-view.js";
 import { getBindingByChannelChat } from "../../../../memory/external-conversation-store.js";
 import {
-  batchGetMessages,
   createDraft,
   createDraftRaw,
   getProfile,
-  listMessages,
+  getThread,
 } from "../../../../messaging/providers/gmail/client.js";
 import { buildMultipartMime } from "../../../../messaging/providers/gmail/mime-builder.js";
 import type {
@@ -72,19 +72,19 @@ export async function run(
       const gmailConn = conn;
       // 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(gmailConn, `thread:${threadId}`, 10);
-        if (!list.messages?.length) {
+        // Fetch thread messages directly via Threads API
+        const thread = await getThread(gmailConn, threadId, "metadata", [
+          "From",
+          "To",
+          "Cc",
+          "Message-ID",
+          "Subject",
+        ]);
+        const messages = thread.messages ?? [];
+        if (!messages.length) {
           return err("No messages found in this thread.");
         }
 
-        const messages = await batchGetMessages(
-          gmailConn,
-          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 ?? [];
@@ -150,6 +150,14 @@ export async function run(
             ccList.length > 0
               ? `To: ${toList.join(", ")}; Cc: ${ccList.join(", ")}`
               : `To: ${toList.join(", ")}`;
+          void emitFeedEvent({
+            source: "gmail",
+            title: "Email Draft Created",
+            summary: `Drafted reply to ${recipientSummary}.`,
+            dedupKey: `email-draft:${draft.id}`,
+          }).catch((err) => {
+            log.warn({ err }, "Failed to emit email draft feed event");
+          });
           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.`,
           );
@@ -170,6 +178,14 @@ export async function run(
           ccList.length > 0
             ? `To: ${toList.join(", ")}; Cc: ${ccList.join(", ")}`
             : `To: ${toList.join(", ")}`;
+        void emitFeedEvent({
+          source: "gmail",
+          title: "Email Draft Created",
+          summary: `Drafted reply to ${recipientSummary}.`,
+          dedupKey: `email-draft:${draft.id}`,
+        }).catch((err) => {
+          log.warn({ err }, "Failed to emit email draft feed event");
+        });
         return ok(
           `Gmail draft created (ID: ${draft.id}). ${recipientSummary}. Review in Gmail Drafts, then tell me to send it or send it yourself.`,
         );
@@ -196,6 +212,14 @@ export async function run(
         const draft = await createDraftRaw(gmailConn, raw, threadId);
 
         const filenames = attachments.map((a) => a.filename).join(", ");
+        void emitFeedEvent({
+          source: "gmail",
+          title: "Email Draft Created",
+          summary: "Created an email draft.",
+          dedupKey: `email-draft:${draft.id}`,
+        }).catch((err) => {
+          log.warn({ err }, "Failed to emit email draft feed event");
+        });
         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.`,
         );
@@ -212,6 +236,14 @@ export async function run(
         undefined,
         threadId,
       );
+      void emitFeedEvent({
+        source: "gmail",
+        title: "Email Draft Created",
+        summary: "Created an email draft.",
+        dedupKey: `email-draft:${draft.id}`,
+      }).catch((err) => {
+        log.warn({ err }, "Failed to emit email draft feed event");
+      });
       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.`,
       );
@@ -225,6 +257,31 @@ export async function run(
       assistantId: context.assistantId,
     });
 
+    const sendSummary =
+      provider.id === "slack"
+        ? "Sent a Slack message."
+        : provider.id === "telegram"
+          ? "Sent a Telegram message."
+          : "Sent an email.";
+    void emitFeedEvent({
+      source:
+        provider.id === "slack"
+          ? "slack"
+          : provider.id === "telegram"
+            ? "telegram"
+            : "gmail",
+      title:
+        provider.id === "slack"
+          ? "Slack Message Sent"
+          : provider.id === "telegram"
+            ? "Telegram Message Sent"
+            : "Email Sent",
+      summary: sendSummary,
+      dedupKey: `message-sent:${result.id}`,
+    }).catch((err) => {
+      log.warn({ err }, "Failed to emit message send feed event");
+    });
+
     const threadSuffix = result.threadId
       ? `, "thread_id": "${result.threadId}"`
       : "";

package/src/config/bundled-skills/phone-calls/references/CONFIG.md

@@ -10,23 +10,24 @@ All call-related settings can be managed via `assistant config`:
 | `calls.userConsultTimeoutSeconds`           | How long to wait for user answers                                                                                                                                                                                                         | `120` (2 min)                                                                                            |
 | `calls.disclosure.enabled`                  | Whether the AI announces itself at call start                                                                                                                                                                                             | `true`                                                                                                   |
 | `calls.disclosure.text`                     | The disclosure message spoken at call start                                                                                                                                                                                               | `"At the very beginning of the call, introduce yourself as an assistant calling on behalf of my human."` |
-| `calls.model`                               | Override LLM model for call orchestration                                                                                                                                                                                                 | _(uses default model)_                                                                                   |
+| `llm.callSites.callAgent.model`             | Override LLM model for call orchestration                                                                                                                                                                                                 | _(unset — falls back to `llm.default.model`)_                                                            |
 | `calls.callerIdentity.allowPerCallOverride` | Allow per-call caller identity selection                                                                                                                                                                                                  | `true`                                                                                                   |
 | `calls.callerIdentity.userNumber`           | E.164 phone number for user-number mode                                                                                                                                                                                                   | _(empty)_                                                                                                |
 | `calls.voice.language`                      | Language code for TTS and transcription                                                                                                                                                                                                   | `en-US`                                                                                                  |
-| `services.stt.provider`                     | STT provider for transcription and telephony. Determines the Twilio integration path at call setup time (Deepgram/Google use native ConversationRelay; OpenAI Whisper uses media-stream).                                                 | `deepgram`                                                                                               |
-| `services.tts.provider`                     | Active TTS provider for speech synthesis. Must be a provider ID from the catalog (`elevenlabs`, `fish-audio`, `deepgram`). New providers can be added via the catalog without code changes to call routing.                               | `elevenlabs`                                                                                             |
+| `services.stt.provider`                     | STT provider for transcription and telephony. Determines the Twilio integration path at call setup time (Deepgram/Google use native ConversationRelay; OpenAI Whisper and xAI use media-stream).                                          | `deepgram`                                                                                               |
+| `services.tts.provider`                     | Active TTS provider for speech synthesis. Must be a provider ID from the catalog (`elevenlabs`, `fish-audio`, `deepgram`, `xai`). New providers can be added via the catalog without code changes to call routing.                        | `elevenlabs`                                                                                             |
 | `services.tts.providers.<id>.*`             | Provider-specific settings block. Each catalog provider has its own settings namespace under `services.tts.providers.<id>`. See voice settings in the desktop/iOS app or run `assistant config list` for available settings per provider. | _(per-provider defaults)_                                                                                |
 
 ## TTS provider call-path behavior
 
 Each TTS provider uses one of two call-path modes during phone calls:
 
-| Provider     | Call mode          | Description                                                                                                                                                           |
-| ------------ | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `elevenlabs` | `native-twilio`    | Text tokens are forwarded to Twilio's ConversationRelay, which synthesizes audio via its built-in ElevenLabs integration.                                             |
-| `fish-audio` | `synthesized-play` | The assistant synthesizes audio server-side via Fish Audio's HTTP API and streams chunks to Twilio via play messages.                                                 |
-| `deepgram`   | `synthesized-play` | The assistant synthesizes audio server-side via Deepgram's HTTP API and streams chunks to Twilio via play messages. Uses the same API key as Deepgram speech-to-text. |
+| Provider     | Call mode          | Description                                                                                                                                                              |
+| ------------ | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `elevenlabs` | `native-twilio`    | Text tokens are forwarded to Twilio's ConversationRelay, which synthesizes audio via its built-in ElevenLabs integration.                                                |
+| `fish-audio` | `synthesized-play` | The assistant synthesizes audio server-side via Fish Audio's HTTP API and streams chunks to Twilio via play messages.                                                    |
+| `deepgram`   | `synthesized-play` | The assistant synthesizes audio server-side via Deepgram's HTTP API and streams chunks to Twilio via play messages. Uses the same API key as Deepgram speech-to-text.    |
+| `xai`        | `synthesized-play` | The assistant synthesizes audio server-side via xAI's HTTP API and streams chunks to Twilio via play messages. No native Twilio fallback (`allowNativeFallback: false`). |
 
 Providers using `synthesized-play` add a small amount of latency compared to `native-twilio` because audio must be synthesized server-side before playback. The assistant handles chunk buffering and streaming automatically.
 

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

@@ -8,7 +8,7 @@ metadata:
     display-name: "Schedule"
 ---
 
-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).
+Manage scheduled automations. Schedules can be **recurring** (cron or RRULE expression) or **one-shot** (a single `fire_at` timestamp). Schedules support three modes: **execute** (run a message through the assistant), **notify** (send a notification to the user), and **script** (run a shell command directly without LLM involvement).
 
 ## Schedule Syntax
 
@@ -70,11 +70,13 @@ Exclusions (EXDATE, EXRULE) always take precedence over inclusions (RRULE, RDATE
 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"`
 
@@ -84,8 +86,9 @@ 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.
+- **script** - runs the `script` field as a shell command directly. No LLM invoked, no conversation created. stdout/stderr are captured in the schedule run record. Exit code 0 = success, non-zero = error. Commands run in the workspace directory with a 60-second timeout.
 
-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").
+Use `notify` for simple reminders ("remind me to take medicine at 9am"), `execute` for tasks that need assistant action ("check my calendar at 8am and send me a digest"), and `script` for lightweight shell automations that don't need LLM involvement ("refresh a cache", "poll an API", "rotate logs").
 
 ## Conversation Reuse
 
@@ -121,6 +124,7 @@ Optionally pass `routing_hints` (a JSON object) to influence routing decisions (
   3. If neither field is present or the interface is `cli`, omit `preferred_channels`.
 
   When a channel is determined, include it as a routing hint:
+
   ```
   routing_hints: { preferred_channels: ["<resolved channel>"] }
   routing_intent: "all_channels"
@@ -157,6 +161,7 @@ Phrases like "at the 45 minute mark", "at the top of the hour", "at noon", or "2
    - "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").
 
@@ -184,7 +189,7 @@ Scheduled messages run without user interaction. If the task produces output tha
 Choose the right delivery tool based on the content:
 
 - **Rich content** (digests, summaries, reports): For Gmail, use `messaging_send` with the target platform and conversation ID. For Slack, use the Slack Web API directly via CLI (`chat.postMessage`). This preserves the full content and posts directly.
-- **Short alerts** (status updates, completion notices): Use `send_notification` to let the notification router pick the best channel. Note: the router's decision engine rewrites content into short alerts, so it is not suitable for rich content.
+- **Short alerts** (status updates, completion notices): Use `assistant notifications send` via `bash` to let the notification router pick the best channel. Note: the router's decision engine rewrites content into short alerts, so it is not suitable for rich content.
 
 Example schedule message for a Slack digest:
 

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

@@ -32,7 +32,11 @@
           },
           "message": {
             "type": "string",
-            "description": "The message to send to the assistant when the schedule triggers"
+            "description": "The message to send to the assistant when the schedule triggers. Required for execute and notify modes."
+          },
+          "script": {
+            "type": "string",
+            "description": "The shell command to run when the schedule triggers. Required for script mode. Runs in the workspace directory with a sanitized environment."
           },
           "enabled": {
             "type": "boolean",
@@ -40,8 +44,8 @@
           },
           "mode": {
             "type": "string",
-            "enum": ["notify", "execute"],
-            "description": "Whether to notify the user or execute autonomously when triggered. Defaults to \"execute\"."
+            "enum": ["notify", "execute", "script"],
+            "description": "Whether to notify the user, execute autonomously via LLM, or run a shell command directly. Defaults to \"execute\"."
           },
           "routing_intent": {
             "type": "string",
@@ -65,7 +69,7 @@
             "description": "Brief non-technical explanation of why this tool is being called"
           }
         },
-        "required": ["name", "message"]
+        "required": ["name"]
       },
       "executor": "tools/schedule-create.ts",
       "execution_target": "host"
@@ -127,7 +131,11 @@
           },
           "message": {
             "type": "string",
-            "description": "New message to send when triggered"
+            "description": "New message to send when triggered (for execute/notify modes)"
+          },
+          "script": {
+            "type": "string",
+            "description": "New shell command to run when triggered (for script mode)"
           },
           "enabled": {
             "type": "boolean",
@@ -135,8 +143,8 @@
           },
           "mode": {
             "type": "string",
-            "enum": ["notify", "execute"],
-            "description": "Whether to notify the user or execute autonomously when triggered"
+            "enum": ["notify", "execute", "script"],
+            "description": "Whether to notify the user, execute autonomously via LLM, or run a shell command directly"
           },
           "routing_intent": {
             "type": "string",