@vellumai/assistant 0.4.43 → 0.4.45

package/src/config/bundled-skills/slack-app-setup/SKILL.md

@@ -1,178 +0,0 @@
----
-name: slack-app-setup
-description: Connect a Slack app to the Vellum Assistant via Socket Mode with guided app creation and guardian verification
-compatibility: "Designed for Vellum personal assistants"
-metadata: {"emoji":"💬","vellum":{"display-name":"Slack App Setup","user-invocable":true,"includes":["guardian-verify-setup"]}}
----
-
-You are helping your user connect a Slack bot to the Vellum Assistant via Socket Mode. Walk through each step below.
-
-## Value Classification
-
-| Value     | Type       | Storage method            | Secret? |
-| --------- | ---------- | ------------------------- | ------- |
-| App Token | Credential | `credential_store` prompt | **Yes** |
-| Bot Token | Credential | `credential_store` prompt | **Yes** |
-
-- Both tokens are secrets. Always collect via `credential_store` prompt — never accept them pasted in plaintext chat.
-
-# Setup Steps
-
-## Step 1: Generate Manifest & Create Slack App
-
-Ask the user what they'd like to name their Slack bot and optionally provide a short description. Use their answers (or sensible defaults) to generate a pre-configured Slack app manifest.
-
-Generate the manifest JSON:
-
-```json
-{
-  "display_information": {
-    "name": "<user's chosen name>",
-    "description": "<user's chosen description>",
-    "background_color": "#1a1a2e"
-  },
-  "features": {
-    "app_home": {
-      "home_tab_enabled": true,
-      "messages_tab_enabled": true,
-      "messages_tab_read_only_enabled": false
-    },
-    "bot_user": {
-      "display_name": "<user's chosen name>",
-      "always_online": true
-    }
-  },
-  "oauth_config": {
-    "scopes": {
-      "bot": [
-        "app_mentions:read",
-        "channels:history",
-        "chat:write",
-        "files:write",
-        "im:history",
-        "im:read",
-        "im:write",
-        "reactions:write",
-        "users:read"
-      ]
-    }
-  },
-  "settings": {
-    "event_subscriptions": {
-      "bot_events": [
-        "app_home_opened",
-        "app_mention",
-        "message.channels",
-        "message.im"
-      ]
-    },
-    "interactivity": { "is_enabled": true },
-    "org_deploy_enabled": false,
-    "socket_mode_enabled": true,
-    "token_rotation_enabled": false
-  }
-}
-```
-
-After generating the manifest, URL-encode it and construct the create-from-manifest link:
-
-```
-https://api.slack.com/apps?new_app=1&manifest_json=<url_encoded_manifest>
-```
-
-Present the link to the user: "Click this link to create your Slack app. It's pre-configured with all the right permissions, events, and Socket Mode. Just select your workspace and click **Create**."
-
-Wait for the user to confirm they've created the app before proceeding.
-
-## Step 2: Generate App Token & Collect It
-
-Tell the user to navigate to **Settings > Basic Information > App-Level Tokens** in their newly created Slack app, then:
-
-1. Click **Generate Token and Scopes**
-2. Token name: "Socket Mode" (or any name they prefer)
-3. Add scope: `connections:write`
-4. Click **Generate**
-
-Collect the app token securely:
-
-- Call `credential_store` with `action: "prompt"`, `service: "slack_channel"`, `field: "app_token"`, `label: "App-Level Token"`, `placeholder: "xapp-..."`, `description: "Paste the App-Level Token you just generated"`
-
-After collection, validate the app token format:
-
-```bash
-APP_TOKEN=$(assistant credentials reveal slack_channel:app_token)
-if [[ "$APP_TOKEN" != xapp-* ]]; then
-  echo "ERROR: App token must start with xapp-"
-  assistant credentials delete slack_channel:app_token
-  exit 1
-fi
-echo "App token format valid"
-```
-
-If the token does not start with `xapp-`, inform the user it is invalid, delete it, and ask them to re-enter (repeat the collection above).
-
-## Step 3: Install App & Collect Bot Token
-
-Tell the user to navigate to **Settings > Install App** in the sidebar, then click **Install to Workspace** and authorize the requested permissions (already pre-configured from the manifest).
-
-After installation, collect the bot token securely:
-
-- Call `credential_store` with `action: "prompt"`, `service: "slack_channel"`, `field: "bot_token"`, `label: "Bot User OAuth Token"`, `placeholder: "xoxb-..."`, `description: "Paste the Bot User OAuth Token shown after installing"`
-
-## Step 4: Validate Bot Token & Store Workspace Metadata
-
-```bash
-BOT_TOKEN=$(assistant credentials reveal slack_channel:bot_token)
-AUTH_RESPONSE=$(curl -sf -X POST "https://slack.com/api/auth.test" \
-  -H "Authorization: Bearer $BOT_TOKEN")
-echo "$AUTH_RESPONSE" | jq .
-```
-
-If `ok` is `false`, the token is invalid — ask the user to re-enter (repeat Step 3).
-
-If `ok` is `true`, parse the response and persist workspace metadata so the Settings UI can display the connected bot and workspace:
-
-```bash
-TEAM_ID=$(echo "$AUTH_RESPONSE" | jq -r '.team_id')
-TEAM_NAME=$(echo "$AUTH_RESPONSE" | jq -r '.team')
-BOT_USER_ID=$(echo "$AUTH_RESPONSE" | jq -r '.user_id')
-BOT_USERNAME=$(echo "$AUTH_RESPONSE" | jq -r '.user')
-assistant config set slack.teamId "$TEAM_ID"
-assistant config set slack.teamName "$TEAM_NAME"
-assistant config set slack.botUserId "$BOT_USER_ID"
-assistant config set slack.botUsername "$BOT_USERNAME"
-```
-
-Report the bot username and workspace from the response.
-
-Socket Mode connects automatically once both credentials are stored — no further action needed.
-
-## Step 5: Guardian Verification (Optional)
-
-Link the user's Slack account as the trusted guardian. Load the **guardian-verify-setup** skill:
-
-- Call `skill_load` with `skill: "guardian-verify-setup"`.
-
-If the user declines, skip and continue.
-
-## Step 6: Report Success
-
-Summarize:
-
-- Bot connected: {username} in {workspace}
-- Socket Mode: active (gateway auto-connects when credentials are stored)
-- Guardian: {verified | skipped}
-- Usage: @{botUsername} in any channel, or DM the bot directly
-
-# Clearing Credentials
-
-To disconnect Slack:
-
-```bash
-assistant credentials delete slack_channel:bot_token
-assistant credentials delete slack_channel:app_token
-assistant config set slack.teamId ""
-assistant config set slack.teamName ""
-assistant config set slack.botUserId ""
-assistant config set slack.botUsername ""
-```

package/src/config/bundled-skills/slack-digest-setup/SKILL.md

@@ -1,163 +0,0 @@
----
-name: slack-digest-setup
-description: Set up recurring Slack channel digests with scanning schedules, channel configuration, and delivery — codifies best practices for high-quality automated summaries
-compatibility: "Designed for Vellum personal assistants"
-metadata: {"emoji":"📊","vellum":{"display-name":"Slack Digest Setup","user-invocable":true,"includes":["slack","schedule"]}}
----
-
-You are helping your user set up a recurring Slack digest: automated channel scanning on a schedule that delivers prose-style summaries of what's happening across their workspace. This skill walks through configuration, scheduling, and — critically — the execution protocol that ensures every digest is actually useful.
-
-## Prerequisites
-
-Before starting, verify:
-
-1. **Slack is connected.** The `slack_scan_digest` tool must be available. If not, load the `slack-app-setup` skill first.
-2. **Bot has channel access.** The Slack bot must be invited to each channel it needs to scan. Users can do this with `/invite @BotName` in each channel.
-
-## Step 1: Configure Channels
-
-Help the user decide which channels to scan. Ask what channels matter most to them, then use `slack_configure_channels` with `action: "set"` to save their preferences.
-
-Tips for channel selection:
-
-- Start with 5-10 high-signal channels (team channels, engineering, announcements)
-- Skip noisy bot/CI channels unless the user specifically wants them
-- Private channels work too, as long as the bot is invited
-- The user can update this list anytime with `slack_configure_channels`
-
-If the user already has preferred channels configured, show the current list and ask if they want to adjust.
-
-## Step 2: Set Up the Schedule
-
-Create a recurring schedule using `schedule_create`. The recommended default is **hourly, 7am-7pm in the user's timezone**, with the overnight gap.
-
-**Cron expression:** `0 7-19 * * *` (fires at the top of each hour, 7am through 7pm)
-
-**Determine the delivery target.** Ask the user where digests should be delivered — typically their Slack DM or a dedicated channel like `#alex-agent-messages`. Use `messaging_read` or the Slack API to resolve the `conversation_id` for the target. This ID gets baked into the schedule message so scheduled sessions know where to post.
-
-**The schedule message is critical.** Scheduled sessions have no memory of this setup conversation. The message must be completely self-contained with every instruction needed to execute properly. Use the Scan Execution Protocol below as the template for the schedule message content.
-
-### Scan Window Logic
-
-- The **first scan of the day** (e.g. 7am) covers everything since the last scan the previous evening. If the last scan was at 7pm, that's 12 hours of overnight activity.
-- All **subsequent scans** cover since the previous hourly scan (roughly 1 hour).
-- The scan reads `data/last_slack_scan.json` for the timestamp of the last scan and calculates `hours_back` accordingly.
-
-## Step 3: Create Tracking Files
-
-Set up two files for scan state and history:
-
-**`data/last_slack_scan.json`** — Stores the timestamp of the last successful scan:
-
-```json
-{ "timestamp": "2026-01-01T12:00:00Z", "hours_back": 1, "channels_scanned": 0 }
-```
-
-**`data/slack_scan_log.md`** — Running log of scan activity:
-
-```markdown
-# Slack Scan Log
-
-## YYYY-MM-DD HH:MM ET | Window: Xh | N channels scanned
-
-Summary of what was found, or "All clear."
-```
-
-Create both files during setup with initial values. The scheduled scan sessions update them after each run.
-
-## Step 4: Scan Execution Protocol
-
-**This is the most important section.** Every scheduled scan MUST follow this exact protocol. Embed these instructions directly in the schedule message so the session cannot deviate.
-
-### The Protocol
-
-1. **Load the Slack skill.** Call `skill_load` with `skill: "slack"` to ensure scan tools are available.
-
-2. **Call `slack_scan_digest` with `include_threads: true`.** Check `data/last_slack_scan.json` for the last scan timestamp and calculate the appropriate `hours_back`. Actually call the tool. Do not skip this step. Do not assume nothing happened.
-
-3. **Read the actual results.** Look at what the scan returned before deciding what to report. If the tool returned messages, proceed to step 4a. If it returned zero messages, proceed to step 4b.
-
-4a. **If there are messages: Write a full prose digest.** Break down by channel. For each channel with activity, include:
-
-- Channel name
-- Who's talking (real names, not user IDs)
-- What's being discussed (specific topics, not vague summaries)
-- Reply counts on notable threads
-- Decisions made, questions asked, action items
-- Anything that looks like it needs the user's attention or a reply
-
-Write in prose style, conversational. Not bullet lists of channel names. Highlight what matters, skip noise, but be specific about what's quiet too.
-
-4b. **If genuinely zero messages: Name the channels you scanned.** The user needs to know coverage was complete. Example: "Scanned team-atlas, team-illuminati, ask-eng, team-jarvis, and 3 others. Nothing new in the last hour."
-
-5. **Deliver via `messaging_send`.** Call `messaging_send` with `platform: "slack"` and the target `conversation_id` (determined during setup — typically the user's preferred DM or a dedicated digest channel). The `message` field MUST contain the full prose digest you wrote in step 4. Do NOT use `send_notification` for digests — the notification router's decision engine rewrites content into short alerts, stripping the actual digest.
-
-6. **Update tracking files.** Write the current timestamp to `data/last_slack_scan.json` and append a log entry to `data/slack_scan_log.md`.
-
-### Template Schedule Message
-
-Use this as the schedule message when creating the schedule. Adjust the delivery target and channel exclusions per the user's preferences:
-
-```
-Run the Slack digest scan. Follow every instruction exactly:
-
-1. Load the Slack skill.
-2. Call slack_scan_digest with include_threads: true to scan preferred channels. Check data/last_slack_scan.json for the time window.
-3. Read the actual results. Do NOT skip this or assume nothing happened.
-4. Build the digest:
-   - If there are messages: write a prose-style digest broken down by channel with channel names, who's talking (real names), specific topics, reply counts, decisions, questions, and anything needing attention.
-   - If zero messages: list which channels were scanned so coverage is clear.
-5. Send using messaging_send with platform "slack" and conversation_id "<target_channel_id>". The MESSAGE field must contain the full digest from step 4. Never send a generic status like "scan completed." Do NOT use send_notification — it rewrites content into short alerts.
-6. Update data/last_slack_scan.json and append to data/slack_scan_log.md.
-```
-
-## Step 5: HEARTBEAT.md Integration (Optional)
-
-If the user has the heartbeat feature enabled (`heartbeat.enabled: true` in config.json), add the scan protocol to `HEARTBEAT.md` as a checklist item instead of (or in addition to) using `schedule_create`. The heartbeat runs on its own interval and reads HEARTBEAT.md for instructions.
-
-Either approach works. The key is that the execution instructions are explicit and self-contained regardless of where they live.
-
-## Quality Standard
-
-Every digest, whether it covers 1 hour or 12 hours, must meet the same quality bar:
-
-- **Prose style, conversational.** Not bullet lists of channel names. Write like you're briefing a busy person.
-- **Specific.** Name the people, name the topics, give reply counts. "Team-atlas had some discussion" is useless. "Marina and Emmie discussed the CI pipeline fix in team-atlas (7 replies, still in progress)" is useful.
-- **Prioritized.** Lead with what matters. Decisions, blockers, and things needing the user's attention come first. Background chatter comes last or gets skipped.
-- **Honest about quiet periods.** If nothing happened, say so, but name what you scanned.
-
-The morning overnight digest is not a different format. It just covers more time and will naturally be longer.
-
-## Privacy Rules
-
-- Content from `isPrivate: true` channels MUST NEVER appear in digests delivered to other channels or external destinations.
-- If the user designates specific channels as sensitive (e.g. a war-room), exclude them from digests entirely. Document these exclusions in the schedule message so scheduled sessions respect them.
-- When in doubt about whether content can be shared, err on the side of omission.
-
-## Common Pitfalls
-
-These are hard-won lessons from debugging digest quality issues. They exist here so other assistants don't repeat the same mistakes.
-
-### Pitfall: Skipping the scan call
-
-The `slack_scan_digest` tool is what fetches messages. Without calling it, you have nothing to summarize. Never report "all clear" or "0 channels active" without having actually called the scan tool and confirmed zero messages came back. The scan does the fetching. You do the summarizing.
-
-### Pitfall: Using `send_notification` for digests
-
-The notification router's decision engine rewrites `send_notification` content into short alerts (title ≤ 8 words, body ≤ 2 sentences). If you put a full prose digest in `send_notification`, it will be truncated or rewritten. Always use `messaging_send` with the target `conversation_id` for digest delivery. The `messaging_send` message field is delivered verbatim.
-
-### Pitfall: Not naming channels in quiet reports
-
-Even when nothing happened, the user needs to know the scan actually ran and what it covered. "All clear" by itself could mean you scanned 12 channels and found nothing, or it could mean you didn't scan at all. List the channels.
-
-### Pitfall: Losing context between sessions
-
-Scheduled sessions start fresh with no memory of the setup conversation. They don't know what format to use, where to deliver, or what channels to skip unless you tell them. The schedule message must contain every instruction needed to execute properly. If it's not in the message, it won't happen.
-
-### Pitfall: Different quality for hourly vs overnight
-
-There is no "hourly format" vs "overnight format." Every digest follows the same structure. The overnight one is just longer because it covers more time. Don't phone in the hourly scans with one-line summaries while giving the overnight scan full channel-by-channel treatment.
-
-## Verification
-
-After setup is complete, suggest the user test the digest by temporarily setting the schedule to run every 2 minutes (`*/2 * * * *`). Watch for the first notification, verify it contains actual content (not a generic status), then switch back to hourly.

package/src/config/bundled-skills/slack-oauth-setup/SKILL.md

@@ -1,157 +0,0 @@
----
-name: slack-oauth-setup
-description: Create Slack App and OAuth credentials for Slack integration using browser automation
-compatibility: "Designed for Vellum personal assistants"
-metadata: {"emoji":"🔑","vellum":{"display-name":"Slack OAuth Setup","user-invocable":true,"includes":["browser"]}}
----
-
-You are helping your user create a Slack App and OAuth credentials so the Messaging integration can connect to their Slack workspace. Walk through each step below using `browser_navigate`, `browser_snapshot`, `browser_screenshot`, `browser_click`, `browser_type`, and `browser_extract` tools.
-
-**Tone:** Be friendly and reassuring throughout. Narrate what you're doing in plain language so the user always knows what's happening. After each step, briefly confirm what was accomplished before moving on.
-
-## Before You Start
-
-Tell the user:
-- "I'll walk you through creating a Slack App so Vellum can connect to your workspace. The whole process takes a few minutes."
-- "I'll be automating the Slack API website in the browser — you'll be able to see everything I'm doing."
-- "I'll ask for your approval before each major step, so nothing happens without your say-so."
-- "No sensitive credentials will be shown in the conversation."
-
-## Step 1: Navigate to Slack API
-
-Tell the user: "First, let me open the Slack API dashboard."
-
-Use `browser_navigate` to go to `https://api.slack.com/apps`.
-
-Take a `browser_screenshot` to show the user what loaded, then take a `browser_snapshot` to check the page state:
-- **If a sign-in page appears:** Tell the user "Please sign in to your Slack account in the browser window. Let me know when you're done." Wait for their confirmation, then take another snapshot.
-- **If the apps dashboard loads:** Tell the user "Slack API dashboard is loaded. Let's create your app!" and continue to Step 2.
-
-## Step 2: Create a Slack App
-
-**Ask for approval before proceeding.** Use `ui_show` with `surface_type: "confirmation"` and this message:
-
-> **Create a Slack App**
->
-> I'm about to create a new Slack App called "Vellum Assistant" in your workspace. This app will only have the permissions you approve in the next step. It won't post anything or access any data until you explicitly authorize it.
-
-Wait for the user to approve. If they decline, explain that the app is required for OAuth and offer to try again or cancel.
-
-Once approved:
-1. Click "Create New App"
-2. Select "From scratch"
-3. Enter app name: "Vellum Assistant"
-4. Select the user's workspace from the dropdown
-5. Click "Create App"
-
-Take a `browser_screenshot` to show the result.
-
-Tell the user: "App created! Now let's configure the permissions it needs."
-
-## Step 3: Configure OAuth Scopes
-
-**Ask for approval before proceeding.** Use `ui_show` with `surface_type: "confirmation"` and this message:
-
-> **Configure Slack Permissions**
->
-> I'm about to add the following User Token Scopes to your Slack App. These let Vellum read your messages and channels, send messages on your behalf, search your message history, and add emoji reactions:
->
-> - `channels:read` — View basic channel info
-> - `channels:history` — Read message history in public channels
-> - `groups:read` — View private channel info
-> - `groups:history` — Read message history in private channels
-> - `im:read` — View direct message info
-> - `im:history` — Read direct message history
-> - `im:write` — Open and send direct messages
-> - `mpim:read` — View group DM info
-> - `mpim:history` — Read group DM history
-> - `users:read` — View user profiles
-> - `chat:write` — Send messages
-> - `search:read` — Search messages
-> - `reactions:write` — Add emoji reactions
-
-Wait for the user to approve.
-
-Once approved:
-1. Navigate to "OAuth & Permissions" in the left sidebar (or go to the app's OAuth page directly)
-2. Scroll to "User Token Scopes"
-3. Add each scope listed above using the "Add an OAuth Scope" button
-
-Take a `browser_screenshot` after adding all scopes.
-
-Tell the user: "Permissions configured! Now let's set up the redirect URL and get the credentials."
-
-## Step 4: Add Redirect URL
-
-Navigate to the "OAuth & Permissions" page if not already there.
-
-Before entering the redirect URL, resolve the exact value from the well-known OAuth config:
-
-```
-credential_store describe:
-  service: "integration:slack"
-```
-
-Read the `redirectUri` field from that response and use it exactly as shown.
-
-In the "Redirect URLs" section:
-1. If `redirectUri` says "automatic", skip adding a redirect URL for this provider.
-2. If `redirectUri` mentions "not currently configured" / `GATEWAY_BASE_URL` / `INGRESS_PUBLIC_BASE_URL`, stop and ask the user to configure public ingress first.
-3. Otherwise, click "Add New Redirect URL" and enter the `redirectUri` value exactly as returned.
-4. Click "Add" then "Save URLs"
-
-Take a `browser_snapshot` to confirm.
-
-Tell the user: "Redirect URL configured using the redirect URI from Vellum's Slack OAuth profile."
-
-## Step 5: Extract Client ID and Client Secret
-
-Navigate to "Basic Information" in the left sidebar.
-
-Use `browser_extract` to read:
-1. **Client ID** from the "App Credentials" section
-2. **Client Secret** — click "Show" first, then extract the value
-
-**Important:** Slack requires a client secret for the token exchange (unlike Google which uses PKCE). Both values are needed.
-
-Tell the user: "Credentials extracted! Now let's connect your Slack workspace."
-
-## Step 6: Connect Slack
-
-Tell the user: "Opening Slack authorization so you can grant Vellum access to your workspace. You'll see a Slack consent page — just click 'Allow'."
-
-Use the `credential_store` tool to connect Slack via OAuth2:
-
-```
-action: "oauth2_connect"
-service: "integration:slack"
-client_id: "<the extracted Client ID>"
-client_secret: "<the extracted Client Secret>"
-auth_url: "https://slack.com/oauth/v2/authorize"
-token_url: "https://slack.com/api/oauth.v2.access"
-scopes: ["channels:read", "channels:history", "groups:read", "groups:history", "im:read", "im:history", "im:write", "mpim:read", "mpim:history", "users:read", "chat:write", "search:read", "reactions:write"]
-extra_params: {"user_scope": "channels:read,channels:history,groups:read,groups:history,im:read,im:history,im:write,mpim:read,mpim:history,users:read,chat:write,search:read,reactions:write"}
-```
-
-This will open the Slack authorization page in the user's browser. Wait for the flow to complete.
-
-## Step 7: Celebrate!
-
-Once connected, tell the user:
-
-"**Slack is connected!** You're all set. You can now read channels, search messages, send messages, and manage your Slack workspace through Vellum. Try asking me to check your unread Slack messages!"
-
-Summarize what was accomplished:
-- Created a Slack App called "Vellum Assistant"
-- Configured User Token Scopes for reading, writing, and searching
-- Set up the OAuth redirect URL from the Slack OAuth profile
-- Connected your Slack workspace
-
-## Error Handling
-
-- **Page load failures:** Retry navigation once. If it still fails, tell the user and ask them to check their internet connection.
-- **Workspace selection issues:** The user may need admin permissions to install apps. Explain this clearly.
-- **Element not found for click/type:** Take a fresh `browser_snapshot` to re-assess the page layout. Slack's UI may have changed; adapt your selectors.
-- **User declines an approval gate:** Don't push back. Explain briefly why the step matters, offer to try again, or cancel gracefully.
-- **OAuth flow timeout or failure:** Tell the user what happened and offer to retry. The app is already created, so they only need to re-run the connect step.
-- **Any unexpected state:** Take a `browser_screenshot` and `browser_snapshot`, describe what you see, and ask the user for guidance.

package/src/config/bundled-skills/start-the-day/SKILL.md

@@ -1,70 +0,0 @@
----
-name: start-the-day
-description: Get a personalized daily briefing with weather, news, and actionable insights
-compatibility: "Designed for Vellum personal assistants"
-metadata: {"emoji":"🌅","vellum":{"display-name":"Start the Day","user-invocable":true}}
----
-
-You are a personal daily briefing assistant. When the user invokes this skill, generate a concise, actionable briefing tailored to the current moment.
-
-## Briefing Structure
-
-Build the briefing in sections. Use what you know about the user and their context to decide which sections are relevant. Don't include sections you have nothing useful to say about.
-
-### 1. Weather & Conditions
-
-Check the user's location (from system context or ask once) and provide:
-- Current conditions and temperature
-- High/low for the day
-- Notable weather (rain, extreme temps, wind) — only if it affects plans
-
-### 2. Top Headlines
-
-Summarize 3-5 notable news items. Prioritize:
-- Stories relevant to the user's interests or industry
-- Major world events
-- Tech/product launches if relevant
-- Keep each to one sentence
-
-### 3. Calendar & Meetings
-
-If you have access to calendar context:
-- List today's meetings with times
-- Flag any prep needed (documents to review, talking points)
-- Note gaps that could be used for focused work
-
-### 4. Email & Messages
-
-If you have access to communication context:
-- Summarize unread messages that need responses
-- Draft quick replies for straightforward ones — present them for review
-- Flag anything urgent or time-sensitive
-
-### 5. Tasks & Priorities
-
-If you have context on the user's work:
-- Surface top 3 priorities for the day
-- Note any deadlines approaching
-- Suggest one thing to tackle first
-
-### 6. Something Interesting
-
-End with one of:
-- An interesting fact or quote
-- A relevant article worth reading later
-- A tip related to something the user is working on
-
-## Tone
-
-- Concise and scannable — use bullet points, not paragraphs
-- Conversational but efficient — like a sharp executive assistant
-- Don't pad with filler — if you only have 2 useful sections, give 2 sections
-- Time-aware: morning briefings differ from afternoon check-ins
-
-## Adaptation Over Time
-
-As you learn more about the user:
-- Weight news toward their interests and industry
-- Remember their schedule patterns (e.g. "you usually have standup at 10")
-- Track recurring tasks and deadlines
-- Get more specific and less generic with each use

package/src/config/bundled-skills/start-the-day/icon.svg

@@ -1,13 +0,0 @@
-<svg viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
-  <rect x="0" y="0" width="16" height="16" fill="#1a1a2e"/>
-  <rect x="2" y="2" width="12" height="12" fill="#16213e"/>
-  <rect x="3" y="3" width="10" height="10" fill="#0f3460"/>
-  <rect x="4" y="4" width="8" height="2" fill="#e94560"/>
-  <rect x="4" y="7" width="8" height="1" fill="#ffd700"/>
-  <rect x="4" y="9" width="8" height="1" fill="#ffd700"/>
-  <rect x="4" y="11" width="8" height="1" fill="#ffd700"/>
-  <rect x="2" y="2" width="1" height="12" fill="#16a085"/>
-  <rect x="13" y="2" width="1" height="12" fill="#16a085"/>
-  <rect x="7" y="1" width="2" height="1" fill="#ffd700"/>
-  <rect x="6" y="0" width="4" height="1" fill="#e94560"/>
-</svg>